]>
Commit | Line | Data |
---|---|---|
5e6908ea | 1 | /* Expands front end tree to back end RTL for GCC. |
af841dbd | 2 | Copyright (C) 1987, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, |
66647d44 | 3 | 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 |
bfc45551 | 4 | Free Software Foundation, Inc. |
6f086dfc | 5 | |
1322177d | 6 | This file is part of GCC. |
6f086dfc | 7 | |
1322177d LB |
8 | GCC is free software; you can redistribute it and/or modify it under |
9 | the terms of the GNU General Public License as published by the Free | |
9dcd6f09 | 10 | Software Foundation; either version 3, or (at your option) any later |
1322177d | 11 | version. |
6f086dfc | 12 | |
1322177d LB |
13 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
14 | WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
15 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
16 | for more details. | |
6f086dfc RS |
17 | |
18 | You should have received a copy of the GNU General Public License | |
9dcd6f09 NC |
19 | along with GCC; see the file COPYING3. If not see |
20 | <http://www.gnu.org/licenses/>. */ | |
6f086dfc | 21 | |
6f086dfc RS |
22 | /* This file handles the generation of rtl code from tree structure |
23 | at the level of the function as a whole. | |
24 | It creates the rtl expressions for parameters and auto variables | |
25 | and has full responsibility for allocating stack slots. | |
26 | ||
27 | `expand_function_start' is called at the beginning of a function, | |
28 | before the function body is parsed, and `expand_function_end' is | |
29 | called after parsing the body. | |
30 | ||
31 | Call `assign_stack_local' to allocate a stack slot for a local variable. | |
32 | This is usually done during the RTL generation for the function body, | |
33 | but it can also be done in the reload pass when a pseudo-register does | |
8fff4fc1 | 34 | not get a hard register. */ |
6f086dfc RS |
35 | |
36 | #include "config.h" | |
670ee920 | 37 | #include "system.h" |
4977bab6 ZW |
38 | #include "coretypes.h" |
39 | #include "tm.h" | |
6f086dfc RS |
40 | #include "rtl.h" |
41 | #include "tree.h" | |
42 | #include "flags.h" | |
1ef08c63 | 43 | #include "except.h" |
6f086dfc | 44 | #include "function.h" |
6f086dfc | 45 | #include "expr.h" |
c6b97fac | 46 | #include "optabs.h" |
e78d8e51 | 47 | #include "libfuncs.h" |
6f086dfc RS |
48 | #include "regs.h" |
49 | #include "hard-reg-set.h" | |
50 | #include "insn-config.h" | |
51 | #include "recog.h" | |
52 | #include "output.h" | |
bdac5f58 | 53 | #include "basic-block.h" |
10f0ad3d | 54 | #include "toplev.h" |
e2500fed | 55 | #include "hashtab.h" |
87ff9c8e | 56 | #include "ggc.h" |
b1474bb7 | 57 | #include "tm_p.h" |
c0e7830f | 58 | #include "integrate.h" |
7afff7cf | 59 | #include "langhooks.h" |
61f71b34 | 60 | #include "target.h" |
623a66fa | 61 | #include "cfglayout.h" |
726a989a | 62 | #include "gimple.h" |
ef330312 | 63 | #include "tree-pass.h" |
7d69de61 | 64 | #include "predict.h" |
6fb5fa3c DB |
65 | #include "df.h" |
66 | #include "timevar.h" | |
e3df376d | 67 | #include "vecprim.h" |
7d69de61 | 68 | |
5576d6f2 TT |
69 | /* So we can assign to cfun in this file. */ |
70 | #undef cfun | |
71 | ||
95f3f59e JDA |
72 | #ifndef STACK_ALIGNMENT_NEEDED |
73 | #define STACK_ALIGNMENT_NEEDED 1 | |
74 | #endif | |
75 | ||
975f3818 RS |
76 | #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT) |
77 | ||
293e3de4 RS |
78 | /* Some systems use __main in a way incompatible with its use in gcc, in these |
79 | cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to | |
80 | give the same symbol without quotes for an alternative entry point. You | |
0f41302f | 81 | must define both, or neither. */ |
293e3de4 RS |
82 | #ifndef NAME__MAIN |
83 | #define NAME__MAIN "__main" | |
293e3de4 RS |
84 | #endif |
85 | ||
6f086dfc RS |
86 | /* Round a value to the lowest integer less than it that is a multiple of |
87 | the required alignment. Avoid using division in case the value is | |
88 | negative. Assume the alignment is a power of two. */ | |
89 | #define FLOOR_ROUND(VALUE,ALIGN) ((VALUE) & ~((ALIGN) - 1)) | |
90 | ||
91 | /* Similar, but round to the next highest integer that meets the | |
92 | alignment. */ | |
93 | #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1)) | |
94 | ||
54ff41b7 JW |
95 | /* Nonzero if function being compiled doesn't contain any calls |
96 | (ignoring the prologue and epilogue). This is set prior to | |
97 | local register allocation and is valid for the remaining | |
718fe406 | 98 | compiler passes. */ |
54ff41b7 JW |
99 | int current_function_is_leaf; |
100 | ||
fdb8a883 JW |
101 | /* Nonzero if function being compiled doesn't modify the stack pointer |
102 | (ignoring the prologue and epilogue). This is only valid after | |
6fb5fa3c | 103 | pass_stack_ptr_mod has run. */ |
fdb8a883 JW |
104 | int current_function_sp_is_unchanging; |
105 | ||
54ff41b7 JW |
106 | /* Nonzero if the function being compiled is a leaf function which only |
107 | uses leaf registers. This is valid after reload (specifically after | |
108 | sched2) and is useful only if the port defines LEAF_REGISTERS. */ | |
54ff41b7 JW |
109 | int current_function_uses_only_leaf_regs; |
110 | ||
6f086dfc | 111 | /* Nonzero once virtual register instantiation has been done. |
c39ada04 DD |
112 | assign_stack_local uses frame_pointer_rtx when this is nonzero. |
113 | calls.c:emit_library_call_value_1 uses it to set up | |
114 | post-instantiation libcalls. */ | |
115 | int virtuals_instantiated; | |
6f086dfc | 116 | |
df696a75 | 117 | /* Assign unique numbers to labels generated for profiling, debugging, etc. */ |
17211ab5 | 118 | static GTY(()) int funcdef_no; |
f6f315fe | 119 | |
414c4dc4 NC |
120 | /* These variables hold pointers to functions to create and destroy |
121 | target specific, per-function data structures. */ | |
fa8db1f7 | 122 | struct machine_function * (*init_machine_status) (void); |
46766466 | 123 | |
b384405b | 124 | /* The currently compiled function. */ |
01d939e8 | 125 | struct function *cfun = 0; |
b384405b | 126 | |
cd9c1ca8 RH |
127 | /* These hashes record the prologue and epilogue insns. */ |
128 | static GTY((if_marked ("ggc_marked_p"), param_is (struct rtx_def))) | |
129 | htab_t prologue_insn_hash; | |
130 | static GTY((if_marked ("ggc_marked_p"), param_is (struct rtx_def))) | |
131 | htab_t epilogue_insn_hash; | |
6f086dfc | 132 | \f |
e15679f8 RK |
133 | /* Forward declarations. */ |
134 | ||
fa8db1f7 | 135 | static struct temp_slot *find_temp_slot_from_address (rtx); |
fa8db1f7 AJ |
136 | static void pad_to_arg_alignment (struct args_size *, int, struct args_size *); |
137 | static void pad_below (struct args_size *, enum machine_mode, tree); | |
2c217442 | 138 | static void reorder_blocks_1 (rtx, tree, VEC(tree,heap) **); |
fa8db1f7 AJ |
139 | static int all_blocks (tree, tree *); |
140 | static tree *get_block_vector (tree, int *); | |
141 | extern tree debug_find_var_in_block_tree (tree, tree); | |
1f52178b | 142 | /* We always define `record_insns' even if it's not used so that we |
ec97b83a | 143 | can always export `prologue_epilogue_contains'. */ |
cd9c1ca8 RH |
144 | static void record_insns (rtx, rtx, htab_t *) ATTRIBUTE_UNUSED; |
145 | static bool contains (const_rtx, htab_t); | |
73ef99fb | 146 | #ifdef HAVE_return |
6039a0c7 | 147 | static void emit_return_into_block (basic_block); |
73ef99fb | 148 | #endif |
db2960f4 | 149 | static void prepare_function_start (void); |
fa8db1f7 AJ |
150 | static void do_clobber_return_reg (rtx, void *); |
151 | static void do_use_return_reg (rtx, void *); | |
4c4d143a | 152 | static void set_insn_locators (rtx, int) ATTRIBUTE_UNUSED; |
c20bf1f3 | 153 | \f |
936fc9ba JH |
154 | /* Stack of nested functions. */ |
155 | /* Keep track of the cfun stack. */ | |
e5e809f4 | 156 | |
936fc9ba | 157 | typedef struct function *function_p; |
e5e809f4 | 158 | |
936fc9ba JH |
159 | DEF_VEC_P(function_p); |
160 | DEF_VEC_ALLOC_P(function_p,heap); | |
161 | static VEC(function_p,heap) *function_context_stack; | |
6f086dfc RS |
162 | |
163 | /* Save the current context for compilation of a nested function. | |
d2784db4 | 164 | This is called from language-specific code. */ |
6f086dfc RS |
165 | |
166 | void | |
d2784db4 | 167 | push_function_context (void) |
6f086dfc | 168 | { |
01d939e8 | 169 | if (cfun == 0) |
182e0d71 | 170 | allocate_struct_function (NULL, false); |
b384405b | 171 | |
936fc9ba | 172 | VEC_safe_push (function_p, heap, function_context_stack, cfun); |
db2960f4 | 173 | set_cfun (NULL); |
6f086dfc RS |
174 | } |
175 | ||
176 | /* Restore the last saved context, at the end of a nested function. | |
177 | This function is called from language-specific code. */ | |
178 | ||
179 | void | |
d2784db4 | 180 | pop_function_context (void) |
6f086dfc | 181 | { |
936fc9ba | 182 | struct function *p = VEC_pop (function_p, function_context_stack); |
db2960f4 | 183 | set_cfun (p); |
6f086dfc | 184 | current_function_decl = p->decl; |
6f086dfc | 185 | |
6f086dfc | 186 | /* Reset variables that have known state during rtx generation. */ |
6f086dfc | 187 | virtuals_instantiated = 0; |
1b3d8f8a | 188 | generating_concat_p = 1; |
6f086dfc | 189 | } |
e4a4639e | 190 | |
fa51b01b RH |
191 | /* Clear out all parts of the state in F that can safely be discarded |
192 | after the function has been parsed, but not compiled, to let | |
193 | garbage collection reclaim the memory. */ | |
194 | ||
195 | void | |
fa8db1f7 | 196 | free_after_parsing (struct function *f) |
fa51b01b | 197 | { |
e8924938 | 198 | f->language = 0; |
fa51b01b RH |
199 | } |
200 | ||
e2ecd91c BS |
201 | /* Clear out all parts of the state in F that can safely be discarded |
202 | after the function has been compiled, to let garbage collection | |
0a8a198c | 203 | reclaim the memory. */ |
21cd906e | 204 | |
e2ecd91c | 205 | void |
fa8db1f7 | 206 | free_after_compilation (struct function *f) |
e2ecd91c | 207 | { |
cd9c1ca8 RH |
208 | prologue_insn_hash = NULL; |
209 | epilogue_insn_hash = NULL; | |
210 | ||
3e029763 JH |
211 | if (crtl->emit.regno_pointer_align) |
212 | free (crtl->emit.regno_pointer_align); | |
f995dcfe | 213 | |
3e029763 | 214 | memset (crtl, 0, sizeof (struct rtl_data)); |
e2500fed | 215 | f->eh = NULL; |
e2500fed | 216 | f->machine = NULL; |
997de8ed | 217 | f->cfg = NULL; |
fa51b01b | 218 | |
57b9e367 | 219 | regno_reg_rtx = NULL; |
825b2fe7 | 220 | insn_locators_free (); |
e2ecd91c | 221 | } |
6f086dfc | 222 | \f |
49ad7cfa BS |
223 | /* Return size needed for stack frame based on slots so far allocated. |
224 | This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY; | |
225 | the caller may have to do that. */ | |
9fb798d7 | 226 | |
49ad7cfa | 227 | HOST_WIDE_INT |
fa8db1f7 | 228 | get_frame_size (void) |
49ad7cfa | 229 | { |
bd60bab2 JH |
230 | if (FRAME_GROWS_DOWNWARD) |
231 | return -frame_offset; | |
232 | else | |
233 | return frame_offset; | |
49ad7cfa BS |
234 | } |
235 | ||
9fb798d7 EB |
236 | /* Issue an error message and return TRUE if frame OFFSET overflows in |
237 | the signed target pointer arithmetics for function FUNC. Otherwise | |
238 | return FALSE. */ | |
239 | ||
240 | bool | |
241 | frame_offset_overflow (HOST_WIDE_INT offset, tree func) | |
242 | { | |
243 | unsigned HOST_WIDE_INT size = FRAME_GROWS_DOWNWARD ? -offset : offset; | |
244 | ||
245 | if (size > ((unsigned HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (Pmode) - 1)) | |
246 | /* Leave room for the fixed part of the frame. */ | |
247 | - 64 * UNITS_PER_WORD) | |
248 | { | |
249 | error ("%Jtotal size of local objects too large", func); | |
250 | return TRUE; | |
251 | } | |
252 | ||
253 | return FALSE; | |
254 | } | |
255 | ||
76fe54f0 L |
256 | /* Return stack slot alignment in bits for TYPE and MODE. */ |
257 | ||
258 | static unsigned int | |
259 | get_stack_local_alignment (tree type, enum machine_mode mode) | |
260 | { | |
261 | unsigned int alignment; | |
262 | ||
263 | if (mode == BLKmode) | |
264 | alignment = BIGGEST_ALIGNMENT; | |
265 | else | |
266 | alignment = GET_MODE_ALIGNMENT (mode); | |
267 | ||
268 | /* Allow the frond-end to (possibly) increase the alignment of this | |
269 | stack slot. */ | |
270 | if (! type) | |
271 | type = lang_hooks.types.type_for_mode (mode, 0); | |
272 | ||
273 | return STACK_SLOT_ALIGNMENT (type, mode, alignment); | |
274 | } | |
275 | ||
6f086dfc RS |
276 | /* Allocate a stack slot of SIZE bytes and return a MEM rtx for it |
277 | with machine mode MODE. | |
718fe406 | 278 | |
6f086dfc RS |
279 | ALIGN controls the amount of alignment for the address of the slot: |
280 | 0 means according to MODE, | |
281 | -1 means use BIGGEST_ALIGNMENT and round size to multiple of that, | |
cfa29a4c | 282 | -2 means use BITS_PER_UNIT, |
6f086dfc RS |
283 | positive specifies alignment boundary in bits. |
284 | ||
2e3f842f L |
285 | If REDUCE_ALIGNMENT_OK is true, it is OK to reduce alignment. |
286 | ||
bd60bab2 | 287 | We do not round to stack_boundary here. */ |
6f086dfc | 288 | |
bd60bab2 | 289 | rtx |
2e3f842f L |
290 | assign_stack_local_1 (enum machine_mode mode, HOST_WIDE_INT size, |
291 | int align, | |
292 | bool reduce_alignment_ok ATTRIBUTE_UNUSED) | |
6f086dfc | 293 | { |
b3694847 | 294 | rtx x, addr; |
6f086dfc | 295 | int bigend_correction = 0; |
76fe54f0 | 296 | unsigned int alignment, alignment_in_bits; |
58dbcf05 | 297 | int frame_off, frame_alignment, frame_phase; |
6f086dfc RS |
298 | |
299 | if (align == 0) | |
300 | { | |
76fe54f0 | 301 | alignment = get_stack_local_alignment (NULL, mode); |
d16790f2 | 302 | alignment /= BITS_PER_UNIT; |
6f086dfc RS |
303 | } |
304 | else if (align == -1) | |
305 | { | |
306 | alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT; | |
307 | size = CEIL_ROUND (size, alignment); | |
308 | } | |
cfa29a4c EB |
309 | else if (align == -2) |
310 | alignment = 1; /* BITS_PER_UNIT / BITS_PER_UNIT */ | |
6f086dfc RS |
311 | else |
312 | alignment = align / BITS_PER_UNIT; | |
313 | ||
2e3f842f L |
314 | alignment_in_bits = alignment * BITS_PER_UNIT; |
315 | ||
f62c8a5c | 316 | if (FRAME_GROWS_DOWNWARD) |
bd60bab2 | 317 | frame_offset -= size; |
1474e303 | 318 | |
2e3f842f L |
319 | /* Ignore alignment if it exceeds MAX_SUPPORTED_STACK_ALIGNMENT. */ |
320 | if (alignment_in_bits > MAX_SUPPORTED_STACK_ALIGNMENT) | |
321 | { | |
322 | alignment_in_bits = MAX_SUPPORTED_STACK_ALIGNMENT; | |
323 | alignment = alignment_in_bits / BITS_PER_UNIT; | |
324 | } | |
a0871656 | 325 | |
2e3f842f L |
326 | if (SUPPORTS_STACK_ALIGNMENT) |
327 | { | |
328 | if (crtl->stack_alignment_estimated < alignment_in_bits) | |
329 | { | |
330 | if (!crtl->stack_realign_processed) | |
331 | crtl->stack_alignment_estimated = alignment_in_bits; | |
332 | else | |
333 | { | |
334 | /* If stack is realigned and stack alignment value | |
335 | hasn't been finalized, it is OK not to increase | |
336 | stack_alignment_estimated. The bigger alignment | |
337 | requirement is recorded in stack_alignment_needed | |
338 | below. */ | |
339 | gcc_assert (!crtl->stack_realign_finalized); | |
340 | if (!crtl->stack_realign_needed) | |
341 | { | |
342 | /* It is OK to reduce the alignment as long as the | |
343 | requested size is 0 or the estimated stack | |
344 | alignment >= mode alignment. */ | |
345 | gcc_assert (reduce_alignment_ok | |
346 | || size == 0 | |
347 | || (crtl->stack_alignment_estimated | |
348 | >= GET_MODE_ALIGNMENT (mode))); | |
349 | alignment_in_bits = crtl->stack_alignment_estimated; | |
350 | alignment = alignment_in_bits / BITS_PER_UNIT; | |
351 | } | |
352 | } | |
353 | } | |
354 | } | |
76fe54f0 L |
355 | |
356 | if (crtl->stack_alignment_needed < alignment_in_bits) | |
357 | crtl->stack_alignment_needed = alignment_in_bits; | |
2e3f842f L |
358 | if (crtl->max_used_stack_slot_alignment < crtl->stack_alignment_needed) |
359 | crtl->max_used_stack_slot_alignment = crtl->stack_alignment_needed; | |
a0871656 | 360 | |
58dbcf05 AH |
361 | /* Calculate how many bytes the start of local variables is off from |
362 | stack alignment. */ | |
363 | frame_alignment = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT; | |
364 | frame_off = STARTING_FRAME_OFFSET % frame_alignment; | |
365 | frame_phase = frame_off ? frame_alignment - frame_off : 0; | |
366 | ||
95f3f59e JDA |
367 | /* Round the frame offset to the specified alignment. The default is |
368 | to always honor requests to align the stack but a port may choose to | |
369 | do its own stack alignment by defining STACK_ALIGNMENT_NEEDED. */ | |
370 | if (STACK_ALIGNMENT_NEEDED | |
371 | || mode != BLKmode | |
372 | || size != 0) | |
373 | { | |
374 | /* We must be careful here, since FRAME_OFFSET might be negative and | |
375 | division with a negative dividend isn't as well defined as we might | |
376 | like. So we instead assume that ALIGNMENT is a power of two and | |
377 | use logical operations which are unambiguous. */ | |
f62c8a5c | 378 | if (FRAME_GROWS_DOWNWARD) |
bd60bab2 JH |
379 | frame_offset |
380 | = (FLOOR_ROUND (frame_offset - frame_phase, | |
f62c8a5c JJ |
381 | (unsigned HOST_WIDE_INT) alignment) |
382 | + frame_phase); | |
383 | else | |
bd60bab2 JH |
384 | frame_offset |
385 | = (CEIL_ROUND (frame_offset - frame_phase, | |
f62c8a5c JJ |
386 | (unsigned HOST_WIDE_INT) alignment) |
387 | + frame_phase); | |
95f3f59e | 388 | } |
6f086dfc RS |
389 | |
390 | /* On a big-endian machine, if we are allocating more space than we will use, | |
391 | use the least significant bytes of those that are allocated. */ | |
d70eadf7 | 392 | if (BYTES_BIG_ENDIAN && mode != BLKmode && GET_MODE_SIZE (mode) < size) |
6f086dfc | 393 | bigend_correction = size - GET_MODE_SIZE (mode); |
6f086dfc | 394 | |
6f086dfc RS |
395 | /* If we have already instantiated virtual registers, return the actual |
396 | address relative to the frame pointer. */ | |
bd60bab2 | 397 | if (virtuals_instantiated) |
6f086dfc | 398 | addr = plus_constant (frame_pointer_rtx, |
c41536f5 | 399 | trunc_int_for_mode |
6f086dfc | 400 | (frame_offset + bigend_correction |
c41536f5 | 401 | + STARTING_FRAME_OFFSET, Pmode)); |
6f086dfc RS |
402 | else |
403 | addr = plus_constant (virtual_stack_vars_rtx, | |
c41536f5 | 404 | trunc_int_for_mode |
bd60bab2 | 405 | (frame_offset + bigend_correction, |
c41536f5 | 406 | Pmode)); |
6f086dfc | 407 | |
f62c8a5c | 408 | if (!FRAME_GROWS_DOWNWARD) |
bd60bab2 | 409 | frame_offset += size; |
6f086dfc | 410 | |
38a448ca | 411 | x = gen_rtx_MEM (mode, addr); |
76fe54f0 | 412 | set_mem_align (x, alignment_in_bits); |
be0c514c | 413 | MEM_NOTRAP_P (x) = 1; |
6f086dfc | 414 | |
bd60bab2 JH |
415 | stack_slot_list |
416 | = gen_rtx_EXPR_LIST (VOIDmode, x, stack_slot_list); | |
e2ecd91c | 417 | |
bd60bab2 JH |
418 | if (frame_offset_overflow (frame_offset, current_function_decl)) |
419 | frame_offset = 0; | |
9070115b | 420 | |
6f086dfc RS |
421 | return x; |
422 | } | |
2e3f842f L |
423 | |
424 | /* Wrap up assign_stack_local_1 with last parameter as false. */ | |
425 | ||
426 | rtx | |
427 | assign_stack_local (enum machine_mode mode, HOST_WIDE_INT size, int align) | |
428 | { | |
429 | return assign_stack_local_1 (mode, size, align, false); | |
430 | } | |
0aea6467 | 431 | \f |
fb0703f7 SB |
432 | \f |
433 | /* In order to evaluate some expressions, such as function calls returning | |
434 | structures in memory, we need to temporarily allocate stack locations. | |
435 | We record each allocated temporary in the following structure. | |
436 | ||
437 | Associated with each temporary slot is a nesting level. When we pop up | |
438 | one level, all temporaries associated with the previous level are freed. | |
439 | Normally, all temporaries are freed after the execution of the statement | |
440 | in which they were created. However, if we are inside a ({...}) grouping, | |
441 | the result may be in a temporary and hence must be preserved. If the | |
442 | result could be in a temporary, we preserve it if we can determine which | |
443 | one it is in. If we cannot determine which temporary may contain the | |
444 | result, all temporaries are preserved. A temporary is preserved by | |
445 | pretending it was allocated at the previous nesting level. | |
446 | ||
447 | Automatic variables are also assigned temporary slots, at the nesting | |
448 | level where they are defined. They are marked a "kept" so that | |
449 | free_temp_slots will not free them. */ | |
450 | ||
d1b38208 | 451 | struct GTY(()) temp_slot { |
fb0703f7 SB |
452 | /* Points to next temporary slot. */ |
453 | struct temp_slot *next; | |
454 | /* Points to previous temporary slot. */ | |
455 | struct temp_slot *prev; | |
456 | /* The rtx to used to reference the slot. */ | |
457 | rtx slot; | |
fb0703f7 SB |
458 | /* The size, in units, of the slot. */ |
459 | HOST_WIDE_INT size; | |
460 | /* The type of the object in the slot, or zero if it doesn't correspond | |
461 | to a type. We use this to determine whether a slot can be reused. | |
462 | It can be reused if objects of the type of the new slot will always | |
463 | conflict with objects of the type of the old slot. */ | |
464 | tree type; | |
8f5929e1 JJ |
465 | /* The alignment (in bits) of the slot. */ |
466 | unsigned int align; | |
fb0703f7 SB |
467 | /* Nonzero if this temporary is currently in use. */ |
468 | char in_use; | |
469 | /* Nonzero if this temporary has its address taken. */ | |
470 | char addr_taken; | |
471 | /* Nesting level at which this slot is being used. */ | |
472 | int level; | |
473 | /* Nonzero if this should survive a call to free_temp_slots. */ | |
474 | int keep; | |
475 | /* The offset of the slot from the frame_pointer, including extra space | |
476 | for alignment. This info is for combine_temp_slots. */ | |
477 | HOST_WIDE_INT base_offset; | |
478 | /* The size of the slot, including extra space for alignment. This | |
479 | info is for combine_temp_slots. */ | |
480 | HOST_WIDE_INT full_size; | |
481 | }; | |
482 | ||
483 | /* A table of addresses that represent a stack slot. The table is a mapping | |
484 | from address RTXen to a temp slot. */ | |
485 | static GTY((param_is(struct temp_slot_address_entry))) htab_t temp_slot_address_table; | |
486 | ||
487 | /* Entry for the above hash table. */ | |
d1b38208 | 488 | struct GTY(()) temp_slot_address_entry { |
fb0703f7 SB |
489 | hashval_t hash; |
490 | rtx address; | |
491 | struct temp_slot *temp_slot; | |
492 | }; | |
493 | ||
0aea6467 ZD |
494 | /* Removes temporary slot TEMP from LIST. */ |
495 | ||
496 | static void | |
497 | cut_slot_from_list (struct temp_slot *temp, struct temp_slot **list) | |
498 | { | |
499 | if (temp->next) | |
500 | temp->next->prev = temp->prev; | |
501 | if (temp->prev) | |
502 | temp->prev->next = temp->next; | |
503 | else | |
504 | *list = temp->next; | |
505 | ||
506 | temp->prev = temp->next = NULL; | |
507 | } | |
508 | ||
509 | /* Inserts temporary slot TEMP to LIST. */ | |
510 | ||
511 | static void | |
512 | insert_slot_to_list (struct temp_slot *temp, struct temp_slot **list) | |
513 | { | |
514 | temp->next = *list; | |
515 | if (*list) | |
516 | (*list)->prev = temp; | |
517 | temp->prev = NULL; | |
518 | *list = temp; | |
519 | } | |
520 | ||
521 | /* Returns the list of used temp slots at LEVEL. */ | |
522 | ||
523 | static struct temp_slot ** | |
524 | temp_slots_at_level (int level) | |
525 | { | |
6370682a | 526 | if (level >= (int) VEC_length (temp_slot_p, used_temp_slots)) |
a590ac65 | 527 | VEC_safe_grow_cleared (temp_slot_p, gc, used_temp_slots, level + 1); |
0aea6467 | 528 | |
6370682a | 529 | return &(VEC_address (temp_slot_p, used_temp_slots)[level]); |
0aea6467 ZD |
530 | } |
531 | ||
532 | /* Returns the maximal temporary slot level. */ | |
533 | ||
534 | static int | |
535 | max_slot_level (void) | |
536 | { | |
537 | if (!used_temp_slots) | |
538 | return -1; | |
539 | ||
6370682a | 540 | return VEC_length (temp_slot_p, used_temp_slots) - 1; |
0aea6467 ZD |
541 | } |
542 | ||
543 | /* Moves temporary slot TEMP to LEVEL. */ | |
544 | ||
545 | static void | |
546 | move_slot_to_level (struct temp_slot *temp, int level) | |
547 | { | |
548 | cut_slot_from_list (temp, temp_slots_at_level (temp->level)); | |
549 | insert_slot_to_list (temp, temp_slots_at_level (level)); | |
550 | temp->level = level; | |
551 | } | |
552 | ||
553 | /* Make temporary slot TEMP available. */ | |
554 | ||
555 | static void | |
556 | make_slot_available (struct temp_slot *temp) | |
557 | { | |
558 | cut_slot_from_list (temp, temp_slots_at_level (temp->level)); | |
559 | insert_slot_to_list (temp, &avail_temp_slots); | |
560 | temp->in_use = 0; | |
561 | temp->level = -1; | |
562 | } | |
fb0703f7 SB |
563 | |
564 | /* Compute the hash value for an address -> temp slot mapping. | |
565 | The value is cached on the mapping entry. */ | |
566 | static hashval_t | |
567 | temp_slot_address_compute_hash (struct temp_slot_address_entry *t) | |
568 | { | |
569 | int do_not_record = 0; | |
570 | return hash_rtx (t->address, GET_MODE (t->address), | |
571 | &do_not_record, NULL, false); | |
572 | } | |
573 | ||
574 | /* Return the hash value for an address -> temp slot mapping. */ | |
575 | static hashval_t | |
576 | temp_slot_address_hash (const void *p) | |
577 | { | |
578 | const struct temp_slot_address_entry *t; | |
579 | t = (const struct temp_slot_address_entry *) p; | |
580 | return t->hash; | |
581 | } | |
582 | ||
583 | /* Compare two address -> temp slot mapping entries. */ | |
584 | static int | |
585 | temp_slot_address_eq (const void *p1, const void *p2) | |
586 | { | |
587 | const struct temp_slot_address_entry *t1, *t2; | |
588 | t1 = (const struct temp_slot_address_entry *) p1; | |
589 | t2 = (const struct temp_slot_address_entry *) p2; | |
590 | return exp_equiv_p (t1->address, t2->address, 0, true); | |
591 | } | |
592 | ||
593 | /* Add ADDRESS as an alias of TEMP_SLOT to the addess -> temp slot mapping. */ | |
594 | static void | |
595 | insert_temp_slot_address (rtx address, struct temp_slot *temp_slot) | |
596 | { | |
597 | void **slot; | |
598 | struct temp_slot_address_entry *t = GGC_NEW (struct temp_slot_address_entry); | |
599 | t->address = address; | |
600 | t->temp_slot = temp_slot; | |
601 | t->hash = temp_slot_address_compute_hash (t); | |
602 | slot = htab_find_slot_with_hash (temp_slot_address_table, t, t->hash, INSERT); | |
603 | *slot = t; | |
604 | } | |
605 | ||
606 | /* Remove an address -> temp slot mapping entry if the temp slot is | |
607 | not in use anymore. Callback for remove_unused_temp_slot_addresses. */ | |
608 | static int | |
609 | remove_unused_temp_slot_addresses_1 (void **slot, void *data ATTRIBUTE_UNUSED) | |
610 | { | |
611 | const struct temp_slot_address_entry *t; | |
612 | t = (const struct temp_slot_address_entry *) *slot; | |
613 | if (! t->temp_slot->in_use) | |
614 | *slot = NULL; | |
615 | return 1; | |
616 | } | |
617 | ||
618 | /* Remove all mappings of addresses to unused temp slots. */ | |
619 | static void | |
620 | remove_unused_temp_slot_addresses (void) | |
621 | { | |
622 | htab_traverse (temp_slot_address_table, | |
623 | remove_unused_temp_slot_addresses_1, | |
624 | NULL); | |
625 | } | |
626 | ||
627 | /* Find the temp slot corresponding to the object at address X. */ | |
628 | ||
629 | static struct temp_slot * | |
630 | find_temp_slot_from_address (rtx x) | |
631 | { | |
632 | struct temp_slot *p; | |
633 | struct temp_slot_address_entry tmp, *t; | |
634 | ||
635 | /* First try the easy way: | |
636 | See if X exists in the address -> temp slot mapping. */ | |
637 | tmp.address = x; | |
638 | tmp.temp_slot = NULL; | |
639 | tmp.hash = temp_slot_address_compute_hash (&tmp); | |
640 | t = (struct temp_slot_address_entry *) | |
641 | htab_find_with_hash (temp_slot_address_table, &tmp, tmp.hash); | |
642 | if (t) | |
643 | return t->temp_slot; | |
644 | ||
645 | /* If we have a sum involving a register, see if it points to a temp | |
646 | slot. */ | |
647 | if (GET_CODE (x) == PLUS && REG_P (XEXP (x, 0)) | |
648 | && (p = find_temp_slot_from_address (XEXP (x, 0))) != 0) | |
649 | return p; | |
650 | else if (GET_CODE (x) == PLUS && REG_P (XEXP (x, 1)) | |
651 | && (p = find_temp_slot_from_address (XEXP (x, 1))) != 0) | |
652 | return p; | |
653 | ||
654 | /* Last resort: Address is a virtual stack var address. */ | |
655 | if (GET_CODE (x) == PLUS | |
656 | && XEXP (x, 0) == virtual_stack_vars_rtx | |
657 | && GET_CODE (XEXP (x, 1)) == CONST_INT) | |
658 | { | |
659 | int i; | |
660 | for (i = max_slot_level (); i >= 0; i--) | |
661 | for (p = *temp_slots_at_level (i); p; p = p->next) | |
662 | { | |
663 | if (INTVAL (XEXP (x, 1)) >= p->base_offset | |
664 | && INTVAL (XEXP (x, 1)) < p->base_offset + p->full_size) | |
665 | return p; | |
666 | } | |
667 | } | |
668 | ||
669 | return NULL; | |
670 | } | |
6f086dfc RS |
671 | \f |
672 | /* Allocate a temporary stack slot and record it for possible later | |
673 | reuse. | |
674 | ||
675 | MODE is the machine mode to be given to the returned rtx. | |
676 | ||
677 | SIZE is the size in units of the space required. We do no rounding here | |
678 | since assign_stack_local will do any required rounding. | |
679 | ||
d93d4205 MS |
680 | KEEP is 1 if this slot is to be retained after a call to |
681 | free_temp_slots. Automatic variables for a block are allocated | |
7efcb746 PB |
682 | with this flag. KEEP values of 2 or 3 were needed respectively |
683 | for variables whose lifetime is controlled by CLEANUP_POINT_EXPRs | |
535a42b1 | 684 | or for SAVE_EXPRs, but they are now unused. |
a4c6502a MM |
685 | |
686 | TYPE is the type that will be used for the stack slot. */ | |
6f086dfc | 687 | |
a06ef755 | 688 | rtx |
535a42b1 NS |
689 | assign_stack_temp_for_type (enum machine_mode mode, HOST_WIDE_INT size, |
690 | int keep, tree type) | |
6f086dfc | 691 | { |
74e2819c | 692 | unsigned int align; |
0aea6467 | 693 | struct temp_slot *p, *best_p = 0, *selected = NULL, **pp; |
faa964e5 | 694 | rtx slot; |
6f086dfc | 695 | |
303ec2aa RK |
696 | /* If SIZE is -1 it means that somebody tried to allocate a temporary |
697 | of a variable size. */ | |
0bccc606 | 698 | gcc_assert (size != -1); |
303ec2aa | 699 | |
7efcb746 | 700 | /* These are now unused. */ |
0bccc606 | 701 | gcc_assert (keep <= 1); |
7efcb746 | 702 | |
76fe54f0 | 703 | align = get_stack_local_alignment (type, mode); |
d16790f2 JW |
704 | |
705 | /* Try to find an available, already-allocated temporary of the proper | |
706 | mode which meets the size and alignment requirements. Choose the | |
3e8b0446 ZD |
707 | smallest one with the closest alignment. |
708 | ||
709 | If assign_stack_temp is called outside of the tree->rtl expansion, | |
710 | we cannot reuse the stack slots (that may still refer to | |
711 | VIRTUAL_STACK_VARS_REGNUM). */ | |
712 | if (!virtuals_instantiated) | |
0aea6467 | 713 | { |
3e8b0446 | 714 | for (p = avail_temp_slots; p; p = p->next) |
0aea6467 | 715 | { |
3e8b0446 ZD |
716 | if (p->align >= align && p->size >= size |
717 | && GET_MODE (p->slot) == mode | |
718 | && objects_must_conflict_p (p->type, type) | |
719 | && (best_p == 0 || best_p->size > p->size | |
720 | || (best_p->size == p->size && best_p->align > p->align))) | |
0aea6467 | 721 | { |
3e8b0446 ZD |
722 | if (p->align == align && p->size == size) |
723 | { | |
724 | selected = p; | |
725 | cut_slot_from_list (selected, &avail_temp_slots); | |
726 | best_p = 0; | |
727 | break; | |
728 | } | |
729 | best_p = p; | |
0aea6467 | 730 | } |
0aea6467 ZD |
731 | } |
732 | } | |
6f086dfc RS |
733 | |
734 | /* Make our best, if any, the one to use. */ | |
735 | if (best_p) | |
a45035b6 | 736 | { |
0aea6467 ZD |
737 | selected = best_p; |
738 | cut_slot_from_list (selected, &avail_temp_slots); | |
739 | ||
a45035b6 JW |
740 | /* If there are enough aligned bytes left over, make them into a new |
741 | temp_slot so that the extra bytes don't get wasted. Do this only | |
742 | for BLKmode slots, so that we can be sure of the alignment. */ | |
3bdf5ad1 | 743 | if (GET_MODE (best_p->slot) == BLKmode) |
a45035b6 | 744 | { |
d16790f2 | 745 | int alignment = best_p->align / BITS_PER_UNIT; |
e5e809f4 | 746 | HOST_WIDE_INT rounded_size = CEIL_ROUND (size, alignment); |
a45035b6 JW |
747 | |
748 | if (best_p->size - rounded_size >= alignment) | |
749 | { | |
1b4572a8 | 750 | p = GGC_NEW (struct temp_slot); |
a25d4ba2 | 751 | p->in_use = p->addr_taken = 0; |
a45035b6 | 752 | p->size = best_p->size - rounded_size; |
307d8cd6 RK |
753 | p->base_offset = best_p->base_offset + rounded_size; |
754 | p->full_size = best_p->full_size - rounded_size; | |
be0c514c | 755 | p->slot = adjust_address_nv (best_p->slot, BLKmode, rounded_size); |
d16790f2 | 756 | p->align = best_p->align; |
1da68f56 | 757 | p->type = best_p->type; |
0aea6467 | 758 | insert_slot_to_list (p, &avail_temp_slots); |
a45035b6 | 759 | |
38a448ca RH |
760 | stack_slot_list = gen_rtx_EXPR_LIST (VOIDmode, p->slot, |
761 | stack_slot_list); | |
a45035b6 JW |
762 | |
763 | best_p->size = rounded_size; | |
291dde90 | 764 | best_p->full_size = rounded_size; |
a45035b6 JW |
765 | } |
766 | } | |
a45035b6 | 767 | } |
718fe406 | 768 | |
6f086dfc | 769 | /* If we still didn't find one, make a new temporary. */ |
0aea6467 | 770 | if (selected == 0) |
6f086dfc | 771 | { |
e5e809f4 JL |
772 | HOST_WIDE_INT frame_offset_old = frame_offset; |
773 | ||
1b4572a8 | 774 | p = GGC_NEW (struct temp_slot); |
e5e809f4 | 775 | |
c87a0a39 JL |
776 | /* We are passing an explicit alignment request to assign_stack_local. |
777 | One side effect of that is assign_stack_local will not round SIZE | |
778 | to ensure the frame offset remains suitably aligned. | |
779 | ||
780 | So for requests which depended on the rounding of SIZE, we go ahead | |
781 | and round it now. We also make sure ALIGNMENT is at least | |
782 | BIGGEST_ALIGNMENT. */ | |
0bccc606 | 783 | gcc_assert (mode != BLKmode || align == BIGGEST_ALIGNMENT); |
6f67a30d | 784 | p->slot = assign_stack_local (mode, |
010529e5 | 785 | (mode == BLKmode |
fc555370 | 786 | ? CEIL_ROUND (size, (int) align / BITS_PER_UNIT) |
010529e5 | 787 | : size), |
6f67a30d | 788 | align); |
d16790f2 JW |
789 | |
790 | p->align = align; | |
e5e809f4 | 791 | |
b2a80c0d DE |
792 | /* The following slot size computation is necessary because we don't |
793 | know the actual size of the temporary slot until assign_stack_local | |
794 | has performed all the frame alignment and size rounding for the | |
fc91b0d0 RK |
795 | requested temporary. Note that extra space added for alignment |
796 | can be either above or below this stack slot depending on which | |
797 | way the frame grows. We include the extra space if and only if it | |
798 | is above this slot. */ | |
f62c8a5c JJ |
799 | if (FRAME_GROWS_DOWNWARD) |
800 | p->size = frame_offset_old - frame_offset; | |
801 | else | |
802 | p->size = size; | |
e5e809f4 | 803 | |
fc91b0d0 | 804 | /* Now define the fields used by combine_temp_slots. */ |
f62c8a5c JJ |
805 | if (FRAME_GROWS_DOWNWARD) |
806 | { | |
807 | p->base_offset = frame_offset; | |
808 | p->full_size = frame_offset_old - frame_offset; | |
809 | } | |
810 | else | |
811 | { | |
812 | p->base_offset = frame_offset_old; | |
813 | p->full_size = frame_offset - frame_offset_old; | |
814 | } | |
0aea6467 ZD |
815 | |
816 | selected = p; | |
6f086dfc RS |
817 | } |
818 | ||
0aea6467 | 819 | p = selected; |
6f086dfc | 820 | p->in_use = 1; |
a25d4ba2 | 821 | p->addr_taken = 0; |
1da68f56 | 822 | p->type = type; |
7efcb746 PB |
823 | p->level = temp_slot_level; |
824 | p->keep = keep; | |
1995f267 | 825 | |
0aea6467 ZD |
826 | pp = temp_slots_at_level (p->level); |
827 | insert_slot_to_list (p, pp); | |
fb0703f7 | 828 | insert_temp_slot_address (XEXP (p->slot, 0), p); |
faa964e5 UW |
829 | |
830 | /* Create a new MEM rtx to avoid clobbering MEM flags of old slots. */ | |
831 | slot = gen_rtx_MEM (mode, XEXP (p->slot, 0)); | |
832 | stack_slot_list = gen_rtx_EXPR_LIST (VOIDmode, slot, stack_slot_list); | |
3bdf5ad1 | 833 | |
1da68f56 RK |
834 | /* If we know the alias set for the memory that will be used, use |
835 | it. If there's no TYPE, then we don't know anything about the | |
836 | alias set for the memory. */ | |
faa964e5 UW |
837 | set_mem_alias_set (slot, type ? get_alias_set (type) : 0); |
838 | set_mem_align (slot, align); | |
1da68f56 | 839 | |
30f7a378 | 840 | /* If a type is specified, set the relevant flags. */ |
3bdf5ad1 | 841 | if (type != 0) |
1da68f56 | 842 | { |
faa964e5 | 843 | MEM_VOLATILE_P (slot) = TYPE_VOLATILE (type); |
07cb6e8c JM |
844 | MEM_SET_IN_STRUCT_P (slot, (AGGREGATE_TYPE_P (type) |
845 | || TREE_CODE (type) == COMPLEX_TYPE)); | |
1da68f56 | 846 | } |
be0c514c | 847 | MEM_NOTRAP_P (slot) = 1; |
3bdf5ad1 | 848 | |
faa964e5 | 849 | return slot; |
6f086dfc | 850 | } |
d16790f2 JW |
851 | |
852 | /* Allocate a temporary stack slot and record it for possible later | |
853 | reuse. First three arguments are same as in preceding function. */ | |
854 | ||
855 | rtx | |
fa8db1f7 | 856 | assign_stack_temp (enum machine_mode mode, HOST_WIDE_INT size, int keep) |
d16790f2 JW |
857 | { |
858 | return assign_stack_temp_for_type (mode, size, keep, NULL_TREE); | |
859 | } | |
638141a6 | 860 | \f |
9432c136 EB |
861 | /* Assign a temporary. |
862 | If TYPE_OR_DECL is a decl, then we are doing it on behalf of the decl | |
863 | and so that should be used in error messages. In either case, we | |
864 | allocate of the given type. | |
230f21b4 PB |
865 | KEEP is as for assign_stack_temp. |
866 | MEMORY_REQUIRED is 1 if the result must be addressable stack memory; | |
b55d9ff8 RK |
867 | it is 0 if a register is OK. |
868 | DONT_PROMOTE is 1 if we should not promote values in register | |
869 | to wider modes. */ | |
230f21b4 PB |
870 | |
871 | rtx | |
fa8db1f7 AJ |
872 | assign_temp (tree type_or_decl, int keep, int memory_required, |
873 | int dont_promote ATTRIBUTE_UNUSED) | |
230f21b4 | 874 | { |
9432c136 EB |
875 | tree type, decl; |
876 | enum machine_mode mode; | |
9e1622ed | 877 | #ifdef PROMOTE_MODE |
9432c136 EB |
878 | int unsignedp; |
879 | #endif | |
880 | ||
881 | if (DECL_P (type_or_decl)) | |
882 | decl = type_or_decl, type = TREE_TYPE (decl); | |
883 | else | |
884 | decl = NULL, type = type_or_decl; | |
885 | ||
886 | mode = TYPE_MODE (type); | |
9e1622ed | 887 | #ifdef PROMOTE_MODE |
8df83eae | 888 | unsignedp = TYPE_UNSIGNED (type); |
0ce8a59c | 889 | #endif |
638141a6 | 890 | |
230f21b4 PB |
891 | if (mode == BLKmode || memory_required) |
892 | { | |
e5e809f4 | 893 | HOST_WIDE_INT size = int_size_in_bytes (type); |
230f21b4 PB |
894 | rtx tmp; |
895 | ||
44affdae JH |
896 | /* Zero sized arrays are GNU C extension. Set size to 1 to avoid |
897 | problems with allocating the stack space. */ | |
898 | if (size == 0) | |
899 | size = 1; | |
900 | ||
230f21b4 | 901 | /* Unfortunately, we don't yet know how to allocate variable-sized |
a441447f OH |
902 | temporaries. However, sometimes we can find a fixed upper limit on |
903 | the size, so try that instead. */ | |
904 | else if (size == -1) | |
905 | size = max_int_size_in_bytes (type); | |
e30bb772 | 906 | |
9432c136 EB |
907 | /* The size of the temporary may be too large to fit into an integer. */ |
908 | /* ??? Not sure this should happen except for user silliness, so limit | |
797a6ac1 | 909 | this to things that aren't compiler-generated temporaries. The |
535a42b1 | 910 | rest of the time we'll die in assign_stack_temp_for_type. */ |
9432c136 EB |
911 | if (decl && size == -1 |
912 | && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST) | |
913 | { | |
dee15844 | 914 | error ("size of variable %q+D is too large", decl); |
9432c136 EB |
915 | size = 1; |
916 | } | |
917 | ||
d16790f2 | 918 | tmp = assign_stack_temp_for_type (mode, size, keep, type); |
230f21b4 PB |
919 | return tmp; |
920 | } | |
638141a6 | 921 | |
9e1622ed | 922 | #ifdef PROMOTE_MODE |
b55d9ff8 RK |
923 | if (! dont_promote) |
924 | mode = promote_mode (type, mode, &unsignedp, 0); | |
230f21b4 | 925 | #endif |
638141a6 | 926 | |
230f21b4 PB |
927 | return gen_reg_rtx (mode); |
928 | } | |
638141a6 | 929 | \f |
a45035b6 JW |
930 | /* Combine temporary stack slots which are adjacent on the stack. |
931 | ||
932 | This allows for better use of already allocated stack space. This is only | |
933 | done for BLKmode slots because we can be sure that we won't have alignment | |
934 | problems in this case. */ | |
935 | ||
6fe79279 | 936 | static void |
fa8db1f7 | 937 | combine_temp_slots (void) |
a45035b6 | 938 | { |
0aea6467 | 939 | struct temp_slot *p, *q, *next, *next_q; |
e5e809f4 JL |
940 | int num_slots; |
941 | ||
a4c6502a MM |
942 | /* We can't combine slots, because the information about which slot |
943 | is in which alias set will be lost. */ | |
944 | if (flag_strict_aliasing) | |
945 | return; | |
946 | ||
718fe406 | 947 | /* If there are a lot of temp slots, don't do anything unless |
d6a7951f | 948 | high levels of optimization. */ |
e5e809f4 | 949 | if (! flag_expensive_optimizations) |
0aea6467 | 950 | for (p = avail_temp_slots, num_slots = 0; p; p = p->next, num_slots++) |
e5e809f4 JL |
951 | if (num_slots > 100 || (num_slots > 10 && optimize == 0)) |
952 | return; | |
a45035b6 | 953 | |
0aea6467 | 954 | for (p = avail_temp_slots; p; p = next) |
e9b7093a RS |
955 | { |
956 | int delete_p = 0; | |
e5e809f4 | 957 | |
0aea6467 ZD |
958 | next = p->next; |
959 | ||
960 | if (GET_MODE (p->slot) != BLKmode) | |
961 | continue; | |
962 | ||
963 | for (q = p->next; q; q = next_q) | |
e9b7093a | 964 | { |
0aea6467 ZD |
965 | int delete_q = 0; |
966 | ||
967 | next_q = q->next; | |
968 | ||
969 | if (GET_MODE (q->slot) != BLKmode) | |
970 | continue; | |
971 | ||
972 | if (p->base_offset + p->full_size == q->base_offset) | |
973 | { | |
974 | /* Q comes after P; combine Q into P. */ | |
975 | p->size += q->size; | |
976 | p->full_size += q->full_size; | |
977 | delete_q = 1; | |
978 | } | |
979 | else if (q->base_offset + q->full_size == p->base_offset) | |
980 | { | |
981 | /* P comes after Q; combine P into Q. */ | |
982 | q->size += p->size; | |
983 | q->full_size += p->full_size; | |
984 | delete_p = 1; | |
985 | break; | |
986 | } | |
987 | if (delete_q) | |
988 | cut_slot_from_list (q, &avail_temp_slots); | |
e9b7093a | 989 | } |
0aea6467 ZD |
990 | |
991 | /* Either delete P or advance past it. */ | |
992 | if (delete_p) | |
993 | cut_slot_from_list (p, &avail_temp_slots); | |
e9b7093a | 994 | } |
a45035b6 | 995 | } |
6f086dfc | 996 | \f |
82d6e6fc KG |
997 | /* Indicate that NEW_RTX is an alternate way of referring to the temp |
998 | slot that previously was known by OLD_RTX. */ | |
e5e76139 RK |
999 | |
1000 | void | |
82d6e6fc | 1001 | update_temp_slot_address (rtx old_rtx, rtx new_rtx) |
e5e76139 | 1002 | { |
14a774a9 | 1003 | struct temp_slot *p; |
e5e76139 | 1004 | |
82d6e6fc | 1005 | if (rtx_equal_p (old_rtx, new_rtx)) |
e5e76139 | 1006 | return; |
14a774a9 | 1007 | |
82d6e6fc | 1008 | p = find_temp_slot_from_address (old_rtx); |
14a774a9 | 1009 | |
82d6e6fc KG |
1010 | /* If we didn't find one, see if both OLD_RTX is a PLUS. If so, and |
1011 | NEW_RTX is a register, see if one operand of the PLUS is a | |
1012 | temporary location. If so, NEW_RTX points into it. Otherwise, | |
1013 | if both OLD_RTX and NEW_RTX are a PLUS and if there is a register | |
1014 | in common between them. If so, try a recursive call on those | |
1015 | values. */ | |
14a774a9 RK |
1016 | if (p == 0) |
1017 | { | |
82d6e6fc | 1018 | if (GET_CODE (old_rtx) != PLUS) |
700f19f0 RK |
1019 | return; |
1020 | ||
82d6e6fc | 1021 | if (REG_P (new_rtx)) |
700f19f0 | 1022 | { |
82d6e6fc KG |
1023 | update_temp_slot_address (XEXP (old_rtx, 0), new_rtx); |
1024 | update_temp_slot_address (XEXP (old_rtx, 1), new_rtx); | |
700f19f0 RK |
1025 | return; |
1026 | } | |
82d6e6fc | 1027 | else if (GET_CODE (new_rtx) != PLUS) |
14a774a9 RK |
1028 | return; |
1029 | ||
82d6e6fc KG |
1030 | if (rtx_equal_p (XEXP (old_rtx, 0), XEXP (new_rtx, 0))) |
1031 | update_temp_slot_address (XEXP (old_rtx, 1), XEXP (new_rtx, 1)); | |
1032 | else if (rtx_equal_p (XEXP (old_rtx, 1), XEXP (new_rtx, 0))) | |
1033 | update_temp_slot_address (XEXP (old_rtx, 0), XEXP (new_rtx, 1)); | |
1034 | else if (rtx_equal_p (XEXP (old_rtx, 0), XEXP (new_rtx, 1))) | |
1035 | update_temp_slot_address (XEXP (old_rtx, 1), XEXP (new_rtx, 0)); | |
1036 | else if (rtx_equal_p (XEXP (old_rtx, 1), XEXP (new_rtx, 1))) | |
1037 | update_temp_slot_address (XEXP (old_rtx, 0), XEXP (new_rtx, 0)); | |
14a774a9 RK |
1038 | |
1039 | return; | |
1040 | } | |
1041 | ||
718fe406 | 1042 | /* Otherwise add an alias for the temp's address. */ |
fb0703f7 | 1043 | insert_temp_slot_address (new_rtx, p); |
e5e76139 RK |
1044 | } |
1045 | ||
a25d4ba2 | 1046 | /* If X could be a reference to a temporary slot, mark the fact that its |
9faa82d8 | 1047 | address was taken. */ |
a25d4ba2 RK |
1048 | |
1049 | void | |
fa8db1f7 | 1050 | mark_temp_addr_taken (rtx x) |
a25d4ba2 RK |
1051 | { |
1052 | struct temp_slot *p; | |
1053 | ||
1054 | if (x == 0) | |
1055 | return; | |
1056 | ||
1057 | /* If X is not in memory or is at a constant address, it cannot be in | |
1058 | a temporary slot. */ | |
3c0cb5de | 1059 | if (!MEM_P (x) || CONSTANT_P (XEXP (x, 0))) |
a25d4ba2 RK |
1060 | return; |
1061 | ||
1062 | p = find_temp_slot_from_address (XEXP (x, 0)); | |
1063 | if (p != 0) | |
1064 | p->addr_taken = 1; | |
1065 | } | |
1066 | ||
9cca6a99 MS |
1067 | /* If X could be a reference to a temporary slot, mark that slot as |
1068 | belonging to the to one level higher than the current level. If X | |
1069 | matched one of our slots, just mark that one. Otherwise, we can't | |
1070 | easily predict which it is, so upgrade all of them. Kept slots | |
1071 | need not be touched. | |
6f086dfc RS |
1072 | |
1073 | This is called when an ({...}) construct occurs and a statement | |
1074 | returns a value in memory. */ | |
1075 | ||
1076 | void | |
fa8db1f7 | 1077 | preserve_temp_slots (rtx x) |
6f086dfc | 1078 | { |
0aea6467 | 1079 | struct temp_slot *p = 0, *next; |
6f086dfc | 1080 | |
73620b82 RK |
1081 | /* If there is no result, we still might have some objects whose address |
1082 | were taken, so we need to make sure they stay around. */ | |
e3a77161 | 1083 | if (x == 0) |
73620b82 | 1084 | { |
0aea6467 ZD |
1085 | for (p = *temp_slots_at_level (temp_slot_level); p; p = next) |
1086 | { | |
1087 | next = p->next; | |
1088 | ||
1089 | if (p->addr_taken) | |
1090 | move_slot_to_level (p, temp_slot_level - 1); | |
1091 | } | |
73620b82 | 1092 | |
8fff4fc1 RH |
1093 | return; |
1094 | } | |
f7b6d104 | 1095 | |
8fff4fc1 RH |
1096 | /* If X is a register that is being used as a pointer, see if we have |
1097 | a temporary slot we know it points to. To be consistent with | |
1098 | the code below, we really should preserve all non-kept slots | |
1099 | if we can't find a match, but that seems to be much too costly. */ | |
1100 | if (REG_P (x) && REG_POINTER (x)) | |
1101 | p = find_temp_slot_from_address (x); | |
f7b6d104 | 1102 | |
8fff4fc1 RH |
1103 | /* If X is not in memory or is at a constant address, it cannot be in |
1104 | a temporary slot, but it can contain something whose address was | |
1105 | taken. */ | |
1106 | if (p == 0 && (!MEM_P (x) || CONSTANT_P (XEXP (x, 0)))) | |
1107 | { | |
1108 | for (p = *temp_slots_at_level (temp_slot_level); p; p = next) | |
1109 | { | |
1110 | next = p->next; | |
b5bd3b3c | 1111 | |
8fff4fc1 RH |
1112 | if (p->addr_taken) |
1113 | move_slot_to_level (p, temp_slot_level - 1); | |
e9a25f70 | 1114 | } |
c5c76735 | 1115 | |
8fff4fc1 RH |
1116 | return; |
1117 | } | |
1118 | ||
1119 | /* First see if we can find a match. */ | |
1120 | if (p == 0) | |
1121 | p = find_temp_slot_from_address (XEXP (x, 0)); | |
1122 | ||
1123 | if (p != 0) | |
1124 | { | |
1125 | /* Move everything at our level whose address was taken to our new | |
1126 | level in case we used its address. */ | |
1127 | struct temp_slot *q; | |
1128 | ||
1129 | if (p->level == temp_slot_level) | |
fbdfe39c | 1130 | { |
8fff4fc1 | 1131 | for (q = *temp_slots_at_level (temp_slot_level); q; q = next) |
8b04083b | 1132 | { |
8fff4fc1 | 1133 | next = q->next; |
8b04083b | 1134 | |
8fff4fc1 RH |
1135 | if (p != q && q->addr_taken) |
1136 | move_slot_to_level (q, temp_slot_level - 1); | |
8b04083b | 1137 | } |
8fff4fc1 RH |
1138 | |
1139 | move_slot_to_level (p, temp_slot_level - 1); | |
1140 | p->addr_taken = 0; | |
fbdfe39c | 1141 | } |
8fff4fc1 | 1142 | return; |
f7b6d104 | 1143 | } |
e9a25f70 | 1144 | |
8fff4fc1 RH |
1145 | /* Otherwise, preserve all non-kept slots at this level. */ |
1146 | for (p = *temp_slots_at_level (temp_slot_level); p; p = next) | |
e9a25f70 | 1147 | { |
8fff4fc1 | 1148 | next = p->next; |
fe9b4957 | 1149 | |
8fff4fc1 RH |
1150 | if (!p->keep) |
1151 | move_slot_to_level (p, temp_slot_level - 1); | |
1152 | } | |
fe9b4957 MM |
1153 | } |
1154 | ||
8fff4fc1 RH |
1155 | /* Free all temporaries used so far. This is normally called at the |
1156 | end of generating code for a statement. */ | |
fe9b4957 | 1157 | |
8fff4fc1 RH |
1158 | void |
1159 | free_temp_slots (void) | |
fe9b4957 | 1160 | { |
8fff4fc1 | 1161 | struct temp_slot *p, *next; |
fe9b4957 | 1162 | |
8fff4fc1 RH |
1163 | for (p = *temp_slots_at_level (temp_slot_level); p; p = next) |
1164 | { | |
1165 | next = p->next; | |
fe9b4957 | 1166 | |
8fff4fc1 RH |
1167 | if (!p->keep) |
1168 | make_slot_available (p); | |
1169 | } | |
fe9b4957 | 1170 | |
fb0703f7 | 1171 | remove_unused_temp_slot_addresses (); |
8fff4fc1 RH |
1172 | combine_temp_slots (); |
1173 | } | |
fe9b4957 | 1174 | |
8fff4fc1 | 1175 | /* Push deeper into the nesting level for stack temporaries. */ |
fe9b4957 | 1176 | |
8fff4fc1 RH |
1177 | void |
1178 | push_temp_slots (void) | |
fe9b4957 | 1179 | { |
8fff4fc1 | 1180 | temp_slot_level++; |
fe9b4957 MM |
1181 | } |
1182 | ||
8fff4fc1 RH |
1183 | /* Pop a temporary nesting level. All slots in use in the current level |
1184 | are freed. */ | |
fe9b4957 | 1185 | |
8fff4fc1 RH |
1186 | void |
1187 | pop_temp_slots (void) | |
fe9b4957 | 1188 | { |
8fff4fc1 | 1189 | struct temp_slot *p, *next; |
fe9b4957 | 1190 | |
8fff4fc1 RH |
1191 | for (p = *temp_slots_at_level (temp_slot_level); p; p = next) |
1192 | { | |
1193 | next = p->next; | |
1194 | make_slot_available (p); | |
1195 | } | |
e9a25f70 | 1196 | |
fb0703f7 | 1197 | remove_unused_temp_slot_addresses (); |
8fff4fc1 | 1198 | combine_temp_slots (); |
b987f237 | 1199 | |
8fff4fc1 | 1200 | temp_slot_level--; |
8c36698e NC |
1201 | } |
1202 | ||
8fff4fc1 | 1203 | /* Initialize temporary slots. */ |
e9a25f70 JL |
1204 | |
1205 | void | |
8fff4fc1 | 1206 | init_temp_slots (void) |
e9a25f70 | 1207 | { |
8fff4fc1 RH |
1208 | /* We have not allocated any temporaries yet. */ |
1209 | avail_temp_slots = 0; | |
1210 | used_temp_slots = 0; | |
1211 | temp_slot_level = 0; | |
fb0703f7 SB |
1212 | |
1213 | /* Set up the table to map addresses to temp slots. */ | |
1214 | if (! temp_slot_address_table) | |
1215 | temp_slot_address_table = htab_create_ggc (32, | |
1216 | temp_slot_address_hash, | |
1217 | temp_slot_address_eq, | |
1218 | NULL); | |
1219 | else | |
1220 | htab_empty (temp_slot_address_table); | |
8fff4fc1 RH |
1221 | } |
1222 | \f | |
1223 | /* These routines are responsible for converting virtual register references | |
1224 | to the actual hard register references once RTL generation is complete. | |
718fe406 | 1225 | |
8fff4fc1 RH |
1226 | The following four variables are used for communication between the |
1227 | routines. They contain the offsets of the virtual registers from their | |
1228 | respective hard registers. */ | |
fe9b4957 | 1229 | |
8fff4fc1 RH |
1230 | static int in_arg_offset; |
1231 | static int var_offset; | |
1232 | static int dynamic_offset; | |
1233 | static int out_arg_offset; | |
1234 | static int cfa_offset; | |
8a5275eb | 1235 | |
8fff4fc1 RH |
1236 | /* In most machines, the stack pointer register is equivalent to the bottom |
1237 | of the stack. */ | |
718fe406 | 1238 | |
8fff4fc1 RH |
1239 | #ifndef STACK_POINTER_OFFSET |
1240 | #define STACK_POINTER_OFFSET 0 | |
1241 | #endif | |
8c36698e | 1242 | |
8fff4fc1 RH |
1243 | /* If not defined, pick an appropriate default for the offset of dynamically |
1244 | allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS, | |
1245 | REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE. */ | |
fe9b4957 | 1246 | |
8fff4fc1 | 1247 | #ifndef STACK_DYNAMIC_OFFSET |
8a5275eb | 1248 | |
8fff4fc1 RH |
1249 | /* The bottom of the stack points to the actual arguments. If |
1250 | REG_PARM_STACK_SPACE is defined, this includes the space for the register | |
1251 | parameters. However, if OUTGOING_REG_PARM_STACK space is not defined, | |
1252 | stack space for register parameters is not pushed by the caller, but | |
1253 | rather part of the fixed stack areas and hence not included in | |
38173d38 | 1254 | `crtl->outgoing_args_size'. Nevertheless, we must allow |
8fff4fc1 | 1255 | for it when allocating stack dynamic objects. */ |
8a5275eb | 1256 | |
ac294f0b | 1257 | #if defined(REG_PARM_STACK_SPACE) |
8fff4fc1 RH |
1258 | #define STACK_DYNAMIC_OFFSET(FNDECL) \ |
1259 | ((ACCUMULATE_OUTGOING_ARGS \ | |
38173d38 | 1260 | ? (crtl->outgoing_args_size \ |
81464b2c KT |
1261 | + (OUTGOING_REG_PARM_STACK_SPACE ((!(FNDECL) ? NULL_TREE : TREE_TYPE (FNDECL))) ? 0 \ |
1262 | : REG_PARM_STACK_SPACE (FNDECL))) \ | |
ac294f0b | 1263 | : 0) + (STACK_POINTER_OFFSET)) |
8fff4fc1 RH |
1264 | #else |
1265 | #define STACK_DYNAMIC_OFFSET(FNDECL) \ | |
38173d38 | 1266 | ((ACCUMULATE_OUTGOING_ARGS ? crtl->outgoing_args_size : 0) \ |
8fff4fc1 RH |
1267 | + (STACK_POINTER_OFFSET)) |
1268 | #endif | |
1269 | #endif | |
4fa48eae | 1270 | |
659e47fb | 1271 | \f |
bbf9b913 RH |
1272 | /* Given a piece of RTX and a pointer to a HOST_WIDE_INT, if the RTX |
1273 | is a virtual register, return the equivalent hard register and set the | |
1274 | offset indirectly through the pointer. Otherwise, return 0. */ | |
6f086dfc | 1275 | |
bbf9b913 RH |
1276 | static rtx |
1277 | instantiate_new_reg (rtx x, HOST_WIDE_INT *poffset) | |
6f086dfc | 1278 | { |
82d6e6fc | 1279 | rtx new_rtx; |
bbf9b913 | 1280 | HOST_WIDE_INT offset; |
6f086dfc | 1281 | |
bbf9b913 | 1282 | if (x == virtual_incoming_args_rtx) |
2e3f842f | 1283 | { |
d015f7cc | 1284 | if (stack_realign_drap) |
2e3f842f | 1285 | { |
d015f7cc L |
1286 | /* Replace virtual_incoming_args_rtx with internal arg |
1287 | pointer if DRAP is used to realign stack. */ | |
82d6e6fc | 1288 | new_rtx = crtl->args.internal_arg_pointer; |
2e3f842f L |
1289 | offset = 0; |
1290 | } | |
1291 | else | |
82d6e6fc | 1292 | new_rtx = arg_pointer_rtx, offset = in_arg_offset; |
2e3f842f | 1293 | } |
bbf9b913 | 1294 | else if (x == virtual_stack_vars_rtx) |
82d6e6fc | 1295 | new_rtx = frame_pointer_rtx, offset = var_offset; |
bbf9b913 | 1296 | else if (x == virtual_stack_dynamic_rtx) |
82d6e6fc | 1297 | new_rtx = stack_pointer_rtx, offset = dynamic_offset; |
bbf9b913 | 1298 | else if (x == virtual_outgoing_args_rtx) |
82d6e6fc | 1299 | new_rtx = stack_pointer_rtx, offset = out_arg_offset; |
bbf9b913 | 1300 | else if (x == virtual_cfa_rtx) |
f6672e8e RH |
1301 | { |
1302 | #ifdef FRAME_POINTER_CFA_OFFSET | |
82d6e6fc | 1303 | new_rtx = frame_pointer_rtx; |
f6672e8e | 1304 | #else |
82d6e6fc | 1305 | new_rtx = arg_pointer_rtx; |
f6672e8e RH |
1306 | #endif |
1307 | offset = cfa_offset; | |
1308 | } | |
bbf9b913 RH |
1309 | else |
1310 | return NULL_RTX; | |
6f086dfc | 1311 | |
bbf9b913 | 1312 | *poffset = offset; |
82d6e6fc | 1313 | return new_rtx; |
6f086dfc RS |
1314 | } |
1315 | ||
bbf9b913 RH |
1316 | /* A subroutine of instantiate_virtual_regs, called via for_each_rtx. |
1317 | Instantiate any virtual registers present inside of *LOC. The expression | |
1318 | is simplified, as much as possible, but is not to be considered "valid" | |
1319 | in any sense implied by the target. If any change is made, set CHANGED | |
1320 | to true. */ | |
6f086dfc | 1321 | |
bbf9b913 RH |
1322 | static int |
1323 | instantiate_virtual_regs_in_rtx (rtx *loc, void *data) | |
6f086dfc | 1324 | { |
bbf9b913 RH |
1325 | HOST_WIDE_INT offset; |
1326 | bool *changed = (bool *) data; | |
82d6e6fc | 1327 | rtx x, new_rtx; |
6f086dfc | 1328 | |
bbf9b913 RH |
1329 | x = *loc; |
1330 | if (x == 0) | |
1331 | return 0; | |
1332 | ||
1333 | switch (GET_CODE (x)) | |
6f086dfc | 1334 | { |
bbf9b913 | 1335 | case REG: |
82d6e6fc KG |
1336 | new_rtx = instantiate_new_reg (x, &offset); |
1337 | if (new_rtx) | |
bbf9b913 | 1338 | { |
82d6e6fc | 1339 | *loc = plus_constant (new_rtx, offset); |
bbf9b913 RH |
1340 | if (changed) |
1341 | *changed = true; | |
1342 | } | |
1343 | return -1; | |
1344 | ||
1345 | case PLUS: | |
82d6e6fc KG |
1346 | new_rtx = instantiate_new_reg (XEXP (x, 0), &offset); |
1347 | if (new_rtx) | |
bbf9b913 | 1348 | { |
82d6e6fc KG |
1349 | new_rtx = plus_constant (new_rtx, offset); |
1350 | *loc = simplify_gen_binary (PLUS, GET_MODE (x), new_rtx, XEXP (x, 1)); | |
bbf9b913 RH |
1351 | if (changed) |
1352 | *changed = true; | |
1353 | return -1; | |
1354 | } | |
e5e809f4 | 1355 | |
bbf9b913 RH |
1356 | /* FIXME -- from old code */ |
1357 | /* If we have (plus (subreg (virtual-reg)) (const_int)), we know | |
1358 | we can commute the PLUS and SUBREG because pointers into the | |
1359 | frame are well-behaved. */ | |
1360 | break; | |
ce717ce4 | 1361 | |
bbf9b913 RH |
1362 | default: |
1363 | break; | |
6f086dfc RS |
1364 | } |
1365 | ||
bbf9b913 | 1366 | return 0; |
6f086dfc RS |
1367 | } |
1368 | ||
bbf9b913 RH |
1369 | /* A subroutine of instantiate_virtual_regs_in_insn. Return true if X |
1370 | matches the predicate for insn CODE operand OPERAND. */ | |
6f086dfc | 1371 | |
bbf9b913 RH |
1372 | static int |
1373 | safe_insn_predicate (int code, int operand, rtx x) | |
6f086dfc | 1374 | { |
bbf9b913 | 1375 | const struct insn_operand_data *op_data; |
6f086dfc | 1376 | |
bbf9b913 RH |
1377 | if (code < 0) |
1378 | return true; | |
6f086dfc | 1379 | |
bbf9b913 RH |
1380 | op_data = &insn_data[code].operand[operand]; |
1381 | if (op_data->predicate == NULL) | |
1382 | return true; | |
5a73491b | 1383 | |
bbf9b913 RH |
1384 | return op_data->predicate (x, op_data->mode); |
1385 | } | |
5a73491b | 1386 | |
bbf9b913 RH |
1387 | /* A subroutine of instantiate_virtual_regs. Instantiate any virtual |
1388 | registers present inside of insn. The result will be a valid insn. */ | |
5a73491b RK |
1389 | |
1390 | static void | |
bbf9b913 | 1391 | instantiate_virtual_regs_in_insn (rtx insn) |
5a73491b | 1392 | { |
bbf9b913 RH |
1393 | HOST_WIDE_INT offset; |
1394 | int insn_code, i; | |
9325973e | 1395 | bool any_change = false; |
82d6e6fc | 1396 | rtx set, new_rtx, x, seq; |
32e66afd | 1397 | |
bbf9b913 RH |
1398 | /* There are some special cases to be handled first. */ |
1399 | set = single_set (insn); | |
1400 | if (set) | |
32e66afd | 1401 | { |
bbf9b913 RH |
1402 | /* We're allowed to assign to a virtual register. This is interpreted |
1403 | to mean that the underlying register gets assigned the inverse | |
1404 | transformation. This is used, for example, in the handling of | |
1405 | non-local gotos. */ | |
82d6e6fc KG |
1406 | new_rtx = instantiate_new_reg (SET_DEST (set), &offset); |
1407 | if (new_rtx) | |
bbf9b913 RH |
1408 | { |
1409 | start_sequence (); | |
32e66afd | 1410 | |
bbf9b913 | 1411 | for_each_rtx (&SET_SRC (set), instantiate_virtual_regs_in_rtx, NULL); |
82d6e6fc | 1412 | x = simplify_gen_binary (PLUS, GET_MODE (new_rtx), SET_SRC (set), |
bbf9b913 | 1413 | GEN_INT (-offset)); |
82d6e6fc KG |
1414 | x = force_operand (x, new_rtx); |
1415 | if (x != new_rtx) | |
1416 | emit_move_insn (new_rtx, x); | |
5a73491b | 1417 | |
bbf9b913 RH |
1418 | seq = get_insns (); |
1419 | end_sequence (); | |
5a73491b | 1420 | |
bbf9b913 RH |
1421 | emit_insn_before (seq, insn); |
1422 | delete_insn (insn); | |
1423 | return; | |
1424 | } | |
5a73491b | 1425 | |
bbf9b913 RH |
1426 | /* Handle a straight copy from a virtual register by generating a |
1427 | new add insn. The difference between this and falling through | |
1428 | to the generic case is avoiding a new pseudo and eliminating a | |
1429 | move insn in the initial rtl stream. */ | |
82d6e6fc KG |
1430 | new_rtx = instantiate_new_reg (SET_SRC (set), &offset); |
1431 | if (new_rtx && offset != 0 | |
bbf9b913 RH |
1432 | && REG_P (SET_DEST (set)) |
1433 | && REGNO (SET_DEST (set)) > LAST_VIRTUAL_REGISTER) | |
1434 | { | |
1435 | start_sequence (); | |
5a73491b | 1436 | |
bbf9b913 | 1437 | x = expand_simple_binop (GET_MODE (SET_DEST (set)), PLUS, |
82d6e6fc | 1438 | new_rtx, GEN_INT (offset), SET_DEST (set), |
bbf9b913 RH |
1439 | 1, OPTAB_LIB_WIDEN); |
1440 | if (x != SET_DEST (set)) | |
1441 | emit_move_insn (SET_DEST (set), x); | |
770ae6cc | 1442 | |
bbf9b913 RH |
1443 | seq = get_insns (); |
1444 | end_sequence (); | |
87ce34d6 | 1445 | |
bbf9b913 RH |
1446 | emit_insn_before (seq, insn); |
1447 | delete_insn (insn); | |
87ce34d6 | 1448 | return; |
bbf9b913 | 1449 | } |
5a73491b | 1450 | |
bbf9b913 | 1451 | extract_insn (insn); |
9325973e | 1452 | insn_code = INSN_CODE (insn); |
5a73491b | 1453 | |
bbf9b913 RH |
1454 | /* Handle a plus involving a virtual register by determining if the |
1455 | operands remain valid if they're modified in place. */ | |
1456 | if (GET_CODE (SET_SRC (set)) == PLUS | |
1457 | && recog_data.n_operands >= 3 | |
1458 | && recog_data.operand_loc[1] == &XEXP (SET_SRC (set), 0) | |
1459 | && recog_data.operand_loc[2] == &XEXP (SET_SRC (set), 1) | |
1460 | && GET_CODE (recog_data.operand[2]) == CONST_INT | |
82d6e6fc | 1461 | && (new_rtx = instantiate_new_reg (recog_data.operand[1], &offset))) |
bbf9b913 RH |
1462 | { |
1463 | offset += INTVAL (recog_data.operand[2]); | |
5a73491b | 1464 | |
bbf9b913 | 1465 | /* If the sum is zero, then replace with a plain move. */ |
9325973e RH |
1466 | if (offset == 0 |
1467 | && REG_P (SET_DEST (set)) | |
1468 | && REGNO (SET_DEST (set)) > LAST_VIRTUAL_REGISTER) | |
bbf9b913 RH |
1469 | { |
1470 | start_sequence (); | |
82d6e6fc | 1471 | emit_move_insn (SET_DEST (set), new_rtx); |
bbf9b913 RH |
1472 | seq = get_insns (); |
1473 | end_sequence (); | |
d1405722 | 1474 | |
bbf9b913 RH |
1475 | emit_insn_before (seq, insn); |
1476 | delete_insn (insn); | |
1477 | return; | |
1478 | } | |
d1405722 | 1479 | |
bbf9b913 | 1480 | x = gen_int_mode (offset, recog_data.operand_mode[2]); |
bbf9b913 RH |
1481 | |
1482 | /* Using validate_change and apply_change_group here leaves | |
1483 | recog_data in an invalid state. Since we know exactly what | |
1484 | we want to check, do those two by hand. */ | |
82d6e6fc | 1485 | if (safe_insn_predicate (insn_code, 1, new_rtx) |
bbf9b913 RH |
1486 | && safe_insn_predicate (insn_code, 2, x)) |
1487 | { | |
82d6e6fc | 1488 | *recog_data.operand_loc[1] = recog_data.operand[1] = new_rtx; |
bbf9b913 RH |
1489 | *recog_data.operand_loc[2] = recog_data.operand[2] = x; |
1490 | any_change = true; | |
9325973e RH |
1491 | |
1492 | /* Fall through into the regular operand fixup loop in | |
1493 | order to take care of operands other than 1 and 2. */ | |
bbf9b913 RH |
1494 | } |
1495 | } | |
1496 | } | |
d1405722 | 1497 | else |
9325973e RH |
1498 | { |
1499 | extract_insn (insn); | |
1500 | insn_code = INSN_CODE (insn); | |
1501 | } | |
5dc96d60 | 1502 | |
bbf9b913 RH |
1503 | /* In the general case, we expect virtual registers to appear only in |
1504 | operands, and then only as either bare registers or inside memories. */ | |
1505 | for (i = 0; i < recog_data.n_operands; ++i) | |
1506 | { | |
1507 | x = recog_data.operand[i]; | |
1508 | switch (GET_CODE (x)) | |
1509 | { | |
1510 | case MEM: | |
1511 | { | |
1512 | rtx addr = XEXP (x, 0); | |
1513 | bool changed = false; | |
1514 | ||
1515 | for_each_rtx (&addr, instantiate_virtual_regs_in_rtx, &changed); | |
1516 | if (!changed) | |
1517 | continue; | |
1518 | ||
1519 | start_sequence (); | |
1520 | x = replace_equiv_address (x, addr); | |
a5bfb13a MM |
1521 | /* It may happen that the address with the virtual reg |
1522 | was valid (e.g. based on the virtual stack reg, which might | |
1523 | be acceptable to the predicates with all offsets), whereas | |
1524 | the address now isn't anymore, for instance when the address | |
1525 | is still offsetted, but the base reg isn't virtual-stack-reg | |
1526 | anymore. Below we would do a force_reg on the whole operand, | |
1527 | but this insn might actually only accept memory. Hence, | |
1528 | before doing that last resort, try to reload the address into | |
1529 | a register, so this operand stays a MEM. */ | |
1530 | if (!safe_insn_predicate (insn_code, i, x)) | |
1531 | { | |
1532 | addr = force_reg (GET_MODE (addr), addr); | |
1533 | x = replace_equiv_address (x, addr); | |
1534 | } | |
bbf9b913 RH |
1535 | seq = get_insns (); |
1536 | end_sequence (); | |
1537 | if (seq) | |
1538 | emit_insn_before (seq, insn); | |
1539 | } | |
1540 | break; | |
1541 | ||
1542 | case REG: | |
82d6e6fc KG |
1543 | new_rtx = instantiate_new_reg (x, &offset); |
1544 | if (new_rtx == NULL) | |
bbf9b913 RH |
1545 | continue; |
1546 | if (offset == 0) | |
82d6e6fc | 1547 | x = new_rtx; |
bbf9b913 RH |
1548 | else |
1549 | { | |
1550 | start_sequence (); | |
6f086dfc | 1551 | |
bbf9b913 RH |
1552 | /* Careful, special mode predicates may have stuff in |
1553 | insn_data[insn_code].operand[i].mode that isn't useful | |
1554 | to us for computing a new value. */ | |
1555 | /* ??? Recognize address_operand and/or "p" constraints | |
1556 | to see if (plus new offset) is a valid before we put | |
1557 | this through expand_simple_binop. */ | |
82d6e6fc | 1558 | x = expand_simple_binop (GET_MODE (x), PLUS, new_rtx, |
bbf9b913 RH |
1559 | GEN_INT (offset), NULL_RTX, |
1560 | 1, OPTAB_LIB_WIDEN); | |
1561 | seq = get_insns (); | |
1562 | end_sequence (); | |
1563 | emit_insn_before (seq, insn); | |
1564 | } | |
1565 | break; | |
6f086dfc | 1566 | |
bbf9b913 | 1567 | case SUBREG: |
82d6e6fc KG |
1568 | new_rtx = instantiate_new_reg (SUBREG_REG (x), &offset); |
1569 | if (new_rtx == NULL) | |
bbf9b913 RH |
1570 | continue; |
1571 | if (offset != 0) | |
1572 | { | |
1573 | start_sequence (); | |
82d6e6fc | 1574 | new_rtx = expand_simple_binop (GET_MODE (new_rtx), PLUS, new_rtx, |
bbf9b913 RH |
1575 | GEN_INT (offset), NULL_RTX, |
1576 | 1, OPTAB_LIB_WIDEN); | |
1577 | seq = get_insns (); | |
1578 | end_sequence (); | |
1579 | emit_insn_before (seq, insn); | |
1580 | } | |
82d6e6fc KG |
1581 | x = simplify_gen_subreg (recog_data.operand_mode[i], new_rtx, |
1582 | GET_MODE (new_rtx), SUBREG_BYTE (x)); | |
7314c7dd | 1583 | gcc_assert (x); |
bbf9b913 | 1584 | break; |
6f086dfc | 1585 | |
bbf9b913 RH |
1586 | default: |
1587 | continue; | |
1588 | } | |
6f086dfc | 1589 | |
bbf9b913 RH |
1590 | /* At this point, X contains the new value for the operand. |
1591 | Validate the new value vs the insn predicate. Note that | |
1592 | asm insns will have insn_code -1 here. */ | |
1593 | if (!safe_insn_predicate (insn_code, i, x)) | |
6ba1bd36 JM |
1594 | { |
1595 | start_sequence (); | |
1596 | x = force_reg (insn_data[insn_code].operand[i].mode, x); | |
1597 | seq = get_insns (); | |
1598 | end_sequence (); | |
1599 | if (seq) | |
1600 | emit_insn_before (seq, insn); | |
1601 | } | |
6f086dfc | 1602 | |
bbf9b913 RH |
1603 | *recog_data.operand_loc[i] = recog_data.operand[i] = x; |
1604 | any_change = true; | |
1605 | } | |
6f086dfc | 1606 | |
bbf9b913 RH |
1607 | if (any_change) |
1608 | { | |
1609 | /* Propagate operand changes into the duplicates. */ | |
1610 | for (i = 0; i < recog_data.n_dups; ++i) | |
1611 | *recog_data.dup_loc[i] | |
3e916873 | 1612 | = copy_rtx (recog_data.operand[(unsigned)recog_data.dup_num[i]]); |
5dc96d60 | 1613 | |
bbf9b913 RH |
1614 | /* Force re-recognition of the instruction for validation. */ |
1615 | INSN_CODE (insn) = -1; | |
1616 | } | |
6f086dfc | 1617 | |
bbf9b913 | 1618 | if (asm_noperands (PATTERN (insn)) >= 0) |
6f086dfc | 1619 | { |
bbf9b913 | 1620 | if (!check_asm_operands (PATTERN (insn))) |
6f086dfc | 1621 | { |
bbf9b913 RH |
1622 | error_for_asm (insn, "impossible constraint in %<asm%>"); |
1623 | delete_insn (insn); | |
1624 | } | |
1625 | } | |
1626 | else | |
1627 | { | |
1628 | if (recog_memoized (insn) < 0) | |
1629 | fatal_insn_not_found (insn); | |
1630 | } | |
1631 | } | |
14a774a9 | 1632 | |
bbf9b913 RH |
1633 | /* Subroutine of instantiate_decls. Given RTL representing a decl, |
1634 | do any instantiation required. */ | |
14a774a9 | 1635 | |
e41b2a33 PB |
1636 | void |
1637 | instantiate_decl_rtl (rtx x) | |
bbf9b913 RH |
1638 | { |
1639 | rtx addr; | |
6f086dfc | 1640 | |
bbf9b913 RH |
1641 | if (x == 0) |
1642 | return; | |
6f086dfc | 1643 | |
bbf9b913 RH |
1644 | /* If this is a CONCAT, recurse for the pieces. */ |
1645 | if (GET_CODE (x) == CONCAT) | |
1646 | { | |
e41b2a33 PB |
1647 | instantiate_decl_rtl (XEXP (x, 0)); |
1648 | instantiate_decl_rtl (XEXP (x, 1)); | |
bbf9b913 RH |
1649 | return; |
1650 | } | |
6f086dfc | 1651 | |
bbf9b913 RH |
1652 | /* If this is not a MEM, no need to do anything. Similarly if the |
1653 | address is a constant or a register that is not a virtual register. */ | |
1654 | if (!MEM_P (x)) | |
1655 | return; | |
6f086dfc | 1656 | |
bbf9b913 RH |
1657 | addr = XEXP (x, 0); |
1658 | if (CONSTANT_P (addr) | |
1659 | || (REG_P (addr) | |
1660 | && (REGNO (addr) < FIRST_VIRTUAL_REGISTER | |
1661 | || REGNO (addr) > LAST_VIRTUAL_REGISTER))) | |
1662 | return; | |
6f086dfc | 1663 | |
bbf9b913 RH |
1664 | for_each_rtx (&XEXP (x, 0), instantiate_virtual_regs_in_rtx, NULL); |
1665 | } | |
6f086dfc | 1666 | |
434eba35 JJ |
1667 | /* Helper for instantiate_decls called via walk_tree: Process all decls |
1668 | in the given DECL_VALUE_EXPR. */ | |
1669 | ||
1670 | static tree | |
1671 | instantiate_expr (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED) | |
1672 | { | |
1673 | tree t = *tp; | |
726a989a | 1674 | if (! EXPR_P (t)) |
434eba35 JJ |
1675 | { |
1676 | *walk_subtrees = 0; | |
1677 | if (DECL_P (t) && DECL_RTL_SET_P (t)) | |
e41b2a33 | 1678 | instantiate_decl_rtl (DECL_RTL (t)); |
434eba35 JJ |
1679 | } |
1680 | return NULL; | |
1681 | } | |
1682 | ||
bbf9b913 RH |
1683 | /* Subroutine of instantiate_decls: Process all decls in the given |
1684 | BLOCK node and all its subblocks. */ | |
6f086dfc | 1685 | |
bbf9b913 RH |
1686 | static void |
1687 | instantiate_decls_1 (tree let) | |
1688 | { | |
1689 | tree t; | |
6f086dfc | 1690 | |
bbf9b913 | 1691 | for (t = BLOCK_VARS (let); t; t = TREE_CHAIN (t)) |
434eba35 JJ |
1692 | { |
1693 | if (DECL_RTL_SET_P (t)) | |
e41b2a33 | 1694 | instantiate_decl_rtl (DECL_RTL (t)); |
434eba35 JJ |
1695 | if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t)) |
1696 | { | |
1697 | tree v = DECL_VALUE_EXPR (t); | |
1698 | walk_tree (&v, instantiate_expr, NULL, NULL); | |
1699 | } | |
1700 | } | |
6f086dfc | 1701 | |
bbf9b913 | 1702 | /* Process all subblocks. */ |
87caf699 | 1703 | for (t = BLOCK_SUBBLOCKS (let); t; t = BLOCK_CHAIN (t)) |
bbf9b913 RH |
1704 | instantiate_decls_1 (t); |
1705 | } | |
6f086dfc | 1706 | |
bbf9b913 RH |
1707 | /* Scan all decls in FNDECL (both variables and parameters) and instantiate |
1708 | all virtual registers in their DECL_RTL's. */ | |
6f086dfc | 1709 | |
bbf9b913 RH |
1710 | static void |
1711 | instantiate_decls (tree fndecl) | |
1712 | { | |
802e9f8e | 1713 | tree decl, t, next; |
6f086dfc | 1714 | |
bbf9b913 RH |
1715 | /* Process all parameters of the function. */ |
1716 | for (decl = DECL_ARGUMENTS (fndecl); decl; decl = TREE_CHAIN (decl)) | |
1717 | { | |
e41b2a33 PB |
1718 | instantiate_decl_rtl (DECL_RTL (decl)); |
1719 | instantiate_decl_rtl (DECL_INCOMING_RTL (decl)); | |
434eba35 JJ |
1720 | if (DECL_HAS_VALUE_EXPR_P (decl)) |
1721 | { | |
1722 | tree v = DECL_VALUE_EXPR (decl); | |
1723 | walk_tree (&v, instantiate_expr, NULL, NULL); | |
1724 | } | |
bbf9b913 | 1725 | } |
4fd796bb | 1726 | |
bbf9b913 RH |
1727 | /* Now process all variables defined in the function or its subblocks. */ |
1728 | instantiate_decls_1 (DECL_INITIAL (fndecl)); | |
802e9f8e JJ |
1729 | |
1730 | t = cfun->local_decls; | |
1731 | cfun->local_decls = NULL_TREE; | |
1732 | for (; t; t = next) | |
1733 | { | |
1734 | next = TREE_CHAIN (t); | |
1735 | decl = TREE_VALUE (t); | |
1736 | if (DECL_RTL_SET_P (decl)) | |
1737 | instantiate_decl_rtl (DECL_RTL (decl)); | |
1738 | ggc_free (t); | |
1739 | } | |
bbf9b913 | 1740 | } |
6f086dfc | 1741 | |
bbf9b913 RH |
1742 | /* Pass through the INSNS of function FNDECL and convert virtual register |
1743 | references to hard register references. */ | |
6f086dfc | 1744 | |
c2924966 | 1745 | static unsigned int |
bbf9b913 RH |
1746 | instantiate_virtual_regs (void) |
1747 | { | |
ba4807a0 | 1748 | rtx insn; |
6f086dfc | 1749 | |
bbf9b913 RH |
1750 | /* Compute the offsets to use for this function. */ |
1751 | in_arg_offset = FIRST_PARM_OFFSET (current_function_decl); | |
1752 | var_offset = STARTING_FRAME_OFFSET; | |
1753 | dynamic_offset = STACK_DYNAMIC_OFFSET (current_function_decl); | |
1754 | out_arg_offset = STACK_POINTER_OFFSET; | |
f6672e8e RH |
1755 | #ifdef FRAME_POINTER_CFA_OFFSET |
1756 | cfa_offset = FRAME_POINTER_CFA_OFFSET (current_function_decl); | |
1757 | #else | |
bbf9b913 | 1758 | cfa_offset = ARG_POINTER_CFA_OFFSET (current_function_decl); |
f6672e8e | 1759 | #endif |
e9a25f70 | 1760 | |
bbf9b913 RH |
1761 | /* Initialize recognition, indicating that volatile is OK. */ |
1762 | init_recog (); | |
6f086dfc | 1763 | |
bbf9b913 RH |
1764 | /* Scan through all the insns, instantiating every virtual register still |
1765 | present. */ | |
ba4807a0 LB |
1766 | for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) |
1767 | if (INSN_P (insn)) | |
1768 | { | |
1769 | /* These patterns in the instruction stream can never be recognized. | |
1770 | Fortunately, they shouldn't contain virtual registers either. */ | |
1771 | if (GET_CODE (PATTERN (insn)) == USE | |
1772 | || GET_CODE (PATTERN (insn)) == CLOBBER | |
1773 | || GET_CODE (PATTERN (insn)) == ADDR_VEC | |
1774 | || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC | |
1775 | || GET_CODE (PATTERN (insn)) == ASM_INPUT) | |
1776 | continue; | |
1777 | ||
1778 | instantiate_virtual_regs_in_insn (insn); | |
1779 | ||
1780 | if (INSN_DELETED_P (insn)) | |
1781 | continue; | |
1782 | ||
1783 | for_each_rtx (®_NOTES (insn), instantiate_virtual_regs_in_rtx, NULL); | |
1784 | ||
1785 | /* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE. */ | |
1786 | if (GET_CODE (insn) == CALL_INSN) | |
1787 | for_each_rtx (&CALL_INSN_FUNCTION_USAGE (insn), | |
1788 | instantiate_virtual_regs_in_rtx, NULL); | |
1789 | } | |
6f086dfc | 1790 | |
bbf9b913 RH |
1791 | /* Instantiate the virtual registers in the DECLs for debugging purposes. */ |
1792 | instantiate_decls (current_function_decl); | |
1793 | ||
e41b2a33 PB |
1794 | targetm.instantiate_decls (); |
1795 | ||
bbf9b913 RH |
1796 | /* Indicate that, from now on, assign_stack_local should use |
1797 | frame_pointer_rtx. */ | |
1798 | virtuals_instantiated = 1; | |
c2924966 | 1799 | return 0; |
6f086dfc | 1800 | } |
ef330312 | 1801 | |
8ddbbcae | 1802 | struct rtl_opt_pass pass_instantiate_virtual_regs = |
ef330312 | 1803 | { |
8ddbbcae JH |
1804 | { |
1805 | RTL_PASS, | |
defb77dc | 1806 | "vregs", /* name */ |
ef330312 PB |
1807 | NULL, /* gate */ |
1808 | instantiate_virtual_regs, /* execute */ | |
1809 | NULL, /* sub */ | |
1810 | NULL, /* next */ | |
1811 | 0, /* static_pass_number */ | |
7072a650 | 1812 | TV_NONE, /* tv_id */ |
ef330312 PB |
1813 | 0, /* properties_required */ |
1814 | 0, /* properties_provided */ | |
1815 | 0, /* properties_destroyed */ | |
1816 | 0, /* todo_flags_start */ | |
8ddbbcae JH |
1817 | TODO_dump_func /* todo_flags_finish */ |
1818 | } | |
ef330312 PB |
1819 | }; |
1820 | ||
6f086dfc | 1821 | \f |
d181c154 RS |
1822 | /* Return 1 if EXP is an aggregate type (or a value with aggregate type). |
1823 | This means a type for which function calls must pass an address to the | |
1824 | function or get an address back from the function. | |
1825 | EXP may be a type node or an expression (whose type is tested). */ | |
6f086dfc RS |
1826 | |
1827 | int | |
586de218 | 1828 | aggregate_value_p (const_tree exp, const_tree fntype) |
6f086dfc | 1829 | { |
9d790a4f RS |
1830 | int i, regno, nregs; |
1831 | rtx reg; | |
2f939d94 | 1832 | |
586de218 | 1833 | const_tree type = (TYPE_P (exp)) ? exp : TREE_TYPE (exp); |
d181c154 | 1834 | |
500c353d OH |
1835 | /* DECL node associated with FNTYPE when relevant, which we might need to |
1836 | check for by-invisible-reference returns, typically for CALL_EXPR input | |
1837 | EXPressions. */ | |
586de218 | 1838 | const_tree fndecl = NULL_TREE; |
500c353d | 1839 | |
61f71b34 DD |
1840 | if (fntype) |
1841 | switch (TREE_CODE (fntype)) | |
1842 | { | |
1843 | case CALL_EXPR: | |
500c353d | 1844 | fndecl = get_callee_fndecl (fntype); |
45769134 KT |
1845 | fntype = (fndecl |
1846 | ? TREE_TYPE (fndecl) | |
c433cb14 | 1847 | : TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (fntype)))); |
61f71b34 DD |
1848 | break; |
1849 | case FUNCTION_DECL: | |
500c353d OH |
1850 | fndecl = fntype; |
1851 | fntype = TREE_TYPE (fndecl); | |
61f71b34 DD |
1852 | break; |
1853 | case FUNCTION_TYPE: | |
1854 | case METHOD_TYPE: | |
1855 | break; | |
1856 | case IDENTIFIER_NODE: | |
1857 | fntype = 0; | |
1858 | break; | |
1859 | default: | |
1860 | /* We don't expect other rtl types here. */ | |
0bccc606 | 1861 | gcc_unreachable (); |
61f71b34 DD |
1862 | } |
1863 | ||
d7bf8ada MM |
1864 | if (TREE_CODE (type) == VOID_TYPE) |
1865 | return 0; | |
500c353d | 1866 | |
cc77ae10 JM |
1867 | /* If the front end has decided that this needs to be passed by |
1868 | reference, do so. */ | |
1869 | if ((TREE_CODE (exp) == PARM_DECL || TREE_CODE (exp) == RESULT_DECL) | |
1870 | && DECL_BY_REFERENCE (exp)) | |
1871 | return 1; | |
500c353d OH |
1872 | |
1873 | /* If the EXPression is a CALL_EXPR, honor DECL_BY_REFERENCE set on the | |
1874 | called function RESULT_DECL, meaning the function returns in memory by | |
1875 | invisible reference. This check lets front-ends not set TREE_ADDRESSABLE | |
1876 | on the function type, which used to be the way to request such a return | |
1877 | mechanism but might now be causing troubles at gimplification time if | |
1878 | temporaries with the function type need to be created. */ | |
1879 | if (TREE_CODE (exp) == CALL_EXPR && fndecl && DECL_RESULT (fndecl) | |
1880 | && DECL_BY_REFERENCE (DECL_RESULT (fndecl))) | |
1881 | return 1; | |
1882 | ||
61f71b34 | 1883 | if (targetm.calls.return_in_memory (type, fntype)) |
6f086dfc | 1884 | return 1; |
956d6950 | 1885 | /* Types that are TREE_ADDRESSABLE must be constructed in memory, |
49a2e5b2 DE |
1886 | and thus can't be returned in registers. */ |
1887 | if (TREE_ADDRESSABLE (type)) | |
1888 | return 1; | |
05e3bdb9 | 1889 | if (flag_pcc_struct_return && AGGREGATE_TYPE_P (type)) |
6f086dfc | 1890 | return 1; |
9d790a4f RS |
1891 | /* Make sure we have suitable call-clobbered regs to return |
1892 | the value in; if not, we must return it in memory. */ | |
1d636cc6 | 1893 | reg = hard_function_value (type, 0, fntype, 0); |
e71f7aa5 JW |
1894 | |
1895 | /* If we have something other than a REG (e.g. a PARALLEL), then assume | |
1896 | it is OK. */ | |
f8cfc6aa | 1897 | if (!REG_P (reg)) |
e71f7aa5 JW |
1898 | return 0; |
1899 | ||
9d790a4f | 1900 | regno = REGNO (reg); |
66fd46b6 | 1901 | nregs = hard_regno_nregs[regno][TYPE_MODE (type)]; |
9d790a4f RS |
1902 | for (i = 0; i < nregs; i++) |
1903 | if (! call_used_regs[regno + i]) | |
1904 | return 1; | |
6f086dfc RS |
1905 | return 0; |
1906 | } | |
1907 | \f | |
8fff4fc1 RH |
1908 | /* Return true if we should assign DECL a pseudo register; false if it |
1909 | should live on the local stack. */ | |
1910 | ||
1911 | bool | |
fa233e34 | 1912 | use_register_for_decl (const_tree decl) |
8fff4fc1 | 1913 | { |
007e61c2 PB |
1914 | if (!targetm.calls.allocate_stack_slots_for_args()) |
1915 | return true; | |
1916 | ||
8fff4fc1 RH |
1917 | /* Honor volatile. */ |
1918 | if (TREE_SIDE_EFFECTS (decl)) | |
1919 | return false; | |
1920 | ||
1921 | /* Honor addressability. */ | |
1922 | if (TREE_ADDRESSABLE (decl)) | |
1923 | return false; | |
1924 | ||
1925 | /* Only register-like things go in registers. */ | |
1926 | if (DECL_MODE (decl) == BLKmode) | |
1927 | return false; | |
1928 | ||
1929 | /* If -ffloat-store specified, don't put explicit float variables | |
1930 | into registers. */ | |
1931 | /* ??? This should be checked after DECL_ARTIFICIAL, but tree-ssa | |
1932 | propagates values across these stores, and it probably shouldn't. */ | |
1933 | if (flag_float_store && FLOAT_TYPE_P (TREE_TYPE (decl))) | |
1934 | return false; | |
1935 | ||
78e0d62b RH |
1936 | /* If we're not interested in tracking debugging information for |
1937 | this decl, then we can certainly put it in a register. */ | |
1938 | if (DECL_IGNORED_P (decl)) | |
8fff4fc1 RH |
1939 | return true; |
1940 | ||
d130d647 JJ |
1941 | if (optimize) |
1942 | return true; | |
1943 | ||
1944 | if (!DECL_REGISTER (decl)) | |
1945 | return false; | |
1946 | ||
1947 | switch (TREE_CODE (TREE_TYPE (decl))) | |
1948 | { | |
1949 | case RECORD_TYPE: | |
1950 | case UNION_TYPE: | |
1951 | case QUAL_UNION_TYPE: | |
1952 | /* When not optimizing, disregard register keyword for variables with | |
1953 | types containing methods, otherwise the methods won't be callable | |
1954 | from the debugger. */ | |
1955 | if (TYPE_METHODS (TREE_TYPE (decl))) | |
1956 | return false; | |
1957 | break; | |
1958 | default: | |
1959 | break; | |
1960 | } | |
1961 | ||
1962 | return true; | |
8fff4fc1 RH |
1963 | } |
1964 | ||
0976078c RH |
1965 | /* Return true if TYPE should be passed by invisible reference. */ |
1966 | ||
1967 | bool | |
8cd5a4e0 RH |
1968 | pass_by_reference (CUMULATIVE_ARGS *ca, enum machine_mode mode, |
1969 | tree type, bool named_arg) | |
0976078c RH |
1970 | { |
1971 | if (type) | |
1972 | { | |
1973 | /* If this type contains non-trivial constructors, then it is | |
1974 | forbidden for the middle-end to create any new copies. */ | |
1975 | if (TREE_ADDRESSABLE (type)) | |
1976 | return true; | |
1977 | ||
d58247a3 RH |
1978 | /* GCC post 3.4 passes *all* variable sized types by reference. */ |
1979 | if (!TYPE_SIZE (type) || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) | |
0976078c RH |
1980 | return true; |
1981 | } | |
1982 | ||
8cd5a4e0 | 1983 | return targetm.calls.pass_by_reference (ca, mode, type, named_arg); |
0976078c RH |
1984 | } |
1985 | ||
6cdd5672 RH |
1986 | /* Return true if TYPE, which is passed by reference, should be callee |
1987 | copied instead of caller copied. */ | |
1988 | ||
1989 | bool | |
1990 | reference_callee_copied (CUMULATIVE_ARGS *ca, enum machine_mode mode, | |
1991 | tree type, bool named_arg) | |
1992 | { | |
1993 | if (type && TREE_ADDRESSABLE (type)) | |
1994 | return false; | |
1995 | return targetm.calls.callee_copies (ca, mode, type, named_arg); | |
1996 | } | |
1997 | ||
6071dc7f RH |
1998 | /* Structures to communicate between the subroutines of assign_parms. |
1999 | The first holds data persistent across all parameters, the second | |
2000 | is cleared out for each parameter. */ | |
6f086dfc | 2001 | |
6071dc7f | 2002 | struct assign_parm_data_all |
6f086dfc | 2003 | { |
6f086dfc | 2004 | CUMULATIVE_ARGS args_so_far; |
6f086dfc | 2005 | struct args_size stack_args_size; |
6071dc7f RH |
2006 | tree function_result_decl; |
2007 | tree orig_fnargs; | |
bb27eeda SE |
2008 | rtx first_conversion_insn; |
2009 | rtx last_conversion_insn; | |
6071dc7f RH |
2010 | HOST_WIDE_INT pretend_args_size; |
2011 | HOST_WIDE_INT extra_pretend_bytes; | |
2012 | int reg_parm_stack_space; | |
2013 | }; | |
6f086dfc | 2014 | |
6071dc7f RH |
2015 | struct assign_parm_data_one |
2016 | { | |
2017 | tree nominal_type; | |
2018 | tree passed_type; | |
2019 | rtx entry_parm; | |
2020 | rtx stack_parm; | |
2021 | enum machine_mode nominal_mode; | |
2022 | enum machine_mode passed_mode; | |
2023 | enum machine_mode promoted_mode; | |
2024 | struct locate_and_pad_arg_data locate; | |
2025 | int partial; | |
2026 | BOOL_BITFIELD named_arg : 1; | |
6071dc7f RH |
2027 | BOOL_BITFIELD passed_pointer : 1; |
2028 | BOOL_BITFIELD on_stack : 1; | |
2029 | BOOL_BITFIELD loaded_in_reg : 1; | |
2030 | }; | |
ebb904cb | 2031 | |
6071dc7f | 2032 | /* A subroutine of assign_parms. Initialize ALL. */ |
6f086dfc | 2033 | |
6071dc7f RH |
2034 | static void |
2035 | assign_parms_initialize_all (struct assign_parm_data_all *all) | |
2036 | { | |
2037 | tree fntype; | |
6f086dfc | 2038 | |
6071dc7f RH |
2039 | memset (all, 0, sizeof (*all)); |
2040 | ||
2041 | fntype = TREE_TYPE (current_function_decl); | |
2042 | ||
2043 | #ifdef INIT_CUMULATIVE_INCOMING_ARGS | |
2044 | INIT_CUMULATIVE_INCOMING_ARGS (all->args_so_far, fntype, NULL_RTX); | |
2045 | #else | |
2046 | INIT_CUMULATIVE_ARGS (all->args_so_far, fntype, NULL_RTX, | |
2047 | current_function_decl, -1); | |
2048 | #endif | |
2049 | ||
2050 | #ifdef REG_PARM_STACK_SPACE | |
2051 | all->reg_parm_stack_space = REG_PARM_STACK_SPACE (current_function_decl); | |
2052 | #endif | |
2053 | } | |
6f086dfc | 2054 | |
6071dc7f RH |
2055 | /* If ARGS contains entries with complex types, split the entry into two |
2056 | entries of the component type. Return a new list of substitutions are | |
2057 | needed, else the old list. */ | |
2058 | ||
2059 | static tree | |
2060 | split_complex_args (tree args) | |
2061 | { | |
2062 | tree p; | |
2063 | ||
2064 | /* Before allocating memory, check for the common case of no complex. */ | |
2065 | for (p = args; p; p = TREE_CHAIN (p)) | |
2066 | { | |
2067 | tree type = TREE_TYPE (p); | |
2068 | if (TREE_CODE (type) == COMPLEX_TYPE | |
2069 | && targetm.calls.split_complex_arg (type)) | |
2070 | goto found; | |
2071 | } | |
2072 | return args; | |
2073 | ||
2074 | found: | |
2075 | args = copy_list (args); | |
2076 | ||
2077 | for (p = args; p; p = TREE_CHAIN (p)) | |
2078 | { | |
2079 | tree type = TREE_TYPE (p); | |
2080 | if (TREE_CODE (type) == COMPLEX_TYPE | |
2081 | && targetm.calls.split_complex_arg (type)) | |
2082 | { | |
2083 | tree decl; | |
2084 | tree subtype = TREE_TYPE (type); | |
6ccd356e | 2085 | bool addressable = TREE_ADDRESSABLE (p); |
6071dc7f RH |
2086 | |
2087 | /* Rewrite the PARM_DECL's type with its component. */ | |
2088 | TREE_TYPE (p) = subtype; | |
2089 | DECL_ARG_TYPE (p) = TREE_TYPE (DECL_ARG_TYPE (p)); | |
2090 | DECL_MODE (p) = VOIDmode; | |
2091 | DECL_SIZE (p) = NULL; | |
2092 | DECL_SIZE_UNIT (p) = NULL; | |
6ccd356e AM |
2093 | /* If this arg must go in memory, put it in a pseudo here. |
2094 | We can't allow it to go in memory as per normal parms, | |
2095 | because the usual place might not have the imag part | |
2096 | adjacent to the real part. */ | |
2097 | DECL_ARTIFICIAL (p) = addressable; | |
2098 | DECL_IGNORED_P (p) = addressable; | |
2099 | TREE_ADDRESSABLE (p) = 0; | |
6071dc7f RH |
2100 | layout_decl (p, 0); |
2101 | ||
2102 | /* Build a second synthetic decl. */ | |
2103 | decl = build_decl (PARM_DECL, NULL_TREE, subtype); | |
2104 | DECL_ARG_TYPE (decl) = DECL_ARG_TYPE (p); | |
6ccd356e AM |
2105 | DECL_ARTIFICIAL (decl) = addressable; |
2106 | DECL_IGNORED_P (decl) = addressable; | |
6071dc7f RH |
2107 | layout_decl (decl, 0); |
2108 | ||
2109 | /* Splice it in; skip the new decl. */ | |
2110 | TREE_CHAIN (decl) = TREE_CHAIN (p); | |
2111 | TREE_CHAIN (p) = decl; | |
2112 | p = decl; | |
2113 | } | |
2114 | } | |
2115 | ||
2116 | return args; | |
2117 | } | |
2118 | ||
2119 | /* A subroutine of assign_parms. Adjust the parameter list to incorporate | |
2120 | the hidden struct return argument, and (abi willing) complex args. | |
2121 | Return the new parameter list. */ | |
2122 | ||
2123 | static tree | |
2124 | assign_parms_augmented_arg_list (struct assign_parm_data_all *all) | |
2125 | { | |
2126 | tree fndecl = current_function_decl; | |
2127 | tree fntype = TREE_TYPE (fndecl); | |
2128 | tree fnargs = DECL_ARGUMENTS (fndecl); | |
6f086dfc RS |
2129 | |
2130 | /* If struct value address is treated as the first argument, make it so. */ | |
61f71b34 | 2131 | if (aggregate_value_p (DECL_RESULT (fndecl), fndecl) |
e3b5732b | 2132 | && ! cfun->returns_pcc_struct |
61f71b34 | 2133 | && targetm.calls.struct_value_rtx (TREE_TYPE (fndecl), 1) == 0) |
6f086dfc | 2134 | { |
f9f29478 | 2135 | tree type = build_pointer_type (TREE_TYPE (fntype)); |
6071dc7f | 2136 | tree decl; |
6f086dfc | 2137 | |
6071dc7f RH |
2138 | decl = build_decl (PARM_DECL, NULL_TREE, type); |
2139 | DECL_ARG_TYPE (decl) = type; | |
2140 | DECL_ARTIFICIAL (decl) = 1; | |
78e0d62b | 2141 | DECL_IGNORED_P (decl) = 1; |
6f086dfc | 2142 | |
6071dc7f RH |
2143 | TREE_CHAIN (decl) = fnargs; |
2144 | fnargs = decl; | |
2145 | all->function_result_decl = decl; | |
6f086dfc | 2146 | } |
718fe406 | 2147 | |
6071dc7f | 2148 | all->orig_fnargs = fnargs; |
ded9bf77 | 2149 | |
42ba5130 RH |
2150 | /* If the target wants to split complex arguments into scalars, do so. */ |
2151 | if (targetm.calls.split_complex_arg) | |
ded9bf77 AH |
2152 | fnargs = split_complex_args (fnargs); |
2153 | ||
6071dc7f RH |
2154 | return fnargs; |
2155 | } | |
e7949876 | 2156 | |
6071dc7f RH |
2157 | /* A subroutine of assign_parms. Examine PARM and pull out type and mode |
2158 | data for the parameter. Incorporate ABI specifics such as pass-by- | |
2159 | reference and type promotion. */ | |
6f086dfc | 2160 | |
6071dc7f RH |
2161 | static void |
2162 | assign_parm_find_data_types (struct assign_parm_data_all *all, tree parm, | |
2163 | struct assign_parm_data_one *data) | |
2164 | { | |
2165 | tree nominal_type, passed_type; | |
2166 | enum machine_mode nominal_mode, passed_mode, promoted_mode; | |
6f086dfc | 2167 | |
6071dc7f RH |
2168 | memset (data, 0, sizeof (*data)); |
2169 | ||
fa10beec | 2170 | /* NAMED_ARG is a misnomer. We really mean 'non-variadic'. */ |
e3b5732b | 2171 | if (!cfun->stdarg) |
fa10beec | 2172 | data->named_arg = 1; /* No variadic parms. */ |
8117c488 | 2173 | else if (TREE_CHAIN (parm)) |
fa10beec | 2174 | data->named_arg = 1; /* Not the last non-variadic parm. */ |
8117c488 | 2175 | else if (targetm.calls.strict_argument_naming (&all->args_so_far)) |
fa10beec | 2176 | data->named_arg = 1; /* Only variadic ones are unnamed. */ |
6071dc7f | 2177 | else |
fa10beec | 2178 | data->named_arg = 0; /* Treat as variadic. */ |
6071dc7f RH |
2179 | |
2180 | nominal_type = TREE_TYPE (parm); | |
2181 | passed_type = DECL_ARG_TYPE (parm); | |
2182 | ||
2183 | /* Look out for errors propagating this far. Also, if the parameter's | |
2184 | type is void then its value doesn't matter. */ | |
2185 | if (TREE_TYPE (parm) == error_mark_node | |
2186 | /* This can happen after weird syntax errors | |
2187 | or if an enum type is defined among the parms. */ | |
2188 | || TREE_CODE (parm) != PARM_DECL | |
2189 | || passed_type == NULL | |
2190 | || VOID_TYPE_P (nominal_type)) | |
2191 | { | |
2192 | nominal_type = passed_type = void_type_node; | |
2193 | nominal_mode = passed_mode = promoted_mode = VOIDmode; | |
2194 | goto egress; | |
2195 | } | |
108b7d3d | 2196 | |
6071dc7f RH |
2197 | /* Find mode of arg as it is passed, and mode of arg as it should be |
2198 | during execution of this function. */ | |
2199 | passed_mode = TYPE_MODE (passed_type); | |
2200 | nominal_mode = TYPE_MODE (nominal_type); | |
2201 | ||
2202 | /* If the parm is to be passed as a transparent union, use the type of | |
2203 | the first field for the tests below. We have already verified that | |
2204 | the modes are the same. */ | |
52dd234b RH |
2205 | if (TREE_CODE (passed_type) == UNION_TYPE |
2206 | && TYPE_TRANSPARENT_UNION (passed_type)) | |
6071dc7f RH |
2207 | passed_type = TREE_TYPE (TYPE_FIELDS (passed_type)); |
2208 | ||
0976078c RH |
2209 | /* See if this arg was passed by invisible reference. */ |
2210 | if (pass_by_reference (&all->args_so_far, passed_mode, | |
2211 | passed_type, data->named_arg)) | |
6071dc7f RH |
2212 | { |
2213 | passed_type = nominal_type = build_pointer_type (passed_type); | |
2214 | data->passed_pointer = true; | |
2215 | passed_mode = nominal_mode = Pmode; | |
2216 | } | |
6f086dfc | 2217 | |
6071dc7f RH |
2218 | /* Find mode as it is passed by the ABI. */ |
2219 | promoted_mode = passed_mode; | |
2220 | if (targetm.calls.promote_function_args (TREE_TYPE (current_function_decl))) | |
2221 | { | |
2222 | int unsignedp = TYPE_UNSIGNED (passed_type); | |
2223 | promoted_mode = promote_mode (passed_type, promoted_mode, | |
2224 | &unsignedp, 1); | |
2225 | } | |
6f086dfc | 2226 | |
6071dc7f RH |
2227 | egress: |
2228 | data->nominal_type = nominal_type; | |
2229 | data->passed_type = passed_type; | |
2230 | data->nominal_mode = nominal_mode; | |
2231 | data->passed_mode = passed_mode; | |
2232 | data->promoted_mode = promoted_mode; | |
2233 | } | |
16bae307 | 2234 | |
6071dc7f | 2235 | /* A subroutine of assign_parms. Invoke setup_incoming_varargs. */ |
6f086dfc | 2236 | |
6071dc7f RH |
2237 | static void |
2238 | assign_parms_setup_varargs (struct assign_parm_data_all *all, | |
2239 | struct assign_parm_data_one *data, bool no_rtl) | |
2240 | { | |
2241 | int varargs_pretend_bytes = 0; | |
2242 | ||
2243 | targetm.calls.setup_incoming_varargs (&all->args_so_far, | |
2244 | data->promoted_mode, | |
2245 | data->passed_type, | |
2246 | &varargs_pretend_bytes, no_rtl); | |
2247 | ||
2248 | /* If the back-end has requested extra stack space, record how much is | |
2249 | needed. Do not change pretend_args_size otherwise since it may be | |
2250 | nonzero from an earlier partial argument. */ | |
2251 | if (varargs_pretend_bytes > 0) | |
2252 | all->pretend_args_size = varargs_pretend_bytes; | |
2253 | } | |
a53e14c0 | 2254 | |
6071dc7f RH |
2255 | /* A subroutine of assign_parms. Set DATA->ENTRY_PARM corresponding to |
2256 | the incoming location of the current parameter. */ | |
2257 | ||
2258 | static void | |
2259 | assign_parm_find_entry_rtl (struct assign_parm_data_all *all, | |
2260 | struct assign_parm_data_one *data) | |
2261 | { | |
2262 | HOST_WIDE_INT pretend_bytes = 0; | |
2263 | rtx entry_parm; | |
2264 | bool in_regs; | |
2265 | ||
2266 | if (data->promoted_mode == VOIDmode) | |
2267 | { | |
2268 | data->entry_parm = data->stack_parm = const0_rtx; | |
2269 | return; | |
2270 | } | |
a53e14c0 | 2271 | |
6f086dfc | 2272 | #ifdef FUNCTION_INCOMING_ARG |
6071dc7f RH |
2273 | entry_parm = FUNCTION_INCOMING_ARG (all->args_so_far, data->promoted_mode, |
2274 | data->passed_type, data->named_arg); | |
6f086dfc | 2275 | #else |
6071dc7f RH |
2276 | entry_parm = FUNCTION_ARG (all->args_so_far, data->promoted_mode, |
2277 | data->passed_type, data->named_arg); | |
6f086dfc RS |
2278 | #endif |
2279 | ||
6071dc7f RH |
2280 | if (entry_parm == 0) |
2281 | data->promoted_mode = data->passed_mode; | |
6f086dfc | 2282 | |
6071dc7f RH |
2283 | /* Determine parm's home in the stack, in case it arrives in the stack |
2284 | or we should pretend it did. Compute the stack position and rtx where | |
2285 | the argument arrives and its size. | |
6f086dfc | 2286 | |
6071dc7f RH |
2287 | There is one complexity here: If this was a parameter that would |
2288 | have been passed in registers, but wasn't only because it is | |
2289 | __builtin_va_alist, we want locate_and_pad_parm to treat it as if | |
2290 | it came in a register so that REG_PARM_STACK_SPACE isn't skipped. | |
2291 | In this case, we call FUNCTION_ARG with NAMED set to 1 instead of 0 | |
2292 | as it was the previous time. */ | |
2293 | in_regs = entry_parm != 0; | |
6f086dfc | 2294 | #ifdef STACK_PARMS_IN_REG_PARM_AREA |
6071dc7f | 2295 | in_regs = true; |
e7949876 | 2296 | #endif |
6071dc7f RH |
2297 | if (!in_regs && !data->named_arg) |
2298 | { | |
2299 | if (targetm.calls.pretend_outgoing_varargs_named (&all->args_so_far)) | |
e7949876 | 2300 | { |
6071dc7f | 2301 | rtx tem; |
6f086dfc | 2302 | #ifdef FUNCTION_INCOMING_ARG |
6071dc7f RH |
2303 | tem = FUNCTION_INCOMING_ARG (all->args_so_far, data->promoted_mode, |
2304 | data->passed_type, true); | |
6f086dfc | 2305 | #else |
6071dc7f RH |
2306 | tem = FUNCTION_ARG (all->args_so_far, data->promoted_mode, |
2307 | data->passed_type, true); | |
6f086dfc | 2308 | #endif |
6071dc7f | 2309 | in_regs = tem != NULL; |
e7949876 | 2310 | } |
6071dc7f | 2311 | } |
e7949876 | 2312 | |
6071dc7f RH |
2313 | /* If this parameter was passed both in registers and in the stack, use |
2314 | the copy on the stack. */ | |
fe984136 RH |
2315 | if (targetm.calls.must_pass_in_stack (data->promoted_mode, |
2316 | data->passed_type)) | |
6071dc7f | 2317 | entry_parm = 0; |
e7949876 | 2318 | |
6071dc7f RH |
2319 | if (entry_parm) |
2320 | { | |
2321 | int partial; | |
2322 | ||
78a52f11 RH |
2323 | partial = targetm.calls.arg_partial_bytes (&all->args_so_far, |
2324 | data->promoted_mode, | |
2325 | data->passed_type, | |
2326 | data->named_arg); | |
6071dc7f RH |
2327 | data->partial = partial; |
2328 | ||
2329 | /* The caller might already have allocated stack space for the | |
2330 | register parameters. */ | |
2331 | if (partial != 0 && all->reg_parm_stack_space == 0) | |
975f3818 | 2332 | { |
6071dc7f RH |
2333 | /* Part of this argument is passed in registers and part |
2334 | is passed on the stack. Ask the prologue code to extend | |
2335 | the stack part so that we can recreate the full value. | |
2336 | ||
2337 | PRETEND_BYTES is the size of the registers we need to store. | |
2338 | CURRENT_FUNCTION_PRETEND_ARGS_SIZE is the amount of extra | |
2339 | stack space that the prologue should allocate. | |
2340 | ||
2341 | Internally, gcc assumes that the argument pointer is aligned | |
2342 | to STACK_BOUNDARY bits. This is used both for alignment | |
2343 | optimizations (see init_emit) and to locate arguments that are | |
2344 | aligned to more than PARM_BOUNDARY bits. We must preserve this | |
2345 | invariant by rounding CURRENT_FUNCTION_PRETEND_ARGS_SIZE up to | |
2346 | a stack boundary. */ | |
2347 | ||
2348 | /* We assume at most one partial arg, and it must be the first | |
2349 | argument on the stack. */ | |
0bccc606 | 2350 | gcc_assert (!all->extra_pretend_bytes && !all->pretend_args_size); |
6071dc7f | 2351 | |
78a52f11 | 2352 | pretend_bytes = partial; |
6071dc7f RH |
2353 | all->pretend_args_size = CEIL_ROUND (pretend_bytes, STACK_BYTES); |
2354 | ||
2355 | /* We want to align relative to the actual stack pointer, so | |
2356 | don't include this in the stack size until later. */ | |
2357 | all->extra_pretend_bytes = all->pretend_args_size; | |
975f3818 | 2358 | } |
6071dc7f | 2359 | } |
e7949876 | 2360 | |
6071dc7f RH |
2361 | locate_and_pad_parm (data->promoted_mode, data->passed_type, in_regs, |
2362 | entry_parm ? data->partial : 0, current_function_decl, | |
2363 | &all->stack_args_size, &data->locate); | |
6f086dfc | 2364 | |
e94a448f L |
2365 | /* Update parm_stack_boundary if this parameter is passed in the |
2366 | stack. */ | |
2367 | if (!in_regs && crtl->parm_stack_boundary < data->locate.boundary) | |
2368 | crtl->parm_stack_boundary = data->locate.boundary; | |
2369 | ||
6071dc7f RH |
2370 | /* Adjust offsets to include the pretend args. */ |
2371 | pretend_bytes = all->extra_pretend_bytes - pretend_bytes; | |
2372 | data->locate.slot_offset.constant += pretend_bytes; | |
2373 | data->locate.offset.constant += pretend_bytes; | |
ebca59c3 | 2374 | |
6071dc7f RH |
2375 | data->entry_parm = entry_parm; |
2376 | } | |
6f086dfc | 2377 | |
6071dc7f RH |
2378 | /* A subroutine of assign_parms. If there is actually space on the stack |
2379 | for this parm, count it in stack_args_size and return true. */ | |
6f086dfc | 2380 | |
6071dc7f RH |
2381 | static bool |
2382 | assign_parm_is_stack_parm (struct assign_parm_data_all *all, | |
2383 | struct assign_parm_data_one *data) | |
2384 | { | |
2e6ae27f | 2385 | /* Trivially true if we've no incoming register. */ |
6071dc7f RH |
2386 | if (data->entry_parm == NULL) |
2387 | ; | |
2388 | /* Also true if we're partially in registers and partially not, | |
2389 | since we've arranged to drop the entire argument on the stack. */ | |
2390 | else if (data->partial != 0) | |
2391 | ; | |
2392 | /* Also true if the target says that it's passed in both registers | |
2393 | and on the stack. */ | |
2394 | else if (GET_CODE (data->entry_parm) == PARALLEL | |
2395 | && XEXP (XVECEXP (data->entry_parm, 0, 0), 0) == NULL_RTX) | |
2396 | ; | |
2397 | /* Also true if the target says that there's stack allocated for | |
2398 | all register parameters. */ | |
2399 | else if (all->reg_parm_stack_space > 0) | |
2400 | ; | |
2401 | /* Otherwise, no, this parameter has no ABI defined stack slot. */ | |
2402 | else | |
2403 | return false; | |
6f086dfc | 2404 | |
6071dc7f RH |
2405 | all->stack_args_size.constant += data->locate.size.constant; |
2406 | if (data->locate.size.var) | |
2407 | ADD_PARM_SIZE (all->stack_args_size, data->locate.size.var); | |
718fe406 | 2408 | |
6071dc7f RH |
2409 | return true; |
2410 | } | |
0d1416c6 | 2411 | |
6071dc7f RH |
2412 | /* A subroutine of assign_parms. Given that this parameter is allocated |
2413 | stack space by the ABI, find it. */ | |
6f086dfc | 2414 | |
6071dc7f RH |
2415 | static void |
2416 | assign_parm_find_stack_rtl (tree parm, struct assign_parm_data_one *data) | |
2417 | { | |
2418 | rtx offset_rtx, stack_parm; | |
2419 | unsigned int align, boundary; | |
6f086dfc | 2420 | |
6071dc7f RH |
2421 | /* If we're passing this arg using a reg, make its stack home the |
2422 | aligned stack slot. */ | |
2423 | if (data->entry_parm) | |
2424 | offset_rtx = ARGS_SIZE_RTX (data->locate.slot_offset); | |
2425 | else | |
2426 | offset_rtx = ARGS_SIZE_RTX (data->locate.offset); | |
2427 | ||
38173d38 | 2428 | stack_parm = crtl->args.internal_arg_pointer; |
6071dc7f RH |
2429 | if (offset_rtx != const0_rtx) |
2430 | stack_parm = gen_rtx_PLUS (Pmode, stack_parm, offset_rtx); | |
2431 | stack_parm = gen_rtx_MEM (data->promoted_mode, stack_parm); | |
2432 | ||
2433 | set_mem_attributes (stack_parm, parm, 1); | |
fd0a8853 JJ |
2434 | /* set_mem_attributes could set MEM_SIZE to the passed mode's size, |
2435 | while promoted mode's size is needed. */ | |
2436 | if (data->promoted_mode != BLKmode | |
2437 | && data->promoted_mode != DECL_MODE (parm)) | |
997f78fb JJ |
2438 | { |
2439 | set_mem_size (stack_parm, GEN_INT (GET_MODE_SIZE (data->promoted_mode))); | |
2440 | if (MEM_EXPR (stack_parm) && MEM_OFFSET (stack_parm)) | |
2441 | { | |
2442 | int offset = subreg_lowpart_offset (DECL_MODE (parm), | |
2443 | data->promoted_mode); | |
2444 | if (offset) | |
2445 | set_mem_offset (stack_parm, | |
2446 | plus_constant (MEM_OFFSET (stack_parm), -offset)); | |
2447 | } | |
2448 | } | |
6071dc7f | 2449 | |
bfc45551 AM |
2450 | boundary = data->locate.boundary; |
2451 | align = BITS_PER_UNIT; | |
6071dc7f RH |
2452 | |
2453 | /* If we're padding upward, we know that the alignment of the slot | |
2454 | is FUNCTION_ARG_BOUNDARY. If we're using slot_offset, we're | |
2455 | intentionally forcing upward padding. Otherwise we have to come | |
2456 | up with a guess at the alignment based on OFFSET_RTX. */ | |
bfc45551 | 2457 | if (data->locate.where_pad != downward || data->entry_parm) |
6071dc7f RH |
2458 | align = boundary; |
2459 | else if (GET_CODE (offset_rtx) == CONST_INT) | |
2460 | { | |
2461 | align = INTVAL (offset_rtx) * BITS_PER_UNIT | boundary; | |
2462 | align = align & -align; | |
2463 | } | |
bfc45551 | 2464 | set_mem_align (stack_parm, align); |
6071dc7f RH |
2465 | |
2466 | if (data->entry_parm) | |
2467 | set_reg_attrs_for_parm (data->entry_parm, stack_parm); | |
2468 | ||
2469 | data->stack_parm = stack_parm; | |
2470 | } | |
2471 | ||
2472 | /* A subroutine of assign_parms. Adjust DATA->ENTRY_RTL such that it's | |
2473 | always valid and contiguous. */ | |
2474 | ||
2475 | static void | |
2476 | assign_parm_adjust_entry_rtl (struct assign_parm_data_one *data) | |
2477 | { | |
2478 | rtx entry_parm = data->entry_parm; | |
2479 | rtx stack_parm = data->stack_parm; | |
2480 | ||
2481 | /* If this parm was passed part in regs and part in memory, pretend it | |
2482 | arrived entirely in memory by pushing the register-part onto the stack. | |
2483 | In the special case of a DImode or DFmode that is split, we could put | |
2484 | it together in a pseudoreg directly, but for now that's not worth | |
2485 | bothering with. */ | |
2486 | if (data->partial != 0) | |
2487 | { | |
2488 | /* Handle calls that pass values in multiple non-contiguous | |
2489 | locations. The Irix 6 ABI has examples of this. */ | |
2490 | if (GET_CODE (entry_parm) == PARALLEL) | |
2491 | emit_group_store (validize_mem (stack_parm), entry_parm, | |
2492 | data->passed_type, | |
2493 | int_size_in_bytes (data->passed_type)); | |
6f086dfc | 2494 | else |
78a52f11 RH |
2495 | { |
2496 | gcc_assert (data->partial % UNITS_PER_WORD == 0); | |
2497 | move_block_from_reg (REGNO (entry_parm), validize_mem (stack_parm), | |
2498 | data->partial / UNITS_PER_WORD); | |
2499 | } | |
6f086dfc | 2500 | |
6071dc7f RH |
2501 | entry_parm = stack_parm; |
2502 | } | |
6f086dfc | 2503 | |
6071dc7f RH |
2504 | /* If we didn't decide this parm came in a register, by default it came |
2505 | on the stack. */ | |
2506 | else if (entry_parm == NULL) | |
2507 | entry_parm = stack_parm; | |
2508 | ||
2509 | /* When an argument is passed in multiple locations, we can't make use | |
2510 | of this information, but we can save some copying if the whole argument | |
2511 | is passed in a single register. */ | |
2512 | else if (GET_CODE (entry_parm) == PARALLEL | |
2513 | && data->nominal_mode != BLKmode | |
2514 | && data->passed_mode != BLKmode) | |
2515 | { | |
2516 | size_t i, len = XVECLEN (entry_parm, 0); | |
2517 | ||
2518 | for (i = 0; i < len; i++) | |
2519 | if (XEXP (XVECEXP (entry_parm, 0, i), 0) != NULL_RTX | |
2520 | && REG_P (XEXP (XVECEXP (entry_parm, 0, i), 0)) | |
2521 | && (GET_MODE (XEXP (XVECEXP (entry_parm, 0, i), 0)) | |
2522 | == data->passed_mode) | |
2523 | && INTVAL (XEXP (XVECEXP (entry_parm, 0, i), 1)) == 0) | |
2524 | { | |
2525 | entry_parm = XEXP (XVECEXP (entry_parm, 0, i), 0); | |
2526 | break; | |
2527 | } | |
2528 | } | |
e68a6ce1 | 2529 | |
6071dc7f RH |
2530 | data->entry_parm = entry_parm; |
2531 | } | |
6f086dfc | 2532 | |
4d2a9850 DJ |
2533 | /* A subroutine of assign_parms. Reconstitute any values which were |
2534 | passed in multiple registers and would fit in a single register. */ | |
2535 | ||
2536 | static void | |
2537 | assign_parm_remove_parallels (struct assign_parm_data_one *data) | |
2538 | { | |
2539 | rtx entry_parm = data->entry_parm; | |
2540 | ||
2541 | /* Convert the PARALLEL to a REG of the same mode as the parallel. | |
2542 | This can be done with register operations rather than on the | |
2543 | stack, even if we will store the reconstituted parameter on the | |
2544 | stack later. */ | |
85776d60 | 2545 | if (GET_CODE (entry_parm) == PARALLEL && GET_MODE (entry_parm) != BLKmode) |
4d2a9850 DJ |
2546 | { |
2547 | rtx parmreg = gen_reg_rtx (GET_MODE (entry_parm)); | |
bbd46fd5 | 2548 | emit_group_store (parmreg, entry_parm, data->passed_type, |
4d2a9850 DJ |
2549 | GET_MODE_SIZE (GET_MODE (entry_parm))); |
2550 | entry_parm = parmreg; | |
2551 | } | |
2552 | ||
2553 | data->entry_parm = entry_parm; | |
2554 | } | |
2555 | ||
6071dc7f RH |
2556 | /* A subroutine of assign_parms. Adjust DATA->STACK_RTL such that it's |
2557 | always valid and properly aligned. */ | |
6f086dfc | 2558 | |
6071dc7f RH |
2559 | static void |
2560 | assign_parm_adjust_stack_rtl (struct assign_parm_data_one *data) | |
2561 | { | |
2562 | rtx stack_parm = data->stack_parm; | |
2563 | ||
2564 | /* If we can't trust the parm stack slot to be aligned enough for its | |
2565 | ultimate type, don't use that slot after entry. We'll make another | |
2566 | stack slot, if we need one. */ | |
bfc45551 AM |
2567 | if (stack_parm |
2568 | && ((STRICT_ALIGNMENT | |
2569 | && GET_MODE_ALIGNMENT (data->nominal_mode) > MEM_ALIGN (stack_parm)) | |
2570 | || (data->nominal_type | |
2571 | && TYPE_ALIGN (data->nominal_type) > MEM_ALIGN (stack_parm) | |
2572 | && MEM_ALIGN (stack_parm) < PREFERRED_STACK_BOUNDARY))) | |
6071dc7f RH |
2573 | stack_parm = NULL; |
2574 | ||
2575 | /* If parm was passed in memory, and we need to convert it on entry, | |
2576 | don't store it back in that same slot. */ | |
2577 | else if (data->entry_parm == stack_parm | |
2578 | && data->nominal_mode != BLKmode | |
2579 | && data->nominal_mode != data->passed_mode) | |
2580 | stack_parm = NULL; | |
2581 | ||
7d69de61 RH |
2582 | /* If stack protection is in effect for this function, don't leave any |
2583 | pointers in their passed stack slots. */ | |
cb91fab0 | 2584 | else if (crtl->stack_protect_guard |
7d69de61 RH |
2585 | && (flag_stack_protect == 2 |
2586 | || data->passed_pointer | |
2587 | || POINTER_TYPE_P (data->nominal_type))) | |
2588 | stack_parm = NULL; | |
2589 | ||
6071dc7f RH |
2590 | data->stack_parm = stack_parm; |
2591 | } | |
a0506b54 | 2592 | |
6071dc7f RH |
2593 | /* A subroutine of assign_parms. Return true if the current parameter |
2594 | should be stored as a BLKmode in the current frame. */ | |
2595 | ||
2596 | static bool | |
2597 | assign_parm_setup_block_p (struct assign_parm_data_one *data) | |
2598 | { | |
2599 | if (data->nominal_mode == BLKmode) | |
2600 | return true; | |
85776d60 DJ |
2601 | if (GET_MODE (data->entry_parm) == BLKmode) |
2602 | return true; | |
531547e9 | 2603 | |
6e985040 | 2604 | #ifdef BLOCK_REG_PADDING |
ae8c9754 RS |
2605 | /* Only assign_parm_setup_block knows how to deal with register arguments |
2606 | that are padded at the least significant end. */ | |
2607 | if (REG_P (data->entry_parm) | |
2608 | && GET_MODE_SIZE (data->promoted_mode) < UNITS_PER_WORD | |
2609 | && (BLOCK_REG_PADDING (data->passed_mode, data->passed_type, 1) | |
2610 | == (BYTES_BIG_ENDIAN ? upward : downward))) | |
6071dc7f | 2611 | return true; |
6e985040 | 2612 | #endif |
6071dc7f RH |
2613 | |
2614 | return false; | |
2615 | } | |
2616 | ||
2617 | /* A subroutine of assign_parms. Arrange for the parameter to be | |
2618 | present and valid in DATA->STACK_RTL. */ | |
2619 | ||
2620 | static void | |
27e29549 RH |
2621 | assign_parm_setup_block (struct assign_parm_data_all *all, |
2622 | tree parm, struct assign_parm_data_one *data) | |
6071dc7f RH |
2623 | { |
2624 | rtx entry_parm = data->entry_parm; | |
2625 | rtx stack_parm = data->stack_parm; | |
bfc45551 AM |
2626 | HOST_WIDE_INT size; |
2627 | HOST_WIDE_INT size_stored; | |
6071dc7f | 2628 | |
27e29549 RH |
2629 | if (GET_CODE (entry_parm) == PARALLEL) |
2630 | entry_parm = emit_group_move_into_temps (entry_parm); | |
2631 | ||
bfc45551 AM |
2632 | size = int_size_in_bytes (data->passed_type); |
2633 | size_stored = CEIL_ROUND (size, UNITS_PER_WORD); | |
2634 | if (stack_parm == 0) | |
2635 | { | |
a561d88b | 2636 | DECL_ALIGN (parm) = MAX (DECL_ALIGN (parm), BITS_PER_WORD); |
bfc45551 | 2637 | stack_parm = assign_stack_local (BLKmode, size_stored, |
a561d88b | 2638 | DECL_ALIGN (parm)); |
bfc45551 AM |
2639 | if (GET_MODE_SIZE (GET_MODE (entry_parm)) == size) |
2640 | PUT_MODE (stack_parm, GET_MODE (entry_parm)); | |
2641 | set_mem_attributes (stack_parm, parm, 1); | |
2642 | } | |
2643 | ||
6071dc7f RH |
2644 | /* If a BLKmode arrives in registers, copy it to a stack slot. Handle |
2645 | calls that pass values in multiple non-contiguous locations. */ | |
2646 | if (REG_P (entry_parm) || GET_CODE (entry_parm) == PARALLEL) | |
2647 | { | |
6071dc7f RH |
2648 | rtx mem; |
2649 | ||
2650 | /* Note that we will be storing an integral number of words. | |
2651 | So we have to be careful to ensure that we allocate an | |
bfc45551 | 2652 | integral number of words. We do this above when we call |
6071dc7f RH |
2653 | assign_stack_local if space was not allocated in the argument |
2654 | list. If it was, this will not work if PARM_BOUNDARY is not | |
2655 | a multiple of BITS_PER_WORD. It isn't clear how to fix this | |
2656 | if it becomes a problem. Exception is when BLKmode arrives | |
2657 | with arguments not conforming to word_mode. */ | |
2658 | ||
bfc45551 AM |
2659 | if (data->stack_parm == 0) |
2660 | ; | |
6071dc7f RH |
2661 | else if (GET_CODE (entry_parm) == PARALLEL) |
2662 | ; | |
0bccc606 NS |
2663 | else |
2664 | gcc_assert (!size || !(PARM_BOUNDARY % BITS_PER_WORD)); | |
6f086dfc | 2665 | |
6071dc7f | 2666 | mem = validize_mem (stack_parm); |
c6b97fac | 2667 | |
6071dc7f RH |
2668 | /* Handle values in multiple non-contiguous locations. */ |
2669 | if (GET_CODE (entry_parm) == PARALLEL) | |
27e29549 | 2670 | { |
bb27eeda SE |
2671 | push_to_sequence2 (all->first_conversion_insn, |
2672 | all->last_conversion_insn); | |
27e29549 | 2673 | emit_group_store (mem, entry_parm, data->passed_type, size); |
bb27eeda SE |
2674 | all->first_conversion_insn = get_insns (); |
2675 | all->last_conversion_insn = get_last_insn (); | |
27e29549 RH |
2676 | end_sequence (); |
2677 | } | |
c6b97fac | 2678 | |
6071dc7f RH |
2679 | else if (size == 0) |
2680 | ; | |
5c07bd7a | 2681 | |
6071dc7f RH |
2682 | /* If SIZE is that of a mode no bigger than a word, just use |
2683 | that mode's store operation. */ | |
2684 | else if (size <= UNITS_PER_WORD) | |
2685 | { | |
2686 | enum machine_mode mode | |
2687 | = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0); | |
c6b97fac | 2688 | |
6071dc7f | 2689 | if (mode != BLKmode |
6e985040 | 2690 | #ifdef BLOCK_REG_PADDING |
6071dc7f RH |
2691 | && (size == UNITS_PER_WORD |
2692 | || (BLOCK_REG_PADDING (mode, data->passed_type, 1) | |
2693 | != (BYTES_BIG_ENDIAN ? upward : downward))) | |
6e985040 | 2694 | #endif |
6071dc7f RH |
2695 | ) |
2696 | { | |
208996c7 RS |
2697 | rtx reg; |
2698 | ||
2699 | /* We are really truncating a word_mode value containing | |
2700 | SIZE bytes into a value of mode MODE. If such an | |
2701 | operation requires no actual instructions, we can refer | |
2702 | to the value directly in mode MODE, otherwise we must | |
2703 | start with the register in word_mode and explicitly | |
2704 | convert it. */ | |
2705 | if (TRULY_NOOP_TRUNCATION (size * BITS_PER_UNIT, BITS_PER_WORD)) | |
2706 | reg = gen_rtx_REG (mode, REGNO (entry_parm)); | |
2707 | else | |
2708 | { | |
2709 | reg = gen_rtx_REG (word_mode, REGNO (entry_parm)); | |
2710 | reg = convert_to_mode (mode, copy_to_reg (reg), 1); | |
2711 | } | |
6071dc7f RH |
2712 | emit_move_insn (change_address (mem, mode, 0), reg); |
2713 | } | |
c6b97fac | 2714 | |
6071dc7f RH |
2715 | /* Blocks smaller than a word on a BYTES_BIG_ENDIAN |
2716 | machine must be aligned to the left before storing | |
2717 | to memory. Note that the previous test doesn't | |
2718 | handle all cases (e.g. SIZE == 3). */ | |
2719 | else if (size != UNITS_PER_WORD | |
6e985040 | 2720 | #ifdef BLOCK_REG_PADDING |
6071dc7f RH |
2721 | && (BLOCK_REG_PADDING (mode, data->passed_type, 1) |
2722 | == downward) | |
6e985040 | 2723 | #else |
6071dc7f | 2724 | && BYTES_BIG_ENDIAN |
6e985040 | 2725 | #endif |
6071dc7f RH |
2726 | ) |
2727 | { | |
2728 | rtx tem, x; | |
2729 | int by = (UNITS_PER_WORD - size) * BITS_PER_UNIT; | |
65c844e2 | 2730 | rtx reg = gen_rtx_REG (word_mode, REGNO (entry_parm)); |
6071dc7f | 2731 | |
09b52670 | 2732 | x = expand_shift (LSHIFT_EXPR, word_mode, reg, |
7d60be94 | 2733 | build_int_cst (NULL_TREE, by), |
4a90aeeb | 2734 | NULL_RTX, 1); |
6071dc7f RH |
2735 | tem = change_address (mem, word_mode, 0); |
2736 | emit_move_insn (tem, x); | |
6f086dfc | 2737 | } |
6071dc7f | 2738 | else |
27e29549 | 2739 | move_block_from_reg (REGNO (entry_parm), mem, |
6071dc7f | 2740 | size_stored / UNITS_PER_WORD); |
6f086dfc | 2741 | } |
6071dc7f | 2742 | else |
27e29549 | 2743 | move_block_from_reg (REGNO (entry_parm), mem, |
6071dc7f RH |
2744 | size_stored / UNITS_PER_WORD); |
2745 | } | |
bfc45551 AM |
2746 | else if (data->stack_parm == 0) |
2747 | { | |
bb27eeda | 2748 | push_to_sequence2 (all->first_conversion_insn, all->last_conversion_insn); |
bfc45551 AM |
2749 | emit_block_move (stack_parm, data->entry_parm, GEN_INT (size), |
2750 | BLOCK_OP_NORMAL); | |
bb27eeda SE |
2751 | all->first_conversion_insn = get_insns (); |
2752 | all->last_conversion_insn = get_last_insn (); | |
bfc45551 AM |
2753 | end_sequence (); |
2754 | } | |
6071dc7f | 2755 | |
bfc45551 | 2756 | data->stack_parm = stack_parm; |
6071dc7f RH |
2757 | SET_DECL_RTL (parm, stack_parm); |
2758 | } | |
2759 | ||
2760 | /* A subroutine of assign_parms. Allocate a pseudo to hold the current | |
2761 | parameter. Get it there. Perform all ABI specified conversions. */ | |
2762 | ||
2763 | static void | |
2764 | assign_parm_setup_reg (struct assign_parm_data_all *all, tree parm, | |
2765 | struct assign_parm_data_one *data) | |
2766 | { | |
2767 | rtx parmreg; | |
2768 | enum machine_mode promoted_nominal_mode; | |
2769 | int unsignedp = TYPE_UNSIGNED (TREE_TYPE (parm)); | |
2770 | bool did_conversion = false; | |
2771 | ||
2772 | /* Store the parm in a pseudoregister during the function, but we may | |
2773 | need to do it in a wider mode. */ | |
2774 | ||
3f9e6aed PB |
2775 | /* This is not really promoting for a call. However we need to be |
2776 | consistent with assign_parm_find_data_types and expand_expr_real_1. */ | |
6071dc7f | 2777 | promoted_nominal_mode |
3f9e6aed | 2778 | = promote_mode (data->nominal_type, data->nominal_mode, &unsignedp, 1); |
6071dc7f RH |
2779 | |
2780 | parmreg = gen_reg_rtx (promoted_nominal_mode); | |
2781 | ||
2782 | if (!DECL_ARTIFICIAL (parm)) | |
2783 | mark_user_reg (parmreg); | |
2784 | ||
2785 | /* If this was an item that we received a pointer to, | |
2786 | set DECL_RTL appropriately. */ | |
2787 | if (data->passed_pointer) | |
2788 | { | |
2789 | rtx x = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data->passed_type)), parmreg); | |
2790 | set_mem_attributes (x, parm, 1); | |
2791 | SET_DECL_RTL (parm, x); | |
2792 | } | |
2793 | else | |
389fdba0 | 2794 | SET_DECL_RTL (parm, parmreg); |
6071dc7f | 2795 | |
4d2a9850 DJ |
2796 | assign_parm_remove_parallels (data); |
2797 | ||
6071dc7f RH |
2798 | /* Copy the value into the register. */ |
2799 | if (data->nominal_mode != data->passed_mode | |
2800 | || promoted_nominal_mode != data->promoted_mode) | |
2801 | { | |
2802 | int save_tree_used; | |
2803 | ||
2804 | /* ENTRY_PARM has been converted to PROMOTED_MODE, its | |
2805 | mode, by the caller. We now have to convert it to | |
2806 | NOMINAL_MODE, if different. However, PARMREG may be in | |
2807 | a different mode than NOMINAL_MODE if it is being stored | |
2808 | promoted. | |
2809 | ||
2810 | If ENTRY_PARM is a hard register, it might be in a register | |
2811 | not valid for operating in its mode (e.g., an odd-numbered | |
2812 | register for a DFmode). In that case, moves are the only | |
2813 | thing valid, so we can't do a convert from there. This | |
2814 | occurs when the calling sequence allow such misaligned | |
2815 | usages. | |
2816 | ||
2817 | In addition, the conversion may involve a call, which could | |
2818 | clobber parameters which haven't been copied to pseudo | |
2819 | registers yet. Therefore, we must first copy the parm to | |
2820 | a pseudo reg here, and save the conversion until after all | |
2821 | parameters have been moved. */ | |
2822 | ||
2823 | rtx tempreg = gen_reg_rtx (GET_MODE (data->entry_parm)); | |
2824 | ||
2825 | emit_move_insn (tempreg, validize_mem (data->entry_parm)); | |
2826 | ||
bb27eeda | 2827 | push_to_sequence2 (all->first_conversion_insn, all->last_conversion_insn); |
6071dc7f RH |
2828 | tempreg = convert_to_mode (data->nominal_mode, tempreg, unsignedp); |
2829 | ||
2830 | if (GET_CODE (tempreg) == SUBREG | |
2831 | && GET_MODE (tempreg) == data->nominal_mode | |
2832 | && REG_P (SUBREG_REG (tempreg)) | |
2833 | && data->nominal_mode == data->passed_mode | |
2834 | && GET_MODE (SUBREG_REG (tempreg)) == GET_MODE (data->entry_parm) | |
2835 | && GET_MODE_SIZE (GET_MODE (tempreg)) | |
2836 | < GET_MODE_SIZE (GET_MODE (data->entry_parm))) | |
6f086dfc | 2837 | { |
6071dc7f RH |
2838 | /* The argument is already sign/zero extended, so note it |
2839 | into the subreg. */ | |
2840 | SUBREG_PROMOTED_VAR_P (tempreg) = 1; | |
2841 | SUBREG_PROMOTED_UNSIGNED_SET (tempreg, unsignedp); | |
2842 | } | |
00d8a4c1 | 2843 | |
6071dc7f RH |
2844 | /* TREE_USED gets set erroneously during expand_assignment. */ |
2845 | save_tree_used = TREE_USED (parm); | |
79f5e442 | 2846 | expand_assignment (parm, make_tree (data->nominal_type, tempreg), false); |
6071dc7f | 2847 | TREE_USED (parm) = save_tree_used; |
bb27eeda SE |
2848 | all->first_conversion_insn = get_insns (); |
2849 | all->last_conversion_insn = get_last_insn (); | |
6071dc7f | 2850 | end_sequence (); |
00d8a4c1 | 2851 | |
6071dc7f RH |
2852 | did_conversion = true; |
2853 | } | |
2854 | else | |
2855 | emit_move_insn (parmreg, validize_mem (data->entry_parm)); | |
2856 | ||
2857 | /* If we were passed a pointer but the actual value can safely live | |
2858 | in a register, put it in one. */ | |
2859 | if (data->passed_pointer | |
2860 | && TYPE_MODE (TREE_TYPE (parm)) != BLKmode | |
2861 | /* If by-reference argument was promoted, demote it. */ | |
2862 | && (TYPE_MODE (TREE_TYPE (parm)) != GET_MODE (DECL_RTL (parm)) | |
2863 | || use_register_for_decl (parm))) | |
2864 | { | |
2865 | /* We can't use nominal_mode, because it will have been set to | |
2866 | Pmode above. We must use the actual mode of the parm. */ | |
2867 | parmreg = gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm))); | |
2868 | mark_user_reg (parmreg); | |
cd5b3469 | 2869 | |
6071dc7f RH |
2870 | if (GET_MODE (parmreg) != GET_MODE (DECL_RTL (parm))) |
2871 | { | |
2872 | rtx tempreg = gen_reg_rtx (GET_MODE (DECL_RTL (parm))); | |
2873 | int unsigned_p = TYPE_UNSIGNED (TREE_TYPE (parm)); | |
2874 | ||
bb27eeda SE |
2875 | push_to_sequence2 (all->first_conversion_insn, |
2876 | all->last_conversion_insn); | |
6071dc7f RH |
2877 | emit_move_insn (tempreg, DECL_RTL (parm)); |
2878 | tempreg = convert_to_mode (GET_MODE (parmreg), tempreg, unsigned_p); | |
2879 | emit_move_insn (parmreg, tempreg); | |
bb27eeda SE |
2880 | all->first_conversion_insn = get_insns (); |
2881 | all->last_conversion_insn = get_last_insn (); | |
6071dc7f | 2882 | end_sequence (); |
6f086dfc | 2883 | |
6071dc7f RH |
2884 | did_conversion = true; |
2885 | } | |
2886 | else | |
2887 | emit_move_insn (parmreg, DECL_RTL (parm)); | |
6f086dfc | 2888 | |
6071dc7f | 2889 | SET_DECL_RTL (parm, parmreg); |
797a6ac1 | 2890 | |
6071dc7f RH |
2891 | /* STACK_PARM is the pointer, not the parm, and PARMREG is |
2892 | now the parm. */ | |
2893 | data->stack_parm = NULL; | |
2894 | } | |
ddef6bc7 | 2895 | |
6071dc7f RH |
2896 | /* Mark the register as eliminable if we did no conversion and it was |
2897 | copied from memory at a fixed offset, and the arg pointer was not | |
2898 | copied to a pseudo-reg. If the arg pointer is a pseudo reg or the | |
2899 | offset formed an invalid address, such memory-equivalences as we | |
2900 | make here would screw up life analysis for it. */ | |
2901 | if (data->nominal_mode == data->passed_mode | |
2902 | && !did_conversion | |
2903 | && data->stack_parm != 0 | |
2904 | && MEM_P (data->stack_parm) | |
2905 | && data->locate.offset.var == 0 | |
2906 | && reg_mentioned_p (virtual_incoming_args_rtx, | |
2907 | XEXP (data->stack_parm, 0))) | |
2908 | { | |
2909 | rtx linsn = get_last_insn (); | |
2910 | rtx sinsn, set; | |
a03caf76 | 2911 | |
6071dc7f RH |
2912 | /* Mark complex types separately. */ |
2913 | if (GET_CODE (parmreg) == CONCAT) | |
2914 | { | |
2915 | enum machine_mode submode | |
2916 | = GET_MODE_INNER (GET_MODE (parmreg)); | |
1466e387 RH |
2917 | int regnor = REGNO (XEXP (parmreg, 0)); |
2918 | int regnoi = REGNO (XEXP (parmreg, 1)); | |
2919 | rtx stackr = adjust_address_nv (data->stack_parm, submode, 0); | |
2920 | rtx stacki = adjust_address_nv (data->stack_parm, submode, | |
2921 | GET_MODE_SIZE (submode)); | |
6071dc7f RH |
2922 | |
2923 | /* Scan backwards for the set of the real and | |
2924 | imaginary parts. */ | |
2925 | for (sinsn = linsn; sinsn != 0; | |
2926 | sinsn = prev_nonnote_insn (sinsn)) | |
2927 | { | |
2928 | set = single_set (sinsn); | |
2929 | if (set == 0) | |
2930 | continue; | |
2931 | ||
2932 | if (SET_DEST (set) == regno_reg_rtx [regnoi]) | |
a31830a7 | 2933 | set_unique_reg_note (sinsn, REG_EQUIV, stacki); |
6071dc7f | 2934 | else if (SET_DEST (set) == regno_reg_rtx [regnor]) |
a31830a7 | 2935 | set_unique_reg_note (sinsn, REG_EQUIV, stackr); |
a03caf76 | 2936 | } |
6071dc7f RH |
2937 | } |
2938 | else if ((set = single_set (linsn)) != 0 | |
2939 | && SET_DEST (set) == parmreg) | |
a31830a7 | 2940 | set_unique_reg_note (linsn, REG_EQUIV, data->stack_parm); |
6071dc7f RH |
2941 | } |
2942 | ||
2943 | /* For pointer data type, suggest pointer register. */ | |
2944 | if (POINTER_TYPE_P (TREE_TYPE (parm))) | |
2945 | mark_reg_pointer (parmreg, | |
2946 | TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm)))); | |
2947 | } | |
2948 | ||
2949 | /* A subroutine of assign_parms. Allocate stack space to hold the current | |
2950 | parameter. Get it there. Perform all ABI specified conversions. */ | |
2951 | ||
2952 | static void | |
2953 | assign_parm_setup_stack (struct assign_parm_data_all *all, tree parm, | |
2954 | struct assign_parm_data_one *data) | |
2955 | { | |
2956 | /* Value must be stored in the stack slot STACK_PARM during function | |
2957 | execution. */ | |
bfc45551 | 2958 | bool to_conversion = false; |
6071dc7f | 2959 | |
4d2a9850 DJ |
2960 | assign_parm_remove_parallels (data); |
2961 | ||
6071dc7f RH |
2962 | if (data->promoted_mode != data->nominal_mode) |
2963 | { | |
2964 | /* Conversion is required. */ | |
2965 | rtx tempreg = gen_reg_rtx (GET_MODE (data->entry_parm)); | |
6f086dfc | 2966 | |
6071dc7f RH |
2967 | emit_move_insn (tempreg, validize_mem (data->entry_parm)); |
2968 | ||
bb27eeda | 2969 | push_to_sequence2 (all->first_conversion_insn, all->last_conversion_insn); |
bfc45551 AM |
2970 | to_conversion = true; |
2971 | ||
6071dc7f RH |
2972 | data->entry_parm = convert_to_mode (data->nominal_mode, tempreg, |
2973 | TYPE_UNSIGNED (TREE_TYPE (parm))); | |
2974 | ||
2975 | if (data->stack_parm) | |
2976 | /* ??? This may need a big-endian conversion on sparc64. */ | |
2977 | data->stack_parm | |
2978 | = adjust_address (data->stack_parm, data->nominal_mode, 0); | |
6071dc7f RH |
2979 | } |
2980 | ||
2981 | if (data->entry_parm != data->stack_parm) | |
2982 | { | |
bfc45551 AM |
2983 | rtx src, dest; |
2984 | ||
6071dc7f RH |
2985 | if (data->stack_parm == 0) |
2986 | { | |
3a695389 UW |
2987 | int align = STACK_SLOT_ALIGNMENT (data->passed_type, |
2988 | GET_MODE (data->entry_parm), | |
2989 | TYPE_ALIGN (data->passed_type)); | |
6071dc7f RH |
2990 | data->stack_parm |
2991 | = assign_stack_local (GET_MODE (data->entry_parm), | |
2992 | GET_MODE_SIZE (GET_MODE (data->entry_parm)), | |
3a695389 | 2993 | align); |
6071dc7f | 2994 | set_mem_attributes (data->stack_parm, parm, 1); |
6f086dfc | 2995 | } |
6071dc7f | 2996 | |
bfc45551 AM |
2997 | dest = validize_mem (data->stack_parm); |
2998 | src = validize_mem (data->entry_parm); | |
2999 | ||
3000 | if (MEM_P (src)) | |
6f086dfc | 3001 | { |
bfc45551 AM |
3002 | /* Use a block move to handle potentially misaligned entry_parm. */ |
3003 | if (!to_conversion) | |
bb27eeda SE |
3004 | push_to_sequence2 (all->first_conversion_insn, |
3005 | all->last_conversion_insn); | |
bfc45551 AM |
3006 | to_conversion = true; |
3007 | ||
3008 | emit_block_move (dest, src, | |
3009 | GEN_INT (int_size_in_bytes (data->passed_type)), | |
3010 | BLOCK_OP_NORMAL); | |
6071dc7f RH |
3011 | } |
3012 | else | |
bfc45551 AM |
3013 | emit_move_insn (dest, src); |
3014 | } | |
3015 | ||
3016 | if (to_conversion) | |
3017 | { | |
bb27eeda SE |
3018 | all->first_conversion_insn = get_insns (); |
3019 | all->last_conversion_insn = get_last_insn (); | |
bfc45551 | 3020 | end_sequence (); |
6071dc7f | 3021 | } |
6f086dfc | 3022 | |
6071dc7f RH |
3023 | SET_DECL_RTL (parm, data->stack_parm); |
3024 | } | |
3412b298 | 3025 | |
6071dc7f RH |
3026 | /* A subroutine of assign_parms. If the ABI splits complex arguments, then |
3027 | undo the frobbing that we did in assign_parms_augmented_arg_list. */ | |
86f8eff3 | 3028 | |
6071dc7f | 3029 | static void |
6ccd356e | 3030 | assign_parms_unsplit_complex (struct assign_parm_data_all *all, tree fnargs) |
6071dc7f RH |
3031 | { |
3032 | tree parm; | |
6ccd356e | 3033 | tree orig_fnargs = all->orig_fnargs; |
f4ef873c | 3034 | |
6071dc7f RH |
3035 | for (parm = orig_fnargs; parm; parm = TREE_CHAIN (parm)) |
3036 | { | |
3037 | if (TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE | |
3038 | && targetm.calls.split_complex_arg (TREE_TYPE (parm))) | |
3039 | { | |
3040 | rtx tmp, real, imag; | |
3041 | enum machine_mode inner = GET_MODE_INNER (DECL_MODE (parm)); | |
6f086dfc | 3042 | |
6071dc7f RH |
3043 | real = DECL_RTL (fnargs); |
3044 | imag = DECL_RTL (TREE_CHAIN (fnargs)); | |
3045 | if (inner != GET_MODE (real)) | |
6f086dfc | 3046 | { |
6071dc7f RH |
3047 | real = gen_lowpart_SUBREG (inner, real); |
3048 | imag = gen_lowpart_SUBREG (inner, imag); | |
3049 | } | |
6ccd356e AM |
3050 | |
3051 | if (TREE_ADDRESSABLE (parm)) | |
3052 | { | |
3053 | rtx rmem, imem; | |
3054 | HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (parm)); | |
3a695389 UW |
3055 | int align = STACK_SLOT_ALIGNMENT (TREE_TYPE (parm), |
3056 | DECL_MODE (parm), | |
3057 | TYPE_ALIGN (TREE_TYPE (parm))); | |
6ccd356e AM |
3058 | |
3059 | /* split_complex_arg put the real and imag parts in | |
3060 | pseudos. Move them to memory. */ | |
3a695389 | 3061 | tmp = assign_stack_local (DECL_MODE (parm), size, align); |
6ccd356e AM |
3062 | set_mem_attributes (tmp, parm, 1); |
3063 | rmem = adjust_address_nv (tmp, inner, 0); | |
3064 | imem = adjust_address_nv (tmp, inner, GET_MODE_SIZE (inner)); | |
bb27eeda SE |
3065 | push_to_sequence2 (all->first_conversion_insn, |
3066 | all->last_conversion_insn); | |
6ccd356e AM |
3067 | emit_move_insn (rmem, real); |
3068 | emit_move_insn (imem, imag); | |
bb27eeda SE |
3069 | all->first_conversion_insn = get_insns (); |
3070 | all->last_conversion_insn = get_last_insn (); | |
6ccd356e AM |
3071 | end_sequence (); |
3072 | } | |
3073 | else | |
3074 | tmp = gen_rtx_CONCAT (DECL_MODE (parm), real, imag); | |
6071dc7f | 3075 | SET_DECL_RTL (parm, tmp); |
7e41ffa2 | 3076 | |
6071dc7f RH |
3077 | real = DECL_INCOMING_RTL (fnargs); |
3078 | imag = DECL_INCOMING_RTL (TREE_CHAIN (fnargs)); | |
3079 | if (inner != GET_MODE (real)) | |
3080 | { | |
3081 | real = gen_lowpart_SUBREG (inner, real); | |
3082 | imag = gen_lowpart_SUBREG (inner, imag); | |
6f086dfc | 3083 | } |
6071dc7f | 3084 | tmp = gen_rtx_CONCAT (DECL_MODE (parm), real, imag); |
5141868d | 3085 | set_decl_incoming_rtl (parm, tmp, false); |
6071dc7f RH |
3086 | fnargs = TREE_CHAIN (fnargs); |
3087 | } | |
3088 | else | |
3089 | { | |
3090 | SET_DECL_RTL (parm, DECL_RTL (fnargs)); | |
5141868d | 3091 | set_decl_incoming_rtl (parm, DECL_INCOMING_RTL (fnargs), false); |
6f086dfc | 3092 | |
6071dc7f RH |
3093 | /* Set MEM_EXPR to the original decl, i.e. to PARM, |
3094 | instead of the copy of decl, i.e. FNARGS. */ | |
3095 | if (DECL_INCOMING_RTL (parm) && MEM_P (DECL_INCOMING_RTL (parm))) | |
3096 | set_mem_expr (DECL_INCOMING_RTL (parm), parm); | |
6f086dfc | 3097 | } |
6071dc7f RH |
3098 | |
3099 | fnargs = TREE_CHAIN (fnargs); | |
6f086dfc | 3100 | } |
6071dc7f RH |
3101 | } |
3102 | ||
3103 | /* Assign RTL expressions to the function's parameters. This may involve | |
3104 | copying them into registers and using those registers as the DECL_RTL. */ | |
3105 | ||
6fe79279 | 3106 | static void |
6071dc7f RH |
3107 | assign_parms (tree fndecl) |
3108 | { | |
3109 | struct assign_parm_data_all all; | |
3110 | tree fnargs, parm; | |
6f086dfc | 3111 | |
38173d38 | 3112 | crtl->args.internal_arg_pointer |
150cdc9e | 3113 | = targetm.calls.internal_arg_pointer (); |
6071dc7f RH |
3114 | |
3115 | assign_parms_initialize_all (&all); | |
3116 | fnargs = assign_parms_augmented_arg_list (&all); | |
3117 | ||
3118 | for (parm = fnargs; parm; parm = TREE_CHAIN (parm)) | |
ded9bf77 | 3119 | { |
6071dc7f RH |
3120 | struct assign_parm_data_one data; |
3121 | ||
3122 | /* Extract the type of PARM; adjust it according to ABI. */ | |
3123 | assign_parm_find_data_types (&all, parm, &data); | |
3124 | ||
3125 | /* Early out for errors and void parameters. */ | |
3126 | if (data.passed_mode == VOIDmode) | |
ded9bf77 | 3127 | { |
6071dc7f RH |
3128 | SET_DECL_RTL (parm, const0_rtx); |
3129 | DECL_INCOMING_RTL (parm) = DECL_RTL (parm); | |
3130 | continue; | |
3131 | } | |
196c42cd | 3132 | |
2e3f842f L |
3133 | /* Estimate stack alignment from parameter alignment. */ |
3134 | if (SUPPORTS_STACK_ALIGNMENT) | |
3135 | { | |
3136 | unsigned int align = FUNCTION_ARG_BOUNDARY (data.promoted_mode, | |
3137 | data.passed_type); | |
3138 | if (TYPE_ALIGN (data.nominal_type) > align) | |
3139 | align = TYPE_ALIGN (data.passed_type); | |
3140 | if (crtl->stack_alignment_estimated < align) | |
3141 | { | |
3142 | gcc_assert (!crtl->stack_realign_processed); | |
3143 | crtl->stack_alignment_estimated = align; | |
3144 | } | |
3145 | } | |
3146 | ||
e3b5732b | 3147 | if (cfun->stdarg && !TREE_CHAIN (parm)) |
8117c488 | 3148 | assign_parms_setup_varargs (&all, &data, false); |
196c42cd | 3149 | |
6071dc7f RH |
3150 | /* Find out where the parameter arrives in this function. */ |
3151 | assign_parm_find_entry_rtl (&all, &data); | |
3152 | ||
3153 | /* Find out where stack space for this parameter might be. */ | |
3154 | if (assign_parm_is_stack_parm (&all, &data)) | |
3155 | { | |
3156 | assign_parm_find_stack_rtl (parm, &data); | |
3157 | assign_parm_adjust_entry_rtl (&data); | |
ded9bf77 | 3158 | } |
6071dc7f RH |
3159 | |
3160 | /* Record permanently how this parm was passed. */ | |
5141868d | 3161 | set_decl_incoming_rtl (parm, data.entry_parm, data.passed_pointer); |
6071dc7f RH |
3162 | |
3163 | /* Update info on where next arg arrives in registers. */ | |
3164 | FUNCTION_ARG_ADVANCE (all.args_so_far, data.promoted_mode, | |
3165 | data.passed_type, data.named_arg); | |
3166 | ||
3167 | assign_parm_adjust_stack_rtl (&data); | |
3168 | ||
3169 | if (assign_parm_setup_block_p (&data)) | |
27e29549 | 3170 | assign_parm_setup_block (&all, parm, &data); |
6071dc7f RH |
3171 | else if (data.passed_pointer || use_register_for_decl (parm)) |
3172 | assign_parm_setup_reg (&all, parm, &data); | |
3173 | else | |
3174 | assign_parm_setup_stack (&all, parm, &data); | |
ded9bf77 AH |
3175 | } |
3176 | ||
6071dc7f | 3177 | if (targetm.calls.split_complex_arg && fnargs != all.orig_fnargs) |
6ccd356e | 3178 | assign_parms_unsplit_complex (&all, fnargs); |
6071dc7f | 3179 | |
3412b298 JW |
3180 | /* Output all parameter conversion instructions (possibly including calls) |
3181 | now that all parameters have been copied out of hard registers. */ | |
bb27eeda | 3182 | emit_insn (all.first_conversion_insn); |
3412b298 | 3183 | |
2e3f842f L |
3184 | /* Estimate reload stack alignment from scalar return mode. */ |
3185 | if (SUPPORTS_STACK_ALIGNMENT) | |
3186 | { | |
3187 | if (DECL_RESULT (fndecl)) | |
3188 | { | |
3189 | tree type = TREE_TYPE (DECL_RESULT (fndecl)); | |
3190 | enum machine_mode mode = TYPE_MODE (type); | |
3191 | ||
3192 | if (mode != BLKmode | |
3193 | && mode != VOIDmode | |
3194 | && !AGGREGATE_TYPE_P (type)) | |
3195 | { | |
3196 | unsigned int align = GET_MODE_ALIGNMENT (mode); | |
3197 | if (crtl->stack_alignment_estimated < align) | |
3198 | { | |
3199 | gcc_assert (!crtl->stack_realign_processed); | |
3200 | crtl->stack_alignment_estimated = align; | |
3201 | } | |
3202 | } | |
3203 | } | |
3204 | } | |
3205 | ||
b36a8cc2 OH |
3206 | /* If we are receiving a struct value address as the first argument, set up |
3207 | the RTL for the function result. As this might require code to convert | |
3208 | the transmitted address to Pmode, we do this here to ensure that possible | |
3209 | preliminary conversions of the address have been emitted already. */ | |
6071dc7f | 3210 | if (all.function_result_decl) |
b36a8cc2 | 3211 | { |
6071dc7f RH |
3212 | tree result = DECL_RESULT (current_function_decl); |
3213 | rtx addr = DECL_RTL (all.function_result_decl); | |
b36a8cc2 | 3214 | rtx x; |
fa8db1f7 | 3215 | |
cc77ae10 JM |
3216 | if (DECL_BY_REFERENCE (result)) |
3217 | x = addr; | |
3218 | else | |
3219 | { | |
3220 | addr = convert_memory_address (Pmode, addr); | |
3221 | x = gen_rtx_MEM (DECL_MODE (result), addr); | |
3222 | set_mem_attributes (x, result, 1); | |
3223 | } | |
b36a8cc2 OH |
3224 | SET_DECL_RTL (result, x); |
3225 | } | |
3226 | ||
53c428d0 | 3227 | /* We have aligned all the args, so add space for the pretend args. */ |
38173d38 | 3228 | crtl->args.pretend_args_size = all.pretend_args_size; |
6071dc7f | 3229 | all.stack_args_size.constant += all.extra_pretend_bytes; |
38173d38 | 3230 | crtl->args.size = all.stack_args_size.constant; |
6f086dfc RS |
3231 | |
3232 | /* Adjust function incoming argument size for alignment and | |
3233 | minimum length. */ | |
3234 | ||
3235 | #ifdef REG_PARM_STACK_SPACE | |
38173d38 | 3236 | crtl->args.size = MAX (crtl->args.size, |
6f086dfc | 3237 | REG_PARM_STACK_SPACE (fndecl)); |
6f90e075 | 3238 | #endif |
6f086dfc | 3239 | |
38173d38 | 3240 | crtl->args.size = CEIL_ROUND (crtl->args.size, |
53366450 | 3241 | PARM_BOUNDARY / BITS_PER_UNIT); |
4433e339 | 3242 | |
6f086dfc | 3243 | #ifdef ARGS_GROW_DOWNWARD |
38173d38 | 3244 | crtl->args.arg_offset_rtx |
477eff96 | 3245 | = (all.stack_args_size.var == 0 ? GEN_INT (-all.stack_args_size.constant) |
6071dc7f RH |
3246 | : expand_expr (size_diffop (all.stack_args_size.var, |
3247 | size_int (-all.stack_args_size.constant)), | |
bbbbb16a | 3248 | NULL_RTX, VOIDmode, EXPAND_NORMAL)); |
6f086dfc | 3249 | #else |
38173d38 | 3250 | crtl->args.arg_offset_rtx = ARGS_SIZE_RTX (all.stack_args_size); |
6f086dfc RS |
3251 | #endif |
3252 | ||
3253 | /* See how many bytes, if any, of its args a function should try to pop | |
3254 | on return. */ | |
3255 | ||
38173d38 JH |
3256 | crtl->args.pops_args = RETURN_POPS_ARGS (fndecl, TREE_TYPE (fndecl), |
3257 | crtl->args.size); | |
6f086dfc | 3258 | |
3b69d50e RK |
3259 | /* For stdarg.h function, save info about |
3260 | regs and stack space used by the named args. */ | |
6f086dfc | 3261 | |
38173d38 | 3262 | crtl->args.info = all.args_so_far; |
6f086dfc RS |
3263 | |
3264 | /* Set the rtx used for the function return value. Put this in its | |
3265 | own variable so any optimizers that need this information don't have | |
3266 | to include tree.h. Do this here so it gets done when an inlined | |
3267 | function gets output. */ | |
3268 | ||
38173d38 | 3269 | crtl->return_rtx |
19e7881c MM |
3270 | = (DECL_RTL_SET_P (DECL_RESULT (fndecl)) |
3271 | ? DECL_RTL (DECL_RESULT (fndecl)) : NULL_RTX); | |
ce5e43d0 JJ |
3272 | |
3273 | /* If scalar return value was computed in a pseudo-reg, or was a named | |
3274 | return value that got dumped to the stack, copy that to the hard | |
3275 | return register. */ | |
3276 | if (DECL_RTL_SET_P (DECL_RESULT (fndecl))) | |
3277 | { | |
3278 | tree decl_result = DECL_RESULT (fndecl); | |
3279 | rtx decl_rtl = DECL_RTL (decl_result); | |
3280 | ||
3281 | if (REG_P (decl_rtl) | |
3282 | ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER | |
3283 | : DECL_REGISTER (decl_result)) | |
3284 | { | |
3285 | rtx real_decl_rtl; | |
3286 | ||
1d636cc6 RG |
3287 | real_decl_rtl = targetm.calls.function_value (TREE_TYPE (decl_result), |
3288 | fndecl, true); | |
ce5e43d0 | 3289 | REG_FUNCTION_VALUE_P (real_decl_rtl) = 1; |
38173d38 | 3290 | /* The delay slot scheduler assumes that crtl->return_rtx |
ce5e43d0 JJ |
3291 | holds the hard register containing the return value, not a |
3292 | temporary pseudo. */ | |
38173d38 | 3293 | crtl->return_rtx = real_decl_rtl; |
ce5e43d0 JJ |
3294 | } |
3295 | } | |
6f086dfc | 3296 | } |
4744afba RH |
3297 | |
3298 | /* A subroutine of gimplify_parameters, invoked via walk_tree. | |
3299 | For all seen types, gimplify their sizes. */ | |
3300 | ||
3301 | static tree | |
3302 | gimplify_parm_type (tree *tp, int *walk_subtrees, void *data) | |
3303 | { | |
3304 | tree t = *tp; | |
3305 | ||
3306 | *walk_subtrees = 0; | |
3307 | if (TYPE_P (t)) | |
3308 | { | |
3309 | if (POINTER_TYPE_P (t)) | |
3310 | *walk_subtrees = 1; | |
ad50bc8d RH |
3311 | else if (TYPE_SIZE (t) && !TREE_CONSTANT (TYPE_SIZE (t)) |
3312 | && !TYPE_SIZES_GIMPLIFIED (t)) | |
4744afba | 3313 | { |
726a989a | 3314 | gimplify_type_sizes (t, (gimple_seq *) data); |
4744afba RH |
3315 | *walk_subtrees = 1; |
3316 | } | |
3317 | } | |
3318 | ||
3319 | return NULL; | |
3320 | } | |
3321 | ||
3322 | /* Gimplify the parameter list for current_function_decl. This involves | |
3323 | evaluating SAVE_EXPRs of variable sized parameters and generating code | |
726a989a RB |
3324 | to implement callee-copies reference parameters. Returns a sequence of |
3325 | statements to add to the beginning of the function. */ | |
4744afba | 3326 | |
726a989a | 3327 | gimple_seq |
4744afba RH |
3328 | gimplify_parameters (void) |
3329 | { | |
3330 | struct assign_parm_data_all all; | |
726a989a RB |
3331 | tree fnargs, parm; |
3332 | gimple_seq stmts = NULL; | |
4744afba RH |
3333 | |
3334 | assign_parms_initialize_all (&all); | |
3335 | fnargs = assign_parms_augmented_arg_list (&all); | |
3336 | ||
3337 | for (parm = fnargs; parm; parm = TREE_CHAIN (parm)) | |
3338 | { | |
3339 | struct assign_parm_data_one data; | |
3340 | ||
3341 | /* Extract the type of PARM; adjust it according to ABI. */ | |
3342 | assign_parm_find_data_types (&all, parm, &data); | |
3343 | ||
3344 | /* Early out for errors and void parameters. */ | |
3345 | if (data.passed_mode == VOIDmode || DECL_SIZE (parm) == NULL) | |
3346 | continue; | |
3347 | ||
3348 | /* Update info on where next arg arrives in registers. */ | |
3349 | FUNCTION_ARG_ADVANCE (all.args_so_far, data.promoted_mode, | |
3350 | data.passed_type, data.named_arg); | |
3351 | ||
3352 | /* ??? Once upon a time variable_size stuffed parameter list | |
3353 | SAVE_EXPRs (amongst others) onto a pending sizes list. This | |
3354 | turned out to be less than manageable in the gimple world. | |
3355 | Now we have to hunt them down ourselves. */ | |
3356 | walk_tree_without_duplicates (&data.passed_type, | |
3357 | gimplify_parm_type, &stmts); | |
3358 | ||
b38f3813 | 3359 | if (TREE_CODE (DECL_SIZE_UNIT (parm)) != INTEGER_CST) |
4744afba RH |
3360 | { |
3361 | gimplify_one_sizepos (&DECL_SIZE (parm), &stmts); | |
3362 | gimplify_one_sizepos (&DECL_SIZE_UNIT (parm), &stmts); | |
3363 | } | |
3364 | ||
3365 | if (data.passed_pointer) | |
3366 | { | |
3367 | tree type = TREE_TYPE (data.passed_type); | |
3368 | if (reference_callee_copied (&all.args_so_far, TYPE_MODE (type), | |
3369 | type, data.named_arg)) | |
3370 | { | |
3371 | tree local, t; | |
3372 | ||
b38f3813 | 3373 | /* For constant-sized objects, this is trivial; for |
4744afba | 3374 | variable-sized objects, we have to play games. */ |
b38f3813 EB |
3375 | if (TREE_CODE (DECL_SIZE_UNIT (parm)) == INTEGER_CST |
3376 | && !(flag_stack_check == GENERIC_STACK_CHECK | |
3377 | && compare_tree_int (DECL_SIZE_UNIT (parm), | |
3378 | STACK_CHECK_MAX_VAR_SIZE) > 0)) | |
4744afba RH |
3379 | { |
3380 | local = create_tmp_var (type, get_name (parm)); | |
3381 | DECL_IGNORED_P (local) = 0; | |
04487a2f JJ |
3382 | /* If PARM was addressable, move that flag over |
3383 | to the local copy, as its address will be taken, | |
3384 | not the PARMs. */ | |
3385 | if (TREE_ADDRESSABLE (parm)) | |
3386 | { | |
3387 | TREE_ADDRESSABLE (parm) = 0; | |
3388 | TREE_ADDRESSABLE (local) = 1; | |
3389 | } | |
4744afba RH |
3390 | } |
3391 | else | |
3392 | { | |
5039610b | 3393 | tree ptr_type, addr; |
4744afba RH |
3394 | |
3395 | ptr_type = build_pointer_type (type); | |
3396 | addr = create_tmp_var (ptr_type, get_name (parm)); | |
3397 | DECL_IGNORED_P (addr) = 0; | |
3398 | local = build_fold_indirect_ref (addr); | |
3399 | ||
4744afba | 3400 | t = built_in_decls[BUILT_IN_ALLOCA]; |
5039610b | 3401 | t = build_call_expr (t, 1, DECL_SIZE_UNIT (parm)); |
4744afba | 3402 | t = fold_convert (ptr_type, t); |
726a989a | 3403 | t = build2 (MODIFY_EXPR, TREE_TYPE (addr), addr, t); |
4744afba RH |
3404 | gimplify_and_add (t, &stmts); |
3405 | } | |
3406 | ||
726a989a | 3407 | gimplify_assign (local, parm, &stmts); |
4744afba | 3408 | |
833b3afe DB |
3409 | SET_DECL_VALUE_EXPR (parm, local); |
3410 | DECL_HAS_VALUE_EXPR_P (parm) = 1; | |
4744afba RH |
3411 | } |
3412 | } | |
3413 | } | |
3414 | ||
3415 | return stmts; | |
3416 | } | |
75dc3319 | 3417 | \f |
6f086dfc RS |
3418 | /* Compute the size and offset from the start of the stacked arguments for a |
3419 | parm passed in mode PASSED_MODE and with type TYPE. | |
3420 | ||
3421 | INITIAL_OFFSET_PTR points to the current offset into the stacked | |
3422 | arguments. | |
3423 | ||
e7949876 AM |
3424 | The starting offset and size for this parm are returned in |
3425 | LOCATE->OFFSET and LOCATE->SIZE, respectively. When IN_REGS is | |
3426 | nonzero, the offset is that of stack slot, which is returned in | |
3427 | LOCATE->SLOT_OFFSET. LOCATE->ALIGNMENT_PAD is the amount of | |
3428 | padding required from the initial offset ptr to the stack slot. | |
6f086dfc | 3429 | |
cc2902df | 3430 | IN_REGS is nonzero if the argument will be passed in registers. It will |
6f086dfc RS |
3431 | never be set if REG_PARM_STACK_SPACE is not defined. |
3432 | ||
3433 | FNDECL is the function in which the argument was defined. | |
3434 | ||
3435 | There are two types of rounding that are done. The first, controlled by | |
3436 | FUNCTION_ARG_BOUNDARY, forces the offset from the start of the argument | |
3437 | list to be aligned to the specific boundary (in bits). This rounding | |
3438 | affects the initial and starting offsets, but not the argument size. | |
3439 | ||
3440 | The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY, | |
3441 | optionally rounds the size of the parm to PARM_BOUNDARY. The | |
3442 | initial offset is not affected by this rounding, while the size always | |
3443 | is and the starting offset may be. */ | |
3444 | ||
e7949876 AM |
3445 | /* LOCATE->OFFSET will be negative for ARGS_GROW_DOWNWARD case; |
3446 | INITIAL_OFFSET_PTR is positive because locate_and_pad_parm's | |
6f086dfc | 3447 | callers pass in the total size of args so far as |
e7949876 | 3448 | INITIAL_OFFSET_PTR. LOCATE->SIZE is always positive. */ |
6f086dfc | 3449 | |
6f086dfc | 3450 | void |
fa8db1f7 AJ |
3451 | locate_and_pad_parm (enum machine_mode passed_mode, tree type, int in_regs, |
3452 | int partial, tree fndecl ATTRIBUTE_UNUSED, | |
3453 | struct args_size *initial_offset_ptr, | |
3454 | struct locate_and_pad_arg_data *locate) | |
6f086dfc | 3455 | { |
e7949876 AM |
3456 | tree sizetree; |
3457 | enum direction where_pad; | |
c7e777b5 | 3458 | unsigned int boundary; |
e7949876 AM |
3459 | int reg_parm_stack_space = 0; |
3460 | int part_size_in_regs; | |
6f086dfc RS |
3461 | |
3462 | #ifdef REG_PARM_STACK_SPACE | |
e7949876 | 3463 | reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl); |
e7949876 | 3464 | |
6f086dfc RS |
3465 | /* If we have found a stack parm before we reach the end of the |
3466 | area reserved for registers, skip that area. */ | |
3467 | if (! in_regs) | |
3468 | { | |
6f086dfc RS |
3469 | if (reg_parm_stack_space > 0) |
3470 | { | |
3471 | if (initial_offset_ptr->var) | |
3472 | { | |
3473 | initial_offset_ptr->var | |
3474 | = size_binop (MAX_EXPR, ARGS_SIZE_TREE (*initial_offset_ptr), | |
fed3cef0 | 3475 | ssize_int (reg_parm_stack_space)); |
6f086dfc RS |
3476 | initial_offset_ptr->constant = 0; |
3477 | } | |
3478 | else if (initial_offset_ptr->constant < reg_parm_stack_space) | |
3479 | initial_offset_ptr->constant = reg_parm_stack_space; | |
3480 | } | |
3481 | } | |
3482 | #endif /* REG_PARM_STACK_SPACE */ | |
3483 | ||
78a52f11 | 3484 | part_size_in_regs = (reg_parm_stack_space == 0 ? partial : 0); |
e7949876 AM |
3485 | |
3486 | sizetree | |
3487 | = type ? size_in_bytes (type) : size_int (GET_MODE_SIZE (passed_mode)); | |
3488 | where_pad = FUNCTION_ARG_PADDING (passed_mode, type); | |
3489 | boundary = FUNCTION_ARG_BOUNDARY (passed_mode, type); | |
6e985040 | 3490 | locate->where_pad = where_pad; |
2e3f842f L |
3491 | |
3492 | /* Alignment can't exceed MAX_SUPPORTED_STACK_ALIGNMENT. */ | |
3493 | if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT) | |
3494 | boundary = MAX_SUPPORTED_STACK_ALIGNMENT; | |
3495 | ||
bfc45551 | 3496 | locate->boundary = boundary; |
6f086dfc | 3497 | |
2e3f842f L |
3498 | if (SUPPORTS_STACK_ALIGNMENT) |
3499 | { | |
3500 | /* stack_alignment_estimated can't change after stack has been | |
3501 | realigned. */ | |
3502 | if (crtl->stack_alignment_estimated < boundary) | |
3503 | { | |
3504 | if (!crtl->stack_realign_processed) | |
3505 | crtl->stack_alignment_estimated = boundary; | |
3506 | else | |
3507 | { | |
3508 | /* If stack is realigned and stack alignment value | |
3509 | hasn't been finalized, it is OK not to increase | |
3510 | stack_alignment_estimated. The bigger alignment | |
3511 | requirement is recorded in stack_alignment_needed | |
3512 | below. */ | |
3513 | gcc_assert (!crtl->stack_realign_finalized | |
3514 | && crtl->stack_realign_needed); | |
3515 | } | |
3516 | } | |
3517 | } | |
3518 | ||
c7e777b5 RH |
3519 | /* Remember if the outgoing parameter requires extra alignment on the |
3520 | calling function side. */ | |
cb91fab0 JH |
3521 | if (crtl->stack_alignment_needed < boundary) |
3522 | crtl->stack_alignment_needed = boundary; | |
2e3f842f L |
3523 | if (crtl->max_used_stack_slot_alignment < crtl->stack_alignment_needed) |
3524 | crtl->max_used_stack_slot_alignment = crtl->stack_alignment_needed; | |
3525 | if (crtl->preferred_stack_boundary < boundary) | |
3526 | crtl->preferred_stack_boundary = boundary; | |
c7e777b5 | 3527 | |
6f086dfc | 3528 | #ifdef ARGS_GROW_DOWNWARD |
e7949876 | 3529 | locate->slot_offset.constant = -initial_offset_ptr->constant; |
6f086dfc | 3530 | if (initial_offset_ptr->var) |
e7949876 AM |
3531 | locate->slot_offset.var = size_binop (MINUS_EXPR, ssize_int (0), |
3532 | initial_offset_ptr->var); | |
9dff28ab | 3533 | |
e7949876 AM |
3534 | { |
3535 | tree s2 = sizetree; | |
3536 | if (where_pad != none | |
3537 | && (!host_integerp (sizetree, 1) | |
3538 | || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % PARM_BOUNDARY)) | |
3539 | s2 = round_up (s2, PARM_BOUNDARY / BITS_PER_UNIT); | |
3540 | SUB_PARM_SIZE (locate->slot_offset, s2); | |
3541 | } | |
3542 | ||
3543 | locate->slot_offset.constant += part_size_in_regs; | |
9dff28ab JDA |
3544 | |
3545 | if (!in_regs | |
3546 | #ifdef REG_PARM_STACK_SPACE | |
3547 | || REG_PARM_STACK_SPACE (fndecl) > 0 | |
3548 | #endif | |
3549 | ) | |
e7949876 AM |
3550 | pad_to_arg_alignment (&locate->slot_offset, boundary, |
3551 | &locate->alignment_pad); | |
9dff28ab | 3552 | |
e7949876 AM |
3553 | locate->size.constant = (-initial_offset_ptr->constant |
3554 | - locate->slot_offset.constant); | |
6f086dfc | 3555 | if (initial_offset_ptr->var) |
e7949876 AM |
3556 | locate->size.var = size_binop (MINUS_EXPR, |
3557 | size_binop (MINUS_EXPR, | |
3558 | ssize_int (0), | |
3559 | initial_offset_ptr->var), | |
3560 | locate->slot_offset.var); | |
3561 | ||
3562 | /* Pad_below needs the pre-rounded size to know how much to pad | |
3563 | below. */ | |
3564 | locate->offset = locate->slot_offset; | |
3565 | if (where_pad == downward) | |
3566 | pad_below (&locate->offset, passed_mode, sizetree); | |
9dff28ab | 3567 | |
6f086dfc | 3568 | #else /* !ARGS_GROW_DOWNWARD */ |
832ea3b3 FS |
3569 | if (!in_regs |
3570 | #ifdef REG_PARM_STACK_SPACE | |
3571 | || REG_PARM_STACK_SPACE (fndecl) > 0 | |
3572 | #endif | |
3573 | ) | |
e7949876 AM |
3574 | pad_to_arg_alignment (initial_offset_ptr, boundary, |
3575 | &locate->alignment_pad); | |
3576 | locate->slot_offset = *initial_offset_ptr; | |
6f086dfc RS |
3577 | |
3578 | #ifdef PUSH_ROUNDING | |
3579 | if (passed_mode != BLKmode) | |
3580 | sizetree = size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree))); | |
3581 | #endif | |
3582 | ||
d4b0a7a0 DE |
3583 | /* Pad_below needs the pre-rounded size to know how much to pad below |
3584 | so this must be done before rounding up. */ | |
e7949876 AM |
3585 | locate->offset = locate->slot_offset; |
3586 | if (where_pad == downward) | |
3587 | pad_below (&locate->offset, passed_mode, sizetree); | |
d4b0a7a0 | 3588 | |
6f086dfc | 3589 | if (where_pad != none |
1468899d RK |
3590 | && (!host_integerp (sizetree, 1) |
3591 | || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % PARM_BOUNDARY)) | |
6f086dfc RS |
3592 | sizetree = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT); |
3593 | ||
e7949876 AM |
3594 | ADD_PARM_SIZE (locate->size, sizetree); |
3595 | ||
3596 | locate->size.constant -= part_size_in_regs; | |
6f086dfc | 3597 | #endif /* ARGS_GROW_DOWNWARD */ |
099590dc MM |
3598 | |
3599 | #ifdef FUNCTION_ARG_OFFSET | |
3600 | locate->offset.constant += FUNCTION_ARG_OFFSET (passed_mode, type); | |
3601 | #endif | |
6f086dfc RS |
3602 | } |
3603 | ||
e16c591a RS |
3604 | /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY. |
3605 | BOUNDARY is measured in bits, but must be a multiple of a storage unit. */ | |
3606 | ||
6f086dfc | 3607 | static void |
fa8db1f7 AJ |
3608 | pad_to_arg_alignment (struct args_size *offset_ptr, int boundary, |
3609 | struct args_size *alignment_pad) | |
6f086dfc | 3610 | { |
a544cfd2 KG |
3611 | tree save_var = NULL_TREE; |
3612 | HOST_WIDE_INT save_constant = 0; | |
a751cd5b | 3613 | int boundary_in_bytes = boundary / BITS_PER_UNIT; |
a594a19c GK |
3614 | HOST_WIDE_INT sp_offset = STACK_POINTER_OFFSET; |
3615 | ||
3616 | #ifdef SPARC_STACK_BOUNDARY_HACK | |
2358ff91 EB |
3617 | /* ??? The SPARC port may claim a STACK_BOUNDARY higher than |
3618 | the real alignment of %sp. However, when it does this, the | |
3619 | alignment of %sp+STACK_POINTER_OFFSET is STACK_BOUNDARY. */ | |
a594a19c GK |
3620 | if (SPARC_STACK_BOUNDARY_HACK) |
3621 | sp_offset = 0; | |
3622 | #endif | |
4fc026cd | 3623 | |
6f6b8f81 | 3624 | if (boundary > PARM_BOUNDARY) |
4fc026cd CM |
3625 | { |
3626 | save_var = offset_ptr->var; | |
3627 | save_constant = offset_ptr->constant; | |
3628 | } | |
3629 | ||
3630 | alignment_pad->var = NULL_TREE; | |
3631 | alignment_pad->constant = 0; | |
4fc026cd | 3632 | |
6f086dfc RS |
3633 | if (boundary > BITS_PER_UNIT) |
3634 | { | |
3635 | if (offset_ptr->var) | |
3636 | { | |
a594a19c GK |
3637 | tree sp_offset_tree = ssize_int (sp_offset); |
3638 | tree offset = size_binop (PLUS_EXPR, | |
3639 | ARGS_SIZE_TREE (*offset_ptr), | |
3640 | sp_offset_tree); | |
6f086dfc | 3641 | #ifdef ARGS_GROW_DOWNWARD |
a594a19c | 3642 | tree rounded = round_down (offset, boundary / BITS_PER_UNIT); |
6f086dfc | 3643 | #else |
a594a19c | 3644 | tree rounded = round_up (offset, boundary / BITS_PER_UNIT); |
6f086dfc | 3645 | #endif |
a594a19c GK |
3646 | |
3647 | offset_ptr->var = size_binop (MINUS_EXPR, rounded, sp_offset_tree); | |
e7949876 AM |
3648 | /* ARGS_SIZE_TREE includes constant term. */ |
3649 | offset_ptr->constant = 0; | |
6f6b8f81 | 3650 | if (boundary > PARM_BOUNDARY) |
dd3f0101 | 3651 | alignment_pad->var = size_binop (MINUS_EXPR, offset_ptr->var, |
fed3cef0 | 3652 | save_var); |
6f086dfc RS |
3653 | } |
3654 | else | |
718fe406 | 3655 | { |
a594a19c | 3656 | offset_ptr->constant = -sp_offset + |
6f086dfc | 3657 | #ifdef ARGS_GROW_DOWNWARD |
a594a19c | 3658 | FLOOR_ROUND (offset_ptr->constant + sp_offset, boundary_in_bytes); |
6f086dfc | 3659 | #else |
a594a19c | 3660 | CEIL_ROUND (offset_ptr->constant + sp_offset, boundary_in_bytes); |
6f086dfc | 3661 | #endif |
6f6b8f81 | 3662 | if (boundary > PARM_BOUNDARY) |
718fe406 KH |
3663 | alignment_pad->constant = offset_ptr->constant - save_constant; |
3664 | } | |
6f086dfc RS |
3665 | } |
3666 | } | |
3667 | ||
3668 | static void | |
fa8db1f7 | 3669 | pad_below (struct args_size *offset_ptr, enum machine_mode passed_mode, tree sizetree) |
6f086dfc RS |
3670 | { |
3671 | if (passed_mode != BLKmode) | |
3672 | { | |
3673 | if (GET_MODE_BITSIZE (passed_mode) % PARM_BOUNDARY) | |
3674 | offset_ptr->constant | |
3675 | += (((GET_MODE_BITSIZE (passed_mode) + PARM_BOUNDARY - 1) | |
3676 | / PARM_BOUNDARY * PARM_BOUNDARY / BITS_PER_UNIT) | |
3677 | - GET_MODE_SIZE (passed_mode)); | |
3678 | } | |
3679 | else | |
3680 | { | |
3681 | if (TREE_CODE (sizetree) != INTEGER_CST | |
3682 | || (TREE_INT_CST_LOW (sizetree) * BITS_PER_UNIT) % PARM_BOUNDARY) | |
3683 | { | |
3684 | /* Round the size up to multiple of PARM_BOUNDARY bits. */ | |
3685 | tree s2 = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT); | |
3686 | /* Add it in. */ | |
3687 | ADD_PARM_SIZE (*offset_ptr, s2); | |
3688 | SUB_PARM_SIZE (*offset_ptr, sizetree); | |
3689 | } | |
3690 | } | |
3691 | } | |
6f086dfc | 3692 | \f |
6f086dfc | 3693 | |
6fb5fa3c DB |
3694 | /* True if register REGNO was alive at a place where `setjmp' was |
3695 | called and was set more than once or is an argument. Such regs may | |
3696 | be clobbered by `longjmp'. */ | |
3697 | ||
3698 | static bool | |
3699 | regno_clobbered_at_setjmp (bitmap setjmp_crosses, int regno) | |
3700 | { | |
3701 | /* There appear to be cases where some local vars never reach the | |
3702 | backend but have bogus regnos. */ | |
3703 | if (regno >= max_reg_num ()) | |
3704 | return false; | |
3705 | ||
3706 | return ((REG_N_SETS (regno) > 1 | |
3707 | || REGNO_REG_SET_P (df_get_live_out (ENTRY_BLOCK_PTR), regno)) | |
3708 | && REGNO_REG_SET_P (setjmp_crosses, regno)); | |
3709 | } | |
3710 | ||
3711 | /* Walk the tree of blocks describing the binding levels within a | |
3712 | function and warn about variables the might be killed by setjmp or | |
3713 | vfork. This is done after calling flow_analysis before register | |
3714 | allocation since that will clobber the pseudo-regs to hard | |
3715 | regs. */ | |
3716 | ||
3717 | static void | |
3718 | setjmp_vars_warning (bitmap setjmp_crosses, tree block) | |
6f086dfc | 3719 | { |
b3694847 | 3720 | tree decl, sub; |
6de9cd9a | 3721 | |
6f086dfc RS |
3722 | for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl)) |
3723 | { | |
6de9cd9a | 3724 | if (TREE_CODE (decl) == VAR_DECL |
bc41842b | 3725 | && DECL_RTL_SET_P (decl) |
f8cfc6aa | 3726 | && REG_P (DECL_RTL (decl)) |
6fb5fa3c | 3727 | && regno_clobbered_at_setjmp (setjmp_crosses, REGNO (DECL_RTL (decl)))) |
2b001724 MLI |
3728 | warning (OPT_Wclobbered, "variable %q+D might be clobbered by" |
3729 | " %<longjmp%> or %<vfork%>", decl); | |
6f086dfc | 3730 | } |
6de9cd9a | 3731 | |
87caf699 | 3732 | for (sub = BLOCK_SUBBLOCKS (block); sub; sub = BLOCK_CHAIN (sub)) |
6fb5fa3c | 3733 | setjmp_vars_warning (setjmp_crosses, sub); |
6f086dfc RS |
3734 | } |
3735 | ||
6de9cd9a | 3736 | /* Do the appropriate part of setjmp_vars_warning |
6f086dfc RS |
3737 | but for arguments instead of local variables. */ |
3738 | ||
6fb5fa3c DB |
3739 | static void |
3740 | setjmp_args_warning (bitmap setjmp_crosses) | |
6f086dfc | 3741 | { |
b3694847 | 3742 | tree decl; |
6f086dfc RS |
3743 | for (decl = DECL_ARGUMENTS (current_function_decl); |
3744 | decl; decl = TREE_CHAIN (decl)) | |
3745 | if (DECL_RTL (decl) != 0 | |
f8cfc6aa | 3746 | && REG_P (DECL_RTL (decl)) |
6fb5fa3c | 3747 | && regno_clobbered_at_setjmp (setjmp_crosses, REGNO (DECL_RTL (decl)))) |
2b001724 MLI |
3748 | warning (OPT_Wclobbered, |
3749 | "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>", | |
dee15844 | 3750 | decl); |
6f086dfc RS |
3751 | } |
3752 | ||
6fb5fa3c DB |
3753 | /* Generate warning messages for variables live across setjmp. */ |
3754 | ||
3755 | void | |
3756 | generate_setjmp_warnings (void) | |
3757 | { | |
3758 | bitmap setjmp_crosses = regstat_get_setjmp_crosses (); | |
3759 | ||
3760 | if (n_basic_blocks == NUM_FIXED_BLOCKS | |
3761 | || bitmap_empty_p (setjmp_crosses)) | |
3762 | return; | |
3763 | ||
3764 | setjmp_vars_warning (setjmp_crosses, DECL_INITIAL (current_function_decl)); | |
3765 | setjmp_args_warning (setjmp_crosses); | |
3766 | } | |
3767 | ||
6f086dfc | 3768 | \f |
a20612aa RH |
3769 | /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END}, |
3770 | and create duplicate blocks. */ | |
3771 | /* ??? Need an option to either create block fragments or to create | |
3772 | abstract origin duplicates of a source block. It really depends | |
3773 | on what optimization has been performed. */ | |
467456d0 | 3774 | |
116eebd6 | 3775 | void |
fa8db1f7 | 3776 | reorder_blocks (void) |
467456d0 | 3777 | { |
116eebd6 | 3778 | tree block = DECL_INITIAL (current_function_decl); |
2c217442 | 3779 | VEC(tree,heap) *block_stack; |
467456d0 | 3780 | |
1a4450c7 | 3781 | if (block == NULL_TREE) |
116eebd6 | 3782 | return; |
fc289cd1 | 3783 | |
2c217442 | 3784 | block_stack = VEC_alloc (tree, heap, 10); |
18c038b9 | 3785 | |
a20612aa | 3786 | /* Reset the TREE_ASM_WRITTEN bit for all blocks. */ |
6de9cd9a | 3787 | clear_block_marks (block); |
a20612aa | 3788 | |
116eebd6 MM |
3789 | /* Prune the old trees away, so that they don't get in the way. */ |
3790 | BLOCK_SUBBLOCKS (block) = NULL_TREE; | |
3791 | BLOCK_CHAIN (block) = NULL_TREE; | |
fc289cd1 | 3792 | |
a20612aa | 3793 | /* Recreate the block tree from the note nesting. */ |
116eebd6 | 3794 | reorder_blocks_1 (get_insns (), block, &block_stack); |
718fe406 | 3795 | BLOCK_SUBBLOCKS (block) = blocks_nreverse (BLOCK_SUBBLOCKS (block)); |
18c038b9 | 3796 | |
2c217442 | 3797 | VEC_free (tree, heap, block_stack); |
467456d0 RS |
3798 | } |
3799 | ||
a20612aa | 3800 | /* Helper function for reorder_blocks. Reset TREE_ASM_WRITTEN. */ |
0a1c58a2 | 3801 | |
6de9cd9a DN |
3802 | void |
3803 | clear_block_marks (tree block) | |
cc1fe44f | 3804 | { |
a20612aa | 3805 | while (block) |
cc1fe44f | 3806 | { |
a20612aa | 3807 | TREE_ASM_WRITTEN (block) = 0; |
6de9cd9a | 3808 | clear_block_marks (BLOCK_SUBBLOCKS (block)); |
a20612aa | 3809 | block = BLOCK_CHAIN (block); |
cc1fe44f DD |
3810 | } |
3811 | } | |
3812 | ||
0a1c58a2 | 3813 | static void |
2c217442 | 3814 | reorder_blocks_1 (rtx insns, tree current_block, VEC(tree,heap) **p_block_stack) |
0a1c58a2 JL |
3815 | { |
3816 | rtx insn; | |
3817 | ||
3818 | for (insn = insns; insn; insn = NEXT_INSN (insn)) | |
3819 | { | |
4b4bf941 | 3820 | if (NOTE_P (insn)) |
0a1c58a2 | 3821 | { |
a38e7aa5 | 3822 | if (NOTE_KIND (insn) == NOTE_INSN_BLOCK_BEG) |
0a1c58a2 JL |
3823 | { |
3824 | tree block = NOTE_BLOCK (insn); | |
51b7d006 DJ |
3825 | tree origin; |
3826 | ||
3827 | origin = (BLOCK_FRAGMENT_ORIGIN (block) | |
3828 | ? BLOCK_FRAGMENT_ORIGIN (block) | |
3829 | : block); | |
a20612aa RH |
3830 | |
3831 | /* If we have seen this block before, that means it now | |
3832 | spans multiple address regions. Create a new fragment. */ | |
0a1c58a2 JL |
3833 | if (TREE_ASM_WRITTEN (block)) |
3834 | { | |
a20612aa | 3835 | tree new_block = copy_node (block); |
a20612aa | 3836 | |
a20612aa RH |
3837 | BLOCK_FRAGMENT_ORIGIN (new_block) = origin; |
3838 | BLOCK_FRAGMENT_CHAIN (new_block) | |
3839 | = BLOCK_FRAGMENT_CHAIN (origin); | |
3840 | BLOCK_FRAGMENT_CHAIN (origin) = new_block; | |
3841 | ||
3842 | NOTE_BLOCK (insn) = new_block; | |
3843 | block = new_block; | |
0a1c58a2 | 3844 | } |
a20612aa | 3845 | |
0a1c58a2 JL |
3846 | BLOCK_SUBBLOCKS (block) = 0; |
3847 | TREE_ASM_WRITTEN (block) = 1; | |
339a28b9 ZW |
3848 | /* When there's only one block for the entire function, |
3849 | current_block == block and we mustn't do this, it | |
3850 | will cause infinite recursion. */ | |
3851 | if (block != current_block) | |
3852 | { | |
51b7d006 DJ |
3853 | if (block != origin) |
3854 | gcc_assert (BLOCK_SUPERCONTEXT (origin) == current_block); | |
3855 | ||
339a28b9 ZW |
3856 | BLOCK_SUPERCONTEXT (block) = current_block; |
3857 | BLOCK_CHAIN (block) = BLOCK_SUBBLOCKS (current_block); | |
3858 | BLOCK_SUBBLOCKS (current_block) = block; | |
51b7d006 | 3859 | current_block = origin; |
339a28b9 | 3860 | } |
2c217442 | 3861 | VEC_safe_push (tree, heap, *p_block_stack, block); |
0a1c58a2 | 3862 | } |
a38e7aa5 | 3863 | else if (NOTE_KIND (insn) == NOTE_INSN_BLOCK_END) |
0a1c58a2 | 3864 | { |
2c217442 | 3865 | NOTE_BLOCK (insn) = VEC_pop (tree, *p_block_stack); |
0a1c58a2 JL |
3866 | BLOCK_SUBBLOCKS (current_block) |
3867 | = blocks_nreverse (BLOCK_SUBBLOCKS (current_block)); | |
3868 | current_block = BLOCK_SUPERCONTEXT (current_block); | |
3869 | } | |
3870 | } | |
0a1c58a2 JL |
3871 | } |
3872 | } | |
3873 | ||
467456d0 RS |
3874 | /* Reverse the order of elements in the chain T of blocks, |
3875 | and return the new head of the chain (old last element). */ | |
3876 | ||
6de9cd9a | 3877 | tree |
fa8db1f7 | 3878 | blocks_nreverse (tree t) |
467456d0 | 3879 | { |
b3694847 | 3880 | tree prev = 0, decl, next; |
467456d0 RS |
3881 | for (decl = t; decl; decl = next) |
3882 | { | |
3883 | next = BLOCK_CHAIN (decl); | |
3884 | BLOCK_CHAIN (decl) = prev; | |
3885 | prev = decl; | |
3886 | } | |
3887 | return prev; | |
3888 | } | |
3889 | ||
18c038b9 MM |
3890 | /* Count the subblocks of the list starting with BLOCK. If VECTOR is |
3891 | non-NULL, list them all into VECTOR, in a depth-first preorder | |
3892 | traversal of the block tree. Also clear TREE_ASM_WRITTEN in all | |
b2a59b15 | 3893 | blocks. */ |
467456d0 RS |
3894 | |
3895 | static int | |
fa8db1f7 | 3896 | all_blocks (tree block, tree *vector) |
467456d0 | 3897 | { |
b2a59b15 MS |
3898 | int n_blocks = 0; |
3899 | ||
a84efb51 JO |
3900 | while (block) |
3901 | { | |
3902 | TREE_ASM_WRITTEN (block) = 0; | |
b2a59b15 | 3903 | |
a84efb51 JO |
3904 | /* Record this block. */ |
3905 | if (vector) | |
3906 | vector[n_blocks] = block; | |
b2a59b15 | 3907 | |
a84efb51 | 3908 | ++n_blocks; |
718fe406 | 3909 | |
a84efb51 JO |
3910 | /* Record the subblocks, and their subblocks... */ |
3911 | n_blocks += all_blocks (BLOCK_SUBBLOCKS (block), | |
3912 | vector ? vector + n_blocks : 0); | |
3913 | block = BLOCK_CHAIN (block); | |
3914 | } | |
467456d0 RS |
3915 | |
3916 | return n_blocks; | |
3917 | } | |
18c038b9 MM |
3918 | |
3919 | /* Return a vector containing all the blocks rooted at BLOCK. The | |
3920 | number of elements in the vector is stored in N_BLOCKS_P. The | |
3921 | vector is dynamically allocated; it is the caller's responsibility | |
3922 | to call `free' on the pointer returned. */ | |
718fe406 | 3923 | |
18c038b9 | 3924 | static tree * |
fa8db1f7 | 3925 | get_block_vector (tree block, int *n_blocks_p) |
18c038b9 MM |
3926 | { |
3927 | tree *block_vector; | |
3928 | ||
3929 | *n_blocks_p = all_blocks (block, NULL); | |
5ed6ace5 | 3930 | block_vector = XNEWVEC (tree, *n_blocks_p); |
18c038b9 MM |
3931 | all_blocks (block, block_vector); |
3932 | ||
3933 | return block_vector; | |
3934 | } | |
3935 | ||
f83b236e | 3936 | static GTY(()) int next_block_index = 2; |
18c038b9 MM |
3937 | |
3938 | /* Set BLOCK_NUMBER for all the blocks in FN. */ | |
3939 | ||
3940 | void | |
fa8db1f7 | 3941 | number_blocks (tree fn) |
18c038b9 MM |
3942 | { |
3943 | int i; | |
3944 | int n_blocks; | |
3945 | tree *block_vector; | |
3946 | ||
3947 | /* For SDB and XCOFF debugging output, we start numbering the blocks | |
3948 | from 1 within each function, rather than keeping a running | |
3949 | count. */ | |
3950 | #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO) | |
b0e3a658 RK |
3951 | if (write_symbols == SDB_DEBUG || write_symbols == XCOFF_DEBUG) |
3952 | next_block_index = 1; | |
18c038b9 MM |
3953 | #endif |
3954 | ||
3955 | block_vector = get_block_vector (DECL_INITIAL (fn), &n_blocks); | |
3956 | ||
3957 | /* The top-level BLOCK isn't numbered at all. */ | |
3958 | for (i = 1; i < n_blocks; ++i) | |
3959 | /* We number the blocks from two. */ | |
3960 | BLOCK_NUMBER (block_vector[i]) = next_block_index++; | |
3961 | ||
3962 | free (block_vector); | |
3963 | ||
3964 | return; | |
3965 | } | |
df8992f8 RH |
3966 | |
3967 | /* If VAR is present in a subblock of BLOCK, return the subblock. */ | |
3968 | ||
3969 | tree | |
fa8db1f7 | 3970 | debug_find_var_in_block_tree (tree var, tree block) |
df8992f8 RH |
3971 | { |
3972 | tree t; | |
3973 | ||
3974 | for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t)) | |
3975 | if (t == var) | |
3976 | return block; | |
3977 | ||
3978 | for (t = BLOCK_SUBBLOCKS (block); t; t = TREE_CHAIN (t)) | |
3979 | { | |
3980 | tree ret = debug_find_var_in_block_tree (var, t); | |
3981 | if (ret) | |
3982 | return ret; | |
3983 | } | |
3984 | ||
3985 | return NULL_TREE; | |
3986 | } | |
467456d0 | 3987 | \f |
db2960f4 SL |
3988 | /* Keep track of whether we're in a dummy function context. If we are, |
3989 | we don't want to invoke the set_current_function hook, because we'll | |
3990 | get into trouble if the hook calls target_reinit () recursively or | |
3991 | when the initial initialization is not yet complete. */ | |
3992 | ||
3993 | static bool in_dummy_function; | |
3994 | ||
ab442df7 MM |
3995 | /* Invoke the target hook when setting cfun. Update the optimization options |
3996 | if the function uses different options than the default. */ | |
db2960f4 SL |
3997 | |
3998 | static void | |
3999 | invoke_set_current_function_hook (tree fndecl) | |
4000 | { | |
4001 | if (!in_dummy_function) | |
ab442df7 MM |
4002 | { |
4003 | tree opts = ((fndecl) | |
4004 | ? DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl) | |
4005 | : optimization_default_node); | |
4006 | ||
4007 | if (!opts) | |
4008 | opts = optimization_default_node; | |
4009 | ||
4010 | /* Change optimization options if needed. */ | |
4011 | if (optimization_current_node != opts) | |
4012 | { | |
4013 | optimization_current_node = opts; | |
4014 | cl_optimization_restore (TREE_OPTIMIZATION (opts)); | |
4015 | } | |
4016 | ||
4017 | targetm.set_current_function (fndecl); | |
4018 | } | |
db2960f4 SL |
4019 | } |
4020 | ||
4021 | /* cfun should never be set directly; use this function. */ | |
4022 | ||
4023 | void | |
4024 | set_cfun (struct function *new_cfun) | |
4025 | { | |
4026 | if (cfun != new_cfun) | |
4027 | { | |
4028 | cfun = new_cfun; | |
4029 | invoke_set_current_function_hook (new_cfun ? new_cfun->decl : NULL_TREE); | |
4030 | } | |
4031 | } | |
4032 | ||
db2960f4 SL |
4033 | /* Initialized with NOGC, making this poisonous to the garbage collector. */ |
4034 | ||
4035 | static VEC(function_p,heap) *cfun_stack; | |
4036 | ||
4037 | /* Push the current cfun onto the stack, and set cfun to new_cfun. */ | |
4038 | ||
4039 | void | |
4040 | push_cfun (struct function *new_cfun) | |
4041 | { | |
4042 | VEC_safe_push (function_p, heap, cfun_stack, cfun); | |
4043 | set_cfun (new_cfun); | |
4044 | } | |
4045 | ||
4046 | /* Pop cfun from the stack. */ | |
4047 | ||
4048 | void | |
4049 | pop_cfun (void) | |
4050 | { | |
38d34676 | 4051 | struct function *new_cfun = VEC_pop (function_p, cfun_stack); |
38d34676 | 4052 | set_cfun (new_cfun); |
db2960f4 | 4053 | } |
3e87758a RL |
4054 | |
4055 | /* Return value of funcdef and increase it. */ | |
4056 | int | |
62e5bf5d | 4057 | get_next_funcdef_no (void) |
3e87758a RL |
4058 | { |
4059 | return funcdef_no++; | |
4060 | } | |
4061 | ||
3a70d621 | 4062 | /* Allocate a function structure for FNDECL and set its contents |
db2960f4 SL |
4063 | to the defaults. Set cfun to the newly-allocated object. |
4064 | Some of the helper functions invoked during initialization assume | |
4065 | that cfun has already been set. Therefore, assign the new object | |
4066 | directly into cfun and invoke the back end hook explicitly at the | |
4067 | very end, rather than initializing a temporary and calling set_cfun | |
4068 | on it. | |
182e0d71 AK |
4069 | |
4070 | ABSTRACT_P is true if this is a function that will never be seen by | |
4071 | the middle-end. Such functions are front-end concepts (like C++ | |
4072 | function templates) that do not correspond directly to functions | |
4073 | placed in object files. */ | |
7a80cf9a | 4074 | |
3a70d621 | 4075 | void |
182e0d71 | 4076 | allocate_struct_function (tree fndecl, bool abstract_p) |
6f086dfc | 4077 | { |
3a70d621 | 4078 | tree result; |
6de9cd9a | 4079 | tree fntype = fndecl ? TREE_TYPE (fndecl) : NULL_TREE; |
6f086dfc | 4080 | |
1b4572a8 | 4081 | cfun = GGC_CNEW (struct function); |
b384405b | 4082 | |
3a70d621 | 4083 | cfun->function_frequency = FUNCTION_FREQUENCY_NORMAL; |
6f086dfc | 4084 | |
3a70d621 | 4085 | init_eh_for_function (); |
6f086dfc | 4086 | |
3a70d621 RH |
4087 | if (init_machine_status) |
4088 | cfun->machine = (*init_machine_status) (); | |
e2ecd91c | 4089 | |
7c800926 KT |
4090 | #ifdef OVERRIDE_ABI_FORMAT |
4091 | OVERRIDE_ABI_FORMAT (fndecl); | |
4092 | #endif | |
4093 | ||
179d2f74 RH |
4094 | invoke_set_current_function_hook (fndecl); |
4095 | ||
81464b2c | 4096 | if (fndecl != NULL_TREE) |
3a70d621 | 4097 | { |
db2960f4 SL |
4098 | DECL_STRUCT_FUNCTION (fndecl) = cfun; |
4099 | cfun->decl = fndecl; | |
70cf5bc1 | 4100 | current_function_funcdef_no = get_next_funcdef_no (); |
db2960f4 SL |
4101 | |
4102 | result = DECL_RESULT (fndecl); | |
182e0d71 | 4103 | if (!abstract_p && aggregate_value_p (result, fndecl)) |
db2960f4 | 4104 | { |
3a70d621 | 4105 | #ifdef PCC_STATIC_STRUCT_RETURN |
e3b5732b | 4106 | cfun->returns_pcc_struct = 1; |
3a70d621 | 4107 | #endif |
e3b5732b | 4108 | cfun->returns_struct = 1; |
db2960f4 SL |
4109 | } |
4110 | ||
e3b5732b | 4111 | cfun->stdarg |
db2960f4 SL |
4112 | = (fntype |
4113 | && TYPE_ARG_TYPES (fntype) != 0 | |
4114 | && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype))) | |
4115 | != void_type_node)); | |
4116 | ||
4117 | /* Assume all registers in stdarg functions need to be saved. */ | |
4118 | cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE; | |
4119 | cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE; | |
3a70d621 | 4120 | } |
db2960f4 SL |
4121 | } |
4122 | ||
4123 | /* This is like allocate_struct_function, but pushes a new cfun for FNDECL | |
4124 | instead of just setting it. */ | |
9d30f3c1 | 4125 | |
db2960f4 SL |
4126 | void |
4127 | push_struct_function (tree fndecl) | |
4128 | { | |
4129 | VEC_safe_push (function_p, heap, cfun_stack, cfun); | |
182e0d71 | 4130 | allocate_struct_function (fndecl, false); |
3a70d621 | 4131 | } |
6f086dfc | 4132 | |
3a70d621 | 4133 | /* Reset cfun, and other non-struct-function variables to defaults as |
2067c116 | 4134 | appropriate for emitting rtl at the start of a function. */ |
6f086dfc | 4135 | |
3a70d621 | 4136 | static void |
db2960f4 | 4137 | prepare_function_start (void) |
3a70d621 | 4138 | { |
3e029763 | 4139 | gcc_assert (!crtl->emit.x_last_insn); |
fb0703f7 | 4140 | init_temp_slots (); |
0de456a5 | 4141 | init_emit (); |
bd60bab2 | 4142 | init_varasm_status (); |
0de456a5 | 4143 | init_expr (); |
bf08ebeb | 4144 | default_rtl_profile (); |
6f086dfc | 4145 | |
3a70d621 | 4146 | cse_not_expected = ! optimize; |
6f086dfc | 4147 | |
3a70d621 RH |
4148 | /* Caller save not needed yet. */ |
4149 | caller_save_needed = 0; | |
6f086dfc | 4150 | |
3a70d621 RH |
4151 | /* We haven't done register allocation yet. */ |
4152 | reg_renumber = 0; | |
6f086dfc | 4153 | |
b384405b BS |
4154 | /* Indicate that we have not instantiated virtual registers yet. */ |
4155 | virtuals_instantiated = 0; | |
4156 | ||
1b3d8f8a GK |
4157 | /* Indicate that we want CONCATs now. */ |
4158 | generating_concat_p = 1; | |
4159 | ||
b384405b BS |
4160 | /* Indicate we have no need of a frame pointer yet. */ |
4161 | frame_pointer_needed = 0; | |
b384405b BS |
4162 | } |
4163 | ||
4164 | /* Initialize the rtl expansion mechanism so that we can do simple things | |
4165 | like generate sequences. This is used to provide a context during global | |
db2960f4 SL |
4166 | initialization of some passes. You must call expand_dummy_function_end |
4167 | to exit this context. */ | |
4168 | ||
b384405b | 4169 | void |
fa8db1f7 | 4170 | init_dummy_function_start (void) |
b384405b | 4171 | { |
db2960f4 SL |
4172 | gcc_assert (!in_dummy_function); |
4173 | in_dummy_function = true; | |
4174 | push_struct_function (NULL_TREE); | |
4175 | prepare_function_start (); | |
b384405b BS |
4176 | } |
4177 | ||
4178 | /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node) | |
4179 | and initialize static variables for generating RTL for the statements | |
4180 | of the function. */ | |
4181 | ||
4182 | void | |
fa8db1f7 | 4183 | init_function_start (tree subr) |
b384405b | 4184 | { |
db2960f4 SL |
4185 | if (subr && DECL_STRUCT_FUNCTION (subr)) |
4186 | set_cfun (DECL_STRUCT_FUNCTION (subr)); | |
4187 | else | |
182e0d71 | 4188 | allocate_struct_function (subr, false); |
db2960f4 | 4189 | prepare_function_start (); |
b384405b | 4190 | |
6f086dfc RS |
4191 | /* Warn if this value is an aggregate type, |
4192 | regardless of which calling convention we are using for it. */ | |
ccf08a6e DD |
4193 | if (AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr)))) |
4194 | warning (OPT_Waggregate_return, "function returns an aggregate"); | |
49ad7cfa | 4195 | } |
5c7675e9 | 4196 | |
cd9c1ca8 | 4197 | /* Make sure all values used by the optimization passes have sane defaults. */ |
c2924966 | 4198 | unsigned int |
fa8db1f7 | 4199 | init_function_for_compilation (void) |
49ad7cfa BS |
4200 | { |
4201 | reg_renumber = 0; | |
c2924966 | 4202 | return 0; |
6f086dfc RS |
4203 | } |
4204 | ||
8ddbbcae | 4205 | struct rtl_opt_pass pass_init_function = |
ef330312 | 4206 | { |
8ddbbcae JH |
4207 | { |
4208 | RTL_PASS, | |
ef330312 PB |
4209 | NULL, /* name */ |
4210 | NULL, /* gate */ | |
4211 | init_function_for_compilation, /* execute */ | |
4212 | NULL, /* sub */ | |
4213 | NULL, /* next */ | |
4214 | 0, /* static_pass_number */ | |
7072a650 | 4215 | TV_NONE, /* tv_id */ |
ef330312 PB |
4216 | 0, /* properties_required */ |
4217 | 0, /* properties_provided */ | |
4218 | 0, /* properties_destroyed */ | |
4219 | 0, /* todo_flags_start */ | |
8ddbbcae JH |
4220 | 0 /* todo_flags_finish */ |
4221 | } | |
ef330312 PB |
4222 | }; |
4223 | ||
4224 | ||
6f086dfc | 4225 | void |
fa8db1f7 | 4226 | expand_main_function (void) |
6f086dfc | 4227 | { |
3a57c6cb MM |
4228 | #if (defined(INVOKE__main) \ |
4229 | || (!defined(HAS_INIT_SECTION) \ | |
4230 | && !defined(INIT_SECTION_ASM_OP) \ | |
4231 | && !defined(INIT_ARRAY_SECTION_ASM_OP))) | |
68d28100 | 4232 | emit_library_call (init_one_libfunc (NAME__MAIN), LCT_NORMAL, VOIDmode, 0); |
1d482056 | 4233 | #endif |
6f086dfc RS |
4234 | } |
4235 | \f | |
7d69de61 RH |
4236 | /* Expand code to initialize the stack_protect_guard. This is invoked at |
4237 | the beginning of a function to be protected. */ | |
4238 | ||
4239 | #ifndef HAVE_stack_protect_set | |
4240 | # define HAVE_stack_protect_set 0 | |
4241 | # define gen_stack_protect_set(x,y) (gcc_unreachable (), NULL_RTX) | |
4242 | #endif | |
4243 | ||
4244 | void | |
4245 | stack_protect_prologue (void) | |
4246 | { | |
4247 | tree guard_decl = targetm.stack_protect_guard (); | |
4248 | rtx x, y; | |
4249 | ||
4250 | /* Avoid expand_expr here, because we don't want guard_decl pulled | |
4251 | into registers unless absolutely necessary. And we know that | |
cb91fab0 | 4252 | crtl->stack_protect_guard is a local stack slot, so this skips |
7d69de61 | 4253 | all the fluff. */ |
cb91fab0 | 4254 | x = validize_mem (DECL_RTL (crtl->stack_protect_guard)); |
7d69de61 RH |
4255 | y = validize_mem (DECL_RTL (guard_decl)); |
4256 | ||
4257 | /* Allow the target to copy from Y to X without leaking Y into a | |
4258 | register. */ | |
4259 | if (HAVE_stack_protect_set) | |
4260 | { | |
4261 | rtx insn = gen_stack_protect_set (x, y); | |
4262 | if (insn) | |
4263 | { | |
4264 | emit_insn (insn); | |
4265 | return; | |
4266 | } | |
4267 | } | |
4268 | ||
4269 | /* Otherwise do a straight move. */ | |
4270 | emit_move_insn (x, y); | |
4271 | } | |
4272 | ||
4273 | /* Expand code to verify the stack_protect_guard. This is invoked at | |
4274 | the end of a function to be protected. */ | |
4275 | ||
4276 | #ifndef HAVE_stack_protect_test | |
b76be05e JJ |
4277 | # define HAVE_stack_protect_test 0 |
4278 | # define gen_stack_protect_test(x, y, z) (gcc_unreachable (), NULL_RTX) | |
7d69de61 RH |
4279 | #endif |
4280 | ||
b755446c | 4281 | void |
7d69de61 RH |
4282 | stack_protect_epilogue (void) |
4283 | { | |
4284 | tree guard_decl = targetm.stack_protect_guard (); | |
4285 | rtx label = gen_label_rtx (); | |
4286 | rtx x, y, tmp; | |
4287 | ||
4288 | /* Avoid expand_expr here, because we don't want guard_decl pulled | |
4289 | into registers unless absolutely necessary. And we know that | |
cb91fab0 | 4290 | crtl->stack_protect_guard is a local stack slot, so this skips |
7d69de61 | 4291 | all the fluff. */ |
cb91fab0 | 4292 | x = validize_mem (DECL_RTL (crtl->stack_protect_guard)); |
7d69de61 RH |
4293 | y = validize_mem (DECL_RTL (guard_decl)); |
4294 | ||
4295 | /* Allow the target to compare Y with X without leaking either into | |
4296 | a register. */ | |
4297 | switch (HAVE_stack_protect_test != 0) | |
4298 | { | |
4299 | case 1: | |
3aebbe5f | 4300 | tmp = gen_stack_protect_test (x, y, label); |
7d69de61 RH |
4301 | if (tmp) |
4302 | { | |
4303 | emit_insn (tmp); | |
7d69de61 RH |
4304 | break; |
4305 | } | |
4306 | /* FALLTHRU */ | |
4307 | ||
4308 | default: | |
4309 | emit_cmp_and_jump_insns (x, y, EQ, NULL_RTX, ptr_mode, 1, label); | |
4310 | break; | |
4311 | } | |
4312 | ||
4313 | /* The noreturn predictor has been moved to the tree level. The rtl-level | |
4314 | predictors estimate this branch about 20%, which isn't enough to get | |
4315 | things moved out of line. Since this is the only extant case of adding | |
4316 | a noreturn function at the rtl level, it doesn't seem worth doing ought | |
4317 | except adding the prediction by hand. */ | |
4318 | tmp = get_last_insn (); | |
4319 | if (JUMP_P (tmp)) | |
4320 | predict_insn_def (tmp, PRED_NORETURN, TAKEN); | |
4321 | ||
4322 | expand_expr_stmt (targetm.stack_protect_fail ()); | |
4323 | emit_label (label); | |
4324 | } | |
4325 | \f | |
6f086dfc RS |
4326 | /* Start the RTL for a new function, and set variables used for |
4327 | emitting RTL. | |
4328 | SUBR is the FUNCTION_DECL node. | |
4329 | PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with | |
4330 | the function's parameters, which must be run at any return statement. */ | |
4331 | ||
4332 | void | |
b79c5284 | 4333 | expand_function_start (tree subr) |
6f086dfc | 4334 | { |
6f086dfc RS |
4335 | /* Make sure volatile mem refs aren't considered |
4336 | valid operands of arithmetic insns. */ | |
4337 | init_recog_no_volatile (); | |
4338 | ||
e3b5732b | 4339 | crtl->profile |
70f4f91c WC |
4340 | = (profile_flag |
4341 | && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr)); | |
4342 | ||
e3b5732b | 4343 | crtl->limit_stack |
a157febd GK |
4344 | = (stack_limit_rtx != NULL_RTX && ! DECL_NO_LIMIT_STACK (subr)); |
4345 | ||
52a11cbf RH |
4346 | /* Make the label for return statements to jump to. Do not special |
4347 | case machines with special return instructions -- they will be | |
4348 | handled later during jump, ifcvt, or epilogue creation. */ | |
6f086dfc | 4349 | return_label = gen_label_rtx (); |
6f086dfc RS |
4350 | |
4351 | /* Initialize rtx used to return the value. */ | |
4352 | /* Do this before assign_parms so that we copy the struct value address | |
4353 | before any library calls that assign parms might generate. */ | |
4354 | ||
4355 | /* Decide whether to return the value in memory or in a register. */ | |
61f71b34 | 4356 | if (aggregate_value_p (DECL_RESULT (subr), subr)) |
6f086dfc RS |
4357 | { |
4358 | /* Returning something that won't go in a register. */ | |
b3694847 | 4359 | rtx value_address = 0; |
6f086dfc RS |
4360 | |
4361 | #ifdef PCC_STATIC_STRUCT_RETURN | |
e3b5732b | 4362 | if (cfun->returns_pcc_struct) |
6f086dfc RS |
4363 | { |
4364 | int size = int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr))); | |
4365 | value_address = assemble_static_space (size); | |
4366 | } | |
4367 | else | |
4368 | #endif | |
4369 | { | |
2225b57c | 4370 | rtx sv = targetm.calls.struct_value_rtx (TREE_TYPE (subr), 2); |
6f086dfc RS |
4371 | /* Expect to be passed the address of a place to store the value. |
4372 | If it is passed as an argument, assign_parms will take care of | |
4373 | it. */ | |
61f71b34 | 4374 | if (sv) |
6f086dfc RS |
4375 | { |
4376 | value_address = gen_reg_rtx (Pmode); | |
61f71b34 | 4377 | emit_move_insn (value_address, sv); |
6f086dfc RS |
4378 | } |
4379 | } | |
4380 | if (value_address) | |
ccdecf58 | 4381 | { |
01c98570 JM |
4382 | rtx x = value_address; |
4383 | if (!DECL_BY_REFERENCE (DECL_RESULT (subr))) | |
4384 | { | |
4385 | x = gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr)), x); | |
4386 | set_mem_attributes (x, DECL_RESULT (subr), 1); | |
4387 | } | |
abde42f7 | 4388 | SET_DECL_RTL (DECL_RESULT (subr), x); |
ccdecf58 | 4389 | } |
6f086dfc RS |
4390 | } |
4391 | else if (DECL_MODE (DECL_RESULT (subr)) == VOIDmode) | |
4392 | /* If return mode is void, this decl rtl should not be used. */ | |
19e7881c | 4393 | SET_DECL_RTL (DECL_RESULT (subr), NULL_RTX); |
d5bf1143 | 4394 | else |
a53e14c0 | 4395 | { |
d5bf1143 RH |
4396 | /* Compute the return values into a pseudo reg, which we will copy |
4397 | into the true return register after the cleanups are done. */ | |
bef5d8b6 RS |
4398 | tree return_type = TREE_TYPE (DECL_RESULT (subr)); |
4399 | if (TYPE_MODE (return_type) != BLKmode | |
4400 | && targetm.calls.return_in_msb (return_type)) | |
4401 | /* expand_function_end will insert the appropriate padding in | |
4402 | this case. Use the return value's natural (unpadded) mode | |
4403 | within the function proper. */ | |
4404 | SET_DECL_RTL (DECL_RESULT (subr), | |
4405 | gen_reg_rtx (TYPE_MODE (return_type))); | |
80a480ca | 4406 | else |
0bccc606 | 4407 | { |
bef5d8b6 RS |
4408 | /* In order to figure out what mode to use for the pseudo, we |
4409 | figure out what the mode of the eventual return register will | |
4410 | actually be, and use that. */ | |
1d636cc6 | 4411 | rtx hard_reg = hard_function_value (return_type, subr, 0, 1); |
bef5d8b6 RS |
4412 | |
4413 | /* Structures that are returned in registers are not | |
4414 | aggregate_value_p, so we may see a PARALLEL or a REG. */ | |
4415 | if (REG_P (hard_reg)) | |
4416 | SET_DECL_RTL (DECL_RESULT (subr), | |
4417 | gen_reg_rtx (GET_MODE (hard_reg))); | |
4418 | else | |
4419 | { | |
4420 | gcc_assert (GET_CODE (hard_reg) == PARALLEL); | |
4421 | SET_DECL_RTL (DECL_RESULT (subr), gen_group_rtx (hard_reg)); | |
4422 | } | |
0bccc606 | 4423 | } |
a53e14c0 | 4424 | |
084a1106 JDA |
4425 | /* Set DECL_REGISTER flag so that expand_function_end will copy the |
4426 | result to the real return register(s). */ | |
4427 | DECL_REGISTER (DECL_RESULT (subr)) = 1; | |
a53e14c0 | 4428 | } |
6f086dfc RS |
4429 | |
4430 | /* Initialize rtx for parameters and local variables. | |
4431 | In some cases this requires emitting insns. */ | |
0d1416c6 | 4432 | assign_parms (subr); |
6f086dfc | 4433 | |
6de9cd9a DN |
4434 | /* If function gets a static chain arg, store it. */ |
4435 | if (cfun->static_chain_decl) | |
4436 | { | |
7e140280 RH |
4437 | tree parm = cfun->static_chain_decl; |
4438 | rtx local = gen_reg_rtx (Pmode); | |
4439 | ||
5141868d | 4440 | set_decl_incoming_rtl (parm, static_chain_incoming_rtx, false); |
7e140280 | 4441 | SET_DECL_RTL (parm, local); |
7e140280 | 4442 | mark_reg_pointer (local, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm)))); |
6de9cd9a | 4443 | |
7e140280 | 4444 | emit_move_insn (local, static_chain_incoming_rtx); |
6de9cd9a DN |
4445 | } |
4446 | ||
4447 | /* If the function receives a non-local goto, then store the | |
4448 | bits we need to restore the frame pointer. */ | |
4449 | if (cfun->nonlocal_goto_save_area) | |
4450 | { | |
4451 | tree t_save; | |
4452 | rtx r_save; | |
4453 | ||
4454 | /* ??? We need to do this save early. Unfortunately here is | |
4455 | before the frame variable gets declared. Help out... */ | |
4846b435 PB |
4456 | tree var = TREE_OPERAND (cfun->nonlocal_goto_save_area, 0); |
4457 | if (!DECL_RTL_SET_P (var)) | |
4458 | expand_decl (var); | |
6de9cd9a | 4459 | |
3244e67d RS |
4460 | t_save = build4 (ARRAY_REF, ptr_type_node, |
4461 | cfun->nonlocal_goto_save_area, | |
4462 | integer_zero_node, NULL_TREE, NULL_TREE); | |
6de9cd9a | 4463 | r_save = expand_expr (t_save, NULL_RTX, VOIDmode, EXPAND_WRITE); |
5e89a381 | 4464 | r_save = convert_memory_address (Pmode, r_save); |
f0c51a1e | 4465 | |
88280cf9 | 4466 | emit_move_insn (r_save, targetm.builtin_setjmp_frame_value ()); |
6de9cd9a DN |
4467 | update_nonlocal_goto_save_area (); |
4468 | } | |
f0c51a1e | 4469 | |
6f086dfc RS |
4470 | /* The following was moved from init_function_start. |
4471 | The move is supposed to make sdb output more accurate. */ | |
4472 | /* Indicate the beginning of the function body, | |
4473 | as opposed to parm setup. */ | |
2e040219 | 4474 | emit_note (NOTE_INSN_FUNCTION_BEG); |
6f086dfc | 4475 | |
ede497cf SB |
4476 | gcc_assert (NOTE_P (get_last_insn ())); |
4477 | ||
6f086dfc RS |
4478 | parm_birth_insn = get_last_insn (); |
4479 | ||
e3b5732b | 4480 | if (crtl->profile) |
f6f315fe | 4481 | { |
f6f315fe | 4482 | #ifdef PROFILE_HOOK |
df696a75 | 4483 | PROFILE_HOOK (current_function_funcdef_no); |
411707f4 | 4484 | #endif |
f6f315fe | 4485 | } |
411707f4 | 4486 | |
ede497cf SB |
4487 | /* After the display initializations is where the stack checking |
4488 | probe should go. */ | |
4489 | if(flag_stack_check) | |
4490 | stack_check_probe_note = emit_note (NOTE_INSN_DELETED); | |
6f086dfc | 4491 | |
6f086dfc RS |
4492 | /* Make sure there is a line number after the function entry setup code. */ |
4493 | force_next_line_note (); | |
4494 | } | |
4495 | \f | |
49ad7cfa BS |
4496 | /* Undo the effects of init_dummy_function_start. */ |
4497 | void | |
fa8db1f7 | 4498 | expand_dummy_function_end (void) |
49ad7cfa | 4499 | { |
db2960f4 SL |
4500 | gcc_assert (in_dummy_function); |
4501 | ||
49ad7cfa BS |
4502 | /* End any sequences that failed to be closed due to syntax errors. */ |
4503 | while (in_sequence_p ()) | |
4504 | end_sequence (); | |
4505 | ||
4506 | /* Outside function body, can't compute type's actual size | |
4507 | until next function's body starts. */ | |
fa51b01b | 4508 | |
01d939e8 BS |
4509 | free_after_parsing (cfun); |
4510 | free_after_compilation (cfun); | |
db2960f4 SL |
4511 | pop_cfun (); |
4512 | in_dummy_function = false; | |
49ad7cfa BS |
4513 | } |
4514 | ||
c13fde05 RH |
4515 | /* Call DOIT for each hard register used as a return value from |
4516 | the current function. */ | |
bd695e1e RH |
4517 | |
4518 | void | |
fa8db1f7 | 4519 | diddle_return_value (void (*doit) (rtx, void *), void *arg) |
bd695e1e | 4520 | { |
38173d38 | 4521 | rtx outgoing = crtl->return_rtx; |
c13fde05 RH |
4522 | |
4523 | if (! outgoing) | |
4524 | return; | |
bd695e1e | 4525 | |
f8cfc6aa | 4526 | if (REG_P (outgoing)) |
c13fde05 RH |
4527 | (*doit) (outgoing, arg); |
4528 | else if (GET_CODE (outgoing) == PARALLEL) | |
4529 | { | |
4530 | int i; | |
bd695e1e | 4531 | |
c13fde05 RH |
4532 | for (i = 0; i < XVECLEN (outgoing, 0); i++) |
4533 | { | |
4534 | rtx x = XEXP (XVECEXP (outgoing, 0, i), 0); | |
4535 | ||
f8cfc6aa | 4536 | if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER) |
c13fde05 | 4537 | (*doit) (x, arg); |
bd695e1e RH |
4538 | } |
4539 | } | |
4540 | } | |
4541 | ||
c13fde05 | 4542 | static void |
fa8db1f7 | 4543 | do_clobber_return_reg (rtx reg, void *arg ATTRIBUTE_UNUSED) |
c13fde05 | 4544 | { |
c41c1387 | 4545 | emit_clobber (reg); |
c13fde05 RH |
4546 | } |
4547 | ||
4548 | void | |
fa8db1f7 | 4549 | clobber_return_register (void) |
c13fde05 RH |
4550 | { |
4551 | diddle_return_value (do_clobber_return_reg, NULL); | |
9c65bbf4 JH |
4552 | |
4553 | /* In case we do use pseudo to return value, clobber it too. */ | |
4554 | if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl))) | |
4555 | { | |
4556 | tree decl_result = DECL_RESULT (current_function_decl); | |
4557 | rtx decl_rtl = DECL_RTL (decl_result); | |
4558 | if (REG_P (decl_rtl) && REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER) | |
4559 | { | |
4560 | do_clobber_return_reg (decl_rtl, NULL); | |
4561 | } | |
4562 | } | |
c13fde05 RH |
4563 | } |
4564 | ||
4565 | static void | |
fa8db1f7 | 4566 | do_use_return_reg (rtx reg, void *arg ATTRIBUTE_UNUSED) |
c13fde05 | 4567 | { |
c41c1387 | 4568 | emit_use (reg); |
c13fde05 RH |
4569 | } |
4570 | ||
0bf8477d | 4571 | static void |
fa8db1f7 | 4572 | use_return_register (void) |
c13fde05 RH |
4573 | { |
4574 | diddle_return_value (do_use_return_reg, NULL); | |
4575 | } | |
4576 | ||
902edd36 JH |
4577 | /* Possibly warn about unused parameters. */ |
4578 | void | |
4579 | do_warn_unused_parameter (tree fn) | |
4580 | { | |
4581 | tree decl; | |
4582 | ||
4583 | for (decl = DECL_ARGUMENTS (fn); | |
4584 | decl; decl = TREE_CHAIN (decl)) | |
4585 | if (!TREE_USED (decl) && TREE_CODE (decl) == PARM_DECL | |
534fd534 DF |
4586 | && DECL_NAME (decl) && !DECL_ARTIFICIAL (decl) |
4587 | && !TREE_NO_WARNING (decl)) | |
b9b8dde3 | 4588 | warning (OPT_Wunused_parameter, "unused parameter %q+D", decl); |
902edd36 JH |
4589 | } |
4590 | ||
e2500fed GK |
4591 | static GTY(()) rtx initial_trampoline; |
4592 | ||
71c0e7fc | 4593 | /* Generate RTL for the end of the current function. */ |
6f086dfc RS |
4594 | |
4595 | void | |
fa8db1f7 | 4596 | expand_function_end (void) |
6f086dfc | 4597 | { |
932f0847 | 4598 | rtx clobber_after; |
6f086dfc | 4599 | |
964be02f RH |
4600 | /* If arg_pointer_save_area was referenced only from a nested |
4601 | function, we will not have initialized it yet. Do that now. */ | |
e3b5732b | 4602 | if (arg_pointer_save_area && ! crtl->arg_pointer_save_area_init) |
bd60bab2 | 4603 | get_arg_pointer_save_area (); |
964be02f | 4604 | |
b38f3813 | 4605 | /* If we are doing generic stack checking and this function makes calls, |
11044f66 RK |
4606 | do a stack probe at the start of the function to ensure we have enough |
4607 | space for another stack frame. */ | |
b38f3813 | 4608 | if (flag_stack_check == GENERIC_STACK_CHECK) |
11044f66 RK |
4609 | { |
4610 | rtx insn, seq; | |
4611 | ||
4612 | for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) | |
4b4bf941 | 4613 | if (CALL_P (insn)) |
11044f66 RK |
4614 | { |
4615 | start_sequence (); | |
b38f3813 | 4616 | probe_stack_range (STACK_OLD_CHECK_PROTECT, |
11044f66 RK |
4617 | GEN_INT (STACK_CHECK_MAX_FRAME_SIZE)); |
4618 | seq = get_insns (); | |
4619 | end_sequence (); | |
ede497cf | 4620 | emit_insn_before (seq, stack_check_probe_note); |
11044f66 RK |
4621 | break; |
4622 | } | |
4623 | } | |
4624 | ||
6f086dfc RS |
4625 | /* End any sequences that failed to be closed due to syntax errors. */ |
4626 | while (in_sequence_p ()) | |
5f4f0e22 | 4627 | end_sequence (); |
6f086dfc | 4628 | |
6f086dfc RS |
4629 | clear_pending_stack_adjust (); |
4630 | do_pending_stack_adjust (); | |
4631 | ||
6f086dfc RS |
4632 | /* Output a linenumber for the end of the function. |
4633 | SDB depends on this. */ | |
0cea056b | 4634 | force_next_line_note (); |
55e092c4 | 4635 | set_curr_insn_source_location (input_location); |
6f086dfc | 4636 | |
fbffc70a | 4637 | /* Before the return label (if any), clobber the return |
a1f300c0 | 4638 | registers so that they are not propagated live to the rest of |
fbffc70a GK |
4639 | the function. This can only happen with functions that drop |
4640 | through; if there had been a return statement, there would | |
932f0847 JH |
4641 | have either been a return rtx, or a jump to the return label. |
4642 | ||
4643 | We delay actual code generation after the current_function_value_rtx | |
4644 | is computed. */ | |
4645 | clobber_after = get_last_insn (); | |
fbffc70a | 4646 | |
526c334b KH |
4647 | /* Output the label for the actual return from the function. */ |
4648 | emit_label (return_label); | |
6f086dfc | 4649 | |
815eb8f0 AM |
4650 | if (USING_SJLJ_EXCEPTIONS) |
4651 | { | |
4652 | /* Let except.c know where it should emit the call to unregister | |
4653 | the function context for sjlj exceptions. */ | |
4654 | if (flag_exceptions) | |
4655 | sjlj_emit_function_exit_after (get_last_insn ()); | |
4656 | } | |
6fb5fa3c DB |
4657 | else |
4658 | { | |
4659 | /* We want to ensure that instructions that may trap are not | |
4660 | moved into the epilogue by scheduling, because we don't | |
4661 | always emit unwind information for the epilogue. */ | |
4662 | if (flag_non_call_exceptions) | |
4663 | emit_insn (gen_blockage ()); | |
4664 | } | |
0b59e81e | 4665 | |
652b0932 RH |
4666 | /* If this is an implementation of throw, do what's necessary to |
4667 | communicate between __builtin_eh_return and the epilogue. */ | |
4668 | expand_eh_return (); | |
4669 | ||
3e4eac3f RH |
4670 | /* If scalar return value was computed in a pseudo-reg, or was a named |
4671 | return value that got dumped to the stack, copy that to the hard | |
4672 | return register. */ | |
19e7881c | 4673 | if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl))) |
6f086dfc | 4674 | { |
3e4eac3f RH |
4675 | tree decl_result = DECL_RESULT (current_function_decl); |
4676 | rtx decl_rtl = DECL_RTL (decl_result); | |
4677 | ||
4678 | if (REG_P (decl_rtl) | |
4679 | ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER | |
4680 | : DECL_REGISTER (decl_result)) | |
4681 | { | |
38173d38 | 4682 | rtx real_decl_rtl = crtl->return_rtx; |
6f086dfc | 4683 | |
ce5e43d0 | 4684 | /* This should be set in assign_parms. */ |
0bccc606 | 4685 | gcc_assert (REG_FUNCTION_VALUE_P (real_decl_rtl)); |
3e4eac3f RH |
4686 | |
4687 | /* If this is a BLKmode structure being returned in registers, | |
4688 | then use the mode computed in expand_return. Note that if | |
797a6ac1 | 4689 | decl_rtl is memory, then its mode may have been changed, |
38173d38 | 4690 | but that crtl->return_rtx has not. */ |
3e4eac3f | 4691 | if (GET_MODE (real_decl_rtl) == BLKmode) |
ce5e43d0 | 4692 | PUT_MODE (real_decl_rtl, GET_MODE (decl_rtl)); |
3e4eac3f | 4693 | |
bef5d8b6 RS |
4694 | /* If a non-BLKmode return value should be padded at the least |
4695 | significant end of the register, shift it left by the appropriate | |
4696 | amount. BLKmode results are handled using the group load/store | |
4697 | machinery. */ | |
4698 | if (TYPE_MODE (TREE_TYPE (decl_result)) != BLKmode | |
4699 | && targetm.calls.return_in_msb (TREE_TYPE (decl_result))) | |
4700 | { | |
4701 | emit_move_insn (gen_rtx_REG (GET_MODE (decl_rtl), | |
4702 | REGNO (real_decl_rtl)), | |
4703 | decl_rtl); | |
4704 | shift_return_value (GET_MODE (decl_rtl), true, real_decl_rtl); | |
4705 | } | |
3e4eac3f | 4706 | /* If a named return value dumped decl_return to memory, then |
797a6ac1 | 4707 | we may need to re-do the PROMOTE_MODE signed/unsigned |
3e4eac3f | 4708 | extension. */ |
bef5d8b6 | 4709 | else if (GET_MODE (real_decl_rtl) != GET_MODE (decl_rtl)) |
3e4eac3f | 4710 | { |
8df83eae | 4711 | int unsignedp = TYPE_UNSIGNED (TREE_TYPE (decl_result)); |
3e4eac3f | 4712 | |
61f71b34 DD |
4713 | if (targetm.calls.promote_function_return (TREE_TYPE (current_function_decl))) |
4714 | promote_mode (TREE_TYPE (decl_result), GET_MODE (decl_rtl), | |
4715 | &unsignedp, 1); | |
3e4eac3f RH |
4716 | |
4717 | convert_move (real_decl_rtl, decl_rtl, unsignedp); | |
4718 | } | |
aa570f54 | 4719 | else if (GET_CODE (real_decl_rtl) == PARALLEL) |
084a1106 JDA |
4720 | { |
4721 | /* If expand_function_start has created a PARALLEL for decl_rtl, | |
4722 | move the result to the real return registers. Otherwise, do | |
4723 | a group load from decl_rtl for a named return. */ | |
4724 | if (GET_CODE (decl_rtl) == PARALLEL) | |
4725 | emit_group_move (real_decl_rtl, decl_rtl); | |
4726 | else | |
4727 | emit_group_load (real_decl_rtl, decl_rtl, | |
6e985040 | 4728 | TREE_TYPE (decl_result), |
084a1106 JDA |
4729 | int_size_in_bytes (TREE_TYPE (decl_result))); |
4730 | } | |
652b0932 RH |
4731 | /* In the case of complex integer modes smaller than a word, we'll |
4732 | need to generate some non-trivial bitfield insertions. Do that | |
4733 | on a pseudo and not the hard register. */ | |
4734 | else if (GET_CODE (decl_rtl) == CONCAT | |
4735 | && GET_MODE_CLASS (GET_MODE (decl_rtl)) == MODE_COMPLEX_INT | |
4736 | && GET_MODE_BITSIZE (GET_MODE (decl_rtl)) <= BITS_PER_WORD) | |
4737 | { | |
4738 | int old_generating_concat_p; | |
4739 | rtx tmp; | |
4740 | ||
4741 | old_generating_concat_p = generating_concat_p; | |
4742 | generating_concat_p = 0; | |
4743 | tmp = gen_reg_rtx (GET_MODE (decl_rtl)); | |
4744 | generating_concat_p = old_generating_concat_p; | |
4745 | ||
4746 | emit_move_insn (tmp, decl_rtl); | |
4747 | emit_move_insn (real_decl_rtl, tmp); | |
4748 | } | |
3e4eac3f RH |
4749 | else |
4750 | emit_move_insn (real_decl_rtl, decl_rtl); | |
3e4eac3f | 4751 | } |
6f086dfc RS |
4752 | } |
4753 | ||
4754 | /* If returning a structure, arrange to return the address of the value | |
4755 | in a place where debuggers expect to find it. | |
4756 | ||
4757 | If returning a structure PCC style, | |
4758 | the caller also depends on this value. | |
e3b5732b JH |
4759 | And cfun->returns_pcc_struct is not necessarily set. */ |
4760 | if (cfun->returns_struct | |
4761 | || cfun->returns_pcc_struct) | |
6f086dfc | 4762 | { |
cc77ae10 | 4763 | rtx value_address = DECL_RTL (DECL_RESULT (current_function_decl)); |
6f086dfc | 4764 | tree type = TREE_TYPE (DECL_RESULT (current_function_decl)); |
cc77ae10 JM |
4765 | rtx outgoing; |
4766 | ||
4767 | if (DECL_BY_REFERENCE (DECL_RESULT (current_function_decl))) | |
4768 | type = TREE_TYPE (type); | |
4769 | else | |
4770 | value_address = XEXP (value_address, 0); | |
4771 | ||
1d636cc6 RG |
4772 | outgoing = targetm.calls.function_value (build_pointer_type (type), |
4773 | current_function_decl, true); | |
6f086dfc RS |
4774 | |
4775 | /* Mark this as a function return value so integrate will delete the | |
4776 | assignment and USE below when inlining this function. */ | |
4777 | REG_FUNCTION_VALUE_P (outgoing) = 1; | |
4778 | ||
d1608933 | 4779 | /* The address may be ptr_mode and OUTGOING may be Pmode. */ |
5ae6cd0d MM |
4780 | value_address = convert_memory_address (GET_MODE (outgoing), |
4781 | value_address); | |
d1608933 | 4782 | |
6f086dfc | 4783 | emit_move_insn (outgoing, value_address); |
d1608933 RK |
4784 | |
4785 | /* Show return register used to hold result (in this case the address | |
4786 | of the result. */ | |
38173d38 | 4787 | crtl->return_rtx = outgoing; |
6f086dfc RS |
4788 | } |
4789 | ||
932f0847 JH |
4790 | /* Emit the actual code to clobber return register. */ |
4791 | { | |
609c3937 | 4792 | rtx seq; |
797a6ac1 | 4793 | |
932f0847 JH |
4794 | start_sequence (); |
4795 | clobber_return_register (); | |
2f937369 | 4796 | seq = get_insns (); |
932f0847 JH |
4797 | end_sequence (); |
4798 | ||
609c3937 | 4799 | emit_insn_after (seq, clobber_after); |
932f0847 JH |
4800 | } |
4801 | ||
609c3937 | 4802 | /* Output the label for the naked return from the function. */ |
4c33221c UW |
4803 | if (naked_return_label) |
4804 | emit_label (naked_return_label); | |
6e3077c6 | 4805 | |
25108646 AH |
4806 | /* @@@ This is a kludge. We want to ensure that instructions that |
4807 | may trap are not moved into the epilogue by scheduling, because | |
56d17681 | 4808 | we don't always emit unwind information for the epilogue. */ |
25108646 | 4809 | if (! USING_SJLJ_EXCEPTIONS && flag_non_call_exceptions) |
56d17681 | 4810 | emit_insn (gen_blockage ()); |
25108646 | 4811 | |
7d69de61 | 4812 | /* If stack protection is enabled for this function, check the guard. */ |
cb91fab0 | 4813 | if (crtl->stack_protect_guard) |
7d69de61 RH |
4814 | stack_protect_epilogue (); |
4815 | ||
40184445 BS |
4816 | /* If we had calls to alloca, and this machine needs |
4817 | an accurate stack pointer to exit the function, | |
4818 | insert some code to save and restore the stack pointer. */ | |
4819 | if (! EXIT_IGNORE_STACK | |
e3b5732b | 4820 | && cfun->calls_alloca) |
40184445 BS |
4821 | { |
4822 | rtx tem = 0; | |
4823 | ||
4824 | emit_stack_save (SAVE_FUNCTION, &tem, parm_birth_insn); | |
4825 | emit_stack_restore (SAVE_FUNCTION, tem, NULL_RTX); | |
4826 | } | |
4827 | ||
c13fde05 RH |
4828 | /* ??? This should no longer be necessary since stupid is no longer with |
4829 | us, but there are some parts of the compiler (eg reload_combine, and | |
4830 | sh mach_dep_reorg) that still try and compute their own lifetime info | |
4831 | instead of using the general framework. */ | |
4832 | use_return_register (); | |
6f086dfc | 4833 | } |
278ed218 RH |
4834 | |
4835 | rtx | |
bd60bab2 | 4836 | get_arg_pointer_save_area (void) |
278ed218 | 4837 | { |
bd60bab2 | 4838 | rtx ret = arg_pointer_save_area; |
278ed218 RH |
4839 | |
4840 | if (! ret) | |
4841 | { | |
bd60bab2 JH |
4842 | ret = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0); |
4843 | arg_pointer_save_area = ret; | |
964be02f RH |
4844 | } |
4845 | ||
e3b5732b | 4846 | if (! crtl->arg_pointer_save_area_init) |
964be02f RH |
4847 | { |
4848 | rtx seq; | |
278ed218 | 4849 | |
797a6ac1 | 4850 | /* Save the arg pointer at the beginning of the function. The |
964be02f | 4851 | generated stack slot may not be a valid memory address, so we |
278ed218 RH |
4852 | have to check it and fix it if necessary. */ |
4853 | start_sequence (); | |
2e3f842f L |
4854 | emit_move_insn (validize_mem (ret), |
4855 | crtl->args.internal_arg_pointer); | |
2f937369 | 4856 | seq = get_insns (); |
278ed218 RH |
4857 | end_sequence (); |
4858 | ||
964be02f | 4859 | push_topmost_sequence (); |
1cb2fc7b | 4860 | emit_insn_after (seq, entry_of_function ()); |
964be02f | 4861 | pop_topmost_sequence (); |
278ed218 RH |
4862 | } |
4863 | ||
4864 | return ret; | |
4865 | } | |
bdac5f58 | 4866 | \f |
cd9c1ca8 RH |
4867 | /* Add a list of INSNS to the hash HASHP, possibly allocating HASHP |
4868 | for the first time. */ | |
bdac5f58 | 4869 | |
0a1c58a2 | 4870 | static void |
cd9c1ca8 | 4871 | record_insns (rtx insns, rtx end, htab_t *hashp) |
bdac5f58 | 4872 | { |
2f937369 | 4873 | rtx tmp; |
cd9c1ca8 | 4874 | htab_t hash = *hashp; |
0a1c58a2 | 4875 | |
cd9c1ca8 RH |
4876 | if (hash == NULL) |
4877 | *hashp = hash | |
4878 | = htab_create_ggc (17, htab_hash_pointer, htab_eq_pointer, NULL); | |
4879 | ||
4880 | for (tmp = insns; tmp != end; tmp = NEXT_INSN (tmp)) | |
4881 | { | |
4882 | void **slot = htab_find_slot (hash, tmp, INSERT); | |
4883 | gcc_assert (*slot == NULL); | |
4884 | *slot = tmp; | |
4885 | } | |
4886 | } | |
4887 | ||
4888 | /* INSN has been duplicated as COPY, as part of duping a basic block. | |
4889 | If INSN is an epilogue insn, then record COPY as epilogue as well. */ | |
4890 | ||
4891 | void | |
4892 | maybe_copy_epilogue_insn (rtx insn, rtx copy) | |
4893 | { | |
4894 | void **slot; | |
4895 | ||
4896 | if (epilogue_insn_hash == NULL | |
4897 | || htab_find (epilogue_insn_hash, insn) == NULL) | |
4898 | return; | |
4899 | ||
4900 | slot = htab_find_slot (epilogue_insn_hash, copy, INSERT); | |
4901 | gcc_assert (*slot == NULL); | |
4902 | *slot = copy; | |
bdac5f58 TW |
4903 | } |
4904 | ||
589fe865 | 4905 | /* Set the locator of the insn chain starting at INSN to LOC. */ |
0435312e | 4906 | static void |
fa8db1f7 | 4907 | set_insn_locators (rtx insn, int loc) |
0435312e JH |
4908 | { |
4909 | while (insn != NULL_RTX) | |
4910 | { | |
4911 | if (INSN_P (insn)) | |
4912 | INSN_LOCATOR (insn) = loc; | |
4913 | insn = NEXT_INSN (insn); | |
4914 | } | |
4915 | } | |
4916 | ||
cd9c1ca8 RH |
4917 | /* Determine if any INSNs in HASH are, or are part of, INSN. Because |
4918 | we can be running after reorg, SEQUENCE rtl is possible. */ | |
bdac5f58 | 4919 | |
cd9c1ca8 RH |
4920 | static bool |
4921 | contains (const_rtx insn, htab_t hash) | |
bdac5f58 | 4922 | { |
cd9c1ca8 RH |
4923 | if (hash == NULL) |
4924 | return false; | |
bdac5f58 | 4925 | |
cd9c1ca8 | 4926 | if (NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE) |
bdac5f58 | 4927 | { |
cd9c1ca8 | 4928 | int i; |
bdac5f58 | 4929 | for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--) |
cd9c1ca8 RH |
4930 | if (htab_find (hash, XVECEXP (PATTERN (insn), 0, i))) |
4931 | return true; | |
4932 | return false; | |
bdac5f58 | 4933 | } |
cd9c1ca8 RH |
4934 | |
4935 | return htab_find (hash, insn) != NULL; | |
bdac5f58 | 4936 | } |
5c7675e9 RH |
4937 | |
4938 | int | |
4f588890 | 4939 | prologue_epilogue_contains (const_rtx insn) |
5c7675e9 | 4940 | { |
cd9c1ca8 | 4941 | if (contains (insn, prologue_insn_hash)) |
5c7675e9 | 4942 | return 1; |
cd9c1ca8 | 4943 | if (contains (insn, epilogue_insn_hash)) |
5c7675e9 RH |
4944 | return 1; |
4945 | return 0; | |
4946 | } | |
bdac5f58 | 4947 | |
73ef99fb | 4948 | #ifdef HAVE_return |
69732dcb RH |
4949 | /* Insert gen_return at the end of block BB. This also means updating |
4950 | block_for_insn appropriately. */ | |
4951 | ||
4952 | static void | |
6039a0c7 | 4953 | emit_return_into_block (basic_block bb) |
69732dcb | 4954 | { |
a813c111 | 4955 | emit_jump_insn_after (gen_return (), BB_END (bb)); |
69732dcb | 4956 | } |
73ef99fb | 4957 | #endif /* HAVE_return */ |
69732dcb | 4958 | |
9faa82d8 | 4959 | /* Generate the prologue and epilogue RTL if the machine supports it. Thread |
bdac5f58 TW |
4960 | this into place with notes indicating where the prologue ends and where |
4961 | the epilogue begins. Update the basic block information when possible. */ | |
4962 | ||
6fb5fa3c DB |
4963 | static void |
4964 | thread_prologue_and_epilogue_insns (void) | |
bdac5f58 | 4965 | { |
ca1117cc | 4966 | int inserted = 0; |
19d3c25c | 4967 | edge e; |
91ea4f8d | 4968 | #if defined (HAVE_sibcall_epilogue) || defined (HAVE_epilogue) || defined (HAVE_return) || defined (HAVE_prologue) |
19d3c25c | 4969 | rtx seq; |
91ea4f8d | 4970 | #endif |
86c82654 RH |
4971 | #if defined (HAVE_epilogue) || defined(HAVE_return) |
4972 | rtx epilogue_end = NULL_RTX; | |
4973 | #endif | |
628f6a4e | 4974 | edge_iterator ei; |
e881bb1b | 4975 | |
a8ba47cb | 4976 | rtl_profile_for_bb (ENTRY_BLOCK_PTR); |
bdac5f58 TW |
4977 | #ifdef HAVE_prologue |
4978 | if (HAVE_prologue) | |
4979 | { | |
e881bb1b | 4980 | start_sequence (); |
718fe406 | 4981 | seq = gen_prologue (); |
e881bb1b | 4982 | emit_insn (seq); |
bdac5f58 | 4983 | |
6fb5fa3c DB |
4984 | /* Insert an explicit USE for the frame pointer |
4985 | if the profiling is on and the frame pointer is required. */ | |
e3b5732b | 4986 | if (crtl->profile && frame_pointer_needed) |
c41c1387 | 4987 | emit_use (hard_frame_pointer_rtx); |
6fb5fa3c | 4988 | |
bdac5f58 | 4989 | /* Retain a map of the prologue insns. */ |
cd9c1ca8 | 4990 | record_insns (seq, NULL, &prologue_insn_hash); |
56d17681 UB |
4991 | emit_note (NOTE_INSN_PROLOGUE_END); |
4992 | ||
4993 | #ifndef PROFILE_BEFORE_PROLOGUE | |
4994 | /* Ensure that instructions are not moved into the prologue when | |
4995 | profiling is on. The call to the profiling routine can be | |
4996 | emitted within the live range of a call-clobbered register. */ | |
e3b5732b | 4997 | if (crtl->profile) |
56d17681 UB |
4998 | emit_insn (gen_blockage ()); |
4999 | #endif | |
9185a8d5 | 5000 | |
2f937369 | 5001 | seq = get_insns (); |
e881bb1b | 5002 | end_sequence (); |
0435312e | 5003 | set_insn_locators (seq, prologue_locator); |
e881bb1b | 5004 | |
d6a7951f | 5005 | /* Can't deal with multiple successors of the entry block |
75540af0 JH |
5006 | at the moment. Function should always have at least one |
5007 | entry point. */ | |
c5cbcccf | 5008 | gcc_assert (single_succ_p (ENTRY_BLOCK_PTR)); |
e881bb1b | 5009 | |
c5cbcccf | 5010 | insert_insn_on_edge (seq, single_succ_edge (ENTRY_BLOCK_PTR)); |
75540af0 | 5011 | inserted = 1; |
bdac5f58 | 5012 | } |
bdac5f58 | 5013 | #endif |
bdac5f58 | 5014 | |
19d3c25c RH |
5015 | /* If the exit block has no non-fake predecessors, we don't need |
5016 | an epilogue. */ | |
628f6a4e | 5017 | FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) |
19d3c25c RH |
5018 | if ((e->flags & EDGE_FAKE) == 0) |
5019 | break; | |
5020 | if (e == NULL) | |
5021 | goto epilogue_done; | |
5022 | ||
a8ba47cb | 5023 | rtl_profile_for_bb (EXIT_BLOCK_PTR); |
69732dcb RH |
5024 | #ifdef HAVE_return |
5025 | if (optimize && HAVE_return) | |
5026 | { | |
5027 | /* If we're allowed to generate a simple return instruction, | |
5028 | then by definition we don't need a full epilogue. Examine | |
718fe406 KH |
5029 | the block that falls through to EXIT. If it does not |
5030 | contain any code, examine its predecessors and try to | |
69732dcb RH |
5031 | emit (conditional) return instructions. */ |
5032 | ||
5033 | basic_block last; | |
69732dcb RH |
5034 | rtx label; |
5035 | ||
628f6a4e | 5036 | FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) |
69732dcb RH |
5037 | if (e->flags & EDGE_FALLTHRU) |
5038 | break; | |
5039 | if (e == NULL) | |
5040 | goto epilogue_done; | |
5041 | last = e->src; | |
5042 | ||
5043 | /* Verify that there are no active instructions in the last block. */ | |
a813c111 | 5044 | label = BB_END (last); |
4b4bf941 | 5045 | while (label && !LABEL_P (label)) |
69732dcb RH |
5046 | { |
5047 | if (active_insn_p (label)) | |
5048 | break; | |
5049 | label = PREV_INSN (label); | |
5050 | } | |
5051 | ||
4b4bf941 | 5052 | if (BB_HEAD (last) == label && LABEL_P (label)) |
69732dcb | 5053 | { |
628f6a4e | 5054 | edge_iterator ei2; |
86c82654 | 5055 | |
628f6a4e | 5056 | for (ei2 = ei_start (last->preds); (e = ei_safe_edge (ei2)); ) |
69732dcb RH |
5057 | { |
5058 | basic_block bb = e->src; | |
5059 | rtx jump; | |
5060 | ||
69732dcb | 5061 | if (bb == ENTRY_BLOCK_PTR) |
628f6a4e BE |
5062 | { |
5063 | ei_next (&ei2); | |
5064 | continue; | |
5065 | } | |
69732dcb | 5066 | |
a813c111 | 5067 | jump = BB_END (bb); |
4b4bf941 | 5068 | if (!JUMP_P (jump) || JUMP_LABEL (jump) != label) |
628f6a4e BE |
5069 | { |
5070 | ei_next (&ei2); | |
5071 | continue; | |
5072 | } | |
69732dcb RH |
5073 | |
5074 | /* If we have an unconditional jump, we can replace that | |
5075 | with a simple return instruction. */ | |
5076 | if (simplejump_p (jump)) | |
5077 | { | |
6039a0c7 | 5078 | emit_return_into_block (bb); |
53c17031 | 5079 | delete_insn (jump); |
69732dcb RH |
5080 | } |
5081 | ||
5082 | /* If we have a conditional jump, we can try to replace | |
5083 | that with a conditional return instruction. */ | |
5084 | else if (condjump_p (jump)) | |
5085 | { | |
47009d11 | 5086 | if (! redirect_jump (jump, 0, 0)) |
628f6a4e BE |
5087 | { |
5088 | ei_next (&ei2); | |
5089 | continue; | |
5090 | } | |
718fe406 | 5091 | |
3a75e42e CP |
5092 | /* If this block has only one successor, it both jumps |
5093 | and falls through to the fallthru block, so we can't | |
5094 | delete the edge. */ | |
c5cbcccf | 5095 | if (single_succ_p (bb)) |
628f6a4e BE |
5096 | { |
5097 | ei_next (&ei2); | |
5098 | continue; | |
5099 | } | |
69732dcb RH |
5100 | } |
5101 | else | |
628f6a4e BE |
5102 | { |
5103 | ei_next (&ei2); | |
5104 | continue; | |
5105 | } | |
69732dcb RH |
5106 | |
5107 | /* Fix up the CFG for the successful change we just made. */ | |
86c82654 | 5108 | redirect_edge_succ (e, EXIT_BLOCK_PTR); |
69732dcb | 5109 | } |
69732dcb | 5110 | |
2dd8bc01 GK |
5111 | /* Emit a return insn for the exit fallthru block. Whether |
5112 | this is still reachable will be determined later. */ | |
69732dcb | 5113 | |
a813c111 | 5114 | emit_barrier_after (BB_END (last)); |
6039a0c7 | 5115 | emit_return_into_block (last); |
a813c111 | 5116 | epilogue_end = BB_END (last); |
c5cbcccf | 5117 | single_succ_edge (last)->flags &= ~EDGE_FALLTHRU; |
718fe406 | 5118 | goto epilogue_done; |
2dd8bc01 | 5119 | } |
69732dcb RH |
5120 | } |
5121 | #endif | |
cd9c1ca8 RH |
5122 | |
5123 | /* A small fib -- epilogue is not yet completed, but we wish to re-use | |
5124 | this marker for the splits of EH_RETURN patterns, and nothing else | |
5125 | uses the flag in the meantime. */ | |
5126 | epilogue_completed = 1; | |
5127 | ||
5128 | #ifdef HAVE_eh_return | |
5129 | /* Find non-fallthru edges that end with EH_RETURN instructions. On | |
5130 | some targets, these get split to a special version of the epilogue | |
5131 | code. In order to be able to properly annotate these with unwind | |
5132 | info, try to split them now. If we get a valid split, drop an | |
5133 | EPILOGUE_BEG note and mark the insns as epilogue insns. */ | |
5134 | FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) | |
5135 | { | |
5136 | rtx prev, last, trial; | |
5137 | ||
5138 | if (e->flags & EDGE_FALLTHRU) | |
5139 | continue; | |
5140 | last = BB_END (e->src); | |
5141 | if (!eh_returnjump_p (last)) | |
5142 | continue; | |
5143 | ||
5144 | prev = PREV_INSN (last); | |
5145 | trial = try_split (PATTERN (last), last, 1); | |
5146 | if (trial == last) | |
5147 | continue; | |
5148 | ||
5149 | record_insns (NEXT_INSN (prev), NEXT_INSN (trial), &epilogue_insn_hash); | |
5150 | emit_note_after (NOTE_INSN_EPILOGUE_BEG, prev); | |
5151 | } | |
5152 | #endif | |
5153 | ||
623a66fa R |
5154 | /* Find the edge that falls through to EXIT. Other edges may exist |
5155 | due to RETURN instructions, but those don't need epilogues. | |
5156 | There really shouldn't be a mixture -- either all should have | |
5157 | been converted or none, however... */ | |
5158 | ||
628f6a4e | 5159 | FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) |
623a66fa R |
5160 | if (e->flags & EDGE_FALLTHRU) |
5161 | break; | |
5162 | if (e == NULL) | |
5163 | goto epilogue_done; | |
5164 | ||
bdac5f58 TW |
5165 | #ifdef HAVE_epilogue |
5166 | if (HAVE_epilogue) | |
5167 | { | |
19d3c25c | 5168 | start_sequence (); |
2e040219 | 5169 | epilogue_end = emit_note (NOTE_INSN_EPILOGUE_BEG); |
19d3c25c RH |
5170 | seq = gen_epilogue (); |
5171 | emit_jump_insn (seq); | |
bdac5f58 | 5172 | |
19d3c25c | 5173 | /* Retain a map of the epilogue insns. */ |
cd9c1ca8 | 5174 | record_insns (seq, NULL, &epilogue_insn_hash); |
0435312e | 5175 | set_insn_locators (seq, epilogue_locator); |
bdac5f58 | 5176 | |
2f937369 | 5177 | seq = get_insns (); |
718fe406 | 5178 | end_sequence (); |
e881bb1b | 5179 | |
19d3c25c | 5180 | insert_insn_on_edge (seq, e); |
ca1117cc | 5181 | inserted = 1; |
bdac5f58 | 5182 | } |
623a66fa | 5183 | else |
bdac5f58 | 5184 | #endif |
623a66fa R |
5185 | { |
5186 | basic_block cur_bb; | |
5187 | ||
5188 | if (! next_active_insn (BB_END (e->src))) | |
5189 | goto epilogue_done; | |
5190 | /* We have a fall-through edge to the exit block, the source is not | |
5191 | at the end of the function, and there will be an assembler epilogue | |
5192 | at the end of the function. | |
5193 | We can't use force_nonfallthru here, because that would try to | |
5194 | use return. Inserting a jump 'by hand' is extremely messy, so | |
5195 | we take advantage of cfg_layout_finalize using | |
5196 | fixup_fallthru_exit_predecessor. */ | |
35b6b437 | 5197 | cfg_layout_initialize (0); |
623a66fa | 5198 | FOR_EACH_BB (cur_bb) |
24bd1a0b DB |
5199 | if (cur_bb->index >= NUM_FIXED_BLOCKS |
5200 | && cur_bb->next_bb->index >= NUM_FIXED_BLOCKS) | |
370369e1 | 5201 | cur_bb->aux = cur_bb->next_bb; |
623a66fa R |
5202 | cfg_layout_finalize (); |
5203 | } | |
19d3c25c | 5204 | epilogue_done: |
a8ba47cb | 5205 | default_rtl_profile (); |
e881bb1b | 5206 | |
ca1117cc | 5207 | if (inserted) |
30a873c3 ZD |
5208 | { |
5209 | commit_edge_insertions (); | |
5210 | ||
5211 | /* The epilogue insns we inserted may cause the exit edge to no longer | |
5212 | be fallthru. */ | |
5213 | FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) | |
5214 | { | |
5215 | if (((e->flags & EDGE_FALLTHRU) != 0) | |
5216 | && returnjump_p (BB_END (e->src))) | |
5217 | e->flags &= ~EDGE_FALLTHRU; | |
5218 | } | |
5219 | } | |
0a1c58a2 JL |
5220 | |
5221 | #ifdef HAVE_sibcall_epilogue | |
5222 | /* Emit sibling epilogues before any sibling call sites. */ | |
628f6a4e | 5223 | for (ei = ei_start (EXIT_BLOCK_PTR->preds); (e = ei_safe_edge (ei)); ) |
0a1c58a2 JL |
5224 | { |
5225 | basic_block bb = e->src; | |
a813c111 | 5226 | rtx insn = BB_END (bb); |
0a1c58a2 | 5227 | |
4b4bf941 | 5228 | if (!CALL_P (insn) |
0a1c58a2 | 5229 | || ! SIBLING_CALL_P (insn)) |
628f6a4e BE |
5230 | { |
5231 | ei_next (&ei); | |
5232 | continue; | |
5233 | } | |
0a1c58a2 JL |
5234 | |
5235 | start_sequence (); | |
cd9c1ca8 | 5236 | emit_note (NOTE_INSN_EPILOGUE_BEG); |
0af5c896 RE |
5237 | emit_insn (gen_sibcall_epilogue ()); |
5238 | seq = get_insns (); | |
0a1c58a2 JL |
5239 | end_sequence (); |
5240 | ||
2f937369 DM |
5241 | /* Retain a map of the epilogue insns. Used in life analysis to |
5242 | avoid getting rid of sibcall epilogue insns. Do this before we | |
5243 | actually emit the sequence. */ | |
cd9c1ca8 | 5244 | record_insns (seq, NULL, &epilogue_insn_hash); |
0435312e | 5245 | set_insn_locators (seq, epilogue_locator); |
2f937369 | 5246 | |
5e35992a | 5247 | emit_insn_before (seq, insn); |
628f6a4e | 5248 | ei_next (&ei); |
0a1c58a2 JL |
5249 | } |
5250 | #endif | |
ca1117cc | 5251 | |
86c82654 RH |
5252 | #ifdef HAVE_epilogue |
5253 | if (epilogue_end) | |
5254 | { | |
5255 | rtx insn, next; | |
5256 | ||
5257 | /* Similarly, move any line notes that appear after the epilogue. | |
ff7cc307 | 5258 | There is no need, however, to be quite so anal about the existence |
071a42f9 | 5259 | of such a note. Also possibly move |
84c1fa24 UW |
5260 | NOTE_INSN_FUNCTION_BEG notes, as those can be relevant for debug |
5261 | info generation. */ | |
718fe406 | 5262 | for (insn = epilogue_end; insn; insn = next) |
86c82654 RH |
5263 | { |
5264 | next = NEXT_INSN (insn); | |
4b4bf941 | 5265 | if (NOTE_P (insn) |
a38e7aa5 | 5266 | && (NOTE_KIND (insn) == NOTE_INSN_FUNCTION_BEG)) |
86c82654 RH |
5267 | reorder_insns (insn, insn, PREV_INSN (epilogue_end)); |
5268 | } | |
5269 | } | |
5270 | #endif | |
6fb5fa3c DB |
5271 | |
5272 | /* Threading the prologue and epilogue changes the artificial refs | |
5273 | in the entry and exit blocks. */ | |
5274 | epilogue_completed = 1; | |
5275 | df_update_entry_exit_and_calls (); | |
bdac5f58 TW |
5276 | } |
5277 | ||
cd9c1ca8 RH |
5278 | /* Reposition the prologue-end and epilogue-begin notes after |
5279 | instruction scheduling. */ | |
bdac5f58 TW |
5280 | |
5281 | void | |
6fb5fa3c | 5282 | reposition_prologue_and_epilogue_notes (void) |
bdac5f58 | 5283 | { |
cd9c1ca8 RH |
5284 | #if defined (HAVE_prologue) || defined (HAVE_epilogue) \ |
5285 | || defined (HAVE_sibcall_epilogue) | |
9f53e965 | 5286 | rtx insn, last, note; |
cd9c1ca8 | 5287 | basic_block bb; |
0a1c58a2 | 5288 | |
cd9c1ca8 RH |
5289 | /* Since the hash table is created on demand, the fact that it is |
5290 | non-null is a signal that it is non-empty. */ | |
5291 | if (prologue_insn_hash != NULL) | |
bdac5f58 | 5292 | { |
cd9c1ca8 | 5293 | size_t len = htab_elements (prologue_insn_hash); |
9f53e965 | 5294 | last = 0, note = 0; |
bdac5f58 | 5295 | |
cd9c1ca8 RH |
5296 | /* Scan from the beginning until we reach the last prologue insn. */ |
5297 | /* ??? While we do have the CFG intact, there are two problems: | |
5298 | (1) The prologue can contain loops (typically probing the stack), | |
5299 | which means that the end of the prologue isn't in the first bb. | |
5300 | (2) Sometimes the PROLOGUE_END note gets pushed into the next bb. */ | |
6fb5fa3c | 5301 | for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) |
bdac5f58 | 5302 | { |
4b4bf941 | 5303 | if (NOTE_P (insn)) |
9392c110 | 5304 | { |
a38e7aa5 | 5305 | if (NOTE_KIND (insn) == NOTE_INSN_PROLOGUE_END) |
0a1c58a2 JL |
5306 | note = insn; |
5307 | } | |
cd9c1ca8 | 5308 | else if (contains (insn, prologue_insn_hash)) |
0a1c58a2 | 5309 | { |
9f53e965 RH |
5310 | last = insn; |
5311 | if (--len == 0) | |
5312 | break; | |
5313 | } | |
5314 | } | |
797a6ac1 | 5315 | |
9f53e965 RH |
5316 | if (last) |
5317 | { | |
cd9c1ca8 | 5318 | if (note == NULL) |
9f53e965 | 5319 | { |
cd9c1ca8 RH |
5320 | /* Scan forward looking for the PROLOGUE_END note. It should |
5321 | be right at the beginning of the block, possibly with other | |
5322 | insn notes that got moved there. */ | |
5323 | for (note = NEXT_INSN (last); ; note = NEXT_INSN (note)) | |
5324 | { | |
5325 | if (NOTE_P (note) | |
5326 | && NOTE_KIND (note) == NOTE_INSN_PROLOGUE_END) | |
5327 | break; | |
5328 | } | |
9f53e965 | 5329 | } |
c93b03c2 | 5330 | |
9f53e965 | 5331 | /* Avoid placing note between CODE_LABEL and BASIC_BLOCK note. */ |
4b4bf941 | 5332 | if (LABEL_P (last)) |
9f53e965 RH |
5333 | last = NEXT_INSN (last); |
5334 | reorder_insns (note, note, last); | |
bdac5f58 | 5335 | } |
0a1c58a2 JL |
5336 | } |
5337 | ||
cd9c1ca8 | 5338 | if (epilogue_insn_hash != NULL) |
0a1c58a2 | 5339 | { |
cd9c1ca8 RH |
5340 | edge_iterator ei; |
5341 | edge e; | |
bdac5f58 | 5342 | |
cd9c1ca8 | 5343 | FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) |
bdac5f58 | 5344 | { |
cd9c1ca8 RH |
5345 | last = 0, note = 0; |
5346 | bb = e->src; | |
c93b03c2 | 5347 | |
cd9c1ca8 RH |
5348 | /* Scan from the beginning until we reach the first epilogue insn. |
5349 | Take the cue for whether this is a plain or sibcall epilogue | |
5350 | from the kind of note we find first. */ | |
5351 | FOR_BB_INSNS (bb, insn) | |
9f53e965 | 5352 | { |
cd9c1ca8 RH |
5353 | if (NOTE_P (insn)) |
5354 | { | |
5355 | if (NOTE_KIND (insn) == NOTE_INSN_EPILOGUE_BEG) | |
5356 | { | |
5357 | note = insn; | |
5358 | if (last) | |
5359 | break; | |
5360 | } | |
5361 | } | |
5362 | else if (contains (insn, epilogue_insn_hash)) | |
5363 | { | |
5364 | last = insn; | |
5365 | if (note != NULL) | |
5366 | break; | |
5367 | } | |
9392c110 | 5368 | } |
cd9c1ca8 RH |
5369 | |
5370 | if (last && note && PREV_INSN (last) != note) | |
9f53e965 | 5371 | reorder_insns (note, note, PREV_INSN (last)); |
bdac5f58 TW |
5372 | } |
5373 | } | |
5374 | #endif /* HAVE_prologue or HAVE_epilogue */ | |
5375 | } | |
87ff9c8e | 5376 | |
faed5cc3 SB |
5377 | /* Returns the name of the current function. */ |
5378 | const char * | |
5379 | current_function_name (void) | |
5380 | { | |
ae2bcd98 | 5381 | return lang_hooks.decl_printable_name (cfun->decl, 2); |
faed5cc3 | 5382 | } |
ef330312 PB |
5383 | \f |
5384 | ||
c2924966 | 5385 | static unsigned int |
ef330312 PB |
5386 | rest_of_handle_check_leaf_regs (void) |
5387 | { | |
5388 | #ifdef LEAF_REGISTERS | |
5389 | current_function_uses_only_leaf_regs | |
5390 | = optimize > 0 && only_leaf_regs_used () && leaf_function_p (); | |
5391 | #endif | |
c2924966 | 5392 | return 0; |
ef330312 PB |
5393 | } |
5394 | ||
8d8d1a28 AH |
5395 | /* Insert a TYPE into the used types hash table of CFUN. */ |
5396 | static void | |
5397 | used_types_insert_helper (tree type, struct function *func) | |
33c9159e | 5398 | { |
8d8d1a28 | 5399 | if (type != NULL && func != NULL) |
33c9159e AH |
5400 | { |
5401 | void **slot; | |
5402 | ||
5403 | if (func->used_types_hash == NULL) | |
5404 | func->used_types_hash = htab_create_ggc (37, htab_hash_pointer, | |
8d8d1a28 AH |
5405 | htab_eq_pointer, NULL); |
5406 | slot = htab_find_slot (func->used_types_hash, type, INSERT); | |
33c9159e | 5407 | if (*slot == NULL) |
8d8d1a28 | 5408 | *slot = type; |
33c9159e AH |
5409 | } |
5410 | } | |
5411 | ||
8d8d1a28 AH |
5412 | /* Given a type, insert it into the used hash table in cfun. */ |
5413 | void | |
5414 | used_types_insert (tree t) | |
5415 | { | |
5416 | while (POINTER_TYPE_P (t) || TREE_CODE (t) == ARRAY_TYPE) | |
5417 | t = TREE_TYPE (t); | |
5418 | t = TYPE_MAIN_VARIANT (t); | |
5419 | if (debug_info_level > DINFO_LEVEL_NONE) | |
5420 | used_types_insert_helper (t, cfun); | |
5421 | } | |
5422 | ||
8ddbbcae | 5423 | struct rtl_opt_pass pass_leaf_regs = |
ef330312 | 5424 | { |
8ddbbcae JH |
5425 | { |
5426 | RTL_PASS, | |
ef330312 PB |
5427 | NULL, /* name */ |
5428 | NULL, /* gate */ | |
5429 | rest_of_handle_check_leaf_regs, /* execute */ | |
5430 | NULL, /* sub */ | |
5431 | NULL, /* next */ | |
5432 | 0, /* static_pass_number */ | |
7072a650 | 5433 | TV_NONE, /* tv_id */ |
ef330312 PB |
5434 | 0, /* properties_required */ |
5435 | 0, /* properties_provided */ | |
5436 | 0, /* properties_destroyed */ | |
5437 | 0, /* todo_flags_start */ | |
8ddbbcae JH |
5438 | 0 /* todo_flags_finish */ |
5439 | } | |
ef330312 PB |
5440 | }; |
5441 | ||
6fb5fa3c DB |
5442 | static unsigned int |
5443 | rest_of_handle_thread_prologue_and_epilogue (void) | |
5444 | { | |
5445 | if (optimize) | |
5446 | cleanup_cfg (CLEANUP_EXPENSIVE); | |
5447 | /* On some machines, the prologue and epilogue code, or parts thereof, | |
5448 | can be represented as RTL. Doing so lets us schedule insns between | |
5449 | it and the rest of the code and also allows delayed branch | |
5450 | scheduling to operate in the epilogue. */ | |
5451 | ||
5452 | thread_prologue_and_epilogue_insns (); | |
5453 | return 0; | |
5454 | } | |
5455 | ||
8ddbbcae | 5456 | struct rtl_opt_pass pass_thread_prologue_and_epilogue = |
6fb5fa3c | 5457 | { |
8ddbbcae JH |
5458 | { |
5459 | RTL_PASS, | |
6fb5fa3c DB |
5460 | "pro_and_epilogue", /* name */ |
5461 | NULL, /* gate */ | |
5462 | rest_of_handle_thread_prologue_and_epilogue, /* execute */ | |
5463 | NULL, /* sub */ | |
5464 | NULL, /* next */ | |
5465 | 0, /* static_pass_number */ | |
5466 | TV_THREAD_PROLOGUE_AND_EPILOGUE, /* tv_id */ | |
5467 | 0, /* properties_required */ | |
5468 | 0, /* properties_provided */ | |
5469 | 0, /* properties_destroyed */ | |
5470 | TODO_verify_flow, /* todo_flags_start */ | |
5471 | TODO_dump_func | | |
0d475361 | 5472 | TODO_df_verify | |
a36b8a1e | 5473 | TODO_df_finish | TODO_verify_rtl_sharing | |
8ddbbcae JH |
5474 | TODO_ggc_collect /* todo_flags_finish */ |
5475 | } | |
6fb5fa3c | 5476 | }; |
d8d72314 PB |
5477 | \f |
5478 | ||
5479 | /* This mini-pass fixes fall-out from SSA in asm statements that have | |
5480 | in-out constraints. Say you start with | |
5481 | ||
5482 | orig = inout; | |
5483 | asm ("": "+mr" (inout)); | |
5484 | use (orig); | |
5485 | ||
5486 | which is transformed very early to use explicit output and match operands: | |
5487 | ||
5488 | orig = inout; | |
5489 | asm ("": "=mr" (inout) : "0" (inout)); | |
5490 | use (orig); | |
5491 | ||
5492 | Or, after SSA and copyprop, | |
5493 | ||
5494 | asm ("": "=mr" (inout_2) : "0" (inout_1)); | |
5495 | use (inout_1); | |
5496 | ||
5497 | Clearly inout_2 and inout_1 can't be coalesced easily anymore, as | |
5498 | they represent two separate values, so they will get different pseudo | |
5499 | registers during expansion. Then, since the two operands need to match | |
5500 | per the constraints, but use different pseudo registers, reload can | |
5501 | only register a reload for these operands. But reloads can only be | |
5502 | satisfied by hardregs, not by memory, so we need a register for this | |
5503 | reload, just because we are presented with non-matching operands. | |
5504 | So, even though we allow memory for this operand, no memory can be | |
5505 | used for it, just because the two operands don't match. This can | |
5506 | cause reload failures on register-starved targets. | |
5507 | ||
5508 | So it's a symptom of reload not being able to use memory for reloads | |
5509 | or, alternatively it's also a symptom of both operands not coming into | |
5510 | reload as matching (in which case the pseudo could go to memory just | |
5511 | fine, as the alternative allows it, and no reload would be necessary). | |
5512 | We fix the latter problem here, by transforming | |
5513 | ||
5514 | asm ("": "=mr" (inout_2) : "0" (inout_1)); | |
5515 | ||
5516 | back to | |
5517 | ||
5518 | inout_2 = inout_1; | |
5519 | asm ("": "=mr" (inout_2) : "0" (inout_2)); */ | |
5520 | ||
5521 | static void | |
5522 | match_asm_constraints_1 (rtx insn, rtx *p_sets, int noutputs) | |
5523 | { | |
5524 | int i; | |
5525 | bool changed = false; | |
5526 | rtx op = SET_SRC (p_sets[0]); | |
5527 | int ninputs = ASM_OPERANDS_INPUT_LENGTH (op); | |
5528 | rtvec inputs = ASM_OPERANDS_INPUT_VEC (op); | |
1b4572a8 | 5529 | bool *output_matched = XALLOCAVEC (bool, noutputs); |
d8d72314 | 5530 | |
d7b8033f | 5531 | memset (output_matched, 0, noutputs * sizeof (bool)); |
d8d72314 PB |
5532 | for (i = 0; i < ninputs; i++) |
5533 | { | |
5534 | rtx input, output, insns; | |
5535 | const char *constraint = ASM_OPERANDS_INPUT_CONSTRAINT (op, i); | |
5536 | char *end; | |
53220215 | 5537 | int match, j; |
d8d72314 | 5538 | |
70f16287 JJ |
5539 | if (*constraint == '%') |
5540 | constraint++; | |
5541 | ||
d8d72314 PB |
5542 | match = strtoul (constraint, &end, 10); |
5543 | if (end == constraint) | |
5544 | continue; | |
5545 | ||
5546 | gcc_assert (match < noutputs); | |
5547 | output = SET_DEST (p_sets[match]); | |
5548 | input = RTVEC_ELT (inputs, i); | |
53220215 MM |
5549 | /* Only do the transformation for pseudos. */ |
5550 | if (! REG_P (output) | |
5551 | || rtx_equal_p (output, input) | |
d8d72314 PB |
5552 | || (GET_MODE (input) != VOIDmode |
5553 | && GET_MODE (input) != GET_MODE (output))) | |
5554 | continue; | |
5555 | ||
53220215 MM |
5556 | /* We can't do anything if the output is also used as input, |
5557 | as we're going to overwrite it. */ | |
5558 | for (j = 0; j < ninputs; j++) | |
5559 | if (reg_overlap_mentioned_p (output, RTVEC_ELT (inputs, j))) | |
5560 | break; | |
5561 | if (j != ninputs) | |
5562 | continue; | |
5563 | ||
d7b8033f JJ |
5564 | /* Avoid changing the same input several times. For |
5565 | asm ("" : "=mr" (out1), "=mr" (out2) : "0" (in), "1" (in)); | |
5566 | only change in once (to out1), rather than changing it | |
5567 | first to out1 and afterwards to out2. */ | |
5568 | if (i > 0) | |
5569 | { | |
5570 | for (j = 0; j < noutputs; j++) | |
5571 | if (output_matched[j] && input == SET_DEST (p_sets[j])) | |
5572 | break; | |
5573 | if (j != noutputs) | |
5574 | continue; | |
5575 | } | |
5576 | output_matched[match] = true; | |
5577 | ||
d8d72314 | 5578 | start_sequence (); |
53220215 | 5579 | emit_move_insn (output, input); |
d8d72314 PB |
5580 | insns = get_insns (); |
5581 | end_sequence (); | |
d8d72314 | 5582 | emit_insn_before (insns, insn); |
53220215 MM |
5583 | |
5584 | /* Now replace all mentions of the input with output. We can't | |
fa10beec | 5585 | just replace the occurrence in inputs[i], as the register might |
53220215 MM |
5586 | also be used in some other input (or even in an address of an |
5587 | output), which would mean possibly increasing the number of | |
5588 | inputs by one (namely 'output' in addition), which might pose | |
5589 | a too complicated problem for reload to solve. E.g. this situation: | |
5590 | ||
5591 | asm ("" : "=r" (output), "=m" (input) : "0" (input)) | |
5592 | ||
84fbffb2 | 5593 | Here 'input' is used in two occurrences as input (once for the |
53220215 | 5594 | input operand, once for the address in the second output operand). |
fa10beec | 5595 | If we would replace only the occurrence of the input operand (to |
53220215 MM |
5596 | make the matching) we would be left with this: |
5597 | ||
5598 | output = input | |
5599 | asm ("" : "=r" (output), "=m" (input) : "0" (output)) | |
5600 | ||
5601 | Now we suddenly have two different input values (containing the same | |
5602 | value, but different pseudos) where we formerly had only one. | |
5603 | With more complicated asms this might lead to reload failures | |
5604 | which wouldn't have happen without this pass. So, iterate over | |
84fbffb2 | 5605 | all operands and replace all occurrences of the register used. */ |
53220215 | 5606 | for (j = 0; j < noutputs; j++) |
1596d61e | 5607 | if (!rtx_equal_p (SET_DEST (p_sets[j]), input) |
53220215 MM |
5608 | && reg_overlap_mentioned_p (input, SET_DEST (p_sets[j]))) |
5609 | SET_DEST (p_sets[j]) = replace_rtx (SET_DEST (p_sets[j]), | |
5610 | input, output); | |
5611 | for (j = 0; j < ninputs; j++) | |
5612 | if (reg_overlap_mentioned_p (input, RTVEC_ELT (inputs, j))) | |
5613 | RTVEC_ELT (inputs, j) = replace_rtx (RTVEC_ELT (inputs, j), | |
5614 | input, output); | |
5615 | ||
d8d72314 PB |
5616 | changed = true; |
5617 | } | |
5618 | ||
5619 | if (changed) | |
5620 | df_insn_rescan (insn); | |
5621 | } | |
5622 | ||
5623 | static unsigned | |
5624 | rest_of_match_asm_constraints (void) | |
5625 | { | |
5626 | basic_block bb; | |
5627 | rtx insn, pat, *p_sets; | |
5628 | int noutputs; | |
5629 | ||
e3b5732b | 5630 | if (!crtl->has_asm_statement) |
d8d72314 PB |
5631 | return 0; |
5632 | ||
5633 | df_set_flags (DF_DEFER_INSN_RESCAN); | |
5634 | FOR_EACH_BB (bb) | |
5635 | { | |
5636 | FOR_BB_INSNS (bb, insn) | |
5637 | { | |
5638 | if (!INSN_P (insn)) | |
5639 | continue; | |
5640 | ||
5641 | pat = PATTERN (insn); | |
5642 | if (GET_CODE (pat) == PARALLEL) | |
5643 | p_sets = &XVECEXP (pat, 0, 0), noutputs = XVECLEN (pat, 0); | |
5644 | else if (GET_CODE (pat) == SET) | |
5645 | p_sets = &PATTERN (insn), noutputs = 1; | |
5646 | else | |
5647 | continue; | |
5648 | ||
5649 | if (GET_CODE (*p_sets) == SET | |
5650 | && GET_CODE (SET_SRC (*p_sets)) == ASM_OPERANDS) | |
5651 | match_asm_constraints_1 (insn, p_sets, noutputs); | |
5652 | } | |
5653 | } | |
5654 | ||
5655 | return TODO_df_finish; | |
5656 | } | |
5657 | ||
8ddbbcae | 5658 | struct rtl_opt_pass pass_match_asm_constraints = |
d8d72314 | 5659 | { |
8ddbbcae JH |
5660 | { |
5661 | RTL_PASS, | |
d8d72314 PB |
5662 | "asmcons", /* name */ |
5663 | NULL, /* gate */ | |
5664 | rest_of_match_asm_constraints, /* execute */ | |
5665 | NULL, /* sub */ | |
5666 | NULL, /* next */ | |
5667 | 0, /* static_pass_number */ | |
7072a650 | 5668 | TV_NONE, /* tv_id */ |
d8d72314 PB |
5669 | 0, /* properties_required */ |
5670 | 0, /* properties_provided */ | |
5671 | 0, /* properties_destroyed */ | |
5672 | 0, /* todo_flags_start */ | |
8ddbbcae JH |
5673 | TODO_dump_func /* todo_flags_finish */ |
5674 | } | |
d8d72314 | 5675 | }; |
6fb5fa3c | 5676 | |
faed5cc3 | 5677 | |
e2500fed | 5678 | #include "gt-function.h" |