]>
Commit | Line | Data |
---|---|---|
bccafa26 | 1 | /* Expands front end tree to back end RTL for GCC. |
9daf6266 | 2 | Copyright (C) 1987, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, |
bd564c29 | 3 | 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, |
2e851bb8 | 4 | 2010, 2011, 2012 Free Software Foundation, Inc. |
897b77d6 | 5 | |
f12b58b3 | 6 | This file is part of GCC. |
897b77d6 | 7 | |
f12b58b3 | 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 | |
8c4c00c1 | 10 | Software Foundation; either version 3, or (at your option) any later |
f12b58b3 | 11 | version. |
897b77d6 | 12 | |
f12b58b3 | 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. | |
897b77d6 | 17 | |
18 | You should have received a copy of the GNU General Public License | |
8c4c00c1 | 19 | along with GCC; see the file COPYING3. If not see |
20 | <http://www.gnu.org/licenses/>. */ | |
897b77d6 | 21 | |
897b77d6 | 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 | |
e8825bb0 | 34 | not get a hard register. */ |
897b77d6 | 35 | |
36 | #include "config.h" | |
405711de | 37 | #include "system.h" |
805e22b2 | 38 | #include "coretypes.h" |
39 | #include "tm.h" | |
d7091a76 | 40 | #include "rtl-error.h" |
897b77d6 | 41 | #include "tree.h" |
42 | #include "flags.h" | |
dcabb90e | 43 | #include "except.h" |
897b77d6 | 44 | #include "function.h" |
897b77d6 | 45 | #include "expr.h" |
530178a9 | 46 | #include "optabs.h" |
d8fc4d0b | 47 | #include "libfuncs.h" |
897b77d6 | 48 | #include "regs.h" |
49 | #include "hard-reg-set.h" | |
50 | #include "insn-config.h" | |
51 | #include "recog.h" | |
52 | #include "output.h" | |
b2c5602e | 53 | #include "basic-block.h" |
1f3233d1 | 54 | #include "hashtab.h" |
a7b0c170 | 55 | #include "ggc.h" |
075136a2 | 56 | #include "tm_p.h" |
96554925 | 57 | #include "langhooks.h" |
45550790 | 58 | #include "target.h" |
218e3e4e | 59 | #include "common/common-target.h" |
75a70cf9 | 60 | #include "gimple.h" |
77fce4cd | 61 | #include "tree-pass.h" |
f1a0edff | 62 | #include "predict.h" |
3072d30e | 63 | #include "df.h" |
05f3df98 | 64 | #include "vecprim.h" |
0a55d497 | 65 | #include "params.h" |
66 | #include "bb-reorder.h" | |
f1a0edff | 67 | |
c8a152f6 | 68 | /* So we can assign to cfun in this file. */ |
69 | #undef cfun | |
70 | ||
256f9b65 | 71 | #ifndef STACK_ALIGNMENT_NEEDED |
72 | #define STACK_ALIGNMENT_NEEDED 1 | |
73 | #endif | |
74 | ||
1cd50c9a | 75 | #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT) |
76 | ||
90ed9d61 | 77 | /* Some systems use __main in a way incompatible with its use in gcc, in these |
78 | cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to | |
79 | give the same symbol without quotes for an alternative entry point. You | |
a92771b8 | 80 | must define both, or neither. */ |
90ed9d61 | 81 | #ifndef NAME__MAIN |
82 | #define NAME__MAIN "__main" | |
90ed9d61 | 83 | #endif |
84 | ||
897b77d6 | 85 | /* Round a value to the lowest integer less than it that is a multiple of |
86 | the required alignment. Avoid using division in case the value is | |
87 | negative. Assume the alignment is a power of two. */ | |
88 | #define FLOOR_ROUND(VALUE,ALIGN) ((VALUE) & ~((ALIGN) - 1)) | |
89 | ||
90 | /* Similar, but round to the next highest integer that meets the | |
91 | alignment. */ | |
92 | #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1)) | |
93 | ||
897b77d6 | 94 | /* Nonzero once virtual register instantiation has been done. |
9c0a756f | 95 | assign_stack_local uses frame_pointer_rtx when this is nonzero. |
96 | calls.c:emit_library_call_value_1 uses it to set up | |
97 | post-instantiation libcalls. */ | |
98 | int virtuals_instantiated; | |
897b77d6 | 99 | |
4781f9b9 | 100 | /* Assign unique numbers to labels generated for profiling, debugging, etc. */ |
573aba85 | 101 | static GTY(()) int funcdef_no; |
b8a21949 | 102 | |
ab5beff9 | 103 | /* These variables hold pointers to functions to create and destroy |
104 | target specific, per-function data structures. */ | |
de1b648b | 105 | struct machine_function * (*init_machine_status) (void); |
adc2961c | 106 | |
304c5bf1 | 107 | /* The currently compiled function. */ |
08513b52 | 108 | struct function *cfun = 0; |
304c5bf1 | 109 | |
25e880b1 | 110 | /* These hashes record the prologue and epilogue insns. */ |
111 | static GTY((if_marked ("ggc_marked_p"), param_is (struct rtx_def))) | |
112 | htab_t prologue_insn_hash; | |
113 | static GTY((if_marked ("ggc_marked_p"), param_is (struct rtx_def))) | |
114 | htab_t epilogue_insn_hash; | |
897b77d6 | 115 | \f |
1a4c44c5 | 116 | |
117 | htab_t types_used_by_vars_hash = NULL; | |
aef48c9a | 118 | VEC(tree,gc) *types_used_by_cur_var_decl; |
1a4c44c5 | 119 | |
209a68cc | 120 | /* Forward declarations. */ |
121 | ||
de1b648b | 122 | static struct temp_slot *find_temp_slot_from_address (rtx); |
de1b648b | 123 | static void pad_to_arg_alignment (struct args_size *, int, struct args_size *); |
124 | static void pad_below (struct args_size *, enum machine_mode, tree); | |
573a97ad | 125 | static void reorder_blocks_1 (rtx, tree, VEC(tree,heap) **); |
de1b648b | 126 | static int all_blocks (tree, tree *); |
127 | static tree *get_block_vector (tree, int *); | |
128 | extern tree debug_find_var_in_block_tree (tree, tree); | |
4885b286 | 129 | /* We always define `record_insns' even if it's not used so that we |
2dc40d2d | 130 | can always export `prologue_epilogue_contains'. */ |
25e880b1 | 131 | static void record_insns (rtx, rtx, htab_t *) ATTRIBUTE_UNUSED; |
132 | static bool contains (const_rtx, htab_t); | |
87d4aa85 | 133 | static void prepare_function_start (void); |
de1b648b | 134 | static void do_clobber_return_reg (rtx, void *); |
135 | static void do_use_return_reg (rtx, void *); | |
76a2507e | 136 | static void set_insn_locators (rtx, int) ATTRIBUTE_UNUSED; |
8e4c05da | 137 | \f |
5737913a | 138 | /* Stack of nested functions. */ |
139 | /* Keep track of the cfun stack. */ | |
997d68fe | 140 | |
5737913a | 141 | typedef struct function *function_p; |
997d68fe | 142 | |
5737913a | 143 | DEF_VEC_P(function_p); |
144 | DEF_VEC_ALLOC_P(function_p,heap); | |
145 | static VEC(function_p,heap) *function_context_stack; | |
897b77d6 | 146 | |
147 | /* Save the current context for compilation of a nested function. | |
d2764e2d | 148 | This is called from language-specific code. */ |
897b77d6 | 149 | |
150 | void | |
d2764e2d | 151 | push_function_context (void) |
897b77d6 | 152 | { |
08513b52 | 153 | if (cfun == 0) |
80f2ef47 | 154 | allocate_struct_function (NULL, false); |
304c5bf1 | 155 | |
5737913a | 156 | VEC_safe_push (function_p, heap, function_context_stack, cfun); |
87d4aa85 | 157 | set_cfun (NULL); |
897b77d6 | 158 | } |
159 | ||
160 | /* Restore the last saved context, at the end of a nested function. | |
161 | This function is called from language-specific code. */ | |
162 | ||
163 | void | |
d2764e2d | 164 | pop_function_context (void) |
897b77d6 | 165 | { |
5737913a | 166 | struct function *p = VEC_pop (function_p, function_context_stack); |
87d4aa85 | 167 | set_cfun (p); |
897b77d6 | 168 | current_function_decl = p->decl; |
897b77d6 | 169 | |
897b77d6 | 170 | /* Reset variables that have known state during rtx generation. */ |
897b77d6 | 171 | virtuals_instantiated = 0; |
316bc009 | 172 | generating_concat_p = 1; |
897b77d6 | 173 | } |
2a228d52 | 174 | |
3c3bb268 | 175 | /* Clear out all parts of the state in F that can safely be discarded |
176 | after the function has been parsed, but not compiled, to let | |
177 | garbage collection reclaim the memory. */ | |
178 | ||
179 | void | |
de1b648b | 180 | free_after_parsing (struct function *f) |
3c3bb268 | 181 | { |
b75409ba | 182 | f->language = 0; |
3c3bb268 | 183 | } |
184 | ||
26df1c5e | 185 | /* Clear out all parts of the state in F that can safely be discarded |
186 | after the function has been compiled, to let garbage collection | |
a57bcb3b | 187 | reclaim the memory. */ |
c788feb1 | 188 | |
26df1c5e | 189 | void |
de1b648b | 190 | free_after_compilation (struct function *f) |
26df1c5e | 191 | { |
25e880b1 | 192 | prologue_insn_hash = NULL; |
193 | epilogue_insn_hash = NULL; | |
194 | ||
dd045aee | 195 | free (crtl->emit.regno_pointer_align); |
a4a0e8fd | 196 | |
fd6ffb7c | 197 | memset (crtl, 0, sizeof (struct rtl_data)); |
1f3233d1 | 198 | f->eh = NULL; |
1f3233d1 | 199 | f->machine = NULL; |
7a22afab | 200 | f->cfg = NULL; |
3c3bb268 | 201 | |
a9f6414b | 202 | regno_reg_rtx = NULL; |
8b3949ab | 203 | insn_locators_free (); |
26df1c5e | 204 | } |
897b77d6 | 205 | \f |
0a893c29 | 206 | /* Return size needed for stack frame based on slots so far allocated. |
207 | This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY; | |
208 | the caller may have to do that. */ | |
26d04e5f | 209 | |
0a893c29 | 210 | HOST_WIDE_INT |
de1b648b | 211 | get_frame_size (void) |
0a893c29 | 212 | { |
b079a207 | 213 | if (FRAME_GROWS_DOWNWARD) |
214 | return -frame_offset; | |
215 | else | |
216 | return frame_offset; | |
0a893c29 | 217 | } |
218 | ||
26d04e5f | 219 | /* Issue an error message and return TRUE if frame OFFSET overflows in |
220 | the signed target pointer arithmetics for function FUNC. Otherwise | |
221 | return FALSE. */ | |
222 | ||
223 | bool | |
224 | frame_offset_overflow (HOST_WIDE_INT offset, tree func) | |
48e1416a | 225 | { |
26d04e5f | 226 | unsigned HOST_WIDE_INT size = FRAME_GROWS_DOWNWARD ? -offset : offset; |
227 | ||
228 | if (size > ((unsigned HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (Pmode) - 1)) | |
229 | /* Leave room for the fixed part of the frame. */ | |
230 | - 64 * UNITS_PER_WORD) | |
231 | { | |
712d2297 | 232 | error_at (DECL_SOURCE_LOCATION (func), |
233 | "total size of local objects too large"); | |
26d04e5f | 234 | return TRUE; |
235 | } | |
236 | ||
237 | return FALSE; | |
238 | } | |
239 | ||
ad33891d | 240 | /* Return stack slot alignment in bits for TYPE and MODE. */ |
241 | ||
242 | static unsigned int | |
243 | get_stack_local_alignment (tree type, enum machine_mode mode) | |
244 | { | |
245 | unsigned int alignment; | |
246 | ||
247 | if (mode == BLKmode) | |
248 | alignment = BIGGEST_ALIGNMENT; | |
249 | else | |
250 | alignment = GET_MODE_ALIGNMENT (mode); | |
251 | ||
252 | /* Allow the frond-end to (possibly) increase the alignment of this | |
253 | stack slot. */ | |
254 | if (! type) | |
255 | type = lang_hooks.types.type_for_mode (mode, 0); | |
256 | ||
257 | return STACK_SLOT_ALIGNMENT (type, mode, alignment); | |
258 | } | |
259 | ||
43165fe4 | 260 | /* Determine whether it is possible to fit a stack slot of size SIZE and |
261 | alignment ALIGNMENT into an area in the stack frame that starts at | |
262 | frame offset START and has a length of LENGTH. If so, store the frame | |
263 | offset to be used for the stack slot in *POFFSET and return true; | |
264 | return false otherwise. This function will extend the frame size when | |
265 | given a start/length pair that lies at the end of the frame. */ | |
266 | ||
267 | static bool | |
268 | try_fit_stack_local (HOST_WIDE_INT start, HOST_WIDE_INT length, | |
269 | HOST_WIDE_INT size, unsigned int alignment, | |
270 | HOST_WIDE_INT *poffset) | |
271 | { | |
272 | HOST_WIDE_INT this_frame_offset; | |
273 | int frame_off, frame_alignment, frame_phase; | |
274 | ||
275 | /* Calculate how many bytes the start of local variables is off from | |
276 | stack alignment. */ | |
277 | frame_alignment = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT; | |
278 | frame_off = STARTING_FRAME_OFFSET % frame_alignment; | |
279 | frame_phase = frame_off ? frame_alignment - frame_off : 0; | |
280 | ||
281 | /* Round the frame offset to the specified alignment. */ | |
282 | ||
283 | /* We must be careful here, since FRAME_OFFSET might be negative and | |
284 | division with a negative dividend isn't as well defined as we might | |
285 | like. So we instead assume that ALIGNMENT is a power of two and | |
286 | use logical operations which are unambiguous. */ | |
287 | if (FRAME_GROWS_DOWNWARD) | |
288 | this_frame_offset | |
289 | = (FLOOR_ROUND (start + length - size - frame_phase, | |
290 | (unsigned HOST_WIDE_INT) alignment) | |
291 | + frame_phase); | |
292 | else | |
293 | this_frame_offset | |
294 | = (CEIL_ROUND (start - frame_phase, | |
295 | (unsigned HOST_WIDE_INT) alignment) | |
296 | + frame_phase); | |
297 | ||
298 | /* See if it fits. If this space is at the edge of the frame, | |
299 | consider extending the frame to make it fit. Our caller relies on | |
300 | this when allocating a new slot. */ | |
301 | if (frame_offset == start && this_frame_offset < frame_offset) | |
302 | frame_offset = this_frame_offset; | |
303 | else if (this_frame_offset < start) | |
304 | return false; | |
305 | else if (start + length == frame_offset | |
306 | && this_frame_offset + size > start + length) | |
307 | frame_offset = this_frame_offset + size; | |
308 | else if (this_frame_offset + size > start + length) | |
309 | return false; | |
310 | ||
311 | *poffset = this_frame_offset; | |
312 | return true; | |
313 | } | |
314 | ||
315 | /* Create a new frame_space structure describing free space in the stack | |
316 | frame beginning at START and ending at END, and chain it into the | |
317 | function's frame_space_list. */ | |
318 | ||
319 | static void | |
320 | add_frame_space (HOST_WIDE_INT start, HOST_WIDE_INT end) | |
321 | { | |
ba72912a | 322 | struct frame_space *space = ggc_alloc_frame_space (); |
43165fe4 | 323 | space->next = crtl->frame_space_list; |
324 | crtl->frame_space_list = space; | |
325 | space->start = start; | |
326 | space->length = end - start; | |
327 | } | |
328 | ||
897b77d6 | 329 | /* Allocate a stack slot of SIZE bytes and return a MEM rtx for it |
330 | with machine mode MODE. | |
06ebc183 | 331 | |
897b77d6 | 332 | ALIGN controls the amount of alignment for the address of the slot: |
333 | 0 means according to MODE, | |
334 | -1 means use BIGGEST_ALIGNMENT and round size to multiple of that, | |
c20b6803 | 335 | -2 means use BITS_PER_UNIT, |
897b77d6 | 336 | positive specifies alignment boundary in bits. |
337 | ||
943d8723 | 338 | KIND has ASLK_REDUCE_ALIGN bit set if it is OK to reduce |
339 | alignment and ASLK_RECORD_PAD bit set if we should remember | |
340 | extra space we allocated for alignment purposes. When we are | |
341 | called from assign_stack_temp_for_type, it is not set so we don't | |
342 | track the same stack slot in two independent lists. | |
27a7a23a | 343 | |
b079a207 | 344 | We do not round to stack_boundary here. */ |
897b77d6 | 345 | |
b079a207 | 346 | rtx |
27a7a23a | 347 | assign_stack_local_1 (enum machine_mode mode, HOST_WIDE_INT size, |
943d8723 | 348 | int align, int kind) |
897b77d6 | 349 | { |
19cb6b50 | 350 | rtx x, addr; |
897b77d6 | 351 | int bigend_correction = 0; |
286887d9 | 352 | HOST_WIDE_INT slot_offset = 0, old_frame_offset; |
ad33891d | 353 | unsigned int alignment, alignment_in_bits; |
897b77d6 | 354 | |
355 | if (align == 0) | |
356 | { | |
ad33891d | 357 | alignment = get_stack_local_alignment (NULL, mode); |
9bd87fd2 | 358 | alignment /= BITS_PER_UNIT; |
897b77d6 | 359 | } |
360 | else if (align == -1) | |
361 | { | |
362 | alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT; | |
363 | size = CEIL_ROUND (size, alignment); | |
364 | } | |
c20b6803 | 365 | else if (align == -2) |
366 | alignment = 1; /* BITS_PER_UNIT / BITS_PER_UNIT */ | |
897b77d6 | 367 | else |
368 | alignment = align / BITS_PER_UNIT; | |
369 | ||
27a7a23a | 370 | alignment_in_bits = alignment * BITS_PER_UNIT; |
371 | ||
27a7a23a | 372 | /* Ignore alignment if it exceeds MAX_SUPPORTED_STACK_ALIGNMENT. */ |
373 | if (alignment_in_bits > MAX_SUPPORTED_STACK_ALIGNMENT) | |
374 | { | |
375 | alignment_in_bits = MAX_SUPPORTED_STACK_ALIGNMENT; | |
376 | alignment = alignment_in_bits / BITS_PER_UNIT; | |
377 | } | |
a79cb8e9 | 378 | |
27a7a23a | 379 | if (SUPPORTS_STACK_ALIGNMENT) |
380 | { | |
381 | if (crtl->stack_alignment_estimated < alignment_in_bits) | |
382 | { | |
383 | if (!crtl->stack_realign_processed) | |
384 | crtl->stack_alignment_estimated = alignment_in_bits; | |
385 | else | |
386 | { | |
387 | /* If stack is realigned and stack alignment value | |
388 | hasn't been finalized, it is OK not to increase | |
389 | stack_alignment_estimated. The bigger alignment | |
390 | requirement is recorded in stack_alignment_needed | |
391 | below. */ | |
392 | gcc_assert (!crtl->stack_realign_finalized); | |
393 | if (!crtl->stack_realign_needed) | |
394 | { | |
395 | /* It is OK to reduce the alignment as long as the | |
396 | requested size is 0 or the estimated stack | |
397 | alignment >= mode alignment. */ | |
943d8723 | 398 | gcc_assert ((kind & ASLK_REDUCE_ALIGN) |
27a7a23a | 399 | || size == 0 |
400 | || (crtl->stack_alignment_estimated | |
401 | >= GET_MODE_ALIGNMENT (mode))); | |
402 | alignment_in_bits = crtl->stack_alignment_estimated; | |
403 | alignment = alignment_in_bits / BITS_PER_UNIT; | |
404 | } | |
405 | } | |
406 | } | |
407 | } | |
ad33891d | 408 | |
409 | if (crtl->stack_alignment_needed < alignment_in_bits) | |
410 | crtl->stack_alignment_needed = alignment_in_bits; | |
bd9c33a8 | 411 | if (crtl->max_used_stack_slot_alignment < alignment_in_bits) |
412 | crtl->max_used_stack_slot_alignment = alignment_in_bits; | |
a79cb8e9 | 413 | |
43165fe4 | 414 | if (mode != BLKmode || size != 0) |
415 | { | |
943d8723 | 416 | if (kind & ASLK_RECORD_PAD) |
43165fe4 | 417 | { |
943d8723 | 418 | struct frame_space **psp; |
419 | ||
420 | for (psp = &crtl->frame_space_list; *psp; psp = &(*psp)->next) | |
421 | { | |
422 | struct frame_space *space = *psp; | |
423 | if (!try_fit_stack_local (space->start, space->length, size, | |
424 | alignment, &slot_offset)) | |
425 | continue; | |
426 | *psp = space->next; | |
427 | if (slot_offset > space->start) | |
428 | add_frame_space (space->start, slot_offset); | |
429 | if (slot_offset + size < space->start + space->length) | |
430 | add_frame_space (slot_offset + size, | |
431 | space->start + space->length); | |
432 | goto found_space; | |
433 | } | |
43165fe4 | 434 | } |
435 | } | |
436 | else if (!STACK_ALIGNMENT_NEEDED) | |
437 | { | |
438 | slot_offset = frame_offset; | |
439 | goto found_space; | |
440 | } | |
441 | ||
442 | old_frame_offset = frame_offset; | |
443 | ||
444 | if (FRAME_GROWS_DOWNWARD) | |
445 | { | |
446 | frame_offset -= size; | |
447 | try_fit_stack_local (frame_offset, size, size, alignment, &slot_offset); | |
9f843b44 | 448 | |
943d8723 | 449 | if (kind & ASLK_RECORD_PAD) |
450 | { | |
451 | if (slot_offset > frame_offset) | |
452 | add_frame_space (frame_offset, slot_offset); | |
453 | if (slot_offset + size < old_frame_offset) | |
454 | add_frame_space (slot_offset + size, old_frame_offset); | |
455 | } | |
43165fe4 | 456 | } |
457 | else | |
256f9b65 | 458 | { |
43165fe4 | 459 | frame_offset += size; |
460 | try_fit_stack_local (old_frame_offset, size, size, alignment, &slot_offset); | |
461 | ||
943d8723 | 462 | if (kind & ASLK_RECORD_PAD) |
463 | { | |
464 | if (slot_offset > old_frame_offset) | |
465 | add_frame_space (old_frame_offset, slot_offset); | |
466 | if (slot_offset + size < frame_offset) | |
467 | add_frame_space (slot_offset + size, frame_offset); | |
468 | } | |
256f9b65 | 469 | } |
897b77d6 | 470 | |
43165fe4 | 471 | found_space: |
897b77d6 | 472 | /* On a big-endian machine, if we are allocating more space than we will use, |
473 | use the least significant bytes of those that are allocated. */ | |
1c088911 | 474 | if (BYTES_BIG_ENDIAN && mode != BLKmode && GET_MODE_SIZE (mode) < size) |
897b77d6 | 475 | bigend_correction = size - GET_MODE_SIZE (mode); |
897b77d6 | 476 | |
897b77d6 | 477 | /* If we have already instantiated virtual registers, return the actual |
478 | address relative to the frame pointer. */ | |
b079a207 | 479 | if (virtuals_instantiated) |
29c05e22 | 480 | addr = plus_constant (Pmode, frame_pointer_rtx, |
eb21abb2 | 481 | trunc_int_for_mode |
43165fe4 | 482 | (slot_offset + bigend_correction |
eb21abb2 | 483 | + STARTING_FRAME_OFFSET, Pmode)); |
897b77d6 | 484 | else |
29c05e22 | 485 | addr = plus_constant (Pmode, virtual_stack_vars_rtx, |
eb21abb2 | 486 | trunc_int_for_mode |
43165fe4 | 487 | (slot_offset + bigend_correction, |
eb21abb2 | 488 | Pmode)); |
897b77d6 | 489 | |
941522d6 | 490 | x = gen_rtx_MEM (mode, addr); |
ad33891d | 491 | set_mem_align (x, alignment_in_bits); |
43283c91 | 492 | MEM_NOTRAP_P (x) = 1; |
897b77d6 | 493 | |
b079a207 | 494 | stack_slot_list |
495 | = gen_rtx_EXPR_LIST (VOIDmode, x, stack_slot_list); | |
26df1c5e | 496 | |
b079a207 | 497 | if (frame_offset_overflow (frame_offset, current_function_decl)) |
498 | frame_offset = 0; | |
55abba5b | 499 | |
897b77d6 | 500 | return x; |
501 | } | |
27a7a23a | 502 | |
503 | /* Wrap up assign_stack_local_1 with last parameter as false. */ | |
504 | ||
505 | rtx | |
506 | assign_stack_local (enum machine_mode mode, HOST_WIDE_INT size, int align) | |
507 | { | |
943d8723 | 508 | return assign_stack_local_1 (mode, size, align, ASLK_RECORD_PAD); |
27a7a23a | 509 | } |
a6629703 | 510 | \f |
fef299ce | 511 | /* In order to evaluate some expressions, such as function calls returning |
512 | structures in memory, we need to temporarily allocate stack locations. | |
513 | We record each allocated temporary in the following structure. | |
514 | ||
515 | Associated with each temporary slot is a nesting level. When we pop up | |
516 | one level, all temporaries associated with the previous level are freed. | |
517 | Normally, all temporaries are freed after the execution of the statement | |
518 | in which they were created. However, if we are inside a ({...}) grouping, | |
519 | the result may be in a temporary and hence must be preserved. If the | |
520 | result could be in a temporary, we preserve it if we can determine which | |
521 | one it is in. If we cannot determine which temporary may contain the | |
522 | result, all temporaries are preserved. A temporary is preserved by | |
0ab48139 | 523 | pretending it was allocated at the previous nesting level. */ |
fef299ce | 524 | |
fb1e4f4a | 525 | struct GTY(()) temp_slot { |
fef299ce | 526 | /* Points to next temporary slot. */ |
527 | struct temp_slot *next; | |
528 | /* Points to previous temporary slot. */ | |
529 | struct temp_slot *prev; | |
530 | /* The rtx to used to reference the slot. */ | |
531 | rtx slot; | |
fef299ce | 532 | /* The size, in units, of the slot. */ |
533 | HOST_WIDE_INT size; | |
534 | /* The type of the object in the slot, or zero if it doesn't correspond | |
535 | to a type. We use this to determine whether a slot can be reused. | |
536 | It can be reused if objects of the type of the new slot will always | |
537 | conflict with objects of the type of the old slot. */ | |
538 | tree type; | |
0ac758f7 | 539 | /* The alignment (in bits) of the slot. */ |
540 | unsigned int align; | |
fef299ce | 541 | /* Nonzero if this temporary is currently in use. */ |
542 | char in_use; | |
fef299ce | 543 | /* Nesting level at which this slot is being used. */ |
544 | int level; | |
fef299ce | 545 | /* The offset of the slot from the frame_pointer, including extra space |
546 | for alignment. This info is for combine_temp_slots. */ | |
547 | HOST_WIDE_INT base_offset; | |
548 | /* The size of the slot, including extra space for alignment. This | |
549 | info is for combine_temp_slots. */ | |
550 | HOST_WIDE_INT full_size; | |
551 | }; | |
552 | ||
553 | /* A table of addresses that represent a stack slot. The table is a mapping | |
554 | from address RTXen to a temp slot. */ | |
555 | static GTY((param_is(struct temp_slot_address_entry))) htab_t temp_slot_address_table; | |
fc3c948c | 556 | static size_t n_temp_slots_in_use; |
fef299ce | 557 | |
558 | /* Entry for the above hash table. */ | |
fb1e4f4a | 559 | struct GTY(()) temp_slot_address_entry { |
fef299ce | 560 | hashval_t hash; |
561 | rtx address; | |
562 | struct temp_slot *temp_slot; | |
563 | }; | |
564 | ||
a6629703 | 565 | /* Removes temporary slot TEMP from LIST. */ |
566 | ||
567 | static void | |
568 | cut_slot_from_list (struct temp_slot *temp, struct temp_slot **list) | |
569 | { | |
570 | if (temp->next) | |
571 | temp->next->prev = temp->prev; | |
572 | if (temp->prev) | |
573 | temp->prev->next = temp->next; | |
574 | else | |
575 | *list = temp->next; | |
576 | ||
577 | temp->prev = temp->next = NULL; | |
578 | } | |
579 | ||
580 | /* Inserts temporary slot TEMP to LIST. */ | |
581 | ||
582 | static void | |
583 | insert_slot_to_list (struct temp_slot *temp, struct temp_slot **list) | |
584 | { | |
585 | temp->next = *list; | |
586 | if (*list) | |
587 | (*list)->prev = temp; | |
588 | temp->prev = NULL; | |
589 | *list = temp; | |
590 | } | |
591 | ||
592 | /* Returns the list of used temp slots at LEVEL. */ | |
593 | ||
594 | static struct temp_slot ** | |
595 | temp_slots_at_level (int level) | |
596 | { | |
84aacb40 | 597 | if (level >= (int) VEC_length (temp_slot_p, used_temp_slots)) |
e85c2c2d | 598 | VEC_safe_grow_cleared (temp_slot_p, gc, used_temp_slots, level + 1); |
a6629703 | 599 | |
84aacb40 | 600 | return &(VEC_address (temp_slot_p, used_temp_slots)[level]); |
a6629703 | 601 | } |
602 | ||
603 | /* Returns the maximal temporary slot level. */ | |
604 | ||
605 | static int | |
606 | max_slot_level (void) | |
607 | { | |
608 | if (!used_temp_slots) | |
609 | return -1; | |
610 | ||
84aacb40 | 611 | return VEC_length (temp_slot_p, used_temp_slots) - 1; |
a6629703 | 612 | } |
613 | ||
614 | /* Moves temporary slot TEMP to LEVEL. */ | |
615 | ||
616 | static void | |
617 | move_slot_to_level (struct temp_slot *temp, int level) | |
618 | { | |
619 | cut_slot_from_list (temp, temp_slots_at_level (temp->level)); | |
620 | insert_slot_to_list (temp, temp_slots_at_level (level)); | |
621 | temp->level = level; | |
622 | } | |
623 | ||
624 | /* Make temporary slot TEMP available. */ | |
625 | ||
626 | static void | |
627 | make_slot_available (struct temp_slot *temp) | |
628 | { | |
629 | cut_slot_from_list (temp, temp_slots_at_level (temp->level)); | |
630 | insert_slot_to_list (temp, &avail_temp_slots); | |
631 | temp->in_use = 0; | |
632 | temp->level = -1; | |
fc3c948c | 633 | n_temp_slots_in_use--; |
a6629703 | 634 | } |
fef299ce | 635 | |
636 | /* Compute the hash value for an address -> temp slot mapping. | |
637 | The value is cached on the mapping entry. */ | |
638 | static hashval_t | |
639 | temp_slot_address_compute_hash (struct temp_slot_address_entry *t) | |
640 | { | |
641 | int do_not_record = 0; | |
642 | return hash_rtx (t->address, GET_MODE (t->address), | |
643 | &do_not_record, NULL, false); | |
644 | } | |
645 | ||
646 | /* Return the hash value for an address -> temp slot mapping. */ | |
647 | static hashval_t | |
648 | temp_slot_address_hash (const void *p) | |
649 | { | |
650 | const struct temp_slot_address_entry *t; | |
651 | t = (const struct temp_slot_address_entry *) p; | |
652 | return t->hash; | |
653 | } | |
654 | ||
655 | /* Compare two address -> temp slot mapping entries. */ | |
656 | static int | |
657 | temp_slot_address_eq (const void *p1, const void *p2) | |
658 | { | |
659 | const struct temp_slot_address_entry *t1, *t2; | |
660 | t1 = (const struct temp_slot_address_entry *) p1; | |
661 | t2 = (const struct temp_slot_address_entry *) p2; | |
662 | return exp_equiv_p (t1->address, t2->address, 0, true); | |
663 | } | |
664 | ||
665 | /* Add ADDRESS as an alias of TEMP_SLOT to the addess -> temp slot mapping. */ | |
666 | static void | |
667 | insert_temp_slot_address (rtx address, struct temp_slot *temp_slot) | |
668 | { | |
669 | void **slot; | |
ba72912a | 670 | struct temp_slot_address_entry *t = ggc_alloc_temp_slot_address_entry (); |
fef299ce | 671 | t->address = address; |
672 | t->temp_slot = temp_slot; | |
673 | t->hash = temp_slot_address_compute_hash (t); | |
674 | slot = htab_find_slot_with_hash (temp_slot_address_table, t, t->hash, INSERT); | |
675 | *slot = t; | |
676 | } | |
677 | ||
678 | /* Remove an address -> temp slot mapping entry if the temp slot is | |
679 | not in use anymore. Callback for remove_unused_temp_slot_addresses. */ | |
680 | static int | |
681 | remove_unused_temp_slot_addresses_1 (void **slot, void *data ATTRIBUTE_UNUSED) | |
682 | { | |
683 | const struct temp_slot_address_entry *t; | |
684 | t = (const struct temp_slot_address_entry *) *slot; | |
685 | if (! t->temp_slot->in_use) | |
fc3c948c | 686 | htab_clear_slot (temp_slot_address_table, slot); |
fef299ce | 687 | return 1; |
688 | } | |
689 | ||
690 | /* Remove all mappings of addresses to unused temp slots. */ | |
691 | static void | |
692 | remove_unused_temp_slot_addresses (void) | |
693 | { | |
fc3c948c | 694 | /* Use quicker clearing if there aren't any active temp slots. */ |
695 | if (n_temp_slots_in_use) | |
696 | htab_traverse (temp_slot_address_table, | |
697 | remove_unused_temp_slot_addresses_1, | |
698 | NULL); | |
699 | else | |
700 | htab_empty (temp_slot_address_table); | |
fef299ce | 701 | } |
702 | ||
703 | /* Find the temp slot corresponding to the object at address X. */ | |
704 | ||
705 | static struct temp_slot * | |
706 | find_temp_slot_from_address (rtx x) | |
707 | { | |
708 | struct temp_slot *p; | |
709 | struct temp_slot_address_entry tmp, *t; | |
710 | ||
711 | /* First try the easy way: | |
712 | See if X exists in the address -> temp slot mapping. */ | |
713 | tmp.address = x; | |
714 | tmp.temp_slot = NULL; | |
715 | tmp.hash = temp_slot_address_compute_hash (&tmp); | |
716 | t = (struct temp_slot_address_entry *) | |
717 | htab_find_with_hash (temp_slot_address_table, &tmp, tmp.hash); | |
718 | if (t) | |
719 | return t->temp_slot; | |
720 | ||
721 | /* If we have a sum involving a register, see if it points to a temp | |
722 | slot. */ | |
723 | if (GET_CODE (x) == PLUS && REG_P (XEXP (x, 0)) | |
724 | && (p = find_temp_slot_from_address (XEXP (x, 0))) != 0) | |
725 | return p; | |
726 | else if (GET_CODE (x) == PLUS && REG_P (XEXP (x, 1)) | |
727 | && (p = find_temp_slot_from_address (XEXP (x, 1))) != 0) | |
728 | return p; | |
729 | ||
730 | /* Last resort: Address is a virtual stack var address. */ | |
731 | if (GET_CODE (x) == PLUS | |
732 | && XEXP (x, 0) == virtual_stack_vars_rtx | |
971ba038 | 733 | && CONST_INT_P (XEXP (x, 1))) |
fef299ce | 734 | { |
735 | int i; | |
736 | for (i = max_slot_level (); i >= 0; i--) | |
737 | for (p = *temp_slots_at_level (i); p; p = p->next) | |
738 | { | |
739 | if (INTVAL (XEXP (x, 1)) >= p->base_offset | |
740 | && INTVAL (XEXP (x, 1)) < p->base_offset + p->full_size) | |
741 | return p; | |
742 | } | |
743 | } | |
744 | ||
745 | return NULL; | |
746 | } | |
897b77d6 | 747 | \f |
748 | /* Allocate a temporary stack slot and record it for possible later | |
749 | reuse. | |
750 | ||
751 | MODE is the machine mode to be given to the returned rtx. | |
752 | ||
753 | SIZE is the size in units of the space required. We do no rounding here | |
754 | since assign_stack_local will do any required rounding. | |
755 | ||
59241190 | 756 | TYPE is the type that will be used for the stack slot. */ |
897b77d6 | 757 | |
2b96c5f6 | 758 | rtx |
89f18f73 | 759 | assign_stack_temp_for_type (enum machine_mode mode, HOST_WIDE_INT size, |
0ab48139 | 760 | tree type) |
897b77d6 | 761 | { |
d3e10bed | 762 | unsigned int align; |
a6629703 | 763 | struct temp_slot *p, *best_p = 0, *selected = NULL, **pp; |
84be287d | 764 | rtx slot; |
897b77d6 | 765 | |
babc13fa | 766 | /* If SIZE is -1 it means that somebody tried to allocate a temporary |
767 | of a variable size. */ | |
fdada98f | 768 | gcc_assert (size != -1); |
babc13fa | 769 | |
ad33891d | 770 | align = get_stack_local_alignment (type, mode); |
9bd87fd2 | 771 | |
772 | /* Try to find an available, already-allocated temporary of the proper | |
773 | mode which meets the size and alignment requirements. Choose the | |
867eb367 | 774 | smallest one with the closest alignment. |
48e1416a | 775 | |
867eb367 | 776 | If assign_stack_temp is called outside of the tree->rtl expansion, |
777 | we cannot reuse the stack slots (that may still refer to | |
778 | VIRTUAL_STACK_VARS_REGNUM). */ | |
779 | if (!virtuals_instantiated) | |
a6629703 | 780 | { |
867eb367 | 781 | for (p = avail_temp_slots; p; p = p->next) |
a6629703 | 782 | { |
867eb367 | 783 | if (p->align >= align && p->size >= size |
784 | && GET_MODE (p->slot) == mode | |
785 | && objects_must_conflict_p (p->type, type) | |
786 | && (best_p == 0 || best_p->size > p->size | |
787 | || (best_p->size == p->size && best_p->align > p->align))) | |
a6629703 | 788 | { |
867eb367 | 789 | if (p->align == align && p->size == size) |
790 | { | |
791 | selected = p; | |
792 | cut_slot_from_list (selected, &avail_temp_slots); | |
793 | best_p = 0; | |
794 | break; | |
795 | } | |
796 | best_p = p; | |
a6629703 | 797 | } |
a6629703 | 798 | } |
799 | } | |
897b77d6 | 800 | |
801 | /* Make our best, if any, the one to use. */ | |
802 | if (best_p) | |
49d3d726 | 803 | { |
a6629703 | 804 | selected = best_p; |
805 | cut_slot_from_list (selected, &avail_temp_slots); | |
806 | ||
49d3d726 | 807 | /* If there are enough aligned bytes left over, make them into a new |
808 | temp_slot so that the extra bytes don't get wasted. Do this only | |
809 | for BLKmode slots, so that we can be sure of the alignment. */ | |
f7c44134 | 810 | if (GET_MODE (best_p->slot) == BLKmode) |
49d3d726 | 811 | { |
9bd87fd2 | 812 | int alignment = best_p->align / BITS_PER_UNIT; |
997d68fe | 813 | HOST_WIDE_INT rounded_size = CEIL_ROUND (size, alignment); |
49d3d726 | 814 | |
815 | if (best_p->size - rounded_size >= alignment) | |
816 | { | |
ba72912a | 817 | p = ggc_alloc_temp_slot (); |
0ab48139 | 818 | p->in_use = 0; |
49d3d726 | 819 | p->size = best_p->size - rounded_size; |
e8a637a3 | 820 | p->base_offset = best_p->base_offset + rounded_size; |
821 | p->full_size = best_p->full_size - rounded_size; | |
43283c91 | 822 | p->slot = adjust_address_nv (best_p->slot, BLKmode, rounded_size); |
9bd87fd2 | 823 | p->align = best_p->align; |
387bc205 | 824 | p->type = best_p->type; |
a6629703 | 825 | insert_slot_to_list (p, &avail_temp_slots); |
49d3d726 | 826 | |
941522d6 | 827 | stack_slot_list = gen_rtx_EXPR_LIST (VOIDmode, p->slot, |
828 | stack_slot_list); | |
49d3d726 | 829 | |
830 | best_p->size = rounded_size; | |
5ea3c815 | 831 | best_p->full_size = rounded_size; |
49d3d726 | 832 | } |
833 | } | |
49d3d726 | 834 | } |
06ebc183 | 835 | |
897b77d6 | 836 | /* If we still didn't find one, make a new temporary. */ |
a6629703 | 837 | if (selected == 0) |
897b77d6 | 838 | { |
997d68fe | 839 | HOST_WIDE_INT frame_offset_old = frame_offset; |
840 | ||
ba72912a | 841 | p = ggc_alloc_temp_slot (); |
997d68fe | 842 | |
d61726bc | 843 | /* We are passing an explicit alignment request to assign_stack_local. |
844 | One side effect of that is assign_stack_local will not round SIZE | |
845 | to ensure the frame offset remains suitably aligned. | |
846 | ||
847 | So for requests which depended on the rounding of SIZE, we go ahead | |
848 | and round it now. We also make sure ALIGNMENT is at least | |
849 | BIGGEST_ALIGNMENT. */ | |
fdada98f | 850 | gcc_assert (mode != BLKmode || align == BIGGEST_ALIGNMENT); |
943d8723 | 851 | p->slot = assign_stack_local_1 (mode, |
852 | (mode == BLKmode | |
853 | ? CEIL_ROUND (size, | |
854 | (int) align | |
855 | / BITS_PER_UNIT) | |
856 | : size), | |
857 | align, 0); | |
9bd87fd2 | 858 | |
859 | p->align = align; | |
997d68fe | 860 | |
ef4d68c5 | 861 | /* The following slot size computation is necessary because we don't |
862 | know the actual size of the temporary slot until assign_stack_local | |
863 | has performed all the frame alignment and size rounding for the | |
d53be447 | 864 | requested temporary. Note that extra space added for alignment |
865 | can be either above or below this stack slot depending on which | |
866 | way the frame grows. We include the extra space if and only if it | |
867 | is above this slot. */ | |
d28d5017 | 868 | if (FRAME_GROWS_DOWNWARD) |
869 | p->size = frame_offset_old - frame_offset; | |
870 | else | |
871 | p->size = size; | |
997d68fe | 872 | |
d53be447 | 873 | /* Now define the fields used by combine_temp_slots. */ |
d28d5017 | 874 | if (FRAME_GROWS_DOWNWARD) |
875 | { | |
876 | p->base_offset = frame_offset; | |
877 | p->full_size = frame_offset_old - frame_offset; | |
878 | } | |
879 | else | |
880 | { | |
881 | p->base_offset = frame_offset_old; | |
882 | p->full_size = frame_offset - frame_offset_old; | |
883 | } | |
a6629703 | 884 | |
885 | selected = p; | |
897b77d6 | 886 | } |
887 | ||
a6629703 | 888 | p = selected; |
897b77d6 | 889 | p->in_use = 1; |
387bc205 | 890 | p->type = type; |
fcb807f8 | 891 | p->level = temp_slot_level; |
fc3c948c | 892 | n_temp_slots_in_use++; |
21c867df | 893 | |
a6629703 | 894 | pp = temp_slots_at_level (p->level); |
895 | insert_slot_to_list (p, pp); | |
fef299ce | 896 | insert_temp_slot_address (XEXP (p->slot, 0), p); |
84be287d | 897 | |
898 | /* Create a new MEM rtx to avoid clobbering MEM flags of old slots. */ | |
899 | slot = gen_rtx_MEM (mode, XEXP (p->slot, 0)); | |
900 | stack_slot_list = gen_rtx_EXPR_LIST (VOIDmode, slot, stack_slot_list); | |
f7c44134 | 901 | |
387bc205 | 902 | /* If we know the alias set for the memory that will be used, use |
903 | it. If there's no TYPE, then we don't know anything about the | |
904 | alias set for the memory. */ | |
84be287d | 905 | set_mem_alias_set (slot, type ? get_alias_set (type) : 0); |
906 | set_mem_align (slot, align); | |
387bc205 | 907 | |
6312a35e | 908 | /* If a type is specified, set the relevant flags. */ |
f7c44134 | 909 | if (type != 0) |
402f6a9e | 910 | MEM_VOLATILE_P (slot) = TYPE_VOLATILE (type); |
43283c91 | 911 | MEM_NOTRAP_P (slot) = 1; |
f7c44134 | 912 | |
84be287d | 913 | return slot; |
897b77d6 | 914 | } |
9bd87fd2 | 915 | |
916 | /* Allocate a temporary stack slot and record it for possible later | |
0ab48139 | 917 | reuse. First two arguments are same as in preceding function. */ |
9bd87fd2 | 918 | |
919 | rtx | |
0ab48139 | 920 | assign_stack_temp (enum machine_mode mode, HOST_WIDE_INT size) |
9bd87fd2 | 921 | { |
0ab48139 | 922 | return assign_stack_temp_for_type (mode, size, NULL_TREE); |
9bd87fd2 | 923 | } |
ad6d0e80 | 924 | \f |
567c22a9 | 925 | /* Assign a temporary. |
926 | If TYPE_OR_DECL is a decl, then we are doing it on behalf of the decl | |
927 | and so that should be used in error messages. In either case, we | |
928 | allocate of the given type. | |
9c457457 | 929 | MEMORY_REQUIRED is 1 if the result must be addressable stack memory; |
30dd806d | 930 | it is 0 if a register is OK. |
931 | DONT_PROMOTE is 1 if we should not promote values in register | |
932 | to wider modes. */ | |
9c457457 | 933 | |
934 | rtx | |
0ab48139 | 935 | assign_temp (tree type_or_decl, int memory_required, |
de1b648b | 936 | int dont_promote ATTRIBUTE_UNUSED) |
9c457457 | 937 | { |
567c22a9 | 938 | tree type, decl; |
939 | enum machine_mode mode; | |
7752d341 | 940 | #ifdef PROMOTE_MODE |
567c22a9 | 941 | int unsignedp; |
942 | #endif | |
943 | ||
944 | if (DECL_P (type_or_decl)) | |
945 | decl = type_or_decl, type = TREE_TYPE (decl); | |
946 | else | |
947 | decl = NULL, type = type_or_decl; | |
948 | ||
949 | mode = TYPE_MODE (type); | |
7752d341 | 950 | #ifdef PROMOTE_MODE |
78a8ed03 | 951 | unsignedp = TYPE_UNSIGNED (type); |
aeb6d7ef | 952 | #endif |
ad6d0e80 | 953 | |
9c457457 | 954 | if (mode == BLKmode || memory_required) |
955 | { | |
997d68fe | 956 | HOST_WIDE_INT size = int_size_in_bytes (type); |
9c457457 | 957 | rtx tmp; |
958 | ||
779a20c8 | 959 | /* Zero sized arrays are GNU C extension. Set size to 1 to avoid |
960 | problems with allocating the stack space. */ | |
961 | if (size == 0) | |
962 | size = 1; | |
963 | ||
9c457457 | 964 | /* Unfortunately, we don't yet know how to allocate variable-sized |
150edb07 | 965 | temporaries. However, sometimes we can find a fixed upper limit on |
966 | the size, so try that instead. */ | |
967 | else if (size == -1) | |
968 | size = max_int_size_in_bytes (type); | |
8c3216ae | 969 | |
567c22a9 | 970 | /* The size of the temporary may be too large to fit into an integer. */ |
971 | /* ??? Not sure this should happen except for user silliness, so limit | |
60d903f5 | 972 | this to things that aren't compiler-generated temporaries. The |
89f18f73 | 973 | rest of the time we'll die in assign_stack_temp_for_type. */ |
567c22a9 | 974 | if (decl && size == -1 |
975 | && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST) | |
976 | { | |
3cf8b391 | 977 | error ("size of variable %q+D is too large", decl); |
567c22a9 | 978 | size = 1; |
979 | } | |
980 | ||
0ab48139 | 981 | tmp = assign_stack_temp_for_type (mode, size, type); |
9c457457 | 982 | return tmp; |
983 | } | |
ad6d0e80 | 984 | |
7752d341 | 985 | #ifdef PROMOTE_MODE |
30dd806d | 986 | if (! dont_promote) |
3b2411a8 | 987 | mode = promote_mode (type, mode, &unsignedp); |
9c457457 | 988 | #endif |
ad6d0e80 | 989 | |
9c457457 | 990 | return gen_reg_rtx (mode); |
991 | } | |
ad6d0e80 | 992 | \f |
49d3d726 | 993 | /* Combine temporary stack slots which are adjacent on the stack. |
994 | ||
995 | This allows for better use of already allocated stack space. This is only | |
996 | done for BLKmode slots because we can be sure that we won't have alignment | |
997 | problems in this case. */ | |
998 | ||
3f0895d3 | 999 | static void |
de1b648b | 1000 | combine_temp_slots (void) |
49d3d726 | 1001 | { |
a6629703 | 1002 | struct temp_slot *p, *q, *next, *next_q; |
997d68fe | 1003 | int num_slots; |
1004 | ||
59241190 | 1005 | /* We can't combine slots, because the information about which slot |
1006 | is in which alias set will be lost. */ | |
1007 | if (flag_strict_aliasing) | |
1008 | return; | |
1009 | ||
06ebc183 | 1010 | /* If there are a lot of temp slots, don't do anything unless |
cb0ccc1e | 1011 | high levels of optimization. */ |
997d68fe | 1012 | if (! flag_expensive_optimizations) |
a6629703 | 1013 | for (p = avail_temp_slots, num_slots = 0; p; p = p->next, num_slots++) |
997d68fe | 1014 | if (num_slots > 100 || (num_slots > 10 && optimize == 0)) |
1015 | return; | |
49d3d726 | 1016 | |
a6629703 | 1017 | for (p = avail_temp_slots; p; p = next) |
ccf0a5eb | 1018 | { |
1019 | int delete_p = 0; | |
997d68fe | 1020 | |
a6629703 | 1021 | next = p->next; |
1022 | ||
1023 | if (GET_MODE (p->slot) != BLKmode) | |
1024 | continue; | |
1025 | ||
1026 | for (q = p->next; q; q = next_q) | |
ccf0a5eb | 1027 | { |
a6629703 | 1028 | int delete_q = 0; |
1029 | ||
1030 | next_q = q->next; | |
1031 | ||
1032 | if (GET_MODE (q->slot) != BLKmode) | |
1033 | continue; | |
1034 | ||
1035 | if (p->base_offset + p->full_size == q->base_offset) | |
1036 | { | |
1037 | /* Q comes after P; combine Q into P. */ | |
1038 | p->size += q->size; | |
1039 | p->full_size += q->full_size; | |
1040 | delete_q = 1; | |
1041 | } | |
1042 | else if (q->base_offset + q->full_size == p->base_offset) | |
1043 | { | |
1044 | /* P comes after Q; combine P into Q. */ | |
1045 | q->size += p->size; | |
1046 | q->full_size += p->full_size; | |
1047 | delete_p = 1; | |
1048 | break; | |
1049 | } | |
1050 | if (delete_q) | |
1051 | cut_slot_from_list (q, &avail_temp_slots); | |
ccf0a5eb | 1052 | } |
a6629703 | 1053 | |
1054 | /* Either delete P or advance past it. */ | |
1055 | if (delete_p) | |
1056 | cut_slot_from_list (p, &avail_temp_slots); | |
ccf0a5eb | 1057 | } |
49d3d726 | 1058 | } |
897b77d6 | 1059 | \f |
f4e36c33 | 1060 | /* Indicate that NEW_RTX is an alternate way of referring to the temp |
1061 | slot that previously was known by OLD_RTX. */ | |
64e90dae | 1062 | |
1063 | void | |
f4e36c33 | 1064 | update_temp_slot_address (rtx old_rtx, rtx new_rtx) |
64e90dae | 1065 | { |
155b05dc | 1066 | struct temp_slot *p; |
64e90dae | 1067 | |
f4e36c33 | 1068 | if (rtx_equal_p (old_rtx, new_rtx)) |
64e90dae | 1069 | return; |
155b05dc | 1070 | |
f4e36c33 | 1071 | p = find_temp_slot_from_address (old_rtx); |
155b05dc | 1072 | |
f4e36c33 | 1073 | /* If we didn't find one, see if both OLD_RTX is a PLUS. If so, and |
1074 | NEW_RTX is a register, see if one operand of the PLUS is a | |
1075 | temporary location. If so, NEW_RTX points into it. Otherwise, | |
1076 | if both OLD_RTX and NEW_RTX are a PLUS and if there is a register | |
1077 | in common between them. If so, try a recursive call on those | |
1078 | values. */ | |
155b05dc | 1079 | if (p == 0) |
1080 | { | |
f4e36c33 | 1081 | if (GET_CODE (old_rtx) != PLUS) |
8911b943 | 1082 | return; |
1083 | ||
f4e36c33 | 1084 | if (REG_P (new_rtx)) |
8911b943 | 1085 | { |
f4e36c33 | 1086 | update_temp_slot_address (XEXP (old_rtx, 0), new_rtx); |
1087 | update_temp_slot_address (XEXP (old_rtx, 1), new_rtx); | |
8911b943 | 1088 | return; |
1089 | } | |
f4e36c33 | 1090 | else if (GET_CODE (new_rtx) != PLUS) |
155b05dc | 1091 | return; |
1092 | ||
f4e36c33 | 1093 | if (rtx_equal_p (XEXP (old_rtx, 0), XEXP (new_rtx, 0))) |
1094 | update_temp_slot_address (XEXP (old_rtx, 1), XEXP (new_rtx, 1)); | |
1095 | else if (rtx_equal_p (XEXP (old_rtx, 1), XEXP (new_rtx, 0))) | |
1096 | update_temp_slot_address (XEXP (old_rtx, 0), XEXP (new_rtx, 1)); | |
1097 | else if (rtx_equal_p (XEXP (old_rtx, 0), XEXP (new_rtx, 1))) | |
1098 | update_temp_slot_address (XEXP (old_rtx, 1), XEXP (new_rtx, 0)); | |
1099 | else if (rtx_equal_p (XEXP (old_rtx, 1), XEXP (new_rtx, 1))) | |
1100 | update_temp_slot_address (XEXP (old_rtx, 0), XEXP (new_rtx, 0)); | |
155b05dc | 1101 | |
1102 | return; | |
1103 | } | |
1104 | ||
06ebc183 | 1105 | /* Otherwise add an alias for the temp's address. */ |
fef299ce | 1106 | insert_temp_slot_address (new_rtx, p); |
64e90dae | 1107 | } |
1108 | ||
30f413ae | 1109 | /* If X could be a reference to a temporary slot, mark that slot as |
1110 | belonging to the to one level higher than the current level. If X | |
1111 | matched one of our slots, just mark that one. Otherwise, we can't | |
0ab48139 | 1112 | easily predict which it is, so upgrade all of them. |
897b77d6 | 1113 | |
1114 | This is called when an ({...}) construct occurs and a statement | |
1115 | returns a value in memory. */ | |
1116 | ||
1117 | void | |
de1b648b | 1118 | preserve_temp_slots (rtx x) |
897b77d6 | 1119 | { |
a6629703 | 1120 | struct temp_slot *p = 0, *next; |
897b77d6 | 1121 | |
c7c7590a | 1122 | if (x == 0) |
0ab48139 | 1123 | return; |
41969bd3 | 1124 | |
e8825bb0 | 1125 | /* If X is a register that is being used as a pointer, see if we have |
0ab48139 | 1126 | a temporary slot we know it points to. */ |
e8825bb0 | 1127 | if (REG_P (x) && REG_POINTER (x)) |
1128 | p = find_temp_slot_from_address (x); | |
41969bd3 | 1129 | |
e8825bb0 | 1130 | /* If X is not in memory or is at a constant address, it cannot be in |
0ab48139 | 1131 | a temporary slot. */ |
e8825bb0 | 1132 | if (p == 0 && (!MEM_P (x) || CONSTANT_P (XEXP (x, 0)))) |
0ab48139 | 1133 | return; |
e8825bb0 | 1134 | |
1135 | /* First see if we can find a match. */ | |
1136 | if (p == 0) | |
1137 | p = find_temp_slot_from_address (XEXP (x, 0)); | |
1138 | ||
1139 | if (p != 0) | |
1140 | { | |
e8825bb0 | 1141 | if (p->level == temp_slot_level) |
0ab48139 | 1142 | move_slot_to_level (p, temp_slot_level - 1); |
e8825bb0 | 1143 | return; |
41969bd3 | 1144 | } |
0dbd1c74 | 1145 | |
e8825bb0 | 1146 | /* Otherwise, preserve all non-kept slots at this level. */ |
1147 | for (p = *temp_slots_at_level (temp_slot_level); p; p = next) | |
0dbd1c74 | 1148 | { |
e8825bb0 | 1149 | next = p->next; |
0ab48139 | 1150 | move_slot_to_level (p, temp_slot_level - 1); |
e8825bb0 | 1151 | } |
c925694c | 1152 | } |
1153 | ||
e8825bb0 | 1154 | /* Free all temporaries used so far. This is normally called at the |
1155 | end of generating code for a statement. */ | |
c925694c | 1156 | |
e8825bb0 | 1157 | void |
1158 | free_temp_slots (void) | |
c925694c | 1159 | { |
e8825bb0 | 1160 | struct temp_slot *p, *next; |
a4da9a83 | 1161 | bool some_available = false; |
c925694c | 1162 | |
e8825bb0 | 1163 | for (p = *temp_slots_at_level (temp_slot_level); p; p = next) |
1164 | { | |
1165 | next = p->next; | |
0ab48139 | 1166 | make_slot_available (p); |
1167 | some_available = true; | |
e8825bb0 | 1168 | } |
c925694c | 1169 | |
a4da9a83 | 1170 | if (some_available) |
1171 | { | |
1172 | remove_unused_temp_slot_addresses (); | |
1173 | combine_temp_slots (); | |
1174 | } | |
e8825bb0 | 1175 | } |
c925694c | 1176 | |
e8825bb0 | 1177 | /* Push deeper into the nesting level for stack temporaries. */ |
c925694c | 1178 | |
e8825bb0 | 1179 | void |
1180 | push_temp_slots (void) | |
c925694c | 1181 | { |
e8825bb0 | 1182 | temp_slot_level++; |
c925694c | 1183 | } |
1184 | ||
e8825bb0 | 1185 | /* Pop a temporary nesting level. All slots in use in the current level |
1186 | are freed. */ | |
c925694c | 1187 | |
e8825bb0 | 1188 | void |
1189 | pop_temp_slots (void) | |
c925694c | 1190 | { |
0ab48139 | 1191 | free_temp_slots (); |
e8825bb0 | 1192 | temp_slot_level--; |
bf5a43e2 | 1193 | } |
1194 | ||
e8825bb0 | 1195 | /* Initialize temporary slots. */ |
0dbd1c74 | 1196 | |
1197 | void | |
e8825bb0 | 1198 | init_temp_slots (void) |
0dbd1c74 | 1199 | { |
e8825bb0 | 1200 | /* We have not allocated any temporaries yet. */ |
1201 | avail_temp_slots = 0; | |
1202 | used_temp_slots = 0; | |
1203 | temp_slot_level = 0; | |
fc3c948c | 1204 | n_temp_slots_in_use = 0; |
fef299ce | 1205 | |
1206 | /* Set up the table to map addresses to temp slots. */ | |
1207 | if (! temp_slot_address_table) | |
1208 | temp_slot_address_table = htab_create_ggc (32, | |
1209 | temp_slot_address_hash, | |
1210 | temp_slot_address_eq, | |
1211 | NULL); | |
1212 | else | |
1213 | htab_empty (temp_slot_address_table); | |
e8825bb0 | 1214 | } |
1215 | \f | |
ea1760a3 | 1216 | /* Functions and data structures to keep track of the values hard regs |
1217 | had at the start of the function. */ | |
1218 | ||
1219 | /* Private type used by get_hard_reg_initial_reg, get_hard_reg_initial_val, | |
1220 | and has_hard_reg_initial_val.. */ | |
1221 | typedef struct GTY(()) initial_value_pair { | |
1222 | rtx hard_reg; | |
1223 | rtx pseudo; | |
1224 | } initial_value_pair; | |
1225 | /* ??? This could be a VEC but there is currently no way to define an | |
1226 | opaque VEC type. This could be worked around by defining struct | |
1227 | initial_value_pair in function.h. */ | |
1228 | typedef struct GTY(()) initial_value_struct { | |
1229 | int num_entries; | |
1230 | int max_entries; | |
1231 | initial_value_pair * GTY ((length ("%h.num_entries"))) entries; | |
1232 | } initial_value_struct; | |
1233 | ||
1234 | /* If a pseudo represents an initial hard reg (or expression), return | |
1235 | it, else return NULL_RTX. */ | |
1236 | ||
1237 | rtx | |
1238 | get_hard_reg_initial_reg (rtx reg) | |
1239 | { | |
1240 | struct initial_value_struct *ivs = crtl->hard_reg_initial_vals; | |
1241 | int i; | |
1242 | ||
1243 | if (ivs == 0) | |
1244 | return NULL_RTX; | |
1245 | ||
1246 | for (i = 0; i < ivs->num_entries; i++) | |
1247 | if (rtx_equal_p (ivs->entries[i].pseudo, reg)) | |
1248 | return ivs->entries[i].hard_reg; | |
1249 | ||
1250 | return NULL_RTX; | |
1251 | } | |
1252 | ||
1253 | /* Make sure that there's a pseudo register of mode MODE that stores the | |
1254 | initial value of hard register REGNO. Return an rtx for such a pseudo. */ | |
1255 | ||
1256 | rtx | |
1257 | get_hard_reg_initial_val (enum machine_mode mode, unsigned int regno) | |
1258 | { | |
1259 | struct initial_value_struct *ivs; | |
1260 | rtx rv; | |
1261 | ||
1262 | rv = has_hard_reg_initial_val (mode, regno); | |
1263 | if (rv) | |
1264 | return rv; | |
1265 | ||
1266 | ivs = crtl->hard_reg_initial_vals; | |
1267 | if (ivs == 0) | |
1268 | { | |
1269 | ivs = ggc_alloc_initial_value_struct (); | |
1270 | ivs->num_entries = 0; | |
1271 | ivs->max_entries = 5; | |
1272 | ivs->entries = ggc_alloc_vec_initial_value_pair (5); | |
1273 | crtl->hard_reg_initial_vals = ivs; | |
1274 | } | |
1275 | ||
1276 | if (ivs->num_entries >= ivs->max_entries) | |
1277 | { | |
1278 | ivs->max_entries += 5; | |
1279 | ivs->entries = GGC_RESIZEVEC (initial_value_pair, ivs->entries, | |
1280 | ivs->max_entries); | |
1281 | } | |
1282 | ||
1283 | ivs->entries[ivs->num_entries].hard_reg = gen_rtx_REG (mode, regno); | |
1284 | ivs->entries[ivs->num_entries].pseudo = gen_reg_rtx (mode); | |
1285 | ||
1286 | return ivs->entries[ivs->num_entries++].pseudo; | |
1287 | } | |
1288 | ||
1289 | /* See if get_hard_reg_initial_val has been used to create a pseudo | |
1290 | for the initial value of hard register REGNO in mode MODE. Return | |
1291 | the associated pseudo if so, otherwise return NULL. */ | |
1292 | ||
1293 | rtx | |
1294 | has_hard_reg_initial_val (enum machine_mode mode, unsigned int regno) | |
1295 | { | |
1296 | struct initial_value_struct *ivs; | |
1297 | int i; | |
1298 | ||
1299 | ivs = crtl->hard_reg_initial_vals; | |
1300 | if (ivs != 0) | |
1301 | for (i = 0; i < ivs->num_entries; i++) | |
1302 | if (GET_MODE (ivs->entries[i].hard_reg) == mode | |
1303 | && REGNO (ivs->entries[i].hard_reg) == regno) | |
1304 | return ivs->entries[i].pseudo; | |
1305 | ||
1306 | return NULL_RTX; | |
1307 | } | |
1308 | ||
1309 | unsigned int | |
1310 | emit_initial_value_sets (void) | |
1311 | { | |
1312 | struct initial_value_struct *ivs = crtl->hard_reg_initial_vals; | |
1313 | int i; | |
1314 | rtx seq; | |
1315 | ||
1316 | if (ivs == 0) | |
1317 | return 0; | |
1318 | ||
1319 | start_sequence (); | |
1320 | for (i = 0; i < ivs->num_entries; i++) | |
1321 | emit_move_insn (ivs->entries[i].pseudo, ivs->entries[i].hard_reg); | |
1322 | seq = get_insns (); | |
1323 | end_sequence (); | |
1324 | ||
1325 | emit_insn_at_entry (seq); | |
1326 | return 0; | |
1327 | } | |
1328 | ||
1329 | /* Return the hardreg-pseudoreg initial values pair entry I and | |
1330 | TRUE if I is a valid entry, or FALSE if I is not a valid entry. */ | |
1331 | bool | |
1332 | initial_value_entry (int i, rtx *hreg, rtx *preg) | |
1333 | { | |
1334 | struct initial_value_struct *ivs = crtl->hard_reg_initial_vals; | |
1335 | if (!ivs || i >= ivs->num_entries) | |
1336 | return false; | |
1337 | ||
1338 | *hreg = ivs->entries[i].hard_reg; | |
1339 | *preg = ivs->entries[i].pseudo; | |
1340 | return true; | |
1341 | } | |
1342 | \f | |
e8825bb0 | 1343 | /* These routines are responsible for converting virtual register references |
1344 | to the actual hard register references once RTL generation is complete. | |
06ebc183 | 1345 | |
e8825bb0 | 1346 | The following four variables are used for communication between the |
1347 | routines. They contain the offsets of the virtual registers from their | |
1348 | respective hard registers. */ | |
c925694c | 1349 | |
e8825bb0 | 1350 | static int in_arg_offset; |
1351 | static int var_offset; | |
1352 | static int dynamic_offset; | |
1353 | static int out_arg_offset; | |
1354 | static int cfa_offset; | |
a8636638 | 1355 | |
e8825bb0 | 1356 | /* In most machines, the stack pointer register is equivalent to the bottom |
1357 | of the stack. */ | |
06ebc183 | 1358 | |
e8825bb0 | 1359 | #ifndef STACK_POINTER_OFFSET |
1360 | #define STACK_POINTER_OFFSET 0 | |
1361 | #endif | |
bf5a43e2 | 1362 | |
e8825bb0 | 1363 | /* If not defined, pick an appropriate default for the offset of dynamically |
1364 | allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS, | |
1365 | REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE. */ | |
c925694c | 1366 | |
e8825bb0 | 1367 | #ifndef STACK_DYNAMIC_OFFSET |
a8636638 | 1368 | |
e8825bb0 | 1369 | /* The bottom of the stack points to the actual arguments. If |
1370 | REG_PARM_STACK_SPACE is defined, this includes the space for the register | |
1371 | parameters. However, if OUTGOING_REG_PARM_STACK space is not defined, | |
1372 | stack space for register parameters is not pushed by the caller, but | |
1373 | rather part of the fixed stack areas and hence not included in | |
abe32cce | 1374 | `crtl->outgoing_args_size'. Nevertheless, we must allow |
e8825bb0 | 1375 | for it when allocating stack dynamic objects. */ |
a8636638 | 1376 | |
63c68695 | 1377 | #if defined(REG_PARM_STACK_SPACE) |
e8825bb0 | 1378 | #define STACK_DYNAMIC_OFFSET(FNDECL) \ |
1379 | ((ACCUMULATE_OUTGOING_ARGS \ | |
abe32cce | 1380 | ? (crtl->outgoing_args_size \ |
22c61100 | 1381 | + (OUTGOING_REG_PARM_STACK_SPACE ((!(FNDECL) ? NULL_TREE : TREE_TYPE (FNDECL))) ? 0 \ |
1382 | : REG_PARM_STACK_SPACE (FNDECL))) \ | |
63c68695 | 1383 | : 0) + (STACK_POINTER_OFFSET)) |
e8825bb0 | 1384 | #else |
1385 | #define STACK_DYNAMIC_OFFSET(FNDECL) \ | |
abe32cce | 1386 | ((ACCUMULATE_OUTGOING_ARGS ? crtl->outgoing_args_size : 0) \ |
e8825bb0 | 1387 | + (STACK_POINTER_OFFSET)) |
1388 | #endif | |
1389 | #endif | |
f678883b | 1390 | |
e3d5af87 | 1391 | \f |
f15c4004 | 1392 | /* Given a piece of RTX and a pointer to a HOST_WIDE_INT, if the RTX |
1393 | is a virtual register, return the equivalent hard register and set the | |
1394 | offset indirectly through the pointer. Otherwise, return 0. */ | |
897b77d6 | 1395 | |
f15c4004 | 1396 | static rtx |
1397 | instantiate_new_reg (rtx x, HOST_WIDE_INT *poffset) | |
897b77d6 | 1398 | { |
f4e36c33 | 1399 | rtx new_rtx; |
f15c4004 | 1400 | HOST_WIDE_INT offset; |
897b77d6 | 1401 | |
f15c4004 | 1402 | if (x == virtual_incoming_args_rtx) |
27a7a23a | 1403 | { |
f6754469 | 1404 | if (stack_realign_drap) |
27a7a23a | 1405 | { |
f6754469 | 1406 | /* Replace virtual_incoming_args_rtx with internal arg |
1407 | pointer if DRAP is used to realign stack. */ | |
f4e36c33 | 1408 | new_rtx = crtl->args.internal_arg_pointer; |
27a7a23a | 1409 | offset = 0; |
1410 | } | |
1411 | else | |
f4e36c33 | 1412 | new_rtx = arg_pointer_rtx, offset = in_arg_offset; |
27a7a23a | 1413 | } |
f15c4004 | 1414 | else if (x == virtual_stack_vars_rtx) |
f4e36c33 | 1415 | new_rtx = frame_pointer_rtx, offset = var_offset; |
f15c4004 | 1416 | else if (x == virtual_stack_dynamic_rtx) |
f4e36c33 | 1417 | new_rtx = stack_pointer_rtx, offset = dynamic_offset; |
f15c4004 | 1418 | else if (x == virtual_outgoing_args_rtx) |
f4e36c33 | 1419 | new_rtx = stack_pointer_rtx, offset = out_arg_offset; |
f15c4004 | 1420 | else if (x == virtual_cfa_rtx) |
da72c083 | 1421 | { |
1422 | #ifdef FRAME_POINTER_CFA_OFFSET | |
f4e36c33 | 1423 | new_rtx = frame_pointer_rtx; |
da72c083 | 1424 | #else |
f4e36c33 | 1425 | new_rtx = arg_pointer_rtx; |
da72c083 | 1426 | #endif |
1427 | offset = cfa_offset; | |
1428 | } | |
60778e62 | 1429 | else if (x == virtual_preferred_stack_boundary_rtx) |
1430 | { | |
1431 | new_rtx = GEN_INT (crtl->preferred_stack_boundary / BITS_PER_UNIT); | |
1432 | offset = 0; | |
1433 | } | |
f15c4004 | 1434 | else |
1435 | return NULL_RTX; | |
897b77d6 | 1436 | |
f15c4004 | 1437 | *poffset = offset; |
f4e36c33 | 1438 | return new_rtx; |
897b77d6 | 1439 | } |
1440 | ||
f15c4004 | 1441 | /* A subroutine of instantiate_virtual_regs, called via for_each_rtx. |
1442 | Instantiate any virtual registers present inside of *LOC. The expression | |
1443 | is simplified, as much as possible, but is not to be considered "valid" | |
1444 | in any sense implied by the target. If any change is made, set CHANGED | |
1445 | to true. */ | |
897b77d6 | 1446 | |
f15c4004 | 1447 | static int |
1448 | instantiate_virtual_regs_in_rtx (rtx *loc, void *data) | |
897b77d6 | 1449 | { |
f15c4004 | 1450 | HOST_WIDE_INT offset; |
1451 | bool *changed = (bool *) data; | |
f4e36c33 | 1452 | rtx x, new_rtx; |
897b77d6 | 1453 | |
f15c4004 | 1454 | x = *loc; |
1455 | if (x == 0) | |
1456 | return 0; | |
1457 | ||
1458 | switch (GET_CODE (x)) | |
897b77d6 | 1459 | { |
f15c4004 | 1460 | case REG: |
f4e36c33 | 1461 | new_rtx = instantiate_new_reg (x, &offset); |
1462 | if (new_rtx) | |
f15c4004 | 1463 | { |
29c05e22 | 1464 | *loc = plus_constant (GET_MODE (x), new_rtx, offset); |
f15c4004 | 1465 | if (changed) |
1466 | *changed = true; | |
1467 | } | |
1468 | return -1; | |
1469 | ||
1470 | case PLUS: | |
f4e36c33 | 1471 | new_rtx = instantiate_new_reg (XEXP (x, 0), &offset); |
1472 | if (new_rtx) | |
f15c4004 | 1473 | { |
29c05e22 | 1474 | new_rtx = plus_constant (GET_MODE (x), new_rtx, offset); |
f4e36c33 | 1475 | *loc = simplify_gen_binary (PLUS, GET_MODE (x), new_rtx, XEXP (x, 1)); |
f15c4004 | 1476 | if (changed) |
1477 | *changed = true; | |
1478 | return -1; | |
1479 | } | |
997d68fe | 1480 | |
f15c4004 | 1481 | /* FIXME -- from old code */ |
1482 | /* If we have (plus (subreg (virtual-reg)) (const_int)), we know | |
1483 | we can commute the PLUS and SUBREG because pointers into the | |
1484 | frame are well-behaved. */ | |
1485 | break; | |
5970b26a | 1486 | |
f15c4004 | 1487 | default: |
1488 | break; | |
897b77d6 | 1489 | } |
1490 | ||
f15c4004 | 1491 | return 0; |
897b77d6 | 1492 | } |
1493 | ||
f15c4004 | 1494 | /* A subroutine of instantiate_virtual_regs_in_insn. Return true if X |
1495 | matches the predicate for insn CODE operand OPERAND. */ | |
897b77d6 | 1496 | |
f15c4004 | 1497 | static int |
1498 | safe_insn_predicate (int code, int operand, rtx x) | |
897b77d6 | 1499 | { |
39c56a89 | 1500 | return code < 0 || insn_operand_matches ((enum insn_code) code, operand, x); |
f15c4004 | 1501 | } |
6d0423b8 | 1502 | |
f15c4004 | 1503 | /* A subroutine of instantiate_virtual_regs. Instantiate any virtual |
1504 | registers present inside of insn. The result will be a valid insn. */ | |
6d0423b8 | 1505 | |
1506 | static void | |
f15c4004 | 1507 | instantiate_virtual_regs_in_insn (rtx insn) |
6d0423b8 | 1508 | { |
f15c4004 | 1509 | HOST_WIDE_INT offset; |
1510 | int insn_code, i; | |
27ca6129 | 1511 | bool any_change = false; |
f4e36c33 | 1512 | rtx set, new_rtx, x, seq; |
00dfb616 | 1513 | |
f15c4004 | 1514 | /* There are some special cases to be handled first. */ |
1515 | set = single_set (insn); | |
1516 | if (set) | |
00dfb616 | 1517 | { |
f15c4004 | 1518 | /* We're allowed to assign to a virtual register. This is interpreted |
1519 | to mean that the underlying register gets assigned the inverse | |
1520 | transformation. This is used, for example, in the handling of | |
1521 | non-local gotos. */ | |
f4e36c33 | 1522 | new_rtx = instantiate_new_reg (SET_DEST (set), &offset); |
1523 | if (new_rtx) | |
f15c4004 | 1524 | { |
1525 | start_sequence (); | |
00dfb616 | 1526 | |
f15c4004 | 1527 | for_each_rtx (&SET_SRC (set), instantiate_virtual_regs_in_rtx, NULL); |
f4e36c33 | 1528 | x = simplify_gen_binary (PLUS, GET_MODE (new_rtx), SET_SRC (set), |
f15c4004 | 1529 | GEN_INT (-offset)); |
f4e36c33 | 1530 | x = force_operand (x, new_rtx); |
1531 | if (x != new_rtx) | |
1532 | emit_move_insn (new_rtx, x); | |
6d0423b8 | 1533 | |
f15c4004 | 1534 | seq = get_insns (); |
1535 | end_sequence (); | |
6d0423b8 | 1536 | |
f15c4004 | 1537 | emit_insn_before (seq, insn); |
1538 | delete_insn (insn); | |
1539 | return; | |
1540 | } | |
6d0423b8 | 1541 | |
f15c4004 | 1542 | /* Handle a straight copy from a virtual register by generating a |
1543 | new add insn. The difference between this and falling through | |
1544 | to the generic case is avoiding a new pseudo and eliminating a | |
1545 | move insn in the initial rtl stream. */ | |
f4e36c33 | 1546 | new_rtx = instantiate_new_reg (SET_SRC (set), &offset); |
1547 | if (new_rtx && offset != 0 | |
f15c4004 | 1548 | && REG_P (SET_DEST (set)) |
1549 | && REGNO (SET_DEST (set)) > LAST_VIRTUAL_REGISTER) | |
1550 | { | |
1551 | start_sequence (); | |
6d0423b8 | 1552 | |
f15c4004 | 1553 | x = expand_simple_binop (GET_MODE (SET_DEST (set)), PLUS, |
f4e36c33 | 1554 | new_rtx, GEN_INT (offset), SET_DEST (set), |
f15c4004 | 1555 | 1, OPTAB_LIB_WIDEN); |
1556 | if (x != SET_DEST (set)) | |
1557 | emit_move_insn (SET_DEST (set), x); | |
02e7a332 | 1558 | |
f15c4004 | 1559 | seq = get_insns (); |
1560 | end_sequence (); | |
e3f529ab | 1561 | |
f15c4004 | 1562 | emit_insn_before (seq, insn); |
1563 | delete_insn (insn); | |
e3f529ab | 1564 | return; |
f15c4004 | 1565 | } |
6d0423b8 | 1566 | |
f15c4004 | 1567 | extract_insn (insn); |
27ca6129 | 1568 | insn_code = INSN_CODE (insn); |
6d0423b8 | 1569 | |
f15c4004 | 1570 | /* Handle a plus involving a virtual register by determining if the |
1571 | operands remain valid if they're modified in place. */ | |
1572 | if (GET_CODE (SET_SRC (set)) == PLUS | |
1573 | && recog_data.n_operands >= 3 | |
1574 | && recog_data.operand_loc[1] == &XEXP (SET_SRC (set), 0) | |
1575 | && recog_data.operand_loc[2] == &XEXP (SET_SRC (set), 1) | |
971ba038 | 1576 | && CONST_INT_P (recog_data.operand[2]) |
f4e36c33 | 1577 | && (new_rtx = instantiate_new_reg (recog_data.operand[1], &offset))) |
f15c4004 | 1578 | { |
1579 | offset += INTVAL (recog_data.operand[2]); | |
6d0423b8 | 1580 | |
f15c4004 | 1581 | /* If the sum is zero, then replace with a plain move. */ |
27ca6129 | 1582 | if (offset == 0 |
1583 | && REG_P (SET_DEST (set)) | |
1584 | && REGNO (SET_DEST (set)) > LAST_VIRTUAL_REGISTER) | |
f15c4004 | 1585 | { |
1586 | start_sequence (); | |
f4e36c33 | 1587 | emit_move_insn (SET_DEST (set), new_rtx); |
f15c4004 | 1588 | seq = get_insns (); |
1589 | end_sequence (); | |
bc17f7a4 | 1590 | |
f15c4004 | 1591 | emit_insn_before (seq, insn); |
1592 | delete_insn (insn); | |
1593 | return; | |
1594 | } | |
bc17f7a4 | 1595 | |
f15c4004 | 1596 | x = gen_int_mode (offset, recog_data.operand_mode[2]); |
f15c4004 | 1597 | |
1598 | /* Using validate_change and apply_change_group here leaves | |
1599 | recog_data in an invalid state. Since we know exactly what | |
1600 | we want to check, do those two by hand. */ | |
f4e36c33 | 1601 | if (safe_insn_predicate (insn_code, 1, new_rtx) |
f15c4004 | 1602 | && safe_insn_predicate (insn_code, 2, x)) |
1603 | { | |
f4e36c33 | 1604 | *recog_data.operand_loc[1] = recog_data.operand[1] = new_rtx; |
f15c4004 | 1605 | *recog_data.operand_loc[2] = recog_data.operand[2] = x; |
1606 | any_change = true; | |
27ca6129 | 1607 | |
1608 | /* Fall through into the regular operand fixup loop in | |
1609 | order to take care of operands other than 1 and 2. */ | |
f15c4004 | 1610 | } |
1611 | } | |
1612 | } | |
bc17f7a4 | 1613 | else |
27ca6129 | 1614 | { |
1615 | extract_insn (insn); | |
1616 | insn_code = INSN_CODE (insn); | |
1617 | } | |
dd79abfb | 1618 | |
f15c4004 | 1619 | /* In the general case, we expect virtual registers to appear only in |
1620 | operands, and then only as either bare registers or inside memories. */ | |
1621 | for (i = 0; i < recog_data.n_operands; ++i) | |
1622 | { | |
1623 | x = recog_data.operand[i]; | |
1624 | switch (GET_CODE (x)) | |
1625 | { | |
1626 | case MEM: | |
1627 | { | |
1628 | rtx addr = XEXP (x, 0); | |
1629 | bool changed = false; | |
1630 | ||
1631 | for_each_rtx (&addr, instantiate_virtual_regs_in_rtx, &changed); | |
1632 | if (!changed) | |
1633 | continue; | |
1634 | ||
1635 | start_sequence (); | |
1636 | x = replace_equiv_address (x, addr); | |
7e507322 | 1637 | /* It may happen that the address with the virtual reg |
1638 | was valid (e.g. based on the virtual stack reg, which might | |
1639 | be acceptable to the predicates with all offsets), whereas | |
1640 | the address now isn't anymore, for instance when the address | |
1641 | is still offsetted, but the base reg isn't virtual-stack-reg | |
1642 | anymore. Below we would do a force_reg on the whole operand, | |
1643 | but this insn might actually only accept memory. Hence, | |
1644 | before doing that last resort, try to reload the address into | |
1645 | a register, so this operand stays a MEM. */ | |
1646 | if (!safe_insn_predicate (insn_code, i, x)) | |
1647 | { | |
1648 | addr = force_reg (GET_MODE (addr), addr); | |
1649 | x = replace_equiv_address (x, addr); | |
1650 | } | |
f15c4004 | 1651 | seq = get_insns (); |
1652 | end_sequence (); | |
1653 | if (seq) | |
1654 | emit_insn_before (seq, insn); | |
1655 | } | |
1656 | break; | |
1657 | ||
1658 | case REG: | |
f4e36c33 | 1659 | new_rtx = instantiate_new_reg (x, &offset); |
1660 | if (new_rtx == NULL) | |
f15c4004 | 1661 | continue; |
1662 | if (offset == 0) | |
f4e36c33 | 1663 | x = new_rtx; |
f15c4004 | 1664 | else |
1665 | { | |
1666 | start_sequence (); | |
897b77d6 | 1667 | |
f15c4004 | 1668 | /* Careful, special mode predicates may have stuff in |
1669 | insn_data[insn_code].operand[i].mode that isn't useful | |
1670 | to us for computing a new value. */ | |
1671 | /* ??? Recognize address_operand and/or "p" constraints | |
1672 | to see if (plus new offset) is a valid before we put | |
1673 | this through expand_simple_binop. */ | |
f4e36c33 | 1674 | x = expand_simple_binop (GET_MODE (x), PLUS, new_rtx, |
f15c4004 | 1675 | GEN_INT (offset), NULL_RTX, |
1676 | 1, OPTAB_LIB_WIDEN); | |
1677 | seq = get_insns (); | |
1678 | end_sequence (); | |
1679 | emit_insn_before (seq, insn); | |
1680 | } | |
1681 | break; | |
897b77d6 | 1682 | |
f15c4004 | 1683 | case SUBREG: |
f4e36c33 | 1684 | new_rtx = instantiate_new_reg (SUBREG_REG (x), &offset); |
1685 | if (new_rtx == NULL) | |
f15c4004 | 1686 | continue; |
1687 | if (offset != 0) | |
1688 | { | |
1689 | start_sequence (); | |
f4e36c33 | 1690 | new_rtx = expand_simple_binop (GET_MODE (new_rtx), PLUS, new_rtx, |
f15c4004 | 1691 | GEN_INT (offset), NULL_RTX, |
1692 | 1, OPTAB_LIB_WIDEN); | |
1693 | seq = get_insns (); | |
1694 | end_sequence (); | |
1695 | emit_insn_before (seq, insn); | |
1696 | } | |
f4e36c33 | 1697 | x = simplify_gen_subreg (recog_data.operand_mode[i], new_rtx, |
1698 | GET_MODE (new_rtx), SUBREG_BYTE (x)); | |
024f0a8a | 1699 | gcc_assert (x); |
f15c4004 | 1700 | break; |
897b77d6 | 1701 | |
f15c4004 | 1702 | default: |
1703 | continue; | |
1704 | } | |
897b77d6 | 1705 | |
f15c4004 | 1706 | /* At this point, X contains the new value for the operand. |
1707 | Validate the new value vs the insn predicate. Note that | |
1708 | asm insns will have insn_code -1 here. */ | |
1709 | if (!safe_insn_predicate (insn_code, i, x)) | |
c5159852 | 1710 | { |
1711 | start_sequence (); | |
83b6c9db | 1712 | if (REG_P (x)) |
1713 | { | |
1714 | gcc_assert (REGNO (x) <= LAST_VIRTUAL_REGISTER); | |
1715 | x = copy_to_reg (x); | |
1716 | } | |
1717 | else | |
1718 | x = force_reg (insn_data[insn_code].operand[i].mode, x); | |
c5159852 | 1719 | seq = get_insns (); |
1720 | end_sequence (); | |
1721 | if (seq) | |
1722 | emit_insn_before (seq, insn); | |
1723 | } | |
897b77d6 | 1724 | |
f15c4004 | 1725 | *recog_data.operand_loc[i] = recog_data.operand[i] = x; |
1726 | any_change = true; | |
1727 | } | |
897b77d6 | 1728 | |
f15c4004 | 1729 | if (any_change) |
1730 | { | |
1731 | /* Propagate operand changes into the duplicates. */ | |
1732 | for (i = 0; i < recog_data.n_dups; ++i) | |
1733 | *recog_data.dup_loc[i] | |
cdf37bc1 | 1734 | = copy_rtx (recog_data.operand[(unsigned)recog_data.dup_num[i]]); |
dd79abfb | 1735 | |
f15c4004 | 1736 | /* Force re-recognition of the instruction for validation. */ |
1737 | INSN_CODE (insn) = -1; | |
1738 | } | |
897b77d6 | 1739 | |
f15c4004 | 1740 | if (asm_noperands (PATTERN (insn)) >= 0) |
897b77d6 | 1741 | { |
f15c4004 | 1742 | if (!check_asm_operands (PATTERN (insn))) |
897b77d6 | 1743 | { |
f15c4004 | 1744 | error_for_asm (insn, "impossible constraint in %<asm%>"); |
fb10e416 | 1745 | delete_insn_and_edges (insn); |
f15c4004 | 1746 | } |
1747 | } | |
1748 | else | |
1749 | { | |
1750 | if (recog_memoized (insn) < 0) | |
1751 | fatal_insn_not_found (insn); | |
1752 | } | |
1753 | } | |
155b05dc | 1754 | |
f15c4004 | 1755 | /* Subroutine of instantiate_decls. Given RTL representing a decl, |
1756 | do any instantiation required. */ | |
155b05dc | 1757 | |
bc5e6ea1 | 1758 | void |
1759 | instantiate_decl_rtl (rtx x) | |
f15c4004 | 1760 | { |
1761 | rtx addr; | |
897b77d6 | 1762 | |
f15c4004 | 1763 | if (x == 0) |
1764 | return; | |
897b77d6 | 1765 | |
f15c4004 | 1766 | /* If this is a CONCAT, recurse for the pieces. */ |
1767 | if (GET_CODE (x) == CONCAT) | |
1768 | { | |
bc5e6ea1 | 1769 | instantiate_decl_rtl (XEXP (x, 0)); |
1770 | instantiate_decl_rtl (XEXP (x, 1)); | |
f15c4004 | 1771 | return; |
1772 | } | |
897b77d6 | 1773 | |
f15c4004 | 1774 | /* If this is not a MEM, no need to do anything. Similarly if the |
1775 | address is a constant or a register that is not a virtual register. */ | |
1776 | if (!MEM_P (x)) | |
1777 | return; | |
897b77d6 | 1778 | |
f15c4004 | 1779 | addr = XEXP (x, 0); |
1780 | if (CONSTANT_P (addr) | |
1781 | || (REG_P (addr) | |
1782 | && (REGNO (addr) < FIRST_VIRTUAL_REGISTER | |
1783 | || REGNO (addr) > LAST_VIRTUAL_REGISTER))) | |
1784 | return; | |
897b77d6 | 1785 | |
f15c4004 | 1786 | for_each_rtx (&XEXP (x, 0), instantiate_virtual_regs_in_rtx, NULL); |
1787 | } | |
897b77d6 | 1788 | |
9338678e | 1789 | /* Helper for instantiate_decls called via walk_tree: Process all decls |
1790 | in the given DECL_VALUE_EXPR. */ | |
1791 | ||
1792 | static tree | |
1793 | instantiate_expr (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED) | |
1794 | { | |
1795 | tree t = *tp; | |
75a70cf9 | 1796 | if (! EXPR_P (t)) |
9338678e | 1797 | { |
1798 | *walk_subtrees = 0; | |
95b985e5 | 1799 | if (DECL_P (t)) |
1800 | { | |
1801 | if (DECL_RTL_SET_P (t)) | |
1802 | instantiate_decl_rtl (DECL_RTL (t)); | |
1803 | if (TREE_CODE (t) == PARM_DECL && DECL_NAMELESS (t) | |
1804 | && DECL_INCOMING_RTL (t)) | |
1805 | instantiate_decl_rtl (DECL_INCOMING_RTL (t)); | |
1806 | if ((TREE_CODE (t) == VAR_DECL | |
1807 | || TREE_CODE (t) == RESULT_DECL) | |
1808 | && DECL_HAS_VALUE_EXPR_P (t)) | |
1809 | { | |
1810 | tree v = DECL_VALUE_EXPR (t); | |
1811 | walk_tree (&v, instantiate_expr, NULL, NULL); | |
1812 | } | |
1813 | } | |
9338678e | 1814 | } |
1815 | return NULL; | |
1816 | } | |
1817 | ||
f15c4004 | 1818 | /* Subroutine of instantiate_decls: Process all decls in the given |
1819 | BLOCK node and all its subblocks. */ | |
897b77d6 | 1820 | |
f15c4004 | 1821 | static void |
1822 | instantiate_decls_1 (tree let) | |
1823 | { | |
1824 | tree t; | |
897b77d6 | 1825 | |
1767a056 | 1826 | for (t = BLOCK_VARS (let); t; t = DECL_CHAIN (t)) |
9338678e | 1827 | { |
1828 | if (DECL_RTL_SET_P (t)) | |
bc5e6ea1 | 1829 | instantiate_decl_rtl (DECL_RTL (t)); |
9338678e | 1830 | if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t)) |
1831 | { | |
1832 | tree v = DECL_VALUE_EXPR (t); | |
1833 | walk_tree (&v, instantiate_expr, NULL, NULL); | |
1834 | } | |
1835 | } | |
897b77d6 | 1836 | |
f15c4004 | 1837 | /* Process all subblocks. */ |
93110716 | 1838 | for (t = BLOCK_SUBBLOCKS (let); t; t = BLOCK_CHAIN (t)) |
f15c4004 | 1839 | instantiate_decls_1 (t); |
1840 | } | |
897b77d6 | 1841 | |
f15c4004 | 1842 | /* Scan all decls in FNDECL (both variables and parameters) and instantiate |
1843 | all virtual registers in their DECL_RTL's. */ | |
897b77d6 | 1844 | |
f15c4004 | 1845 | static void |
1846 | instantiate_decls (tree fndecl) | |
1847 | { | |
2ab2ce89 | 1848 | tree decl; |
1849 | unsigned ix; | |
897b77d6 | 1850 | |
f15c4004 | 1851 | /* Process all parameters of the function. */ |
1767a056 | 1852 | for (decl = DECL_ARGUMENTS (fndecl); decl; decl = DECL_CHAIN (decl)) |
f15c4004 | 1853 | { |
bc5e6ea1 | 1854 | instantiate_decl_rtl (DECL_RTL (decl)); |
1855 | instantiate_decl_rtl (DECL_INCOMING_RTL (decl)); | |
9338678e | 1856 | if (DECL_HAS_VALUE_EXPR_P (decl)) |
1857 | { | |
1858 | tree v = DECL_VALUE_EXPR (decl); | |
1859 | walk_tree (&v, instantiate_expr, NULL, NULL); | |
1860 | } | |
f15c4004 | 1861 | } |
a51c8974 | 1862 | |
95b985e5 | 1863 | if ((decl = DECL_RESULT (fndecl)) |
1864 | && TREE_CODE (decl) == RESULT_DECL) | |
1865 | { | |
1866 | if (DECL_RTL_SET_P (decl)) | |
1867 | instantiate_decl_rtl (DECL_RTL (decl)); | |
1868 | if (DECL_HAS_VALUE_EXPR_P (decl)) | |
1869 | { | |
1870 | tree v = DECL_VALUE_EXPR (decl); | |
1871 | walk_tree (&v, instantiate_expr, NULL, NULL); | |
1872 | } | |
1873 | } | |
1874 | ||
f15c4004 | 1875 | /* Now process all variables defined in the function or its subblocks. */ |
1876 | instantiate_decls_1 (DECL_INITIAL (fndecl)); | |
78fa9ba7 | 1877 | |
2ab2ce89 | 1878 | FOR_EACH_LOCAL_DECL (cfun, ix, decl) |
1879 | if (DECL_RTL_SET_P (decl)) | |
1880 | instantiate_decl_rtl (DECL_RTL (decl)); | |
1881 | VEC_free (tree, gc, cfun->local_decls); | |
f15c4004 | 1882 | } |
897b77d6 | 1883 | |
f15c4004 | 1884 | /* Pass through the INSNS of function FNDECL and convert virtual register |
1885 | references to hard register references. */ | |
897b77d6 | 1886 | |
2a1990e9 | 1887 | static unsigned int |
f15c4004 | 1888 | instantiate_virtual_regs (void) |
1889 | { | |
ca8a2945 | 1890 | rtx insn; |
897b77d6 | 1891 | |
f15c4004 | 1892 | /* Compute the offsets to use for this function. */ |
1893 | in_arg_offset = FIRST_PARM_OFFSET (current_function_decl); | |
1894 | var_offset = STARTING_FRAME_OFFSET; | |
1895 | dynamic_offset = STACK_DYNAMIC_OFFSET (current_function_decl); | |
1896 | out_arg_offset = STACK_POINTER_OFFSET; | |
da72c083 | 1897 | #ifdef FRAME_POINTER_CFA_OFFSET |
1898 | cfa_offset = FRAME_POINTER_CFA_OFFSET (current_function_decl); | |
1899 | #else | |
f15c4004 | 1900 | cfa_offset = ARG_POINTER_CFA_OFFSET (current_function_decl); |
da72c083 | 1901 | #endif |
0dbd1c74 | 1902 | |
f15c4004 | 1903 | /* Initialize recognition, indicating that volatile is OK. */ |
1904 | init_recog (); | |
897b77d6 | 1905 | |
f15c4004 | 1906 | /* Scan through all the insns, instantiating every virtual register still |
1907 | present. */ | |
ca8a2945 | 1908 | for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) |
1909 | if (INSN_P (insn)) | |
1910 | { | |
1911 | /* These patterns in the instruction stream can never be recognized. | |
1912 | Fortunately, they shouldn't contain virtual registers either. */ | |
1913 | if (GET_CODE (PATTERN (insn)) == USE | |
1914 | || GET_CODE (PATTERN (insn)) == CLOBBER | |
1915 | || GET_CODE (PATTERN (insn)) == ADDR_VEC | |
1916 | || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC | |
1917 | || GET_CODE (PATTERN (insn)) == ASM_INPUT) | |
1918 | continue; | |
1919 | else if (DEBUG_INSN_P (insn)) | |
1920 | for_each_rtx (&INSN_VAR_LOCATION (insn), | |
1921 | instantiate_virtual_regs_in_rtx, NULL); | |
1922 | else | |
1923 | instantiate_virtual_regs_in_insn (insn); | |
201f6961 | 1924 | |
ca8a2945 | 1925 | if (INSN_DELETED_P (insn)) |
1926 | continue; | |
d304b9e1 | 1927 | |
ca8a2945 | 1928 | for_each_rtx (®_NOTES (insn), instantiate_virtual_regs_in_rtx, NULL); |
201f6961 | 1929 | |
ca8a2945 | 1930 | /* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE. */ |
1931 | if (CALL_P (insn)) | |
1932 | for_each_rtx (&CALL_INSN_FUNCTION_USAGE (insn), | |
1933 | instantiate_virtual_regs_in_rtx, NULL); | |
1934 | } | |
897b77d6 | 1935 | |
f15c4004 | 1936 | /* Instantiate the virtual registers in the DECLs for debugging purposes. */ |
1937 | instantiate_decls (current_function_decl); | |
1938 | ||
bc5e6ea1 | 1939 | targetm.instantiate_decls (); |
1940 | ||
f15c4004 | 1941 | /* Indicate that, from now on, assign_stack_local should use |
1942 | frame_pointer_rtx. */ | |
1943 | virtuals_instantiated = 1; | |
990495a7 | 1944 | |
2a1990e9 | 1945 | return 0; |
897b77d6 | 1946 | } |
77fce4cd | 1947 | |
20099e35 | 1948 | struct rtl_opt_pass pass_instantiate_virtual_regs = |
77fce4cd | 1949 | { |
20099e35 | 1950 | { |
1951 | RTL_PASS, | |
228967a9 | 1952 | "vregs", /* name */ |
77fce4cd | 1953 | NULL, /* gate */ |
1954 | instantiate_virtual_regs, /* execute */ | |
1955 | NULL, /* sub */ | |
1956 | NULL, /* next */ | |
1957 | 0, /* static_pass_number */ | |
0b1615c1 | 1958 | TV_NONE, /* tv_id */ |
ca8a2945 | 1959 | 0, /* properties_required */ |
77fce4cd | 1960 | 0, /* properties_provided */ |
1961 | 0, /* properties_destroyed */ | |
1962 | 0, /* todo_flags_start */ | |
771e2890 | 1963 | 0 /* todo_flags_finish */ |
20099e35 | 1964 | } |
77fce4cd | 1965 | }; |
1966 | ||
897b77d6 | 1967 | \f |
8f48fc81 | 1968 | /* Return 1 if EXP is an aggregate type (or a value with aggregate type). |
1969 | This means a type for which function calls must pass an address to the | |
1970 | function or get an address back from the function. | |
1971 | EXP may be a type node or an expression (whose type is tested). */ | |
897b77d6 | 1972 | |
1973 | int | |
fb80456a | 1974 | aggregate_value_p (const_tree exp, const_tree fntype) |
897b77d6 | 1975 | { |
4cd5bb61 | 1976 | const_tree type = (TYPE_P (exp)) ? exp : TREE_TYPE (exp); |
d5c7cfd2 | 1977 | int i, regno, nregs; |
1978 | rtx reg; | |
9308e976 | 1979 | |
45550790 | 1980 | if (fntype) |
1981 | switch (TREE_CODE (fntype)) | |
1982 | { | |
1983 | case CALL_EXPR: | |
4cd5bb61 | 1984 | { |
1985 | tree fndecl = get_callee_fndecl (fntype); | |
1986 | fntype = (fndecl | |
1987 | ? TREE_TYPE (fndecl) | |
1988 | : TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (fntype)))); | |
1989 | } | |
45550790 | 1990 | break; |
1991 | case FUNCTION_DECL: | |
4cd5bb61 | 1992 | fntype = TREE_TYPE (fntype); |
45550790 | 1993 | break; |
1994 | case FUNCTION_TYPE: | |
1995 | case METHOD_TYPE: | |
1996 | break; | |
1997 | case IDENTIFIER_NODE: | |
4cd5bb61 | 1998 | fntype = NULL_TREE; |
45550790 | 1999 | break; |
2000 | default: | |
4cd5bb61 | 2001 | /* We don't expect other tree types here. */ |
fdada98f | 2002 | gcc_unreachable (); |
45550790 | 2003 | } |
2004 | ||
4cd5bb61 | 2005 | if (VOID_TYPE_P (type)) |
2c8db4fe | 2006 | return 0; |
6f18455e | 2007 | |
8df5a43d | 2008 | /* If a record should be passed the same as its first (and only) member |
2009 | don't pass it as an aggregate. */ | |
2010 | if (TREE_CODE (type) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type)) | |
2011 | return aggregate_value_p (first_field (type), fntype); | |
2012 | ||
806e4c12 | 2013 | /* If the front end has decided that this needs to be passed by |
2014 | reference, do so. */ | |
2015 | if ((TREE_CODE (exp) == PARM_DECL || TREE_CODE (exp) == RESULT_DECL) | |
2016 | && DECL_BY_REFERENCE (exp)) | |
2017 | return 1; | |
6f18455e | 2018 | |
4cd5bb61 | 2019 | /* Function types that are TREE_ADDRESSABLE force return in memory. */ |
2020 | if (fntype && TREE_ADDRESSABLE (fntype)) | |
6f18455e | 2021 | return 1; |
48e1416a | 2022 | |
ad87de1e | 2023 | /* Types that are TREE_ADDRESSABLE must be constructed in memory, |
79f1a380 | 2024 | and thus can't be returned in registers. */ |
2025 | if (TREE_ADDRESSABLE (type)) | |
2026 | return 1; | |
4cd5bb61 | 2027 | |
727a13df | 2028 | if (flag_pcc_struct_return && AGGREGATE_TYPE_P (type)) |
897b77d6 | 2029 | return 1; |
4cd5bb61 | 2030 | |
2031 | if (targetm.calls.return_in_memory (type, fntype)) | |
2032 | return 1; | |
2033 | ||
d5c7cfd2 | 2034 | /* Make sure we have suitable call-clobbered regs to return |
2035 | the value in; if not, we must return it in memory. */ | |
46b3ff29 | 2036 | reg = hard_function_value (type, 0, fntype, 0); |
84d69b33 | 2037 | |
2038 | /* If we have something other than a REG (e.g. a PARALLEL), then assume | |
2039 | it is OK. */ | |
8ad4c111 | 2040 | if (!REG_P (reg)) |
84d69b33 | 2041 | return 0; |
2042 | ||
d5c7cfd2 | 2043 | regno = REGNO (reg); |
67d6c12b | 2044 | nregs = hard_regno_nregs[regno][TYPE_MODE (type)]; |
d5c7cfd2 | 2045 | for (i = 0; i < nregs; i++) |
2046 | if (! call_used_regs[regno + i]) | |
2047 | return 1; | |
4cd5bb61 | 2048 | |
897b77d6 | 2049 | return 0; |
2050 | } | |
2051 | \f | |
e8825bb0 | 2052 | /* Return true if we should assign DECL a pseudo register; false if it |
2053 | should live on the local stack. */ | |
2054 | ||
2055 | bool | |
b7bf20db | 2056 | use_register_for_decl (const_tree decl) |
e8825bb0 | 2057 | { |
658e203c | 2058 | if (!targetm.calls.allocate_stack_slots_for_args()) |
2059 | return true; | |
48e1416a | 2060 | |
e8825bb0 | 2061 | /* Honor volatile. */ |
2062 | if (TREE_SIDE_EFFECTS (decl)) | |
2063 | return false; | |
2064 | ||
2065 | /* Honor addressability. */ | |
2066 | if (TREE_ADDRESSABLE (decl)) | |
2067 | return false; | |
2068 | ||
2069 | /* Only register-like things go in registers. */ | |
2070 | if (DECL_MODE (decl) == BLKmode) | |
2071 | return false; | |
2072 | ||
2073 | /* If -ffloat-store specified, don't put explicit float variables | |
2074 | into registers. */ | |
2075 | /* ??? This should be checked after DECL_ARTIFICIAL, but tree-ssa | |
2076 | propagates values across these stores, and it probably shouldn't. */ | |
2077 | if (flag_float_store && FLOAT_TYPE_P (TREE_TYPE (decl))) | |
2078 | return false; | |
2079 | ||
553acd9c | 2080 | /* If we're not interested in tracking debugging information for |
2081 | this decl, then we can certainly put it in a register. */ | |
2082 | if (DECL_IGNORED_P (decl)) | |
e8825bb0 | 2083 | return true; |
2084 | ||
f24ccada | 2085 | if (optimize) |
2086 | return true; | |
2087 | ||
2088 | if (!DECL_REGISTER (decl)) | |
2089 | return false; | |
2090 | ||
2091 | switch (TREE_CODE (TREE_TYPE (decl))) | |
2092 | { | |
2093 | case RECORD_TYPE: | |
2094 | case UNION_TYPE: | |
2095 | case QUAL_UNION_TYPE: | |
2096 | /* When not optimizing, disregard register keyword for variables with | |
2097 | types containing methods, otherwise the methods won't be callable | |
2098 | from the debugger. */ | |
2099 | if (TYPE_METHODS (TREE_TYPE (decl))) | |
2100 | return false; | |
2101 | break; | |
2102 | default: | |
2103 | break; | |
2104 | } | |
2105 | ||
2106 | return true; | |
e8825bb0 | 2107 | } |
2108 | ||
cc9b8628 | 2109 | /* Return true if TYPE should be passed by invisible reference. */ |
2110 | ||
2111 | bool | |
b981d932 | 2112 | pass_by_reference (CUMULATIVE_ARGS *ca, enum machine_mode mode, |
2113 | tree type, bool named_arg) | |
cc9b8628 | 2114 | { |
2115 | if (type) | |
2116 | { | |
2117 | /* If this type contains non-trivial constructors, then it is | |
2118 | forbidden for the middle-end to create any new copies. */ | |
2119 | if (TREE_ADDRESSABLE (type)) | |
2120 | return true; | |
2121 | ||
39cd001a | 2122 | /* GCC post 3.4 passes *all* variable sized types by reference. */ |
2123 | if (!TYPE_SIZE (type) || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) | |
cc9b8628 | 2124 | return true; |
8df5a43d | 2125 | |
2126 | /* If a record type should be passed the same as its first (and only) | |
2127 | member, use the type and mode of that member. */ | |
2128 | if (TREE_CODE (type) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type)) | |
2129 | { | |
2130 | type = TREE_TYPE (first_field (type)); | |
2131 | mode = TYPE_MODE (type); | |
2132 | } | |
cc9b8628 | 2133 | } |
2134 | ||
39cba157 | 2135 | return targetm.calls.pass_by_reference (pack_cumulative_args (ca), mode, |
2136 | type, named_arg); | |
cc9b8628 | 2137 | } |
2138 | ||
13f08ee7 | 2139 | /* Return true if TYPE, which is passed by reference, should be callee |
2140 | copied instead of caller copied. */ | |
2141 | ||
2142 | bool | |
2143 | reference_callee_copied (CUMULATIVE_ARGS *ca, enum machine_mode mode, | |
2144 | tree type, bool named_arg) | |
2145 | { | |
2146 | if (type && TREE_ADDRESSABLE (type)) | |
2147 | return false; | |
39cba157 | 2148 | return targetm.calls.callee_copies (pack_cumulative_args (ca), mode, type, |
2149 | named_arg); | |
13f08ee7 | 2150 | } |
2151 | ||
35a569c6 | 2152 | /* Structures to communicate between the subroutines of assign_parms. |
2153 | The first holds data persistent across all parameters, the second | |
2154 | is cleared out for each parameter. */ | |
897b77d6 | 2155 | |
35a569c6 | 2156 | struct assign_parm_data_all |
897b77d6 | 2157 | { |
39cba157 | 2158 | /* When INIT_CUMULATIVE_ARGS gets revamped, allocating CUMULATIVE_ARGS |
2159 | should become a job of the target or otherwise encapsulated. */ | |
2160 | CUMULATIVE_ARGS args_so_far_v; | |
2161 | cumulative_args_t args_so_far; | |
897b77d6 | 2162 | struct args_size stack_args_size; |
35a569c6 | 2163 | tree function_result_decl; |
2164 | tree orig_fnargs; | |
28bf151d | 2165 | rtx first_conversion_insn; |
2166 | rtx last_conversion_insn; | |
35a569c6 | 2167 | HOST_WIDE_INT pretend_args_size; |
2168 | HOST_WIDE_INT extra_pretend_bytes; | |
2169 | int reg_parm_stack_space; | |
2170 | }; | |
897b77d6 | 2171 | |
35a569c6 | 2172 | struct assign_parm_data_one |
2173 | { | |
2174 | tree nominal_type; | |
2175 | tree passed_type; | |
2176 | rtx entry_parm; | |
2177 | rtx stack_parm; | |
2178 | enum machine_mode nominal_mode; | |
2179 | enum machine_mode passed_mode; | |
2180 | enum machine_mode promoted_mode; | |
2181 | struct locate_and_pad_arg_data locate; | |
2182 | int partial; | |
2183 | BOOL_BITFIELD named_arg : 1; | |
35a569c6 | 2184 | BOOL_BITFIELD passed_pointer : 1; |
2185 | BOOL_BITFIELD on_stack : 1; | |
2186 | BOOL_BITFIELD loaded_in_reg : 1; | |
2187 | }; | |
eb749d77 | 2188 | |
35a569c6 | 2189 | /* A subroutine of assign_parms. Initialize ALL. */ |
897b77d6 | 2190 | |
35a569c6 | 2191 | static void |
2192 | assign_parms_initialize_all (struct assign_parm_data_all *all) | |
2193 | { | |
132d5071 | 2194 | tree fntype ATTRIBUTE_UNUSED; |
897b77d6 | 2195 | |
35a569c6 | 2196 | memset (all, 0, sizeof (*all)); |
2197 | ||
2198 | fntype = TREE_TYPE (current_function_decl); | |
2199 | ||
2200 | #ifdef INIT_CUMULATIVE_INCOMING_ARGS | |
39cba157 | 2201 | INIT_CUMULATIVE_INCOMING_ARGS (all->args_so_far_v, fntype, NULL_RTX); |
35a569c6 | 2202 | #else |
39cba157 | 2203 | INIT_CUMULATIVE_ARGS (all->args_so_far_v, fntype, NULL_RTX, |
35a569c6 | 2204 | current_function_decl, -1); |
2205 | #endif | |
39cba157 | 2206 | all->args_so_far = pack_cumulative_args (&all->args_so_far_v); |
35a569c6 | 2207 | |
2208 | #ifdef REG_PARM_STACK_SPACE | |
2209 | all->reg_parm_stack_space = REG_PARM_STACK_SPACE (current_function_decl); | |
2210 | #endif | |
2211 | } | |
897b77d6 | 2212 | |
35a569c6 | 2213 | /* If ARGS contains entries with complex types, split the entry into two |
2214 | entries of the component type. Return a new list of substitutions are | |
2215 | needed, else the old list. */ | |
2216 | ||
3e992c41 | 2217 | static void |
2218 | split_complex_args (VEC(tree, heap) **args) | |
35a569c6 | 2219 | { |
3e992c41 | 2220 | unsigned i; |
35a569c6 | 2221 | tree p; |
2222 | ||
48148244 | 2223 | FOR_EACH_VEC_ELT (tree, *args, i, p) |
35a569c6 | 2224 | { |
2225 | tree type = TREE_TYPE (p); | |
2226 | if (TREE_CODE (type) == COMPLEX_TYPE | |
2227 | && targetm.calls.split_complex_arg (type)) | |
2228 | { | |
2229 | tree decl; | |
2230 | tree subtype = TREE_TYPE (type); | |
e6427ef0 | 2231 | bool addressable = TREE_ADDRESSABLE (p); |
35a569c6 | 2232 | |
2233 | /* Rewrite the PARM_DECL's type with its component. */ | |
3e992c41 | 2234 | p = copy_node (p); |
35a569c6 | 2235 | TREE_TYPE (p) = subtype; |
2236 | DECL_ARG_TYPE (p) = TREE_TYPE (DECL_ARG_TYPE (p)); | |
2237 | DECL_MODE (p) = VOIDmode; | |
2238 | DECL_SIZE (p) = NULL; | |
2239 | DECL_SIZE_UNIT (p) = NULL; | |
e6427ef0 | 2240 | /* If this arg must go in memory, put it in a pseudo here. |
2241 | We can't allow it to go in memory as per normal parms, | |
2242 | because the usual place might not have the imag part | |
2243 | adjacent to the real part. */ | |
2244 | DECL_ARTIFICIAL (p) = addressable; | |
2245 | DECL_IGNORED_P (p) = addressable; | |
2246 | TREE_ADDRESSABLE (p) = 0; | |
35a569c6 | 2247 | layout_decl (p, 0); |
3e992c41 | 2248 | VEC_replace (tree, *args, i, p); |
35a569c6 | 2249 | |
2250 | /* Build a second synthetic decl. */ | |
e60a6f7b | 2251 | decl = build_decl (EXPR_LOCATION (p), |
2252 | PARM_DECL, NULL_TREE, subtype); | |
35a569c6 | 2253 | DECL_ARG_TYPE (decl) = DECL_ARG_TYPE (p); |
e6427ef0 | 2254 | DECL_ARTIFICIAL (decl) = addressable; |
2255 | DECL_IGNORED_P (decl) = addressable; | |
35a569c6 | 2256 | layout_decl (decl, 0); |
3e992c41 | 2257 | VEC_safe_insert (tree, heap, *args, ++i, decl); |
35a569c6 | 2258 | } |
2259 | } | |
35a569c6 | 2260 | } |
2261 | ||
2262 | /* A subroutine of assign_parms. Adjust the parameter list to incorporate | |
2263 | the hidden struct return argument, and (abi willing) complex args. | |
2264 | Return the new parameter list. */ | |
2265 | ||
3e992c41 | 2266 | static VEC(tree, heap) * |
35a569c6 | 2267 | assign_parms_augmented_arg_list (struct assign_parm_data_all *all) |
2268 | { | |
2269 | tree fndecl = current_function_decl; | |
2270 | tree fntype = TREE_TYPE (fndecl); | |
3e992c41 | 2271 | VEC(tree, heap) *fnargs = NULL; |
2272 | tree arg; | |
2273 | ||
1767a056 | 2274 | for (arg = DECL_ARGUMENTS (fndecl); arg; arg = DECL_CHAIN (arg)) |
3e992c41 | 2275 | VEC_safe_push (tree, heap, fnargs, arg); |
2276 | ||
2277 | all->orig_fnargs = DECL_ARGUMENTS (fndecl); | |
897b77d6 | 2278 | |
2279 | /* If struct value address is treated as the first argument, make it so. */ | |
45550790 | 2280 | if (aggregate_value_p (DECL_RESULT (fndecl), fndecl) |
18d50ae6 | 2281 | && ! cfun->returns_pcc_struct |
45550790 | 2282 | && targetm.calls.struct_value_rtx (TREE_TYPE (fndecl), 1) == 0) |
897b77d6 | 2283 | { |
3ff448ca | 2284 | tree type = build_pointer_type (TREE_TYPE (fntype)); |
35a569c6 | 2285 | tree decl; |
897b77d6 | 2286 | |
e60a6f7b | 2287 | decl = build_decl (DECL_SOURCE_LOCATION (fndecl), |
4d5b4e6a | 2288 | PARM_DECL, get_identifier (".result_ptr"), type); |
35a569c6 | 2289 | DECL_ARG_TYPE (decl) = type; |
2290 | DECL_ARTIFICIAL (decl) = 1; | |
4d5b4e6a | 2291 | DECL_NAMELESS (decl) = 1; |
2292 | TREE_CONSTANT (decl) = 1; | |
897b77d6 | 2293 | |
1767a056 | 2294 | DECL_CHAIN (decl) = all->orig_fnargs; |
3e992c41 | 2295 | all->orig_fnargs = decl; |
2296 | VEC_safe_insert (tree, heap, fnargs, 0, decl); | |
2297 | ||
35a569c6 | 2298 | all->function_result_decl = decl; |
897b77d6 | 2299 | } |
06ebc183 | 2300 | |
92d40bc4 | 2301 | /* If the target wants to split complex arguments into scalars, do so. */ |
2302 | if (targetm.calls.split_complex_arg) | |
3e992c41 | 2303 | split_complex_args (&fnargs); |
915e81b8 | 2304 | |
35a569c6 | 2305 | return fnargs; |
2306 | } | |
241399f6 | 2307 | |
35a569c6 | 2308 | /* A subroutine of assign_parms. Examine PARM and pull out type and mode |
2309 | data for the parameter. Incorporate ABI specifics such as pass-by- | |
2310 | reference and type promotion. */ | |
897b77d6 | 2311 | |
35a569c6 | 2312 | static void |
2313 | assign_parm_find_data_types (struct assign_parm_data_all *all, tree parm, | |
2314 | struct assign_parm_data_one *data) | |
2315 | { | |
2316 | tree nominal_type, passed_type; | |
2317 | enum machine_mode nominal_mode, passed_mode, promoted_mode; | |
3b2411a8 | 2318 | int unsignedp; |
897b77d6 | 2319 | |
35a569c6 | 2320 | memset (data, 0, sizeof (*data)); |
2321 | ||
f0b5f617 | 2322 | /* NAMED_ARG is a misnomer. We really mean 'non-variadic'. */ |
18d50ae6 | 2323 | if (!cfun->stdarg) |
f0b5f617 | 2324 | data->named_arg = 1; /* No variadic parms. */ |
1767a056 | 2325 | else if (DECL_CHAIN (parm)) |
f0b5f617 | 2326 | data->named_arg = 1; /* Not the last non-variadic parm. */ |
39cba157 | 2327 | else if (targetm.calls.strict_argument_naming (all->args_so_far)) |
f0b5f617 | 2328 | data->named_arg = 1; /* Only variadic ones are unnamed. */ |
35a569c6 | 2329 | else |
f0b5f617 | 2330 | data->named_arg = 0; /* Treat as variadic. */ |
35a569c6 | 2331 | |
2332 | nominal_type = TREE_TYPE (parm); | |
2333 | passed_type = DECL_ARG_TYPE (parm); | |
2334 | ||
2335 | /* Look out for errors propagating this far. Also, if the parameter's | |
2336 | type is void then its value doesn't matter. */ | |
2337 | if (TREE_TYPE (parm) == error_mark_node | |
2338 | /* This can happen after weird syntax errors | |
2339 | or if an enum type is defined among the parms. */ | |
2340 | || TREE_CODE (parm) != PARM_DECL | |
2341 | || passed_type == NULL | |
2342 | || VOID_TYPE_P (nominal_type)) | |
2343 | { | |
2344 | nominal_type = passed_type = void_type_node; | |
2345 | nominal_mode = passed_mode = promoted_mode = VOIDmode; | |
2346 | goto egress; | |
2347 | } | |
d06f5fba | 2348 | |
35a569c6 | 2349 | /* Find mode of arg as it is passed, and mode of arg as it should be |
2350 | during execution of this function. */ | |
2351 | passed_mode = TYPE_MODE (passed_type); | |
2352 | nominal_mode = TYPE_MODE (nominal_type); | |
2353 | ||
8df5a43d | 2354 | /* If the parm is to be passed as a transparent union or record, use the |
2355 | type of the first field for the tests below. We have already verified | |
2356 | that the modes are the same. */ | |
2357 | if ((TREE_CODE (passed_type) == UNION_TYPE | |
2358 | || TREE_CODE (passed_type) == RECORD_TYPE) | |
2359 | && TYPE_TRANSPARENT_AGGR (passed_type)) | |
2360 | passed_type = TREE_TYPE (first_field (passed_type)); | |
35a569c6 | 2361 | |
cc9b8628 | 2362 | /* See if this arg was passed by invisible reference. */ |
39cba157 | 2363 | if (pass_by_reference (&all->args_so_far_v, passed_mode, |
cc9b8628 | 2364 | passed_type, data->named_arg)) |
35a569c6 | 2365 | { |
2366 | passed_type = nominal_type = build_pointer_type (passed_type); | |
2367 | data->passed_pointer = true; | |
2368 | passed_mode = nominal_mode = Pmode; | |
2369 | } | |
897b77d6 | 2370 | |
35a569c6 | 2371 | /* Find mode as it is passed by the ABI. */ |
3b2411a8 | 2372 | unsignedp = TYPE_UNSIGNED (passed_type); |
2373 | promoted_mode = promote_function_mode (passed_type, passed_mode, &unsignedp, | |
2374 | TREE_TYPE (current_function_decl), 0); | |
897b77d6 | 2375 | |
35a569c6 | 2376 | egress: |
2377 | data->nominal_type = nominal_type; | |
2378 | data->passed_type = passed_type; | |
2379 | data->nominal_mode = nominal_mode; | |
2380 | data->passed_mode = passed_mode; | |
2381 | data->promoted_mode = promoted_mode; | |
2382 | } | |
24ec33e7 | 2383 | |
35a569c6 | 2384 | /* A subroutine of assign_parms. Invoke setup_incoming_varargs. */ |
897b77d6 | 2385 | |
35a569c6 | 2386 | static void |
2387 | assign_parms_setup_varargs (struct assign_parm_data_all *all, | |
2388 | struct assign_parm_data_one *data, bool no_rtl) | |
2389 | { | |
2390 | int varargs_pretend_bytes = 0; | |
2391 | ||
39cba157 | 2392 | targetm.calls.setup_incoming_varargs (all->args_so_far, |
35a569c6 | 2393 | data->promoted_mode, |
2394 | data->passed_type, | |
2395 | &varargs_pretend_bytes, no_rtl); | |
2396 | ||
2397 | /* If the back-end has requested extra stack space, record how much is | |
2398 | needed. Do not change pretend_args_size otherwise since it may be | |
2399 | nonzero from an earlier partial argument. */ | |
2400 | if (varargs_pretend_bytes > 0) | |
2401 | all->pretend_args_size = varargs_pretend_bytes; | |
2402 | } | |
7e8dfb30 | 2403 | |
35a569c6 | 2404 | /* A subroutine of assign_parms. Set DATA->ENTRY_PARM corresponding to |
2405 | the incoming location of the current parameter. */ | |
2406 | ||
2407 | static void | |
2408 | assign_parm_find_entry_rtl (struct assign_parm_data_all *all, | |
2409 | struct assign_parm_data_one *data) | |
2410 | { | |
2411 | HOST_WIDE_INT pretend_bytes = 0; | |
2412 | rtx entry_parm; | |
2413 | bool in_regs; | |
2414 | ||
2415 | if (data->promoted_mode == VOIDmode) | |
2416 | { | |
2417 | data->entry_parm = data->stack_parm = const0_rtx; | |
2418 | return; | |
2419 | } | |
7e8dfb30 | 2420 | |
39cba157 | 2421 | entry_parm = targetm.calls.function_incoming_arg (all->args_so_far, |
f387af4f | 2422 | data->promoted_mode, |
2423 | data->passed_type, | |
2424 | data->named_arg); | |
897b77d6 | 2425 | |
35a569c6 | 2426 | if (entry_parm == 0) |
2427 | data->promoted_mode = data->passed_mode; | |
897b77d6 | 2428 | |
35a569c6 | 2429 | /* Determine parm's home in the stack, in case it arrives in the stack |
2430 | or we should pretend it did. Compute the stack position and rtx where | |
2431 | the argument arrives and its size. | |
897b77d6 | 2432 | |
35a569c6 | 2433 | There is one complexity here: If this was a parameter that would |
2434 | have been passed in registers, but wasn't only because it is | |
2435 | __builtin_va_alist, we want locate_and_pad_parm to treat it as if | |
2436 | it came in a register so that REG_PARM_STACK_SPACE isn't skipped. | |
2437 | In this case, we call FUNCTION_ARG with NAMED set to 1 instead of 0 | |
2438 | as it was the previous time. */ | |
2439 | in_regs = entry_parm != 0; | |
897b77d6 | 2440 | #ifdef STACK_PARMS_IN_REG_PARM_AREA |
35a569c6 | 2441 | in_regs = true; |
241399f6 | 2442 | #endif |
35a569c6 | 2443 | if (!in_regs && !data->named_arg) |
2444 | { | |
39cba157 | 2445 | if (targetm.calls.pretend_outgoing_varargs_named (all->args_so_far)) |
241399f6 | 2446 | { |
35a569c6 | 2447 | rtx tem; |
39cba157 | 2448 | tem = targetm.calls.function_incoming_arg (all->args_so_far, |
f387af4f | 2449 | data->promoted_mode, |
2450 | data->passed_type, true); | |
35a569c6 | 2451 | in_regs = tem != NULL; |
241399f6 | 2452 | } |
35a569c6 | 2453 | } |
241399f6 | 2454 | |
35a569c6 | 2455 | /* If this parameter was passed both in registers and in the stack, use |
2456 | the copy on the stack. */ | |
0336f0f0 | 2457 | if (targetm.calls.must_pass_in_stack (data->promoted_mode, |
2458 | data->passed_type)) | |
35a569c6 | 2459 | entry_parm = 0; |
241399f6 | 2460 | |
35a569c6 | 2461 | if (entry_parm) |
2462 | { | |
2463 | int partial; | |
2464 | ||
39cba157 | 2465 | partial = targetm.calls.arg_partial_bytes (all->args_so_far, |
f054eb3c | 2466 | data->promoted_mode, |
2467 | data->passed_type, | |
2468 | data->named_arg); | |
35a569c6 | 2469 | data->partial = partial; |
2470 | ||
2471 | /* The caller might already have allocated stack space for the | |
2472 | register parameters. */ | |
2473 | if (partial != 0 && all->reg_parm_stack_space == 0) | |
1cd50c9a | 2474 | { |
35a569c6 | 2475 | /* Part of this argument is passed in registers and part |
2476 | is passed on the stack. Ask the prologue code to extend | |
2477 | the stack part so that we can recreate the full value. | |
2478 | ||
2479 | PRETEND_BYTES is the size of the registers we need to store. | |
2480 | CURRENT_FUNCTION_PRETEND_ARGS_SIZE is the amount of extra | |
2481 | stack space that the prologue should allocate. | |
2482 | ||
2483 | Internally, gcc assumes that the argument pointer is aligned | |
2484 | to STACK_BOUNDARY bits. This is used both for alignment | |
2485 | optimizations (see init_emit) and to locate arguments that are | |
2486 | aligned to more than PARM_BOUNDARY bits. We must preserve this | |
2487 | invariant by rounding CURRENT_FUNCTION_PRETEND_ARGS_SIZE up to | |
2488 | a stack boundary. */ | |
2489 | ||
2490 | /* We assume at most one partial arg, and it must be the first | |
2491 | argument on the stack. */ | |
fdada98f | 2492 | gcc_assert (!all->extra_pretend_bytes && !all->pretend_args_size); |
35a569c6 | 2493 | |
f054eb3c | 2494 | pretend_bytes = partial; |
35a569c6 | 2495 | all->pretend_args_size = CEIL_ROUND (pretend_bytes, STACK_BYTES); |
2496 | ||
2497 | /* We want to align relative to the actual stack pointer, so | |
2498 | don't include this in the stack size until later. */ | |
2499 | all->extra_pretend_bytes = all->pretend_args_size; | |
1cd50c9a | 2500 | } |
35a569c6 | 2501 | } |
241399f6 | 2502 | |
35a569c6 | 2503 | locate_and_pad_parm (data->promoted_mode, data->passed_type, in_regs, |
2504 | entry_parm ? data->partial : 0, current_function_decl, | |
2505 | &all->stack_args_size, &data->locate); | |
897b77d6 | 2506 | |
c6586120 | 2507 | /* Update parm_stack_boundary if this parameter is passed in the |
2508 | stack. */ | |
2509 | if (!in_regs && crtl->parm_stack_boundary < data->locate.boundary) | |
2510 | crtl->parm_stack_boundary = data->locate.boundary; | |
2511 | ||
35a569c6 | 2512 | /* Adjust offsets to include the pretend args. */ |
2513 | pretend_bytes = all->extra_pretend_bytes - pretend_bytes; | |
2514 | data->locate.slot_offset.constant += pretend_bytes; | |
2515 | data->locate.offset.constant += pretend_bytes; | |
27664a4b | 2516 | |
35a569c6 | 2517 | data->entry_parm = entry_parm; |
2518 | } | |
897b77d6 | 2519 | |
35a569c6 | 2520 | /* A subroutine of assign_parms. If there is actually space on the stack |
2521 | for this parm, count it in stack_args_size and return true. */ | |
897b77d6 | 2522 | |
35a569c6 | 2523 | static bool |
2524 | assign_parm_is_stack_parm (struct assign_parm_data_all *all, | |
2525 | struct assign_parm_data_one *data) | |
2526 | { | |
a133d57d | 2527 | /* Trivially true if we've no incoming register. */ |
35a569c6 | 2528 | if (data->entry_parm == NULL) |
2529 | ; | |
2530 | /* Also true if we're partially in registers and partially not, | |
2531 | since we've arranged to drop the entire argument on the stack. */ | |
2532 | else if (data->partial != 0) | |
2533 | ; | |
2534 | /* Also true if the target says that it's passed in both registers | |
2535 | and on the stack. */ | |
2536 | else if (GET_CODE (data->entry_parm) == PARALLEL | |
2537 | && XEXP (XVECEXP (data->entry_parm, 0, 0), 0) == NULL_RTX) | |
2538 | ; | |
2539 | /* Also true if the target says that there's stack allocated for | |
2540 | all register parameters. */ | |
2541 | else if (all->reg_parm_stack_space > 0) | |
2542 | ; | |
2543 | /* Otherwise, no, this parameter has no ABI defined stack slot. */ | |
2544 | else | |
2545 | return false; | |
897b77d6 | 2546 | |
35a569c6 | 2547 | all->stack_args_size.constant += data->locate.size.constant; |
2548 | if (data->locate.size.var) | |
2549 | ADD_PARM_SIZE (all->stack_args_size, data->locate.size.var); | |
06ebc183 | 2550 | |
35a569c6 | 2551 | return true; |
2552 | } | |
bffcf014 | 2553 | |
35a569c6 | 2554 | /* A subroutine of assign_parms. Given that this parameter is allocated |
2555 | stack space by the ABI, find it. */ | |
897b77d6 | 2556 | |
35a569c6 | 2557 | static void |
2558 | assign_parm_find_stack_rtl (tree parm, struct assign_parm_data_one *data) | |
2559 | { | |
2560 | rtx offset_rtx, stack_parm; | |
2561 | unsigned int align, boundary; | |
897b77d6 | 2562 | |
35a569c6 | 2563 | /* If we're passing this arg using a reg, make its stack home the |
2564 | aligned stack slot. */ | |
2565 | if (data->entry_parm) | |
2566 | offset_rtx = ARGS_SIZE_RTX (data->locate.slot_offset); | |
2567 | else | |
2568 | offset_rtx = ARGS_SIZE_RTX (data->locate.offset); | |
2569 | ||
abe32cce | 2570 | stack_parm = crtl->args.internal_arg_pointer; |
35a569c6 | 2571 | if (offset_rtx != const0_rtx) |
2572 | stack_parm = gen_rtx_PLUS (Pmode, stack_parm, offset_rtx); | |
2573 | stack_parm = gen_rtx_MEM (data->promoted_mode, stack_parm); | |
2574 | ||
d92e3973 | 2575 | if (!data->passed_pointer) |
7aeb4db5 | 2576 | { |
d92e3973 | 2577 | set_mem_attributes (stack_parm, parm, 1); |
2578 | /* set_mem_attributes could set MEM_SIZE to the passed mode's size, | |
2579 | while promoted mode's size is needed. */ | |
2580 | if (data->promoted_mode != BLKmode | |
2581 | && data->promoted_mode != DECL_MODE (parm)) | |
7aeb4db5 | 2582 | { |
5b2a69fa | 2583 | set_mem_size (stack_parm, GET_MODE_SIZE (data->promoted_mode)); |
da443c27 | 2584 | if (MEM_EXPR (stack_parm) && MEM_OFFSET_KNOWN_P (stack_parm)) |
d92e3973 | 2585 | { |
2586 | int offset = subreg_lowpart_offset (DECL_MODE (parm), | |
2587 | data->promoted_mode); | |
2588 | if (offset) | |
da443c27 | 2589 | set_mem_offset (stack_parm, MEM_OFFSET (stack_parm) - offset); |
d92e3973 | 2590 | } |
7aeb4db5 | 2591 | } |
2592 | } | |
35a569c6 | 2593 | |
c5dc0c32 | 2594 | boundary = data->locate.boundary; |
2595 | align = BITS_PER_UNIT; | |
35a569c6 | 2596 | |
2597 | /* If we're padding upward, we know that the alignment of the slot | |
bd99ba64 | 2598 | is TARGET_FUNCTION_ARG_BOUNDARY. If we're using slot_offset, we're |
35a569c6 | 2599 | intentionally forcing upward padding. Otherwise we have to come |
2600 | up with a guess at the alignment based on OFFSET_RTX. */ | |
c5dc0c32 | 2601 | if (data->locate.where_pad != downward || data->entry_parm) |
35a569c6 | 2602 | align = boundary; |
971ba038 | 2603 | else if (CONST_INT_P (offset_rtx)) |
35a569c6 | 2604 | { |
2605 | align = INTVAL (offset_rtx) * BITS_PER_UNIT | boundary; | |
2606 | align = align & -align; | |
2607 | } | |
c5dc0c32 | 2608 | set_mem_align (stack_parm, align); |
35a569c6 | 2609 | |
2610 | if (data->entry_parm) | |
2611 | set_reg_attrs_for_parm (data->entry_parm, stack_parm); | |
2612 | ||
2613 | data->stack_parm = stack_parm; | |
2614 | } | |
2615 | ||
2616 | /* A subroutine of assign_parms. Adjust DATA->ENTRY_RTL such that it's | |
2617 | always valid and contiguous. */ | |
2618 | ||
2619 | static void | |
2620 | assign_parm_adjust_entry_rtl (struct assign_parm_data_one *data) | |
2621 | { | |
2622 | rtx entry_parm = data->entry_parm; | |
2623 | rtx stack_parm = data->stack_parm; | |
2624 | ||
2625 | /* If this parm was passed part in regs and part in memory, pretend it | |
2626 | arrived entirely in memory by pushing the register-part onto the stack. | |
2627 | In the special case of a DImode or DFmode that is split, we could put | |
2628 | it together in a pseudoreg directly, but for now that's not worth | |
2629 | bothering with. */ | |
2630 | if (data->partial != 0) | |
2631 | { | |
2632 | /* Handle calls that pass values in multiple non-contiguous | |
2633 | locations. The Irix 6 ABI has examples of this. */ | |
2634 | if (GET_CODE (entry_parm) == PARALLEL) | |
2635 | emit_group_store (validize_mem (stack_parm), entry_parm, | |
48e1416a | 2636 | data->passed_type, |
35a569c6 | 2637 | int_size_in_bytes (data->passed_type)); |
897b77d6 | 2638 | else |
f054eb3c | 2639 | { |
2640 | gcc_assert (data->partial % UNITS_PER_WORD == 0); | |
2641 | move_block_from_reg (REGNO (entry_parm), validize_mem (stack_parm), | |
2642 | data->partial / UNITS_PER_WORD); | |
2643 | } | |
897b77d6 | 2644 | |
35a569c6 | 2645 | entry_parm = stack_parm; |
2646 | } | |
897b77d6 | 2647 | |
35a569c6 | 2648 | /* If we didn't decide this parm came in a register, by default it came |
2649 | on the stack. */ | |
2650 | else if (entry_parm == NULL) | |
2651 | entry_parm = stack_parm; | |
2652 | ||
2653 | /* When an argument is passed in multiple locations, we can't make use | |
2654 | of this information, but we can save some copying if the whole argument | |
2655 | is passed in a single register. */ | |
2656 | else if (GET_CODE (entry_parm) == PARALLEL | |
2657 | && data->nominal_mode != BLKmode | |
2658 | && data->passed_mode != BLKmode) | |
2659 | { | |
2660 | size_t i, len = XVECLEN (entry_parm, 0); | |
2661 | ||
2662 | for (i = 0; i < len; i++) | |
2663 | if (XEXP (XVECEXP (entry_parm, 0, i), 0) != NULL_RTX | |
2664 | && REG_P (XEXP (XVECEXP (entry_parm, 0, i), 0)) | |
2665 | && (GET_MODE (XEXP (XVECEXP (entry_parm, 0, i), 0)) | |
2666 | == data->passed_mode) | |
2667 | && INTVAL (XEXP (XVECEXP (entry_parm, 0, i), 1)) == 0) | |
2668 | { | |
2669 | entry_parm = XEXP (XVECEXP (entry_parm, 0, i), 0); | |
2670 | break; | |
2671 | } | |
2672 | } | |
4d6c855d | 2673 | |
35a569c6 | 2674 | data->entry_parm = entry_parm; |
2675 | } | |
897b77d6 | 2676 | |
77c0eeb4 | 2677 | /* A subroutine of assign_parms. Reconstitute any values which were |
2678 | passed in multiple registers and would fit in a single register. */ | |
2679 | ||
2680 | static void | |
2681 | assign_parm_remove_parallels (struct assign_parm_data_one *data) | |
2682 | { | |
2683 | rtx entry_parm = data->entry_parm; | |
2684 | ||
2685 | /* Convert the PARALLEL to a REG of the same mode as the parallel. | |
2686 | This can be done with register operations rather than on the | |
2687 | stack, even if we will store the reconstituted parameter on the | |
2688 | stack later. */ | |
1cf0636a | 2689 | if (GET_CODE (entry_parm) == PARALLEL && GET_MODE (entry_parm) != BLKmode) |
77c0eeb4 | 2690 | { |
2691 | rtx parmreg = gen_reg_rtx (GET_MODE (entry_parm)); | |
77b80ffd | 2692 | emit_group_store (parmreg, entry_parm, data->passed_type, |
77c0eeb4 | 2693 | GET_MODE_SIZE (GET_MODE (entry_parm))); |
2694 | entry_parm = parmreg; | |
2695 | } | |
2696 | ||
2697 | data->entry_parm = entry_parm; | |
2698 | } | |
2699 | ||
35a569c6 | 2700 | /* A subroutine of assign_parms. Adjust DATA->STACK_RTL such that it's |
2701 | always valid and properly aligned. */ | |
897b77d6 | 2702 | |
35a569c6 | 2703 | static void |
2704 | assign_parm_adjust_stack_rtl (struct assign_parm_data_one *data) | |
2705 | { | |
2706 | rtx stack_parm = data->stack_parm; | |
2707 | ||
2708 | /* If we can't trust the parm stack slot to be aligned enough for its | |
2709 | ultimate type, don't use that slot after entry. We'll make another | |
2710 | stack slot, if we need one. */ | |
c5dc0c32 | 2711 | if (stack_parm |
2712 | && ((STRICT_ALIGNMENT | |
2713 | && GET_MODE_ALIGNMENT (data->nominal_mode) > MEM_ALIGN (stack_parm)) | |
2714 | || (data->nominal_type | |
2715 | && TYPE_ALIGN (data->nominal_type) > MEM_ALIGN (stack_parm) | |
2716 | && MEM_ALIGN (stack_parm) < PREFERRED_STACK_BOUNDARY))) | |
35a569c6 | 2717 | stack_parm = NULL; |
2718 | ||
2719 | /* If parm was passed in memory, and we need to convert it on entry, | |
2720 | don't store it back in that same slot. */ | |
2721 | else if (data->entry_parm == stack_parm | |
2722 | && data->nominal_mode != BLKmode | |
2723 | && data->nominal_mode != data->passed_mode) | |
2724 | stack_parm = NULL; | |
2725 | ||
f1a0edff | 2726 | /* If stack protection is in effect for this function, don't leave any |
2727 | pointers in their passed stack slots. */ | |
edb7afe8 | 2728 | else if (crtl->stack_protect_guard |
f1a0edff | 2729 | && (flag_stack_protect == 2 |
2730 | || data->passed_pointer | |
2731 | || POINTER_TYPE_P (data->nominal_type))) | |
2732 | stack_parm = NULL; | |
2733 | ||
35a569c6 | 2734 | data->stack_parm = stack_parm; |
2735 | } | |
90b076ea | 2736 | |
35a569c6 | 2737 | /* A subroutine of assign_parms. Return true if the current parameter |
2738 | should be stored as a BLKmode in the current frame. */ | |
2739 | ||
2740 | static bool | |
2741 | assign_parm_setup_block_p (struct assign_parm_data_one *data) | |
2742 | { | |
2743 | if (data->nominal_mode == BLKmode) | |
2744 | return true; | |
1cf0636a | 2745 | if (GET_MODE (data->entry_parm) == BLKmode) |
2746 | return true; | |
a2509aaa | 2747 | |
5f4cd670 | 2748 | #ifdef BLOCK_REG_PADDING |
ed4b0b75 | 2749 | /* Only assign_parm_setup_block knows how to deal with register arguments |
2750 | that are padded at the least significant end. */ | |
2751 | if (REG_P (data->entry_parm) | |
2752 | && GET_MODE_SIZE (data->promoted_mode) < UNITS_PER_WORD | |
2753 | && (BLOCK_REG_PADDING (data->passed_mode, data->passed_type, 1) | |
2754 | == (BYTES_BIG_ENDIAN ? upward : downward))) | |
35a569c6 | 2755 | return true; |
5f4cd670 | 2756 | #endif |
35a569c6 | 2757 | |
2758 | return false; | |
2759 | } | |
2760 | ||
48e1416a | 2761 | /* A subroutine of assign_parms. Arrange for the parameter to be |
35a569c6 | 2762 | present and valid in DATA->STACK_RTL. */ |
2763 | ||
2764 | static void | |
e2ff5c1b | 2765 | assign_parm_setup_block (struct assign_parm_data_all *all, |
2766 | tree parm, struct assign_parm_data_one *data) | |
35a569c6 | 2767 | { |
2768 | rtx entry_parm = data->entry_parm; | |
2769 | rtx stack_parm = data->stack_parm; | |
c5dc0c32 | 2770 | HOST_WIDE_INT size; |
2771 | HOST_WIDE_INT size_stored; | |
35a569c6 | 2772 | |
e2ff5c1b | 2773 | if (GET_CODE (entry_parm) == PARALLEL) |
2774 | entry_parm = emit_group_move_into_temps (entry_parm); | |
2775 | ||
c5dc0c32 | 2776 | size = int_size_in_bytes (data->passed_type); |
2777 | size_stored = CEIL_ROUND (size, UNITS_PER_WORD); | |
2778 | if (stack_parm == 0) | |
2779 | { | |
3a1c59da | 2780 | DECL_ALIGN (parm) = MAX (DECL_ALIGN (parm), BITS_PER_WORD); |
c5dc0c32 | 2781 | stack_parm = assign_stack_local (BLKmode, size_stored, |
3a1c59da | 2782 | DECL_ALIGN (parm)); |
c5dc0c32 | 2783 | if (GET_MODE_SIZE (GET_MODE (entry_parm)) == size) |
2784 | PUT_MODE (stack_parm, GET_MODE (entry_parm)); | |
2785 | set_mem_attributes (stack_parm, parm, 1); | |
2786 | } | |
2787 | ||
35a569c6 | 2788 | /* If a BLKmode arrives in registers, copy it to a stack slot. Handle |
2789 | calls that pass values in multiple non-contiguous locations. */ | |
2790 | if (REG_P (entry_parm) || GET_CODE (entry_parm) == PARALLEL) | |
2791 | { | |
35a569c6 | 2792 | rtx mem; |
2793 | ||
2794 | /* Note that we will be storing an integral number of words. | |
2795 | So we have to be careful to ensure that we allocate an | |
c5dc0c32 | 2796 | integral number of words. We do this above when we call |
35a569c6 | 2797 | assign_stack_local if space was not allocated in the argument |
2798 | list. If it was, this will not work if PARM_BOUNDARY is not | |
2799 | a multiple of BITS_PER_WORD. It isn't clear how to fix this | |
2800 | if it becomes a problem. Exception is when BLKmode arrives | |
2801 | with arguments not conforming to word_mode. */ | |
2802 | ||
c5dc0c32 | 2803 | if (data->stack_parm == 0) |
2804 | ; | |
35a569c6 | 2805 | else if (GET_CODE (entry_parm) == PARALLEL) |
2806 | ; | |
fdada98f | 2807 | else |
2808 | gcc_assert (!size || !(PARM_BOUNDARY % BITS_PER_WORD)); | |
897b77d6 | 2809 | |
35a569c6 | 2810 | mem = validize_mem (stack_parm); |
530178a9 | 2811 | |
35a569c6 | 2812 | /* Handle values in multiple non-contiguous locations. */ |
2813 | if (GET_CODE (entry_parm) == PARALLEL) | |
e2ff5c1b | 2814 | { |
28bf151d | 2815 | push_to_sequence2 (all->first_conversion_insn, |
2816 | all->last_conversion_insn); | |
e2ff5c1b | 2817 | emit_group_store (mem, entry_parm, data->passed_type, size); |
28bf151d | 2818 | all->first_conversion_insn = get_insns (); |
2819 | all->last_conversion_insn = get_last_insn (); | |
e2ff5c1b | 2820 | end_sequence (); |
2821 | } | |
530178a9 | 2822 | |
35a569c6 | 2823 | else if (size == 0) |
2824 | ; | |
dd6fed02 | 2825 | |
35a569c6 | 2826 | /* If SIZE is that of a mode no bigger than a word, just use |
2827 | that mode's store operation. */ | |
2828 | else if (size <= UNITS_PER_WORD) | |
2829 | { | |
2830 | enum machine_mode mode | |
2831 | = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0); | |
530178a9 | 2832 | |
35a569c6 | 2833 | if (mode != BLKmode |
5f4cd670 | 2834 | #ifdef BLOCK_REG_PADDING |
35a569c6 | 2835 | && (size == UNITS_PER_WORD |
2836 | || (BLOCK_REG_PADDING (mode, data->passed_type, 1) | |
2837 | != (BYTES_BIG_ENDIAN ? upward : downward))) | |
5f4cd670 | 2838 | #endif |
35a569c6 | 2839 | ) |
2840 | { | |
2973927c | 2841 | rtx reg; |
2842 | ||
2843 | /* We are really truncating a word_mode value containing | |
2844 | SIZE bytes into a value of mode MODE. If such an | |
2845 | operation requires no actual instructions, we can refer | |
2846 | to the value directly in mode MODE, otherwise we must | |
2847 | start with the register in word_mode and explicitly | |
2848 | convert it. */ | |
2849 | if (TRULY_NOOP_TRUNCATION (size * BITS_PER_UNIT, BITS_PER_WORD)) | |
2850 | reg = gen_rtx_REG (mode, REGNO (entry_parm)); | |
2851 | else | |
2852 | { | |
2853 | reg = gen_rtx_REG (word_mode, REGNO (entry_parm)); | |
2854 | reg = convert_to_mode (mode, copy_to_reg (reg), 1); | |
2855 | } | |
35a569c6 | 2856 | emit_move_insn (change_address (mem, mode, 0), reg); |
2857 | } | |
530178a9 | 2858 | |
35a569c6 | 2859 | /* Blocks smaller than a word on a BYTES_BIG_ENDIAN |
2860 | machine must be aligned to the left before storing | |
2861 | to memory. Note that the previous test doesn't | |
2862 | handle all cases (e.g. SIZE == 3). */ | |
2863 | else if (size != UNITS_PER_WORD | |
5f4cd670 | 2864 | #ifdef BLOCK_REG_PADDING |
35a569c6 | 2865 | && (BLOCK_REG_PADDING (mode, data->passed_type, 1) |
2866 | == downward) | |
5f4cd670 | 2867 | #else |
35a569c6 | 2868 | && BYTES_BIG_ENDIAN |
5f4cd670 | 2869 | #endif |
35a569c6 | 2870 | ) |
2871 | { | |
2872 | rtx tem, x; | |
2873 | int by = (UNITS_PER_WORD - size) * BITS_PER_UNIT; | |
e1b9bbec | 2874 | rtx reg = gen_rtx_REG (word_mode, REGNO (entry_parm)); |
35a569c6 | 2875 | |
f5ff0b21 | 2876 | x = expand_shift (LSHIFT_EXPR, word_mode, reg, by, NULL_RTX, 1); |
35a569c6 | 2877 | tem = change_address (mem, word_mode, 0); |
2878 | emit_move_insn (tem, x); | |
897b77d6 | 2879 | } |
35a569c6 | 2880 | else |
e2ff5c1b | 2881 | move_block_from_reg (REGNO (entry_parm), mem, |
35a569c6 | 2882 | size_stored / UNITS_PER_WORD); |
897b77d6 | 2883 | } |
35a569c6 | 2884 | else |
e2ff5c1b | 2885 | move_block_from_reg (REGNO (entry_parm), mem, |
35a569c6 | 2886 | size_stored / UNITS_PER_WORD); |
2887 | } | |
c5dc0c32 | 2888 | else if (data->stack_parm == 0) |
2889 | { | |
28bf151d | 2890 | push_to_sequence2 (all->first_conversion_insn, all->last_conversion_insn); |
c5dc0c32 | 2891 | emit_block_move (stack_parm, data->entry_parm, GEN_INT (size), |
2892 | BLOCK_OP_NORMAL); | |
28bf151d | 2893 | all->first_conversion_insn = get_insns (); |
2894 | all->last_conversion_insn = get_last_insn (); | |
c5dc0c32 | 2895 | end_sequence (); |
2896 | } | |
35a569c6 | 2897 | |
c5dc0c32 | 2898 | data->stack_parm = stack_parm; |
35a569c6 | 2899 | SET_DECL_RTL (parm, stack_parm); |
2900 | } | |
2901 | ||
2902 | /* A subroutine of assign_parms. Allocate a pseudo to hold the current | |
2903 | parameter. Get it there. Perform all ABI specified conversions. */ | |
2904 | ||
2905 | static void | |
2906 | assign_parm_setup_reg (struct assign_parm_data_all *all, tree parm, | |
2907 | struct assign_parm_data_one *data) | |
2908 | { | |
f3e93fd1 | 2909 | rtx parmreg, validated_mem; |
2910 | rtx equiv_stack_parm; | |
35a569c6 | 2911 | enum machine_mode promoted_nominal_mode; |
2912 | int unsignedp = TYPE_UNSIGNED (TREE_TYPE (parm)); | |
2913 | bool did_conversion = false; | |
f3e93fd1 | 2914 | bool need_conversion, moved; |
35a569c6 | 2915 | |
2916 | /* Store the parm in a pseudoregister during the function, but we may | |
c879dbcf | 2917 | need to do it in a wider mode. Using 2 here makes the result |
2918 | consistent with promote_decl_mode and thus expand_expr_real_1. */ | |
35a569c6 | 2919 | promoted_nominal_mode |
3b2411a8 | 2920 | = promote_function_mode (data->nominal_type, data->nominal_mode, &unsignedp, |
c879dbcf | 2921 | TREE_TYPE (current_function_decl), 2); |
35a569c6 | 2922 | |
2923 | parmreg = gen_reg_rtx (promoted_nominal_mode); | |
2924 | ||
2925 | if (!DECL_ARTIFICIAL (parm)) | |
2926 | mark_user_reg (parmreg); | |
2927 | ||
2928 | /* If this was an item that we received a pointer to, | |
2929 | set DECL_RTL appropriately. */ | |
2930 | if (data->passed_pointer) | |
2931 | { | |
2932 | rtx x = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data->passed_type)), parmreg); | |
2933 | set_mem_attributes (x, parm, 1); | |
2934 | SET_DECL_RTL (parm, x); | |
2935 | } | |
2936 | else | |
b04fab2a | 2937 | SET_DECL_RTL (parm, parmreg); |
35a569c6 | 2938 | |
77c0eeb4 | 2939 | assign_parm_remove_parallels (data); |
2940 | ||
c879dbcf | 2941 | /* Copy the value into the register, thus bridging between |
2942 | assign_parm_find_data_types and expand_expr_real_1. */ | |
35a569c6 | 2943 | |
f3e93fd1 | 2944 | equiv_stack_parm = data->stack_parm; |
2945 | validated_mem = validize_mem (data->entry_parm); | |
2946 | ||
2947 | need_conversion = (data->nominal_mode != data->passed_mode | |
2948 | || promoted_nominal_mode != data->promoted_mode); | |
2949 | moved = false; | |
2950 | ||
3939ef08 | 2951 | if (need_conversion |
2952 | && GET_MODE_CLASS (data->nominal_mode) == MODE_INT | |
2953 | && data->nominal_mode == data->passed_mode | |
2954 | && data->nominal_mode == GET_MODE (data->entry_parm)) | |
f3e93fd1 | 2955 | { |
35a569c6 | 2956 | /* ENTRY_PARM has been converted to PROMOTED_MODE, its |
2957 | mode, by the caller. We now have to convert it to | |
2958 | NOMINAL_MODE, if different. However, PARMREG may be in | |
2959 | a different mode than NOMINAL_MODE if it is being stored | |
2960 | promoted. | |
2961 | ||
2962 | If ENTRY_PARM is a hard register, it might be in a register | |
2963 | not valid for operating in its mode (e.g., an odd-numbered | |
2964 | register for a DFmode). In that case, moves are the only | |
2965 | thing valid, so we can't do a convert from there. This | |
2966 | occurs when the calling sequence allow such misaligned | |
2967 | usages. | |
2968 | ||
2969 | In addition, the conversion may involve a call, which could | |
2970 | clobber parameters which haven't been copied to pseudo | |
f3e93fd1 | 2971 | registers yet. |
2972 | ||
2973 | First, we try to emit an insn which performs the necessary | |
2974 | conversion. We verify that this insn does not clobber any | |
2975 | hard registers. */ | |
2976 | ||
2977 | enum insn_code icode; | |
2978 | rtx op0, op1; | |
2979 | ||
2980 | icode = can_extend_p (promoted_nominal_mode, data->passed_mode, | |
2981 | unsignedp); | |
2982 | ||
2983 | op0 = parmreg; | |
2984 | op1 = validated_mem; | |
2985 | if (icode != CODE_FOR_nothing | |
39c56a89 | 2986 | && insn_operand_matches (icode, 0, op0) |
2987 | && insn_operand_matches (icode, 1, op1)) | |
f3e93fd1 | 2988 | { |
2989 | enum rtx_code code = unsignedp ? ZERO_EXTEND : SIGN_EXTEND; | |
30790040 | 2990 | rtx insn, insns, t = op1; |
f3e93fd1 | 2991 | HARD_REG_SET hardregs; |
2992 | ||
2993 | start_sequence (); | |
30790040 | 2994 | /* If op1 is a hard register that is likely spilled, first |
2995 | force it into a pseudo, otherwise combiner might extend | |
2996 | its lifetime too much. */ | |
2997 | if (GET_CODE (t) == SUBREG) | |
2998 | t = SUBREG_REG (t); | |
2999 | if (REG_P (t) | |
3000 | && HARD_REGISTER_P (t) | |
3001 | && ! TEST_HARD_REG_BIT (fixed_reg_set, REGNO (t)) | |
3002 | && targetm.class_likely_spilled_p (REGNO_REG_CLASS (REGNO (t)))) | |
3003 | { | |
3004 | t = gen_reg_rtx (GET_MODE (op1)); | |
3005 | emit_move_insn (t, op1); | |
3006 | } | |
3007 | else | |
3008 | t = op1; | |
3009 | insn = gen_extend_insn (op0, t, promoted_nominal_mode, | |
f3e93fd1 | 3010 | data->passed_mode, unsignedp); |
3011 | emit_insn (insn); | |
3012 | insns = get_insns (); | |
3013 | ||
3014 | moved = true; | |
3015 | CLEAR_HARD_REG_SET (hardregs); | |
3016 | for (insn = insns; insn && moved; insn = NEXT_INSN (insn)) | |
3017 | { | |
3018 | if (INSN_P (insn)) | |
3019 | note_stores (PATTERN (insn), record_hard_reg_sets, | |
3020 | &hardregs); | |
3021 | if (!hard_reg_set_empty_p (hardregs)) | |
3022 | moved = false; | |
3023 | } | |
3024 | ||
3025 | end_sequence (); | |
3026 | ||
3027 | if (moved) | |
3028 | { | |
3029 | emit_insn (insns); | |
3939ef08 | 3030 | if (equiv_stack_parm != NULL_RTX) |
3031 | equiv_stack_parm = gen_rtx_fmt_e (code, GET_MODE (parmreg), | |
3032 | equiv_stack_parm); | |
f3e93fd1 | 3033 | } |
3034 | } | |
3035 | } | |
3036 | ||
3037 | if (moved) | |
3038 | /* Nothing to do. */ | |
3039 | ; | |
3040 | else if (need_conversion) | |
3041 | { | |
3042 | /* We did not have an insn to convert directly, or the sequence | |
3043 | generated appeared unsafe. We must first copy the parm to a | |
3044 | pseudo reg, and save the conversion until after all | |
35a569c6 | 3045 | parameters have been moved. */ |
3046 | ||
f3e93fd1 | 3047 | int save_tree_used; |
35a569c6 | 3048 | rtx tempreg = gen_reg_rtx (GET_MODE (data->entry_parm)); |
3049 | ||
f3e93fd1 | 3050 | emit_move_insn (tempreg, validated_mem); |
35a569c6 | 3051 | |
28bf151d | 3052 | push_to_sequence2 (all->first_conversion_insn, all->last_conversion_insn); |
35a569c6 | 3053 | tempreg = convert_to_mode (data->nominal_mode, tempreg, unsignedp); |
3054 | ||
3055 | if (GET_CODE (tempreg) == SUBREG | |
3056 | && GET_MODE (tempreg) == data->nominal_mode | |
3057 | && REG_P (SUBREG_REG (tempreg)) | |
3058 | && data->nominal_mode == data->passed_mode | |
3059 | && GET_MODE (SUBREG_REG (tempreg)) == GET_MODE (data->entry_parm) | |
3060 | && GET_MODE_SIZE (GET_MODE (tempreg)) | |
3061 | < GET_MODE_SIZE (GET_MODE (data->entry_parm))) | |
897b77d6 | 3062 | { |
35a569c6 | 3063 | /* The argument is already sign/zero extended, so note it |
3064 | into the subreg. */ | |
3065 | SUBREG_PROMOTED_VAR_P (tempreg) = 1; | |
3066 | SUBREG_PROMOTED_UNSIGNED_SET (tempreg, unsignedp); | |
3067 | } | |
19e03a68 | 3068 | |
35a569c6 | 3069 | /* TREE_USED gets set erroneously during expand_assignment. */ |
3070 | save_tree_used = TREE_USED (parm); | |
5b5037b3 | 3071 | expand_assignment (parm, make_tree (data->nominal_type, tempreg), false); |
35a569c6 | 3072 | TREE_USED (parm) = save_tree_used; |
28bf151d | 3073 | all->first_conversion_insn = get_insns (); |
3074 | all->last_conversion_insn = get_last_insn (); | |
35a569c6 | 3075 | end_sequence (); |
19e03a68 | 3076 | |
35a569c6 | 3077 | did_conversion = true; |
3078 | } | |
3079 | else | |
f3e93fd1 | 3080 | emit_move_insn (parmreg, validated_mem); |
35a569c6 | 3081 | |
3082 | /* If we were passed a pointer but the actual value can safely live | |
3083 | in a register, put it in one. */ | |
3084 | if (data->passed_pointer | |
3085 | && TYPE_MODE (TREE_TYPE (parm)) != BLKmode | |
3086 | /* If by-reference argument was promoted, demote it. */ | |
3087 | && (TYPE_MODE (TREE_TYPE (parm)) != GET_MODE (DECL_RTL (parm)) | |
3088 | || use_register_for_decl (parm))) | |
3089 | { | |
3090 | /* We can't use nominal_mode, because it will have been set to | |
3091 | Pmode above. We must use the actual mode of the parm. */ | |
3092 | parmreg = gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm))); | |
3093 | mark_user_reg (parmreg); | |
8815f4da | 3094 | |
35a569c6 | 3095 | if (GET_MODE (parmreg) != GET_MODE (DECL_RTL (parm))) |
3096 | { | |
3097 | rtx tempreg = gen_reg_rtx (GET_MODE (DECL_RTL (parm))); | |
3098 | int unsigned_p = TYPE_UNSIGNED (TREE_TYPE (parm)); | |
3099 | ||
28bf151d | 3100 | push_to_sequence2 (all->first_conversion_insn, |
3101 | all->last_conversion_insn); | |
35a569c6 | 3102 | emit_move_insn (tempreg, DECL_RTL (parm)); |
3103 | tempreg = convert_to_mode (GET_MODE (parmreg), tempreg, unsigned_p); | |
3104 | emit_move_insn (parmreg, tempreg); | |
28bf151d | 3105 | all->first_conversion_insn = get_insns (); |
3106 | all->last_conversion_insn = get_last_insn (); | |
35a569c6 | 3107 | end_sequence (); |
897b77d6 | 3108 | |
35a569c6 | 3109 | did_conversion = true; |
3110 | } | |
3111 | else | |
3112 | emit_move_insn (parmreg, DECL_RTL (parm)); | |
897b77d6 | 3113 | |
35a569c6 | 3114 | SET_DECL_RTL (parm, parmreg); |
60d903f5 | 3115 | |
35a569c6 | 3116 | /* STACK_PARM is the pointer, not the parm, and PARMREG is |
3117 | now the parm. */ | |
3118 | data->stack_parm = NULL; | |
3119 | } | |
701e46d0 | 3120 | |
35a569c6 | 3121 | /* Mark the register as eliminable if we did no conversion and it was |
3122 | copied from memory at a fixed offset, and the arg pointer was not | |
3123 | copied to a pseudo-reg. If the arg pointer is a pseudo reg or the | |
3124 | offset formed an invalid address, such memory-equivalences as we | |
3125 | make here would screw up life analysis for it. */ | |
3126 | if (data->nominal_mode == data->passed_mode | |
3127 | && !did_conversion | |
3128 | && data->stack_parm != 0 | |
3129 | && MEM_P (data->stack_parm) | |
3130 | && data->locate.offset.var == 0 | |
3131 | && reg_mentioned_p (virtual_incoming_args_rtx, | |
3132 | XEXP (data->stack_parm, 0))) | |
3133 | { | |
3134 | rtx linsn = get_last_insn (); | |
3135 | rtx sinsn, set; | |
5f85a240 | 3136 | |
35a569c6 | 3137 | /* Mark complex types separately. */ |
3138 | if (GET_CODE (parmreg) == CONCAT) | |
3139 | { | |
3140 | enum machine_mode submode | |
3141 | = GET_MODE_INNER (GET_MODE (parmreg)); | |
de17a47b | 3142 | int regnor = REGNO (XEXP (parmreg, 0)); |
3143 | int regnoi = REGNO (XEXP (parmreg, 1)); | |
3144 | rtx stackr = adjust_address_nv (data->stack_parm, submode, 0); | |
3145 | rtx stacki = adjust_address_nv (data->stack_parm, submode, | |
3146 | GET_MODE_SIZE (submode)); | |
35a569c6 | 3147 | |
3148 | /* Scan backwards for the set of the real and | |
3149 | imaginary parts. */ | |
3150 | for (sinsn = linsn; sinsn != 0; | |
3151 | sinsn = prev_nonnote_insn (sinsn)) | |
3152 | { | |
3153 | set = single_set (sinsn); | |
3154 | if (set == 0) | |
3155 | continue; | |
3156 | ||
3157 | if (SET_DEST (set) == regno_reg_rtx [regnoi]) | |
750a330e | 3158 | set_unique_reg_note (sinsn, REG_EQUIV, stacki); |
35a569c6 | 3159 | else if (SET_DEST (set) == regno_reg_rtx [regnor]) |
750a330e | 3160 | set_unique_reg_note (sinsn, REG_EQUIV, stackr); |
5f85a240 | 3161 | } |
35a569c6 | 3162 | } |
41cf444a | 3163 | else |
3164 | set_dst_reg_note (linsn, REG_EQUIV, equiv_stack_parm, parmreg); | |
35a569c6 | 3165 | } |
3166 | ||
3167 | /* For pointer data type, suggest pointer register. */ | |
3168 | if (POINTER_TYPE_P (TREE_TYPE (parm))) | |
3169 | mark_reg_pointer (parmreg, | |
3170 | TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm)))); | |
3171 | } | |
3172 | ||
3173 | /* A subroutine of assign_parms. Allocate stack space to hold the current | |
3174 | parameter. Get it there. Perform all ABI specified conversions. */ | |
3175 | ||
3176 | static void | |
3177 | assign_parm_setup_stack (struct assign_parm_data_all *all, tree parm, | |
3178 | struct assign_parm_data_one *data) | |
3179 | { | |
3180 | /* Value must be stored in the stack slot STACK_PARM during function | |
3181 | execution. */ | |
c5dc0c32 | 3182 | bool to_conversion = false; |
35a569c6 | 3183 | |
77c0eeb4 | 3184 | assign_parm_remove_parallels (data); |
3185 | ||
35a569c6 | 3186 | if (data->promoted_mode != data->nominal_mode) |
3187 | { | |
3188 | /* Conversion is required. */ | |
3189 | rtx tempreg = gen_reg_rtx (GET_MODE (data->entry_parm)); | |
897b77d6 | 3190 | |
35a569c6 | 3191 | emit_move_insn (tempreg, validize_mem (data->entry_parm)); |
3192 | ||
28bf151d | 3193 | push_to_sequence2 (all->first_conversion_insn, all->last_conversion_insn); |
c5dc0c32 | 3194 | to_conversion = true; |
3195 | ||
35a569c6 | 3196 | data->entry_parm = convert_to_mode (data->nominal_mode, tempreg, |
3197 | TYPE_UNSIGNED (TREE_TYPE (parm))); | |
3198 | ||
3199 | if (data->stack_parm) | |
738ab6f5 | 3200 | { |
3201 | int offset = subreg_lowpart_offset (data->nominal_mode, | |
3202 | GET_MODE (data->stack_parm)); | |
3203 | /* ??? This may need a big-endian conversion on sparc64. */ | |
3204 | data->stack_parm | |
3205 | = adjust_address (data->stack_parm, data->nominal_mode, 0); | |
da443c27 | 3206 | if (offset && MEM_OFFSET_KNOWN_P (data->stack_parm)) |
738ab6f5 | 3207 | set_mem_offset (data->stack_parm, |
da443c27 | 3208 | MEM_OFFSET (data->stack_parm) + offset); |
738ab6f5 | 3209 | } |
35a569c6 | 3210 | } |
3211 | ||
3212 | if (data->entry_parm != data->stack_parm) | |
3213 | { | |
c5dc0c32 | 3214 | rtx src, dest; |
3215 | ||
35a569c6 | 3216 | if (data->stack_parm == 0) |
3217 | { | |
c9b50df7 | 3218 | int align = STACK_SLOT_ALIGNMENT (data->passed_type, |
3219 | GET_MODE (data->entry_parm), | |
3220 | TYPE_ALIGN (data->passed_type)); | |
35a569c6 | 3221 | data->stack_parm |
3222 | = assign_stack_local (GET_MODE (data->entry_parm), | |
3223 | GET_MODE_SIZE (GET_MODE (data->entry_parm)), | |
c9b50df7 | 3224 | align); |
35a569c6 | 3225 | set_mem_attributes (data->stack_parm, parm, 1); |
897b77d6 | 3226 | } |
35a569c6 | 3227 | |
c5dc0c32 | 3228 | dest = validize_mem (data->stack_parm); |
3229 | src = validize_mem (data->entry_parm); | |
3230 | ||
3231 | if (MEM_P (src)) | |
897b77d6 | 3232 | { |
c5dc0c32 | 3233 | /* Use a block move to handle potentially misaligned entry_parm. */ |
3234 | if (!to_conversion) | |
28bf151d | 3235 | push_to_sequence2 (all->first_conversion_insn, |
3236 | all->last_conversion_insn); | |
c5dc0c32 | 3237 | to_conversion = true; |
3238 | ||
3239 | emit_block_move (dest, src, | |
3240 | GEN_INT (int_size_in_bytes (data->passed_type)), | |
3241 | BLOCK_OP_NORMAL); | |
35a569c6 | 3242 | } |
3243 | else | |
c5dc0c32 | 3244 | emit_move_insn (dest, src); |
3245 | } | |
3246 | ||
3247 | if (to_conversion) | |
3248 | { | |
28bf151d | 3249 | all->first_conversion_insn = get_insns (); |
3250 | all->last_conversion_insn = get_last_insn (); | |
c5dc0c32 | 3251 | end_sequence (); |
35a569c6 | 3252 | } |
897b77d6 | 3253 | |
35a569c6 | 3254 | SET_DECL_RTL (parm, data->stack_parm); |
3255 | } | |
b8f621ce | 3256 | |
35a569c6 | 3257 | /* A subroutine of assign_parms. If the ABI splits complex arguments, then |
3258 | undo the frobbing that we did in assign_parms_augmented_arg_list. */ | |
006be676 | 3259 | |
35a569c6 | 3260 | static void |
3e992c41 | 3261 | assign_parms_unsplit_complex (struct assign_parm_data_all *all, |
3262 | VEC(tree, heap) *fnargs) | |
35a569c6 | 3263 | { |
3264 | tree parm; | |
e6427ef0 | 3265 | tree orig_fnargs = all->orig_fnargs; |
3e992c41 | 3266 | unsigned i = 0; |
e513d163 | 3267 | |
3e992c41 | 3268 | for (parm = orig_fnargs; parm; parm = TREE_CHAIN (parm), ++i) |
35a569c6 | 3269 | { |
3270 | if (TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE | |
3271 | && targetm.calls.split_complex_arg (TREE_TYPE (parm))) | |
3272 | { | |
3273 | rtx tmp, real, imag; | |
3274 | enum machine_mode inner = GET_MODE_INNER (DECL_MODE (parm)); | |
897b77d6 | 3275 | |
3e992c41 | 3276 | real = DECL_RTL (VEC_index (tree, fnargs, i)); |
3277 | imag = DECL_RTL (VEC_index (tree, fnargs, i + 1)); | |
35a569c6 | 3278 | if (inner != GET_MODE (real)) |
897b77d6 | 3279 | { |
35a569c6 | 3280 | real = gen_lowpart_SUBREG (inner, real); |
3281 | imag = gen_lowpart_SUBREG (inner, imag); | |
3282 | } | |
e6427ef0 | 3283 | |
3284 | if (TREE_ADDRESSABLE (parm)) | |
3285 | { | |
3286 | rtx rmem, imem; | |
3287 | HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (parm)); | |
c9b50df7 | 3288 | int align = STACK_SLOT_ALIGNMENT (TREE_TYPE (parm), |
3289 | DECL_MODE (parm), | |
3290 | TYPE_ALIGN (TREE_TYPE (parm))); | |
e6427ef0 | 3291 | |
3292 | /* split_complex_arg put the real and imag parts in | |
3293 | pseudos. Move them to memory. */ | |
c9b50df7 | 3294 | tmp = assign_stack_local (DECL_MODE (parm), size, align); |
e6427ef0 | 3295 | set_mem_attributes (tmp, parm, 1); |
3296 | rmem = adjust_address_nv (tmp, inner, 0); | |
3297 | imem = adjust_address_nv (tmp, inner, GET_MODE_SIZE (inner)); | |
28bf151d | 3298 | push_to_sequence2 (all->first_conversion_insn, |
3299 | all->last_conversion_insn); | |
e6427ef0 | 3300 | emit_move_insn (rmem, real); |
3301 | emit_move_insn (imem, imag); | |
28bf151d | 3302 | all->first_conversion_insn = get_insns (); |
3303 | all->last_conversion_insn = get_last_insn (); | |
e6427ef0 | 3304 | end_sequence (); |
3305 | } | |
3306 | else | |
3307 | tmp = gen_rtx_CONCAT (DECL_MODE (parm), real, imag); | |
35a569c6 | 3308 | SET_DECL_RTL (parm, tmp); |
08531d36 | 3309 | |
3e992c41 | 3310 | real = DECL_INCOMING_RTL (VEC_index (tree, fnargs, i)); |
3311 | imag = DECL_INCOMING_RTL (VEC_index (tree, fnargs, i + 1)); | |
35a569c6 | 3312 | if (inner != GET_MODE (real)) |
3313 | { | |
3314 | real = gen_lowpart_SUBREG (inner, real); | |
3315 | imag = gen_lowpart_SUBREG (inner, imag); | |
897b77d6 | 3316 | } |
35a569c6 | 3317 | tmp = gen_rtx_CONCAT (DECL_MODE (parm), real, imag); |
d91cf567 | 3318 | set_decl_incoming_rtl (parm, tmp, false); |
3e992c41 | 3319 | i++; |
897b77d6 | 3320 | } |
897b77d6 | 3321 | } |
35a569c6 | 3322 | } |
3323 | ||
3324 | /* Assign RTL expressions to the function's parameters. This may involve | |
3325 | copying them into registers and using those registers as the DECL_RTL. */ | |
3326 | ||
3f0895d3 | 3327 | static void |
35a569c6 | 3328 | assign_parms (tree fndecl) |
3329 | { | |
3330 | struct assign_parm_data_all all; | |
3e992c41 | 3331 | tree parm; |
3332 | VEC(tree, heap) *fnargs; | |
3333 | unsigned i; | |
897b77d6 | 3334 | |
abe32cce | 3335 | crtl->args.internal_arg_pointer |
567925e3 | 3336 | = targetm.calls.internal_arg_pointer (); |
35a569c6 | 3337 | |
3338 | assign_parms_initialize_all (&all); | |
3339 | fnargs = assign_parms_augmented_arg_list (&all); | |
3340 | ||
48148244 | 3341 | FOR_EACH_VEC_ELT (tree, fnargs, i, parm) |
915e81b8 | 3342 | { |
35a569c6 | 3343 | struct assign_parm_data_one data; |
3344 | ||
3345 | /* Extract the type of PARM; adjust it according to ABI. */ | |
3346 | assign_parm_find_data_types (&all, parm, &data); | |
3347 | ||
3348 | /* Early out for errors and void parameters. */ | |
3349 | if (data.passed_mode == VOIDmode) | |
915e81b8 | 3350 | { |
35a569c6 | 3351 | SET_DECL_RTL (parm, const0_rtx); |
3352 | DECL_INCOMING_RTL (parm) = DECL_RTL (parm); | |
3353 | continue; | |
3354 | } | |
1b4f3c7d | 3355 | |
27a7a23a | 3356 | /* Estimate stack alignment from parameter alignment. */ |
3357 | if (SUPPORTS_STACK_ALIGNMENT) | |
3358 | { | |
bd99ba64 | 3359 | unsigned int align |
3360 | = targetm.calls.function_arg_boundary (data.promoted_mode, | |
3361 | data.passed_type); | |
8645d3e7 | 3362 | align = MINIMUM_ALIGNMENT (data.passed_type, data.promoted_mode, |
3363 | align); | |
27a7a23a | 3364 | if (TYPE_ALIGN (data.nominal_type) > align) |
8645d3e7 | 3365 | align = MINIMUM_ALIGNMENT (data.nominal_type, |
3366 | TYPE_MODE (data.nominal_type), | |
3367 | TYPE_ALIGN (data.nominal_type)); | |
27a7a23a | 3368 | if (crtl->stack_alignment_estimated < align) |
3369 | { | |
3370 | gcc_assert (!crtl->stack_realign_processed); | |
3371 | crtl->stack_alignment_estimated = align; | |
3372 | } | |
3373 | } | |
48e1416a | 3374 | |
1767a056 | 3375 | if (cfun->stdarg && !DECL_CHAIN (parm)) |
e2704f58 | 3376 | assign_parms_setup_varargs (&all, &data, false); |
1b4f3c7d | 3377 | |
35a569c6 | 3378 | /* Find out where the parameter arrives in this function. */ |
3379 | assign_parm_find_entry_rtl (&all, &data); | |
3380 | ||
3381 | /* Find out where stack space for this parameter might be. */ | |
3382 | if (assign_parm_is_stack_parm (&all, &data)) | |
3383 | { | |
3384 | assign_parm_find_stack_rtl (parm, &data); | |
3385 | assign_parm_adjust_entry_rtl (&data); | |
915e81b8 | 3386 | } |
35a569c6 | 3387 | |
3388 | /* Record permanently how this parm was passed. */ | |
56fe7223 | 3389 | if (data.passed_pointer) |
3390 | { | |
3391 | rtx incoming_rtl | |
3392 | = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data.passed_type)), | |
3393 | data.entry_parm); | |
3394 | set_decl_incoming_rtl (parm, incoming_rtl, true); | |
3395 | } | |
3396 | else | |
3397 | set_decl_incoming_rtl (parm, data.entry_parm, false); | |
35a569c6 | 3398 | |
3399 | /* Update info on where next arg arrives in registers. */ | |
39cba157 | 3400 | targetm.calls.function_arg_advance (all.args_so_far, data.promoted_mode, |
f387af4f | 3401 | data.passed_type, data.named_arg); |
35a569c6 | 3402 | |
3403 | assign_parm_adjust_stack_rtl (&data); | |
3404 | ||
3405 | if (assign_parm_setup_block_p (&data)) | |
e2ff5c1b | 3406 | assign_parm_setup_block (&all, parm, &data); |
35a569c6 | 3407 | else if (data.passed_pointer || use_register_for_decl (parm)) |
3408 | assign_parm_setup_reg (&all, parm, &data); | |
3409 | else | |
3410 | assign_parm_setup_stack (&all, parm, &data); | |
915e81b8 | 3411 | } |
3412 | ||
3e992c41 | 3413 | if (targetm.calls.split_complex_arg) |
e6427ef0 | 3414 | assign_parms_unsplit_complex (&all, fnargs); |
35a569c6 | 3415 | |
3e992c41 | 3416 | VEC_free (tree, heap, fnargs); |
3417 | ||
b8f621ce | 3418 | /* Output all parameter conversion instructions (possibly including calls) |
3419 | now that all parameters have been copied out of hard registers. */ | |
28bf151d | 3420 | emit_insn (all.first_conversion_insn); |
b8f621ce | 3421 | |
27a7a23a | 3422 | /* Estimate reload stack alignment from scalar return mode. */ |
3423 | if (SUPPORTS_STACK_ALIGNMENT) | |
3424 | { | |
3425 | if (DECL_RESULT (fndecl)) | |
3426 | { | |
3427 | tree type = TREE_TYPE (DECL_RESULT (fndecl)); | |
3428 | enum machine_mode mode = TYPE_MODE (type); | |
3429 | ||
3430 | if (mode != BLKmode | |
3431 | && mode != VOIDmode | |
3432 | && !AGGREGATE_TYPE_P (type)) | |
3433 | { | |
3434 | unsigned int align = GET_MODE_ALIGNMENT (mode); | |
3435 | if (crtl->stack_alignment_estimated < align) | |
3436 | { | |
3437 | gcc_assert (!crtl->stack_realign_processed); | |
3438 | crtl->stack_alignment_estimated = align; | |
3439 | } | |
3440 | } | |
48e1416a | 3441 | } |
27a7a23a | 3442 | } |
3443 | ||
ba133423 | 3444 | /* If we are receiving a struct value address as the first argument, set up |
3445 | the RTL for the function result. As this might require code to convert | |
3446 | the transmitted address to Pmode, we do this here to ensure that possible | |
3447 | preliminary conversions of the address have been emitted already. */ | |
35a569c6 | 3448 | if (all.function_result_decl) |
ba133423 | 3449 | { |
35a569c6 | 3450 | tree result = DECL_RESULT (current_function_decl); |
3451 | rtx addr = DECL_RTL (all.function_result_decl); | |
ba133423 | 3452 | rtx x; |
de1b648b | 3453 | |
806e4c12 | 3454 | if (DECL_BY_REFERENCE (result)) |
4d5b4e6a | 3455 | { |
3456 | SET_DECL_VALUE_EXPR (result, all.function_result_decl); | |
3457 | x = addr; | |
3458 | } | |
806e4c12 | 3459 | else |
3460 | { | |
4d5b4e6a | 3461 | SET_DECL_VALUE_EXPR (result, |
3462 | build1 (INDIRECT_REF, TREE_TYPE (result), | |
3463 | all.function_result_decl)); | |
806e4c12 | 3464 | addr = convert_memory_address (Pmode, addr); |
3465 | x = gen_rtx_MEM (DECL_MODE (result), addr); | |
3466 | set_mem_attributes (x, result, 1); | |
3467 | } | |
4d5b4e6a | 3468 | |
3469 | DECL_HAS_VALUE_EXPR_P (result) = 1; | |
3470 | ||
ba133423 | 3471 | SET_DECL_RTL (result, x); |
3472 | } | |
3473 | ||
b0cdd2bb | 3474 | /* We have aligned all the args, so add space for the pretend args. */ |
abe32cce | 3475 | crtl->args.pretend_args_size = all.pretend_args_size; |
35a569c6 | 3476 | all.stack_args_size.constant += all.extra_pretend_bytes; |
abe32cce | 3477 | crtl->args.size = all.stack_args_size.constant; |
897b77d6 | 3478 | |
3479 | /* Adjust function incoming argument size for alignment and | |
3480 | minimum length. */ | |
3481 | ||
3482 | #ifdef REG_PARM_STACK_SPACE | |
abe32cce | 3483 | crtl->args.size = MAX (crtl->args.size, |
897b77d6 | 3484 | REG_PARM_STACK_SPACE (fndecl)); |
2d7187c2 | 3485 | #endif |
897b77d6 | 3486 | |
abe32cce | 3487 | crtl->args.size = CEIL_ROUND (crtl->args.size, |
26be63dd | 3488 | PARM_BOUNDARY / BITS_PER_UNIT); |
8967ddf7 | 3489 | |
897b77d6 | 3490 | #ifdef ARGS_GROW_DOWNWARD |
abe32cce | 3491 | crtl->args.arg_offset_rtx |
470f4908 | 3492 | = (all.stack_args_size.var == 0 ? GEN_INT (-all.stack_args_size.constant) |
35a569c6 | 3493 | : expand_expr (size_diffop (all.stack_args_size.var, |
3494 | size_int (-all.stack_args_size.constant)), | |
b9c74b4d | 3495 | NULL_RTX, VOIDmode, EXPAND_NORMAL)); |
897b77d6 | 3496 | #else |
abe32cce | 3497 | crtl->args.arg_offset_rtx = ARGS_SIZE_RTX (all.stack_args_size); |
897b77d6 | 3498 | #endif |
3499 | ||
3500 | /* See how many bytes, if any, of its args a function should try to pop | |
3501 | on return. */ | |
3502 | ||
f5bc28da | 3503 | crtl->args.pops_args = targetm.calls.return_pops_args (fndecl, |
3504 | TREE_TYPE (fndecl), | |
3505 | crtl->args.size); | |
897b77d6 | 3506 | |
ec195bc4 | 3507 | /* For stdarg.h function, save info about |
3508 | regs and stack space used by the named args. */ | |
897b77d6 | 3509 | |
39cba157 | 3510 | crtl->args.info = all.args_so_far_v; |
897b77d6 | 3511 | |
3512 | /* Set the rtx used for the function return value. Put this in its | |
3513 | own variable so any optimizers that need this information don't have | |
3514 | to include tree.h. Do this here so it gets done when an inlined | |
3515 | function gets output. */ | |
3516 | ||
abe32cce | 3517 | crtl->return_rtx |
0e8e37b2 | 3518 | = (DECL_RTL_SET_P (DECL_RESULT (fndecl)) |
3519 | ? DECL_RTL (DECL_RESULT (fndecl)) : NULL_RTX); | |
8839b7f1 | 3520 | |
3521 | /* If scalar return value was computed in a pseudo-reg, or was a named | |
3522 | return value that got dumped to the stack, copy that to the hard | |
3523 | return register. */ | |
3524 | if (DECL_RTL_SET_P (DECL_RESULT (fndecl))) | |
3525 | { | |
3526 | tree decl_result = DECL_RESULT (fndecl); | |
3527 | rtx decl_rtl = DECL_RTL (decl_result); | |
3528 | ||
3529 | if (REG_P (decl_rtl) | |
3530 | ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER | |
3531 | : DECL_REGISTER (decl_result)) | |
3532 | { | |
3533 | rtx real_decl_rtl; | |
3534 | ||
46b3ff29 | 3535 | real_decl_rtl = targetm.calls.function_value (TREE_TYPE (decl_result), |
3536 | fndecl, true); | |
8839b7f1 | 3537 | REG_FUNCTION_VALUE_P (real_decl_rtl) = 1; |
abe32cce | 3538 | /* The delay slot scheduler assumes that crtl->return_rtx |
8839b7f1 | 3539 | holds the hard register containing the return value, not a |
3540 | temporary pseudo. */ | |
abe32cce | 3541 | crtl->return_rtx = real_decl_rtl; |
8839b7f1 | 3542 | } |
3543 | } | |
897b77d6 | 3544 | } |
6b275368 | 3545 | |
3546 | /* A subroutine of gimplify_parameters, invoked via walk_tree. | |
3547 | For all seen types, gimplify their sizes. */ | |
3548 | ||
3549 | static tree | |
3550 | gimplify_parm_type (tree *tp, int *walk_subtrees, void *data) | |
3551 | { | |
3552 | tree t = *tp; | |
3553 | ||
3554 | *walk_subtrees = 0; | |
3555 | if (TYPE_P (t)) | |
3556 | { | |
3557 | if (POINTER_TYPE_P (t)) | |
3558 | *walk_subtrees = 1; | |
bc97b18f | 3559 | else if (TYPE_SIZE (t) && !TREE_CONSTANT (TYPE_SIZE (t)) |
3560 | && !TYPE_SIZES_GIMPLIFIED (t)) | |
6b275368 | 3561 | { |
75a70cf9 | 3562 | gimplify_type_sizes (t, (gimple_seq *) data); |
6b275368 | 3563 | *walk_subtrees = 1; |
3564 | } | |
3565 | } | |
3566 | ||
3567 | return NULL; | |
3568 | } | |
3569 | ||
3570 | /* Gimplify the parameter list for current_function_decl. This involves | |
3571 | evaluating SAVE_EXPRs of variable sized parameters and generating code | |
75a70cf9 | 3572 | to implement callee-copies reference parameters. Returns a sequence of |
3573 | statements to add to the beginning of the function. */ | |
6b275368 | 3574 | |
75a70cf9 | 3575 | gimple_seq |
6b275368 | 3576 | gimplify_parameters (void) |
3577 | { | |
3578 | struct assign_parm_data_all all; | |
3e992c41 | 3579 | tree parm; |
75a70cf9 | 3580 | gimple_seq stmts = NULL; |
3e992c41 | 3581 | VEC(tree, heap) *fnargs; |
3582 | unsigned i; | |
6b275368 | 3583 | |
3584 | assign_parms_initialize_all (&all); | |
3585 | fnargs = assign_parms_augmented_arg_list (&all); | |
3586 | ||
48148244 | 3587 | FOR_EACH_VEC_ELT (tree, fnargs, i, parm) |
6b275368 | 3588 | { |
3589 | struct assign_parm_data_one data; | |
3590 | ||
3591 | /* Extract the type of PARM; adjust it according to ABI. */ | |
3592 | assign_parm_find_data_types (&all, parm, &data); | |
3593 | ||
3594 | /* Early out for errors and void parameters. */ | |
3595 | if (data.passed_mode == VOIDmode || DECL_SIZE (parm) == NULL) | |
3596 | continue; | |
3597 | ||
3598 | /* Update info on where next arg arrives in registers. */ | |
39cba157 | 3599 | targetm.calls.function_arg_advance (all.args_so_far, data.promoted_mode, |
f387af4f | 3600 | data.passed_type, data.named_arg); |
6b275368 | 3601 | |
3602 | /* ??? Once upon a time variable_size stuffed parameter list | |
3603 | SAVE_EXPRs (amongst others) onto a pending sizes list. This | |
3604 | turned out to be less than manageable in the gimple world. | |
3605 | Now we have to hunt them down ourselves. */ | |
3606 | walk_tree_without_duplicates (&data.passed_type, | |
3607 | gimplify_parm_type, &stmts); | |
3608 | ||
4852b829 | 3609 | if (TREE_CODE (DECL_SIZE_UNIT (parm)) != INTEGER_CST) |
6b275368 | 3610 | { |
3611 | gimplify_one_sizepos (&DECL_SIZE (parm), &stmts); | |
3612 | gimplify_one_sizepos (&DECL_SIZE_UNIT (parm), &stmts); | |
3613 | } | |
3614 | ||
3615 | if (data.passed_pointer) | |
3616 | { | |
3617 | tree type = TREE_TYPE (data.passed_type); | |
39cba157 | 3618 | if (reference_callee_copied (&all.args_so_far_v, TYPE_MODE (type), |
6b275368 | 3619 | type, data.named_arg)) |
3620 | { | |
3621 | tree local, t; | |
3622 | ||
4852b829 | 3623 | /* For constant-sized objects, this is trivial; for |
6b275368 | 3624 | variable-sized objects, we have to play games. */ |
4852b829 | 3625 | if (TREE_CODE (DECL_SIZE_UNIT (parm)) == INTEGER_CST |
3626 | && !(flag_stack_check == GENERIC_STACK_CHECK | |
3627 | && compare_tree_int (DECL_SIZE_UNIT (parm), | |
3628 | STACK_CHECK_MAX_VAR_SIZE) > 0)) | |
6b275368 | 3629 | { |
63e6b59a | 3630 | local = create_tmp_var (type, get_name (parm)); |
6b275368 | 3631 | DECL_IGNORED_P (local) = 0; |
ab349ddd | 3632 | /* If PARM was addressable, move that flag over |
3633 | to the local copy, as its address will be taken, | |
5a715a82 | 3634 | not the PARMs. Keep the parms address taken |
3635 | as we'll query that flag during gimplification. */ | |
ab349ddd | 3636 | if (TREE_ADDRESSABLE (parm)) |
5a715a82 | 3637 | TREE_ADDRESSABLE (local) = 1; |
63e6b59a | 3638 | else if (TREE_CODE (type) == COMPLEX_TYPE |
3639 | || TREE_CODE (type) == VECTOR_TYPE) | |
3640 | DECL_GIMPLE_REG_P (local) = 1; | |
6b275368 | 3641 | } |
3642 | else | |
3643 | { | |
c2f47e15 | 3644 | tree ptr_type, addr; |
6b275368 | 3645 | |
3646 | ptr_type = build_pointer_type (type); | |
599548a7 | 3647 | addr = create_tmp_reg (ptr_type, get_name (parm)); |
6b275368 | 3648 | DECL_IGNORED_P (addr) = 0; |
3649 | local = build_fold_indirect_ref (addr); | |
3650 | ||
b9a16870 | 3651 | t = builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN); |
4f986f8b | 3652 | t = build_call_expr (t, 2, DECL_SIZE_UNIT (parm), |
581bf1c2 | 3653 | size_int (DECL_ALIGN (parm))); |
3654 | ||
990495a7 | 3655 | /* The call has been built for a variable-sized object. */ |
a882d754 | 3656 | CALL_ALLOCA_FOR_VAR_P (t) = 1; |
6b275368 | 3657 | t = fold_convert (ptr_type, t); |
75a70cf9 | 3658 | t = build2 (MODIFY_EXPR, TREE_TYPE (addr), addr, t); |
6b275368 | 3659 | gimplify_and_add (t, &stmts); |
3660 | } | |
3661 | ||
75a70cf9 | 3662 | gimplify_assign (local, parm, &stmts); |
6b275368 | 3663 | |
75fa4f82 | 3664 | SET_DECL_VALUE_EXPR (parm, local); |
3665 | DECL_HAS_VALUE_EXPR_P (parm) = 1; | |
6b275368 | 3666 | } |
3667 | } | |
3668 | } | |
3669 | ||
3e992c41 | 3670 | VEC_free (tree, heap, fnargs); |
3671 | ||
6b275368 | 3672 | return stmts; |
3673 | } | |
96b1130a | 3674 | \f |
897b77d6 | 3675 | /* Compute the size and offset from the start of the stacked arguments for a |
3676 | parm passed in mode PASSED_MODE and with type TYPE. | |
3677 | ||
3678 | INITIAL_OFFSET_PTR points to the current offset into the stacked | |
3679 | arguments. | |
3680 | ||
241399f6 | 3681 | The starting offset and size for this parm are returned in |
3682 | LOCATE->OFFSET and LOCATE->SIZE, respectively. When IN_REGS is | |
3683 | nonzero, the offset is that of stack slot, which is returned in | |
3684 | LOCATE->SLOT_OFFSET. LOCATE->ALIGNMENT_PAD is the amount of | |
3685 | padding required from the initial offset ptr to the stack slot. | |
897b77d6 | 3686 | |
6ef828f9 | 3687 | IN_REGS is nonzero if the argument will be passed in registers. It will |
897b77d6 | 3688 | never be set if REG_PARM_STACK_SPACE is not defined. |
3689 | ||
3690 | FNDECL is the function in which the argument was defined. | |
3691 | ||
3692 | There are two types of rounding that are done. The first, controlled by | |
bd99ba64 | 3693 | TARGET_FUNCTION_ARG_BOUNDARY, forces the offset from the start of the |
3694 | argument list to be aligned to the specific boundary (in bits). This | |
3695 | rounding affects the initial and starting offsets, but not the argument | |
3696 | size. | |
897b77d6 | 3697 | |
3698 | The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY, | |
3699 | optionally rounds the size of the parm to PARM_BOUNDARY. The | |
3700 | initial offset is not affected by this rounding, while the size always | |
3701 | is and the starting offset may be. */ | |
3702 | ||
241399f6 | 3703 | /* LOCATE->OFFSET will be negative for ARGS_GROW_DOWNWARD case; |
3704 | INITIAL_OFFSET_PTR is positive because locate_and_pad_parm's | |
897b77d6 | 3705 | callers pass in the total size of args so far as |
241399f6 | 3706 | INITIAL_OFFSET_PTR. LOCATE->SIZE is always positive. */ |
897b77d6 | 3707 | |
897b77d6 | 3708 | void |
de1b648b | 3709 | locate_and_pad_parm (enum machine_mode passed_mode, tree type, int in_regs, |
3710 | int partial, tree fndecl ATTRIBUTE_UNUSED, | |
3711 | struct args_size *initial_offset_ptr, | |
3712 | struct locate_and_pad_arg_data *locate) | |
897b77d6 | 3713 | { |
241399f6 | 3714 | tree sizetree; |
3715 | enum direction where_pad; | |
17bfc2bc | 3716 | unsigned int boundary, round_boundary; |
241399f6 | 3717 | int reg_parm_stack_space = 0; |
3718 | int part_size_in_regs; | |
897b77d6 | 3719 | |
3720 | #ifdef REG_PARM_STACK_SPACE | |
241399f6 | 3721 | reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl); |
241399f6 | 3722 | |
897b77d6 | 3723 | /* If we have found a stack parm before we reach the end of the |
3724 | area reserved for registers, skip that area. */ | |
3725 | if (! in_regs) | |
3726 | { | |
897b77d6 | 3727 | if (reg_parm_stack_space > 0) |
3728 | { | |
3729 | if (initial_offset_ptr->var) | |
3730 | { | |
3731 | initial_offset_ptr->var | |
3732 | = size_binop (MAX_EXPR, ARGS_SIZE_TREE (*initial_offset_ptr), | |
902de8ed | 3733 | ssize_int (reg_parm_stack_space)); |
897b77d6 | 3734 | initial_offset_ptr->constant = 0; |
3735 | } | |
3736 | else if (initial_offset_ptr->constant < reg_parm_stack_space) | |
3737 | initial_offset_ptr->constant = reg_parm_stack_space; | |
3738 | } | |
3739 | } | |
3740 | #endif /* REG_PARM_STACK_SPACE */ | |
3741 | ||
f054eb3c | 3742 | part_size_in_regs = (reg_parm_stack_space == 0 ? partial : 0); |
241399f6 | 3743 | |
3744 | sizetree | |
3745 | = type ? size_in_bytes (type) : size_int (GET_MODE_SIZE (passed_mode)); | |
3746 | where_pad = FUNCTION_ARG_PADDING (passed_mode, type); | |
bd99ba64 | 3747 | boundary = targetm.calls.function_arg_boundary (passed_mode, type); |
17bfc2bc | 3748 | round_boundary = targetm.calls.function_arg_round_boundary (passed_mode, |
3749 | type); | |
5f4cd670 | 3750 | locate->where_pad = where_pad; |
27a7a23a | 3751 | |
3752 | /* Alignment can't exceed MAX_SUPPORTED_STACK_ALIGNMENT. */ | |
3753 | if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT) | |
3754 | boundary = MAX_SUPPORTED_STACK_ALIGNMENT; | |
3755 | ||
c5dc0c32 | 3756 | locate->boundary = boundary; |
897b77d6 | 3757 | |
27a7a23a | 3758 | if (SUPPORTS_STACK_ALIGNMENT) |
3759 | { | |
3760 | /* stack_alignment_estimated can't change after stack has been | |
3761 | realigned. */ | |
3762 | if (crtl->stack_alignment_estimated < boundary) | |
3763 | { | |
3764 | if (!crtl->stack_realign_processed) | |
3765 | crtl->stack_alignment_estimated = boundary; | |
3766 | else | |
3767 | { | |
3768 | /* If stack is realigned and stack alignment value | |
3769 | hasn't been finalized, it is OK not to increase | |
3770 | stack_alignment_estimated. The bigger alignment | |
3771 | requirement is recorded in stack_alignment_needed | |
3772 | below. */ | |
3773 | gcc_assert (!crtl->stack_realign_finalized | |
3774 | && crtl->stack_realign_needed); | |
3775 | } | |
3776 | } | |
3777 | } | |
3778 | ||
90ab54b2 | 3779 | /* Remember if the outgoing parameter requires extra alignment on the |
3780 | calling function side. */ | |
edb7afe8 | 3781 | if (crtl->stack_alignment_needed < boundary) |
3782 | crtl->stack_alignment_needed = boundary; | |
27a7a23a | 3783 | if (crtl->preferred_stack_boundary < boundary) |
3784 | crtl->preferred_stack_boundary = boundary; | |
90ab54b2 | 3785 | |
897b77d6 | 3786 | #ifdef ARGS_GROW_DOWNWARD |
241399f6 | 3787 | locate->slot_offset.constant = -initial_offset_ptr->constant; |
897b77d6 | 3788 | if (initial_offset_ptr->var) |
241399f6 | 3789 | locate->slot_offset.var = size_binop (MINUS_EXPR, ssize_int (0), |
3790 | initial_offset_ptr->var); | |
ac965869 | 3791 | |
241399f6 | 3792 | { |
3793 | tree s2 = sizetree; | |
3794 | if (where_pad != none | |
3795 | && (!host_integerp (sizetree, 1) | |
17bfc2bc | 3796 | || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % round_boundary)) |
3797 | s2 = round_up (s2, round_boundary / BITS_PER_UNIT); | |
241399f6 | 3798 | SUB_PARM_SIZE (locate->slot_offset, s2); |
3799 | } | |
3800 | ||
3801 | locate->slot_offset.constant += part_size_in_regs; | |
ac965869 | 3802 | |
3803 | if (!in_regs | |
3804 | #ifdef REG_PARM_STACK_SPACE | |
3805 | || REG_PARM_STACK_SPACE (fndecl) > 0 | |
3806 | #endif | |
3807 | ) | |
241399f6 | 3808 | pad_to_arg_alignment (&locate->slot_offset, boundary, |
3809 | &locate->alignment_pad); | |
ac965869 | 3810 | |
241399f6 | 3811 | locate->size.constant = (-initial_offset_ptr->constant |
3812 | - locate->slot_offset.constant); | |
897b77d6 | 3813 | if (initial_offset_ptr->var) |
241399f6 | 3814 | locate->size.var = size_binop (MINUS_EXPR, |
3815 | size_binop (MINUS_EXPR, | |
3816 | ssize_int (0), | |
3817 | initial_offset_ptr->var), | |
3818 | locate->slot_offset.var); | |
3819 | ||
3820 | /* Pad_below needs the pre-rounded size to know how much to pad | |
3821 | below. */ | |
3822 | locate->offset = locate->slot_offset; | |
3823 | if (where_pad == downward) | |
3824 | pad_below (&locate->offset, passed_mode, sizetree); | |
ac965869 | 3825 | |
897b77d6 | 3826 | #else /* !ARGS_GROW_DOWNWARD */ |
166b1e83 | 3827 | if (!in_regs |
3828 | #ifdef REG_PARM_STACK_SPACE | |
3829 | || REG_PARM_STACK_SPACE (fndecl) > 0 | |
3830 | #endif | |
3831 | ) | |
241399f6 | 3832 | pad_to_arg_alignment (initial_offset_ptr, boundary, |
3833 | &locate->alignment_pad); | |
3834 | locate->slot_offset = *initial_offset_ptr; | |
897b77d6 | 3835 | |
3836 | #ifdef PUSH_ROUNDING | |
3837 | if (passed_mode != BLKmode) | |
3838 | sizetree = size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree))); | |
3839 | #endif | |
3840 | ||
82f48b55 | 3841 | /* Pad_below needs the pre-rounded size to know how much to pad below |
3842 | so this must be done before rounding up. */ | |
241399f6 | 3843 | locate->offset = locate->slot_offset; |
3844 | if (where_pad == downward) | |
3845 | pad_below (&locate->offset, passed_mode, sizetree); | |
82f48b55 | 3846 | |
897b77d6 | 3847 | if (where_pad != none |
46107564 | 3848 | && (!host_integerp (sizetree, 1) |
17bfc2bc | 3849 | || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % round_boundary)) |
3850 | sizetree = round_up (sizetree, round_boundary / BITS_PER_UNIT); | |
897b77d6 | 3851 | |
241399f6 | 3852 | ADD_PARM_SIZE (locate->size, sizetree); |
3853 | ||
3854 | locate->size.constant -= part_size_in_regs; | |
897b77d6 | 3855 | #endif /* ARGS_GROW_DOWNWARD */ |
b704e80f | 3856 | |
3857 | #ifdef FUNCTION_ARG_OFFSET | |
3858 | locate->offset.constant += FUNCTION_ARG_OFFSET (passed_mode, type); | |
3859 | #endif | |
897b77d6 | 3860 | } |
3861 | ||
ba585215 | 3862 | /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY. |
3863 | BOUNDARY is measured in bits, but must be a multiple of a storage unit. */ | |
3864 | ||
897b77d6 | 3865 | static void |
de1b648b | 3866 | pad_to_arg_alignment (struct args_size *offset_ptr, int boundary, |
3867 | struct args_size *alignment_pad) | |
897b77d6 | 3868 | { |
ef2c4a29 | 3869 | tree save_var = NULL_TREE; |
3870 | HOST_WIDE_INT save_constant = 0; | |
5cf5baa2 | 3871 | int boundary_in_bytes = boundary / BITS_PER_UNIT; |
891a1732 | 3872 | HOST_WIDE_INT sp_offset = STACK_POINTER_OFFSET; |
3873 | ||
3874 | #ifdef SPARC_STACK_BOUNDARY_HACK | |
1aecae7f | 3875 | /* ??? The SPARC port may claim a STACK_BOUNDARY higher than |
3876 | the real alignment of %sp. However, when it does this, the | |
3877 | alignment of %sp+STACK_POINTER_OFFSET is STACK_BOUNDARY. */ | |
891a1732 | 3878 | if (SPARC_STACK_BOUNDARY_HACK) |
3879 | sp_offset = 0; | |
3880 | #endif | |
9d855d2f | 3881 | |
b3f75873 | 3882 | if (boundary > PARM_BOUNDARY) |
9d855d2f | 3883 | { |
3884 | save_var = offset_ptr->var; | |
3885 | save_constant = offset_ptr->constant; | |
3886 | } | |
3887 | ||
3888 | alignment_pad->var = NULL_TREE; | |
3889 | alignment_pad->constant = 0; | |
9d855d2f | 3890 | |
897b77d6 | 3891 | if (boundary > BITS_PER_UNIT) |
3892 | { | |
3893 | if (offset_ptr->var) | |
3894 | { | |
891a1732 | 3895 | tree sp_offset_tree = ssize_int (sp_offset); |
3896 | tree offset = size_binop (PLUS_EXPR, | |
3897 | ARGS_SIZE_TREE (*offset_ptr), | |
3898 | sp_offset_tree); | |
897b77d6 | 3899 | #ifdef ARGS_GROW_DOWNWARD |
891a1732 | 3900 | tree rounded = round_down (offset, boundary / BITS_PER_UNIT); |
897b77d6 | 3901 | #else |
891a1732 | 3902 | tree rounded = round_up (offset, boundary / BITS_PER_UNIT); |
897b77d6 | 3903 | #endif |
891a1732 | 3904 | |
3905 | offset_ptr->var = size_binop (MINUS_EXPR, rounded, sp_offset_tree); | |
241399f6 | 3906 | /* ARGS_SIZE_TREE includes constant term. */ |
3907 | offset_ptr->constant = 0; | |
b3f75873 | 3908 | if (boundary > PARM_BOUNDARY) |
d3371fcd | 3909 | alignment_pad->var = size_binop (MINUS_EXPR, offset_ptr->var, |
902de8ed | 3910 | save_var); |
897b77d6 | 3911 | } |
3912 | else | |
06ebc183 | 3913 | { |
891a1732 | 3914 | offset_ptr->constant = -sp_offset + |
897b77d6 | 3915 | #ifdef ARGS_GROW_DOWNWARD |
891a1732 | 3916 | FLOOR_ROUND (offset_ptr->constant + sp_offset, boundary_in_bytes); |
897b77d6 | 3917 | #else |
891a1732 | 3918 | CEIL_ROUND (offset_ptr->constant + sp_offset, boundary_in_bytes); |
897b77d6 | 3919 | #endif |
b3f75873 | 3920 | if (boundary > PARM_BOUNDARY) |
06ebc183 | 3921 | alignment_pad->constant = offset_ptr->constant - save_constant; |
3922 | } | |
897b77d6 | 3923 | } |
3924 | } | |
3925 | ||
3926 | static void | |
de1b648b | 3927 | pad_below (struct args_size *offset_ptr, enum machine_mode passed_mode, tree sizetree) |
897b77d6 | 3928 | { |
3929 | if (passed_mode != BLKmode) | |
3930 | { | |
3931 | if (GET_MODE_BITSIZE (passed_mode) % PARM_BOUNDARY) | |
3932 | offset_ptr->constant | |
3933 | += (((GET_MODE_BITSIZE (passed_mode) + PARM_BOUNDARY - 1) | |
3934 | / PARM_BOUNDARY * PARM_BOUNDARY / BITS_PER_UNIT) | |
3935 | - GET_MODE_SIZE (passed_mode)); | |
3936 | } | |
3937 | else | |
3938 | { | |
3939 | if (TREE_CODE (sizetree) != INTEGER_CST | |
3940 | || (TREE_INT_CST_LOW (sizetree) * BITS_PER_UNIT) % PARM_BOUNDARY) | |
3941 | { | |
3942 | /* Round the size up to multiple of PARM_BOUNDARY bits. */ | |
3943 | tree s2 = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT); | |
3944 | /* Add it in. */ | |
3945 | ADD_PARM_SIZE (*offset_ptr, s2); | |
3946 | SUB_PARM_SIZE (*offset_ptr, sizetree); | |
3947 | } | |
3948 | } | |
3949 | } | |
897b77d6 | 3950 | \f |
897b77d6 | 3951 | |
3072d30e | 3952 | /* True if register REGNO was alive at a place where `setjmp' was |
3953 | called and was set more than once or is an argument. Such regs may | |
3954 | be clobbered by `longjmp'. */ | |
3955 | ||
3956 | static bool | |
3957 | regno_clobbered_at_setjmp (bitmap setjmp_crosses, int regno) | |
3958 | { | |
3959 | /* There appear to be cases where some local vars never reach the | |
3960 | backend but have bogus regnos. */ | |
3961 | if (regno >= max_reg_num ()) | |
3962 | return false; | |
3963 | ||
3964 | return ((REG_N_SETS (regno) > 1 | |
3965 | || REGNO_REG_SET_P (df_get_live_out (ENTRY_BLOCK_PTR), regno)) | |
3966 | && REGNO_REG_SET_P (setjmp_crosses, regno)); | |
3967 | } | |
3968 | ||
3969 | /* Walk the tree of blocks describing the binding levels within a | |
3970 | function and warn about variables the might be killed by setjmp or | |
3971 | vfork. This is done after calling flow_analysis before register | |
3972 | allocation since that will clobber the pseudo-regs to hard | |
3973 | regs. */ | |
3974 | ||
3975 | static void | |
3976 | setjmp_vars_warning (bitmap setjmp_crosses, tree block) | |
897b77d6 | 3977 | { |
19cb6b50 | 3978 | tree decl, sub; |
4ee9c684 | 3979 | |
1767a056 | 3980 | for (decl = BLOCK_VARS (block); decl; decl = DECL_CHAIN (decl)) |
897b77d6 | 3981 | { |
4ee9c684 | 3982 | if (TREE_CODE (decl) == VAR_DECL |
49bf95f0 | 3983 | && DECL_RTL_SET_P (decl) |
8ad4c111 | 3984 | && REG_P (DECL_RTL (decl)) |
3072d30e | 3985 | && regno_clobbered_at_setjmp (setjmp_crosses, REGNO (DECL_RTL (decl)))) |
48e1416a | 3986 | warning (OPT_Wclobbered, "variable %q+D might be clobbered by" |
0d438110 | 3987 | " %<longjmp%> or %<vfork%>", decl); |
897b77d6 | 3988 | } |
4ee9c684 | 3989 | |
93110716 | 3990 | for (sub = BLOCK_SUBBLOCKS (block); sub; sub = BLOCK_CHAIN (sub)) |
3072d30e | 3991 | setjmp_vars_warning (setjmp_crosses, sub); |
897b77d6 | 3992 | } |
3993 | ||
4ee9c684 | 3994 | /* Do the appropriate part of setjmp_vars_warning |
897b77d6 | 3995 | but for arguments instead of local variables. */ |
3996 | ||
3072d30e | 3997 | static void |
3998 | setjmp_args_warning (bitmap setjmp_crosses) | |
897b77d6 | 3999 | { |
19cb6b50 | 4000 | tree decl; |
897b77d6 | 4001 | for (decl = DECL_ARGUMENTS (current_function_decl); |
1767a056 | 4002 | decl; decl = DECL_CHAIN (decl)) |
897b77d6 | 4003 | if (DECL_RTL (decl) != 0 |
8ad4c111 | 4004 | && REG_P (DECL_RTL (decl)) |
3072d30e | 4005 | && regno_clobbered_at_setjmp (setjmp_crosses, REGNO (DECL_RTL (decl)))) |
48e1416a | 4006 | warning (OPT_Wclobbered, |
0d438110 | 4007 | "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>", |
3cf8b391 | 4008 | decl); |
897b77d6 | 4009 | } |
4010 | ||
3072d30e | 4011 | /* Generate warning messages for variables live across setjmp. */ |
4012 | ||
48e1416a | 4013 | void |
3072d30e | 4014 | generate_setjmp_warnings (void) |
4015 | { | |
4016 | bitmap setjmp_crosses = regstat_get_setjmp_crosses (); | |
4017 | ||
4018 | if (n_basic_blocks == NUM_FIXED_BLOCKS | |
4019 | || bitmap_empty_p (setjmp_crosses)) | |
4020 | return; | |
4021 | ||
4022 | setjmp_vars_warning (setjmp_crosses, DECL_INITIAL (current_function_decl)); | |
4023 | setjmp_args_warning (setjmp_crosses); | |
4024 | } | |
4025 | ||
897b77d6 | 4026 | \f |
d6263c49 | 4027 | /* Reverse the order of elements in the fragment chain T of blocks, |
665611e7 | 4028 | and return the new head of the chain (old last element). |
4029 | In addition to that clear BLOCK_SAME_RANGE flags when needed | |
4030 | and adjust BLOCK_SUPERCONTEXT from the super fragment to | |
4031 | its super fragment origin. */ | |
d6263c49 | 4032 | |
4033 | static tree | |
4034 | block_fragments_nreverse (tree t) | |
4035 | { | |
665611e7 | 4036 | tree prev = 0, block, next, prev_super = 0; |
4037 | tree super = BLOCK_SUPERCONTEXT (t); | |
4038 | if (BLOCK_FRAGMENT_ORIGIN (super)) | |
4039 | super = BLOCK_FRAGMENT_ORIGIN (super); | |
d6263c49 | 4040 | for (block = t; block; block = next) |
4041 | { | |
4042 | next = BLOCK_FRAGMENT_CHAIN (block); | |
4043 | BLOCK_FRAGMENT_CHAIN (block) = prev; | |
665611e7 | 4044 | if ((prev && !BLOCK_SAME_RANGE (prev)) |
4045 | || (BLOCK_FRAGMENT_CHAIN (BLOCK_SUPERCONTEXT (block)) | |
4046 | != prev_super)) | |
4047 | BLOCK_SAME_RANGE (block) = 0; | |
4048 | prev_super = BLOCK_SUPERCONTEXT (block); | |
4049 | BLOCK_SUPERCONTEXT (block) = super; | |
d6263c49 | 4050 | prev = block; |
4051 | } | |
665611e7 | 4052 | t = BLOCK_FRAGMENT_ORIGIN (t); |
4053 | if (BLOCK_FRAGMENT_CHAIN (BLOCK_SUPERCONTEXT (t)) | |
4054 | != prev_super) | |
4055 | BLOCK_SAME_RANGE (t) = 0; | |
4056 | BLOCK_SUPERCONTEXT (t) = super; | |
d6263c49 | 4057 | return prev; |
4058 | } | |
4059 | ||
4060 | /* Reverse the order of elements in the chain T of blocks, | |
4061 | and return the new head of the chain (old last element). | |
4062 | Also do the same on subblocks and reverse the order of elements | |
4063 | in BLOCK_FRAGMENT_CHAIN as well. */ | |
4064 | ||
4065 | static tree | |
4066 | blocks_nreverse_all (tree t) | |
4067 | { | |
4068 | tree prev = 0, block, next; | |
4069 | for (block = t; block; block = next) | |
4070 | { | |
4071 | next = BLOCK_CHAIN (block); | |
4072 | BLOCK_CHAIN (block) = prev; | |
d6263c49 | 4073 | if (BLOCK_FRAGMENT_CHAIN (block) |
4074 | && BLOCK_FRAGMENT_ORIGIN (block) == NULL_TREE) | |
665611e7 | 4075 | { |
4076 | BLOCK_FRAGMENT_CHAIN (block) | |
4077 | = block_fragments_nreverse (BLOCK_FRAGMENT_CHAIN (block)); | |
4078 | if (!BLOCK_SAME_RANGE (BLOCK_FRAGMENT_CHAIN (block))) | |
4079 | BLOCK_SAME_RANGE (block) = 0; | |
4080 | } | |
4081 | BLOCK_SUBBLOCKS (block) = blocks_nreverse_all (BLOCK_SUBBLOCKS (block)); | |
d6263c49 | 4082 | prev = block; |
4083 | } | |
4084 | return prev; | |
4085 | } | |
4086 | ||
4087 | ||
a36145ca | 4088 | /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END}, |
4089 | and create duplicate blocks. */ | |
4090 | /* ??? Need an option to either create block fragments or to create | |
4091 | abstract origin duplicates of a source block. It really depends | |
4092 | on what optimization has been performed. */ | |
11b373ff | 4093 | |
f1ab82be | 4094 | void |
de1b648b | 4095 | reorder_blocks (void) |
11b373ff | 4096 | { |
f1ab82be | 4097 | tree block = DECL_INITIAL (current_function_decl); |
573a97ad | 4098 | VEC(tree,heap) *block_stack; |
11b373ff | 4099 | |
0c45344e | 4100 | if (block == NULL_TREE) |
f1ab82be | 4101 | return; |
9d819987 | 4102 | |
573a97ad | 4103 | block_stack = VEC_alloc (tree, heap, 10); |
5846cb0f | 4104 | |
a36145ca | 4105 | /* Reset the TREE_ASM_WRITTEN bit for all blocks. */ |
4ee9c684 | 4106 | clear_block_marks (block); |
a36145ca | 4107 | |
f1ab82be | 4108 | /* Prune the old trees away, so that they don't get in the way. */ |
4109 | BLOCK_SUBBLOCKS (block) = NULL_TREE; | |
4110 | BLOCK_CHAIN (block) = NULL_TREE; | |
9d819987 | 4111 | |
a36145ca | 4112 | /* Recreate the block tree from the note nesting. */ |
f1ab82be | 4113 | reorder_blocks_1 (get_insns (), block, &block_stack); |
d6263c49 | 4114 | BLOCK_SUBBLOCKS (block) = blocks_nreverse_all (BLOCK_SUBBLOCKS (block)); |
5846cb0f | 4115 | |
573a97ad | 4116 | VEC_free (tree, heap, block_stack); |
11b373ff | 4117 | } |
4118 | ||
a36145ca | 4119 | /* Helper function for reorder_blocks. Reset TREE_ASM_WRITTEN. */ |
60ecc450 | 4120 | |
4ee9c684 | 4121 | void |
4122 | clear_block_marks (tree block) | |
5e960ca9 | 4123 | { |
a36145ca | 4124 | while (block) |
5e960ca9 | 4125 | { |
a36145ca | 4126 | TREE_ASM_WRITTEN (block) = 0; |
4ee9c684 | 4127 | clear_block_marks (BLOCK_SUBBLOCKS (block)); |
a36145ca | 4128 | block = BLOCK_CHAIN (block); |
5e960ca9 | 4129 | } |
4130 | } | |
4131 | ||
60ecc450 | 4132 | static void |
573a97ad | 4133 | reorder_blocks_1 (rtx insns, tree current_block, VEC(tree,heap) **p_block_stack) |
60ecc450 | 4134 | { |
4135 | rtx insn; | |
665611e7 | 4136 | tree prev_beg = NULL_TREE, prev_end = NULL_TREE; |
60ecc450 | 4137 | |
4138 | for (insn = insns; insn; insn = NEXT_INSN (insn)) | |
4139 | { | |
6d7dc5b9 | 4140 | if (NOTE_P (insn)) |
60ecc450 | 4141 | { |
ad4583d9 | 4142 | if (NOTE_KIND (insn) == NOTE_INSN_BLOCK_BEG) |
60ecc450 | 4143 | { |
4144 | tree block = NOTE_BLOCK (insn); | |
70392493 | 4145 | tree origin; |
4146 | ||
d6263c49 | 4147 | gcc_assert (BLOCK_FRAGMENT_ORIGIN (block) == NULL_TREE); |
4148 | origin = block; | |
a36145ca | 4149 | |
665611e7 | 4150 | if (prev_end) |
4151 | BLOCK_SAME_RANGE (prev_end) = 0; | |
4152 | prev_end = NULL_TREE; | |
4153 | ||
a36145ca | 4154 | /* If we have seen this block before, that means it now |
4155 | spans multiple address regions. Create a new fragment. */ | |
60ecc450 | 4156 | if (TREE_ASM_WRITTEN (block)) |
4157 | { | |
a36145ca | 4158 | tree new_block = copy_node (block); |
a36145ca | 4159 | |
665611e7 | 4160 | BLOCK_SAME_RANGE (new_block) = 0; |
a36145ca | 4161 | BLOCK_FRAGMENT_ORIGIN (new_block) = origin; |
4162 | BLOCK_FRAGMENT_CHAIN (new_block) | |
4163 | = BLOCK_FRAGMENT_CHAIN (origin); | |
4164 | BLOCK_FRAGMENT_CHAIN (origin) = new_block; | |
4165 | ||
4166 | NOTE_BLOCK (insn) = new_block; | |
4167 | block = new_block; | |
60ecc450 | 4168 | } |
a36145ca | 4169 | |
665611e7 | 4170 | if (prev_beg == current_block && prev_beg) |
4171 | BLOCK_SAME_RANGE (block) = 1; | |
4172 | ||
4173 | prev_beg = origin; | |
4174 | ||
60ecc450 | 4175 | BLOCK_SUBBLOCKS (block) = 0; |
4176 | TREE_ASM_WRITTEN (block) = 1; | |
31ddae9f | 4177 | /* When there's only one block for the entire function, |
4178 | current_block == block and we mustn't do this, it | |
4179 | will cause infinite recursion. */ | |
4180 | if (block != current_block) | |
4181 | { | |
665611e7 | 4182 | tree super; |
70392493 | 4183 | if (block != origin) |
665611e7 | 4184 | gcc_assert (BLOCK_SUPERCONTEXT (origin) == current_block |
4185 | || BLOCK_FRAGMENT_ORIGIN (BLOCK_SUPERCONTEXT | |
4186 | (origin)) | |
4187 | == current_block); | |
4188 | if (VEC_empty (tree, *p_block_stack)) | |
4189 | super = current_block; | |
4190 | else | |
4191 | { | |
4192 | super = VEC_last (tree, *p_block_stack); | |
4193 | gcc_assert (super == current_block | |
4194 | || BLOCK_FRAGMENT_ORIGIN (super) | |
4195 | == current_block); | |
4196 | } | |
4197 | BLOCK_SUPERCONTEXT (block) = super; | |
31ddae9f | 4198 | BLOCK_CHAIN (block) = BLOCK_SUBBLOCKS (current_block); |
4199 | BLOCK_SUBBLOCKS (current_block) = block; | |
70392493 | 4200 | current_block = origin; |
31ddae9f | 4201 | } |
573a97ad | 4202 | VEC_safe_push (tree, heap, *p_block_stack, block); |
60ecc450 | 4203 | } |
ad4583d9 | 4204 | else if (NOTE_KIND (insn) == NOTE_INSN_BLOCK_END) |
60ecc450 | 4205 | { |
573a97ad | 4206 | NOTE_BLOCK (insn) = VEC_pop (tree, *p_block_stack); |
60ecc450 | 4207 | current_block = BLOCK_SUPERCONTEXT (current_block); |
665611e7 | 4208 | if (BLOCK_FRAGMENT_ORIGIN (current_block)) |
4209 | current_block = BLOCK_FRAGMENT_ORIGIN (current_block); | |
4210 | prev_beg = NULL_TREE; | |
4211 | prev_end = BLOCK_SAME_RANGE (NOTE_BLOCK (insn)) | |
4212 | ? NOTE_BLOCK (insn) : NULL_TREE; | |
60ecc450 | 4213 | } |
4214 | } | |
665611e7 | 4215 | else |
4216 | { | |
4217 | prev_beg = NULL_TREE; | |
4218 | if (prev_end) | |
4219 | BLOCK_SAME_RANGE (prev_end) = 0; | |
4220 | prev_end = NULL_TREE; | |
4221 | } | |
60ecc450 | 4222 | } |
4223 | } | |
4224 | ||
11b373ff | 4225 | /* Reverse the order of elements in the chain T of blocks, |
4226 | and return the new head of the chain (old last element). */ | |
4227 | ||
4ee9c684 | 4228 | tree |
de1b648b | 4229 | blocks_nreverse (tree t) |
11b373ff | 4230 | { |
d6263c49 | 4231 | tree prev = 0, block, next; |
4232 | for (block = t; block; block = next) | |
11b373ff | 4233 | { |
d6263c49 | 4234 | next = BLOCK_CHAIN (block); |
4235 | BLOCK_CHAIN (block) = prev; | |
4236 | prev = block; | |
11b373ff | 4237 | } |
4238 | return prev; | |
4239 | } | |
4240 | ||
2149d019 | 4241 | /* Concatenate two chains of blocks (chained through BLOCK_CHAIN) |
4242 | by modifying the last node in chain 1 to point to chain 2. */ | |
4243 | ||
4244 | tree | |
4245 | block_chainon (tree op1, tree op2) | |
4246 | { | |
4247 | tree t1; | |
4248 | ||
4249 | if (!op1) | |
4250 | return op2; | |
4251 | if (!op2) | |
4252 | return op1; | |
4253 | ||
4254 | for (t1 = op1; BLOCK_CHAIN (t1); t1 = BLOCK_CHAIN (t1)) | |
4255 | continue; | |
4256 | BLOCK_CHAIN (t1) = op2; | |
4257 | ||
4258 | #ifdef ENABLE_TREE_CHECKING | |
4259 | { | |
4260 | tree t2; | |
4261 | for (t2 = op2; t2; t2 = BLOCK_CHAIN (t2)) | |
4262 | gcc_assert (t2 != t1); | |
4263 | } | |
4264 | #endif | |
4265 | ||
4266 | return op1; | |
4267 | } | |
4268 | ||
5846cb0f | 4269 | /* Count the subblocks of the list starting with BLOCK. If VECTOR is |
4270 | non-NULL, list them all into VECTOR, in a depth-first preorder | |
4271 | traversal of the block tree. Also clear TREE_ASM_WRITTEN in all | |
396bfb69 | 4272 | blocks. */ |
11b373ff | 4273 | |
4274 | static int | |
de1b648b | 4275 | all_blocks (tree block, tree *vector) |
11b373ff | 4276 | { |
396bfb69 | 4277 | int n_blocks = 0; |
4278 | ||
874a9b8d | 4279 | while (block) |
4280 | { | |
4281 | TREE_ASM_WRITTEN (block) = 0; | |
396bfb69 | 4282 | |
874a9b8d | 4283 | /* Record this block. */ |
4284 | if (vector) | |
4285 | vector[n_blocks] = block; | |
396bfb69 | 4286 | |
874a9b8d | 4287 | ++n_blocks; |
06ebc183 | 4288 | |
874a9b8d | 4289 | /* Record the subblocks, and their subblocks... */ |
4290 | n_blocks += all_blocks (BLOCK_SUBBLOCKS (block), | |
4291 | vector ? vector + n_blocks : 0); | |
4292 | block = BLOCK_CHAIN (block); | |
4293 | } | |
11b373ff | 4294 | |
4295 | return n_blocks; | |
4296 | } | |
5846cb0f | 4297 | |
4298 | /* Return a vector containing all the blocks rooted at BLOCK. The | |
4299 | number of elements in the vector is stored in N_BLOCKS_P. The | |
4300 | vector is dynamically allocated; it is the caller's responsibility | |
4301 | to call `free' on the pointer returned. */ | |
06ebc183 | 4302 | |
5846cb0f | 4303 | static tree * |
de1b648b | 4304 | get_block_vector (tree block, int *n_blocks_p) |
5846cb0f | 4305 | { |
4306 | tree *block_vector; | |
4307 | ||
4308 | *n_blocks_p = all_blocks (block, NULL); | |
4c36ffe6 | 4309 | block_vector = XNEWVEC (tree, *n_blocks_p); |
5846cb0f | 4310 | all_blocks (block, block_vector); |
4311 | ||
4312 | return block_vector; | |
4313 | } | |
4314 | ||
177c2ebc | 4315 | static GTY(()) int next_block_index = 2; |
5846cb0f | 4316 | |
4317 | /* Set BLOCK_NUMBER for all the blocks in FN. */ | |
4318 | ||
4319 | void | |
de1b648b | 4320 | number_blocks (tree fn) |
5846cb0f | 4321 | { |
4322 | int i; | |
4323 | int n_blocks; | |
4324 | tree *block_vector; | |
4325 | ||
4326 | /* For SDB and XCOFF debugging output, we start numbering the blocks | |
4327 | from 1 within each function, rather than keeping a running | |
4328 | count. */ | |
4329 | #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO) | |
0eb76379 | 4330 | if (write_symbols == SDB_DEBUG || write_symbols == XCOFF_DEBUG) |
4331 | next_block_index = 1; | |
5846cb0f | 4332 | #endif |
4333 | ||
4334 | block_vector = get_block_vector (DECL_INITIAL (fn), &n_blocks); | |
4335 | ||
4336 | /* The top-level BLOCK isn't numbered at all. */ | |
4337 | for (i = 1; i < n_blocks; ++i) | |
4338 | /* We number the blocks from two. */ | |
4339 | BLOCK_NUMBER (block_vector[i]) = next_block_index++; | |
4340 | ||
4341 | free (block_vector); | |
4342 | ||
4343 | return; | |
4344 | } | |
baa8dec7 | 4345 | |
4346 | /* If VAR is present in a subblock of BLOCK, return the subblock. */ | |
4347 | ||
4b987fac | 4348 | DEBUG_FUNCTION tree |
de1b648b | 4349 | debug_find_var_in_block_tree (tree var, tree block) |
baa8dec7 | 4350 | { |
4351 | tree t; | |
4352 | ||
4353 | for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t)) | |
4354 | if (t == var) | |
4355 | return block; | |
4356 | ||
4357 | for (t = BLOCK_SUBBLOCKS (block); t; t = TREE_CHAIN (t)) | |
4358 | { | |
4359 | tree ret = debug_find_var_in_block_tree (var, t); | |
4360 | if (ret) | |
4361 | return ret; | |
4362 | } | |
4363 | ||
4364 | return NULL_TREE; | |
4365 | } | |
11b373ff | 4366 | \f |
87d4aa85 | 4367 | /* Keep track of whether we're in a dummy function context. If we are, |
4368 | we don't want to invoke the set_current_function hook, because we'll | |
4369 | get into trouble if the hook calls target_reinit () recursively or | |
4370 | when the initial initialization is not yet complete. */ | |
4371 | ||
4372 | static bool in_dummy_function; | |
4373 | ||
46f8e3b0 | 4374 | /* Invoke the target hook when setting cfun. Update the optimization options |
4375 | if the function uses different options than the default. */ | |
87d4aa85 | 4376 | |
4377 | static void | |
4378 | invoke_set_current_function_hook (tree fndecl) | |
4379 | { | |
4380 | if (!in_dummy_function) | |
46f8e3b0 | 4381 | { |
4382 | tree opts = ((fndecl) | |
4383 | ? DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl) | |
4384 | : optimization_default_node); | |
4385 | ||
4386 | if (!opts) | |
4387 | opts = optimization_default_node; | |
4388 | ||
4389 | /* Change optimization options if needed. */ | |
4390 | if (optimization_current_node != opts) | |
4391 | { | |
4392 | optimization_current_node = opts; | |
2c5d2e39 | 4393 | cl_optimization_restore (&global_options, TREE_OPTIMIZATION (opts)); |
46f8e3b0 | 4394 | } |
4395 | ||
4396 | targetm.set_current_function (fndecl); | |
4397 | } | |
87d4aa85 | 4398 | } |
4399 | ||
4400 | /* cfun should never be set directly; use this function. */ | |
4401 | ||
4402 | void | |
4403 | set_cfun (struct function *new_cfun) | |
4404 | { | |
4405 | if (cfun != new_cfun) | |
4406 | { | |
4407 | cfun = new_cfun; | |
4408 | invoke_set_current_function_hook (new_cfun ? new_cfun->decl : NULL_TREE); | |
4409 | } | |
4410 | } | |
4411 | ||
87d4aa85 | 4412 | /* Initialized with NOGC, making this poisonous to the garbage collector. */ |
4413 | ||
4414 | static VEC(function_p,heap) *cfun_stack; | |
4415 | ||
4416 | /* Push the current cfun onto the stack, and set cfun to new_cfun. */ | |
4417 | ||
4418 | void | |
4419 | push_cfun (struct function *new_cfun) | |
4420 | { | |
4421 | VEC_safe_push (function_p, heap, cfun_stack, cfun); | |
4422 | set_cfun (new_cfun); | |
4423 | } | |
4424 | ||
4425 | /* Pop cfun from the stack. */ | |
4426 | ||
4427 | void | |
4428 | pop_cfun (void) | |
4429 | { | |
3c9dcda1 | 4430 | struct function *new_cfun = VEC_pop (function_p, cfun_stack); |
3c9dcda1 | 4431 | set_cfun (new_cfun); |
87d4aa85 | 4432 | } |
a3adcd4a | 4433 | |
4434 | /* Return value of funcdef and increase it. */ | |
4435 | int | |
48e1416a | 4436 | get_next_funcdef_no (void) |
a3adcd4a | 4437 | { |
4438 | return funcdef_no++; | |
4439 | } | |
4440 | ||
1ad3e14c | 4441 | /* Return value of funcdef. */ |
4442 | int | |
4443 | get_last_funcdef_no (void) | |
4444 | { | |
4445 | return funcdef_no; | |
4446 | } | |
4447 | ||
ecc82929 | 4448 | /* Allocate a function structure for FNDECL and set its contents |
87d4aa85 | 4449 | to the defaults. Set cfun to the newly-allocated object. |
4450 | Some of the helper functions invoked during initialization assume | |
4451 | that cfun has already been set. Therefore, assign the new object | |
4452 | directly into cfun and invoke the back end hook explicitly at the | |
4453 | very end, rather than initializing a temporary and calling set_cfun | |
4454 | on it. | |
80f2ef47 | 4455 | |
4456 | ABSTRACT_P is true if this is a function that will never be seen by | |
4457 | the middle-end. Such functions are front-end concepts (like C++ | |
4458 | function templates) that do not correspond directly to functions | |
4459 | placed in object files. */ | |
942cc45f | 4460 | |
ecc82929 | 4461 | void |
80f2ef47 | 4462 | allocate_struct_function (tree fndecl, bool abstract_p) |
897b77d6 | 4463 | { |
ecc82929 | 4464 | tree result; |
4ee9c684 | 4465 | tree fntype = fndecl ? TREE_TYPE (fndecl) : NULL_TREE; |
897b77d6 | 4466 | |
ba72912a | 4467 | cfun = ggc_alloc_cleared_function (); |
304c5bf1 | 4468 | |
ecc82929 | 4469 | init_eh_for_function (); |
897b77d6 | 4470 | |
ecc82929 | 4471 | if (init_machine_status) |
4472 | cfun->machine = (*init_machine_status) (); | |
26df1c5e | 4473 | |
d3feb168 | 4474 | #ifdef OVERRIDE_ABI_FORMAT |
4475 | OVERRIDE_ABI_FORMAT (fndecl); | |
4476 | #endif | |
4477 | ||
342ad2d6 | 4478 | invoke_set_current_function_hook (fndecl); |
4479 | ||
22c61100 | 4480 | if (fndecl != NULL_TREE) |
ecc82929 | 4481 | { |
87d4aa85 | 4482 | DECL_STRUCT_FUNCTION (fndecl) = cfun; |
4483 | cfun->decl = fndecl; | |
285aabd1 | 4484 | current_function_funcdef_no = get_next_funcdef_no (); |
87d4aa85 | 4485 | |
4486 | result = DECL_RESULT (fndecl); | |
80f2ef47 | 4487 | if (!abstract_p && aggregate_value_p (result, fndecl)) |
87d4aa85 | 4488 | { |
ecc82929 | 4489 | #ifdef PCC_STATIC_STRUCT_RETURN |
18d50ae6 | 4490 | cfun->returns_pcc_struct = 1; |
ecc82929 | 4491 | #endif |
18d50ae6 | 4492 | cfun->returns_struct = 1; |
87d4aa85 | 4493 | } |
4494 | ||
257d99c3 | 4495 | cfun->stdarg = stdarg_p (fntype); |
48e1416a | 4496 | |
87d4aa85 | 4497 | /* Assume all registers in stdarg functions need to be saved. */ |
4498 | cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE; | |
4499 | cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE; | |
cbeb677e | 4500 | |
4501 | /* ??? This could be set on a per-function basis by the front-end | |
4502 | but is this worth the hassle? */ | |
4503 | cfun->can_throw_non_call_exceptions = flag_non_call_exceptions; | |
ecc82929 | 4504 | } |
87d4aa85 | 4505 | } |
4506 | ||
4507 | /* This is like allocate_struct_function, but pushes a new cfun for FNDECL | |
4508 | instead of just setting it. */ | |
a6c787e5 | 4509 | |
87d4aa85 | 4510 | void |
4511 | push_struct_function (tree fndecl) | |
4512 | { | |
4513 | VEC_safe_push (function_p, heap, cfun_stack, cfun); | |
80f2ef47 | 4514 | allocate_struct_function (fndecl, false); |
ecc82929 | 4515 | } |
897b77d6 | 4516 | |
cbeb677e | 4517 | /* Reset crtl and other non-struct-function variables to defaults as |
f024691d | 4518 | appropriate for emitting rtl at the start of a function. */ |
897b77d6 | 4519 | |
ecc82929 | 4520 | static void |
87d4aa85 | 4521 | prepare_function_start (void) |
ecc82929 | 4522 | { |
fd6ffb7c | 4523 | gcc_assert (!crtl->emit.x_last_insn); |
fef299ce | 4524 | init_temp_slots (); |
957211e4 | 4525 | init_emit (); |
b079a207 | 4526 | init_varasm_status (); |
957211e4 | 4527 | init_expr (); |
7dfb44a0 | 4528 | default_rtl_profile (); |
897b77d6 | 4529 | |
8c0dd614 | 4530 | if (flag_stack_usage_info) |
990495a7 | 4531 | { |
4532 | cfun->su = ggc_alloc_cleared_stack_usage (); | |
4533 | cfun->su->static_stack_size = -1; | |
4534 | } | |
4535 | ||
ecc82929 | 4536 | cse_not_expected = ! optimize; |
897b77d6 | 4537 | |
ecc82929 | 4538 | /* Caller save not needed yet. */ |
4539 | caller_save_needed = 0; | |
897b77d6 | 4540 | |
ecc82929 | 4541 | /* We haven't done register allocation yet. */ |
4542 | reg_renumber = 0; | |
897b77d6 | 4543 | |
304c5bf1 | 4544 | /* Indicate that we have not instantiated virtual registers yet. */ |
4545 | virtuals_instantiated = 0; | |
4546 | ||
316bc009 | 4547 | /* Indicate that we want CONCATs now. */ |
4548 | generating_concat_p = 1; | |
4549 | ||
304c5bf1 | 4550 | /* Indicate we have no need of a frame pointer yet. */ |
4551 | frame_pointer_needed = 0; | |
304c5bf1 | 4552 | } |
4553 | ||
4554 | /* Initialize the rtl expansion mechanism so that we can do simple things | |
4555 | like generate sequences. This is used to provide a context during global | |
87d4aa85 | 4556 | initialization of some passes. You must call expand_dummy_function_end |
4557 | to exit this context. */ | |
4558 | ||
304c5bf1 | 4559 | void |
de1b648b | 4560 | init_dummy_function_start (void) |
304c5bf1 | 4561 | { |
87d4aa85 | 4562 | gcc_assert (!in_dummy_function); |
4563 | in_dummy_function = true; | |
4564 | push_struct_function (NULL_TREE); | |
4565 | prepare_function_start (); | |
304c5bf1 | 4566 | } |
4567 | ||
4568 | /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node) | |
4569 | and initialize static variables for generating RTL for the statements | |
4570 | of the function. */ | |
4571 | ||
4572 | void | |
de1b648b | 4573 | init_function_start (tree subr) |
304c5bf1 | 4574 | { |
87d4aa85 | 4575 | if (subr && DECL_STRUCT_FUNCTION (subr)) |
4576 | set_cfun (DECL_STRUCT_FUNCTION (subr)); | |
4577 | else | |
80f2ef47 | 4578 | allocate_struct_function (subr, false); |
87d4aa85 | 4579 | prepare_function_start (); |
756dcd13 | 4580 | decide_function_section (subr); |
304c5bf1 | 4581 | |
897b77d6 | 4582 | /* Warn if this value is an aggregate type, |
4583 | regardless of which calling convention we are using for it. */ | |
efb9d9ee | 4584 | if (AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr)))) |
4585 | warning (OPT_Waggregate_return, "function returns an aggregate"); | |
0a893c29 | 4586 | } |
a590d94d | 4587 | |
77fce4cd | 4588 | |
897b77d6 | 4589 | void |
de1b648b | 4590 | expand_main_function (void) |
897b77d6 | 4591 | { |
72f9fc81 | 4592 | #if (defined(INVOKE__main) \ |
4593 | || (!defined(HAS_INIT_SECTION) \ | |
4594 | && !defined(INIT_SECTION_ASM_OP) \ | |
4595 | && !defined(INIT_ARRAY_SECTION_ASM_OP))) | |
62f615b1 | 4596 | emit_library_call (init_one_libfunc (NAME__MAIN), LCT_NORMAL, VOIDmode, 0); |
3ca5a306 | 4597 | #endif |
897b77d6 | 4598 | } |
4599 | \f | |
f1a0edff | 4600 | /* Expand code to initialize the stack_protect_guard. This is invoked at |
4601 | the beginning of a function to be protected. */ | |
4602 | ||
4603 | #ifndef HAVE_stack_protect_set | |
4604 | # define HAVE_stack_protect_set 0 | |
4605 | # define gen_stack_protect_set(x,y) (gcc_unreachable (), NULL_RTX) | |
4606 | #endif | |
4607 | ||
4608 | void | |
4609 | stack_protect_prologue (void) | |
4610 | { | |
4611 | tree guard_decl = targetm.stack_protect_guard (); | |
4612 | rtx x, y; | |
4613 | ||
d2a99f05 | 4614 | x = expand_normal (crtl->stack_protect_guard); |
4615 | y = expand_normal (guard_decl); | |
f1a0edff | 4616 | |
4617 | /* Allow the target to copy from Y to X without leaking Y into a | |
4618 | register. */ | |
4619 | if (HAVE_stack_protect_set) | |
4620 | { | |
4621 | rtx insn = gen_stack_protect_set (x, y); | |
4622 | if (insn) | |
4623 | { | |
4624 | emit_insn (insn); | |
4625 | return; | |
4626 | } | |
4627 | } | |
4628 | ||
4629 | /* Otherwise do a straight move. */ | |
4630 | emit_move_insn (x, y); | |
4631 | } | |
4632 | ||
4633 | /* Expand code to verify the stack_protect_guard. This is invoked at | |
4634 | the end of a function to be protected. */ | |
4635 | ||
4636 | #ifndef HAVE_stack_protect_test | |
bbd33557 | 4637 | # define HAVE_stack_protect_test 0 |
4638 | # define gen_stack_protect_test(x, y, z) (gcc_unreachable (), NULL_RTX) | |
f1a0edff | 4639 | #endif |
4640 | ||
71d89928 | 4641 | void |
f1a0edff | 4642 | stack_protect_epilogue (void) |
4643 | { | |
4644 | tree guard_decl = targetm.stack_protect_guard (); | |
4645 | rtx label = gen_label_rtx (); | |
4646 | rtx x, y, tmp; | |
4647 | ||
d2a99f05 | 4648 | x = expand_normal (crtl->stack_protect_guard); |
4649 | y = expand_normal (guard_decl); | |
f1a0edff | 4650 | |
4651 | /* Allow the target to compare Y with X without leaking either into | |
4652 | a register. */ | |
4653 | switch (HAVE_stack_protect_test != 0) | |
4654 | { | |
4655 | case 1: | |
419bcc46 | 4656 | tmp = gen_stack_protect_test (x, y, label); |
f1a0edff | 4657 | if (tmp) |
4658 | { | |
4659 | emit_insn (tmp); | |
f1a0edff | 4660 | break; |
4661 | } | |
4662 | /* FALLTHRU */ | |
4663 | ||
4664 | default: | |
4665 | emit_cmp_and_jump_insns (x, y, EQ, NULL_RTX, ptr_mode, 1, label); | |
4666 | break; | |
4667 | } | |
4668 | ||
4669 | /* The noreturn predictor has been moved to the tree level. The rtl-level | |
4670 | predictors estimate this branch about 20%, which isn't enough to get | |
4671 | things moved out of line. Since this is the only extant case of adding | |
4672 | a noreturn function at the rtl level, it doesn't seem worth doing ought | |
4673 | except adding the prediction by hand. */ | |
4674 | tmp = get_last_insn (); | |
4675 | if (JUMP_P (tmp)) | |
4676 | predict_insn_def (tmp, PRED_NORETURN, TAKEN); | |
4677 | ||
5a13cc45 | 4678 | expand_call (targetm.stack_protect_fail (), NULL_RTX, /*ignore=*/true); |
4679 | free_temp_slots (); | |
f1a0edff | 4680 | emit_label (label); |
4681 | } | |
4682 | \f | |
897b77d6 | 4683 | /* Start the RTL for a new function, and set variables used for |
4684 | emitting RTL. | |
4685 | SUBR is the FUNCTION_DECL node. | |
4686 | PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with | |
4687 | the function's parameters, which must be run at any return statement. */ | |
4688 | ||
4689 | void | |
82aa4bd5 | 4690 | expand_function_start (tree subr) |
897b77d6 | 4691 | { |
897b77d6 | 4692 | /* Make sure volatile mem refs aren't considered |
4693 | valid operands of arithmetic insns. */ | |
4694 | init_recog_no_volatile (); | |
4695 | ||
18d50ae6 | 4696 | crtl->profile |
7811c823 | 4697 | = (profile_flag |
4698 | && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr)); | |
4699 | ||
18d50ae6 | 4700 | crtl->limit_stack |
8f8ac140 | 4701 | = (stack_limit_rtx != NULL_RTX && ! DECL_NO_LIMIT_STACK (subr)); |
4702 | ||
df4b504c | 4703 | /* Make the label for return statements to jump to. Do not special |
4704 | case machines with special return instructions -- they will be | |
4705 | handled later during jump, ifcvt, or epilogue creation. */ | |
897b77d6 | 4706 | return_label = gen_label_rtx (); |
897b77d6 | 4707 | |
4708 | /* Initialize rtx used to return the value. */ | |
4709 | /* Do this before assign_parms so that we copy the struct value address | |
4710 | before any library calls that assign parms might generate. */ | |
4711 | ||
4712 | /* Decide whether to return the value in memory or in a register. */ | |
45550790 | 4713 | if (aggregate_value_p (DECL_RESULT (subr), subr)) |
897b77d6 | 4714 | { |
4715 | /* Returning something that won't go in a register. */ | |
19cb6b50 | 4716 | rtx value_address = 0; |
897b77d6 | 4717 | |
4718 | #ifdef PCC_STATIC_STRUCT_RETURN | |
18d50ae6 | 4719 | if (cfun->returns_pcc_struct) |
897b77d6 | 4720 | { |
4721 | int size = int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr))); | |
4722 | value_address = assemble_static_space (size); | |
4723 | } | |
4724 | else | |
4725 | #endif | |
4726 | { | |
d8c09ceb | 4727 | rtx sv = targetm.calls.struct_value_rtx (TREE_TYPE (subr), 2); |
897b77d6 | 4728 | /* Expect to be passed the address of a place to store the value. |
4729 | If it is passed as an argument, assign_parms will take care of | |
4730 | it. */ | |
45550790 | 4731 | if (sv) |
897b77d6 | 4732 | { |
4733 | value_address = gen_reg_rtx (Pmode); | |
45550790 | 4734 | emit_move_insn (value_address, sv); |
897b77d6 | 4735 | } |
4736 | } | |
4737 | if (value_address) | |
ce88c7f0 | 4738 | { |
648c102e | 4739 | rtx x = value_address; |
4740 | if (!DECL_BY_REFERENCE (DECL_RESULT (subr))) | |
4741 | { | |
4742 | x = gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr)), x); | |
4743 | set_mem_attributes (x, DECL_RESULT (subr), 1); | |
4744 | } | |
d05cd611 | 4745 | SET_DECL_RTL (DECL_RESULT (subr), x); |
ce88c7f0 | 4746 | } |
897b77d6 | 4747 | } |
4748 | else if (DECL_MODE (DECL_RESULT (subr)) == VOIDmode) | |
4749 | /* If return mode is void, this decl rtl should not be used. */ | |
0e8e37b2 | 4750 | SET_DECL_RTL (DECL_RESULT (subr), NULL_RTX); |
7ab29b28 | 4751 | else |
7e8dfb30 | 4752 | { |
7ab29b28 | 4753 | /* Compute the return values into a pseudo reg, which we will copy |
4754 | into the true return register after the cleanups are done. */ | |
05d18e8b | 4755 | tree return_type = TREE_TYPE (DECL_RESULT (subr)); |
4756 | if (TYPE_MODE (return_type) != BLKmode | |
4757 | && targetm.calls.return_in_msb (return_type)) | |
4758 | /* expand_function_end will insert the appropriate padding in | |
4759 | this case. Use the return value's natural (unpadded) mode | |
4760 | within the function proper. */ | |
4761 | SET_DECL_RTL (DECL_RESULT (subr), | |
4762 | gen_reg_rtx (TYPE_MODE (return_type))); | |
92f708ec | 4763 | else |
fdada98f | 4764 | { |
05d18e8b | 4765 | /* In order to figure out what mode to use for the pseudo, we |
4766 | figure out what the mode of the eventual return register will | |
4767 | actually be, and use that. */ | |
46b3ff29 | 4768 | rtx hard_reg = hard_function_value (return_type, subr, 0, 1); |
05d18e8b | 4769 | |
4770 | /* Structures that are returned in registers are not | |
4771 | aggregate_value_p, so we may see a PARALLEL or a REG. */ | |
4772 | if (REG_P (hard_reg)) | |
4773 | SET_DECL_RTL (DECL_RESULT (subr), | |
4774 | gen_reg_rtx (GET_MODE (hard_reg))); | |
4775 | else | |
4776 | { | |
4777 | gcc_assert (GET_CODE (hard_reg) == PARALLEL); | |
4778 | SET_DECL_RTL (DECL_RESULT (subr), gen_group_rtx (hard_reg)); | |
4779 | } | |
fdada98f | 4780 | } |
7e8dfb30 | 4781 | |
b566e2e5 | 4782 | /* Set DECL_REGISTER flag so that expand_function_end will copy the |
4783 | result to the real return register(s). */ | |
4784 | DECL_REGISTER (DECL_RESULT (subr)) = 1; | |
7e8dfb30 | 4785 | } |
897b77d6 | 4786 | |
4787 | /* Initialize rtx for parameters and local variables. | |
4788 | In some cases this requires emitting insns. */ | |
bffcf014 | 4789 | assign_parms (subr); |
897b77d6 | 4790 | |
4ee9c684 | 4791 | /* If function gets a static chain arg, store it. */ |
4792 | if (cfun->static_chain_decl) | |
4793 | { | |
3efaa21f | 4794 | tree parm = cfun->static_chain_decl; |
82c7907c | 4795 | rtx local, chain, insn; |
3efaa21f | 4796 | |
82c7907c | 4797 | local = gen_reg_rtx (Pmode); |
4798 | chain = targetm.calls.static_chain (current_function_decl, true); | |
4799 | ||
4800 | set_decl_incoming_rtl (parm, chain, false); | |
3efaa21f | 4801 | SET_DECL_RTL (parm, local); |
3efaa21f | 4802 | mark_reg_pointer (local, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm)))); |
4ee9c684 | 4803 | |
82c7907c | 4804 | insn = emit_move_insn (local, chain); |
4805 | ||
4806 | /* Mark the register as eliminable, similar to parameters. */ | |
4807 | if (MEM_P (chain) | |
4808 | && reg_mentioned_p (arg_pointer_rtx, XEXP (chain, 0))) | |
41cf444a | 4809 | set_dst_reg_note (insn, REG_EQUIV, chain, local); |
4ee9c684 | 4810 | } |
4811 | ||
4812 | /* If the function receives a non-local goto, then store the | |
4813 | bits we need to restore the frame pointer. */ | |
4814 | if (cfun->nonlocal_goto_save_area) | |
4815 | { | |
4816 | tree t_save; | |
4817 | rtx r_save; | |
4818 | ||
1a105fae | 4819 | tree var = TREE_OPERAND (cfun->nonlocal_goto_save_area, 0); |
7843e4bc | 4820 | gcc_assert (DECL_RTL_SET_P (var)); |
4ee9c684 | 4821 | |
21dc8b2b | 4822 | t_save = build4 (ARRAY_REF, |
4823 | TREE_TYPE (TREE_TYPE (cfun->nonlocal_goto_save_area)), | |
b55f9493 | 4824 | cfun->nonlocal_goto_save_area, |
4825 | integer_zero_node, NULL_TREE, NULL_TREE); | |
4ee9c684 | 4826 | r_save = expand_expr (t_save, NULL_RTX, VOIDmode, EXPAND_WRITE); |
21dc8b2b | 4827 | gcc_assert (GET_MODE (r_save) == Pmode); |
50c48f9b | 4828 | |
6a5dfe57 | 4829 | emit_move_insn (r_save, targetm.builtin_setjmp_frame_value ()); |
4ee9c684 | 4830 | update_nonlocal_goto_save_area (); |
4831 | } | |
50c48f9b | 4832 | |
897b77d6 | 4833 | /* The following was moved from init_function_start. |
4834 | The move is supposed to make sdb output more accurate. */ | |
4835 | /* Indicate the beginning of the function body, | |
4836 | as opposed to parm setup. */ | |
31b97e8f | 4837 | emit_note (NOTE_INSN_FUNCTION_BEG); |
897b77d6 | 4838 | |
1edb3690 | 4839 | gcc_assert (NOTE_P (get_last_insn ())); |
4840 | ||
897b77d6 | 4841 | parm_birth_insn = get_last_insn (); |
4842 | ||
18d50ae6 | 4843 | if (crtl->profile) |
b8a21949 | 4844 | { |
b8a21949 | 4845 | #ifdef PROFILE_HOOK |
4781f9b9 | 4846 | PROFILE_HOOK (current_function_funcdef_no); |
104d9861 | 4847 | #endif |
b8a21949 | 4848 | } |
104d9861 | 4849 | |
f8c438a1 | 4850 | /* If we are doing generic stack checking, the probe should go here. */ |
4851 | if (flag_stack_check == GENERIC_STACK_CHECK) | |
1edb3690 | 4852 | stack_check_probe_note = emit_note (NOTE_INSN_DELETED); |
897b77d6 | 4853 | } |
4854 | \f | |
0a893c29 | 4855 | /* Undo the effects of init_dummy_function_start. */ |
4856 | void | |
de1b648b | 4857 | expand_dummy_function_end (void) |
0a893c29 | 4858 | { |
87d4aa85 | 4859 | gcc_assert (in_dummy_function); |
4860 | ||
0a893c29 | 4861 | /* End any sequences that failed to be closed due to syntax errors. */ |
4862 | while (in_sequence_p ()) | |
4863 | end_sequence (); | |
4864 | ||
4865 | /* Outside function body, can't compute type's actual size | |
4866 | until next function's body starts. */ | |
3c3bb268 | 4867 | |
08513b52 | 4868 | free_after_parsing (cfun); |
4869 | free_after_compilation (cfun); | |
87d4aa85 | 4870 | pop_cfun (); |
4871 | in_dummy_function = false; | |
0a893c29 | 4872 | } |
4873 | ||
2766437e | 4874 | /* Call DOIT for each hard register used as a return value from |
4875 | the current function. */ | |
631ef7ce | 4876 | |
4877 | void | |
de1b648b | 4878 | diddle_return_value (void (*doit) (rtx, void *), void *arg) |
631ef7ce | 4879 | { |
abe32cce | 4880 | rtx outgoing = crtl->return_rtx; |
2766437e | 4881 | |
4882 | if (! outgoing) | |
4883 | return; | |
631ef7ce | 4884 | |
8ad4c111 | 4885 | if (REG_P (outgoing)) |
2766437e | 4886 | (*doit) (outgoing, arg); |
4887 | else if (GET_CODE (outgoing) == PARALLEL) | |
4888 | { | |
4889 | int i; | |
631ef7ce | 4890 | |
2766437e | 4891 | for (i = 0; i < XVECLEN (outgoing, 0); i++) |
4892 | { | |
4893 | rtx x = XEXP (XVECEXP (outgoing, 0, i), 0); | |
4894 | ||
8ad4c111 | 4895 | if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER) |
2766437e | 4896 | (*doit) (x, arg); |
631ef7ce | 4897 | } |
4898 | } | |
4899 | } | |
4900 | ||
2766437e | 4901 | static void |
de1b648b | 4902 | do_clobber_return_reg (rtx reg, void *arg ATTRIBUTE_UNUSED) |
2766437e | 4903 | { |
18b42941 | 4904 | emit_clobber (reg); |
2766437e | 4905 | } |
4906 | ||
4907 | void | |
de1b648b | 4908 | clobber_return_register (void) |
2766437e | 4909 | { |
4910 | diddle_return_value (do_clobber_return_reg, NULL); | |
1b2c7cbd | 4911 | |
4912 | /* In case we do use pseudo to return value, clobber it too. */ | |
4913 | if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl))) | |
4914 | { | |
4915 | tree decl_result = DECL_RESULT (current_function_decl); | |
4916 | rtx decl_rtl = DECL_RTL (decl_result); | |
4917 | if (REG_P (decl_rtl) && REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER) | |
4918 | { | |
4919 | do_clobber_return_reg (decl_rtl, NULL); | |
4920 | } | |
4921 | } | |
2766437e | 4922 | } |
4923 | ||
4924 | static void | |
de1b648b | 4925 | do_use_return_reg (rtx reg, void *arg ATTRIBUTE_UNUSED) |
2766437e | 4926 | { |
18b42941 | 4927 | emit_use (reg); |
2766437e | 4928 | } |
4929 | ||
ab4605bf | 4930 | static void |
de1b648b | 4931 | use_return_register (void) |
2766437e | 4932 | { |
4933 | diddle_return_value (do_use_return_reg, NULL); | |
4934 | } | |
4935 | ||
b69eb0ff | 4936 | /* Possibly warn about unused parameters. */ |
4937 | void | |
4938 | do_warn_unused_parameter (tree fn) | |
4939 | { | |
4940 | tree decl; | |
4941 | ||
4942 | for (decl = DECL_ARGUMENTS (fn); | |
1767a056 | 4943 | decl; decl = DECL_CHAIN (decl)) |
b69eb0ff | 4944 | if (!TREE_USED (decl) && TREE_CODE (decl) == PARM_DECL |
76776e6d | 4945 | && DECL_NAME (decl) && !DECL_ARTIFICIAL (decl) |
4946 | && !TREE_NO_WARNING (decl)) | |
e8d0745d | 4947 | warning (OPT_Wunused_parameter, "unused parameter %q+D", decl); |
b69eb0ff | 4948 | } |
4949 | ||
1f3233d1 | 4950 | static GTY(()) rtx initial_trampoline; |
4951 | ||
6473f3f4 | 4952 | /* Generate RTL for the end of the current function. */ |
897b77d6 | 4953 | |
4954 | void | |
de1b648b | 4955 | expand_function_end (void) |
897b77d6 | 4956 | { |
9b56368f | 4957 | rtx clobber_after; |
897b77d6 | 4958 | |
2032b31d | 4959 | /* If arg_pointer_save_area was referenced only from a nested |
4960 | function, we will not have initialized it yet. Do that now. */ | |
18d50ae6 | 4961 | if (arg_pointer_save_area && ! crtl->arg_pointer_save_area_init) |
b079a207 | 4962 | get_arg_pointer_save_area (); |
2032b31d | 4963 | |
4852b829 | 4964 | /* If we are doing generic stack checking and this function makes calls, |
b22178d2 | 4965 | do a stack probe at the start of the function to ensure we have enough |
4966 | space for another stack frame. */ | |
4852b829 | 4967 | if (flag_stack_check == GENERIC_STACK_CHECK) |
b22178d2 | 4968 | { |
4969 | rtx insn, seq; | |
4970 | ||
4971 | for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) | |
6d7dc5b9 | 4972 | if (CALL_P (insn)) |
b22178d2 | 4973 | { |
d1b92264 | 4974 | rtx max_frame_size = GEN_INT (STACK_CHECK_MAX_FRAME_SIZE); |
b22178d2 | 4975 | start_sequence (); |
d1b92264 | 4976 | if (STACK_CHECK_MOVING_SP) |
4977 | anti_adjust_stack_and_probe (max_frame_size, true); | |
4978 | else | |
4979 | probe_stack_range (STACK_OLD_CHECK_PROTECT, max_frame_size); | |
b22178d2 | 4980 | seq = get_insns (); |
4981 | end_sequence (); | |
dfd9ed5b | 4982 | set_insn_locators (seq, prologue_locator); |
1edb3690 | 4983 | emit_insn_before (seq, stack_check_probe_note); |
b22178d2 | 4984 | break; |
4985 | } | |
4986 | } | |
4987 | ||
897b77d6 | 4988 | /* End any sequences that failed to be closed due to syntax errors. */ |
4989 | while (in_sequence_p ()) | |
1bb04728 | 4990 | end_sequence (); |
897b77d6 | 4991 | |
897b77d6 | 4992 | clear_pending_stack_adjust (); |
4993 | do_pending_stack_adjust (); | |
4994 | ||
897b77d6 | 4995 | /* Output a linenumber for the end of the function. |
4996 | SDB depends on this. */ | |
375c1c8a | 4997 | set_curr_insn_source_location (input_location); |
897b77d6 | 4998 | |
b41180f5 | 4999 | /* Before the return label (if any), clobber the return |
3fb1e43b | 5000 | registers so that they are not propagated live to the rest of |
b41180f5 | 5001 | the function. This can only happen with functions that drop |
5002 | through; if there had been a return statement, there would | |
9b56368f | 5003 | have either been a return rtx, or a jump to the return label. |
5004 | ||
5005 | We delay actual code generation after the current_function_value_rtx | |
5006 | is computed. */ | |
5007 | clobber_after = get_last_insn (); | |
b41180f5 | 5008 | |
7861133f | 5009 | /* Output the label for the actual return from the function. */ |
5010 | emit_label (return_label); | |
897b77d6 | 5011 | |
218e3e4e | 5012 | if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ) |
a7e05170 | 5013 | { |
5014 | /* Let except.c know where it should emit the call to unregister | |
5015 | the function context for sjlj exceptions. */ | |
5016 | if (flag_exceptions) | |
5017 | sjlj_emit_function_exit_after (get_last_insn ()); | |
5018 | } | |
3072d30e | 5019 | else |
5020 | { | |
5021 | /* We want to ensure that instructions that may trap are not | |
5022 | moved into the epilogue by scheduling, because we don't | |
5023 | always emit unwind information for the epilogue. */ | |
cbeb677e | 5024 | if (cfun->can_throw_non_call_exceptions) |
3072d30e | 5025 | emit_insn (gen_blockage ()); |
5026 | } | |
855f1e85 | 5027 | |
80e467e2 | 5028 | /* If this is an implementation of throw, do what's necessary to |
5029 | communicate between __builtin_eh_return and the epilogue. */ | |
5030 | expand_eh_return (); | |
5031 | ||
ae39498f | 5032 | /* If scalar return value was computed in a pseudo-reg, or was a named |
5033 | return value that got dumped to the stack, copy that to the hard | |
5034 | return register. */ | |
0e8e37b2 | 5035 | if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl))) |
897b77d6 | 5036 | { |
ae39498f | 5037 | tree decl_result = DECL_RESULT (current_function_decl); |
5038 | rtx decl_rtl = DECL_RTL (decl_result); | |
5039 | ||
5040 | if (REG_P (decl_rtl) | |
5041 | ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER | |
5042 | : DECL_REGISTER (decl_result)) | |
5043 | { | |
abe32cce | 5044 | rtx real_decl_rtl = crtl->return_rtx; |
897b77d6 | 5045 | |
8839b7f1 | 5046 | /* This should be set in assign_parms. */ |
fdada98f | 5047 | gcc_assert (REG_FUNCTION_VALUE_P (real_decl_rtl)); |
ae39498f | 5048 | |
5049 | /* If this is a BLKmode structure being returned in registers, | |
5050 | then use the mode computed in expand_return. Note that if | |
60d903f5 | 5051 | decl_rtl is memory, then its mode may have been changed, |
abe32cce | 5052 | but that crtl->return_rtx has not. */ |
ae39498f | 5053 | if (GET_MODE (real_decl_rtl) == BLKmode) |
8839b7f1 | 5054 | PUT_MODE (real_decl_rtl, GET_MODE (decl_rtl)); |
ae39498f | 5055 | |
05d18e8b | 5056 | /* If a non-BLKmode return value should be padded at the least |
5057 | significant end of the register, shift it left by the appropriate | |
5058 | amount. BLKmode results are handled using the group load/store | |
5059 | machinery. */ | |
5060 | if (TYPE_MODE (TREE_TYPE (decl_result)) != BLKmode | |
5061 | && targetm.calls.return_in_msb (TREE_TYPE (decl_result))) | |
5062 | { | |
5063 | emit_move_insn (gen_rtx_REG (GET_MODE (decl_rtl), | |
5064 | REGNO (real_decl_rtl)), | |
5065 | decl_rtl); | |
5066 | shift_return_value (GET_MODE (decl_rtl), true, real_decl_rtl); | |
5067 | } | |
ae39498f | 5068 | /* If a named return value dumped decl_return to memory, then |
60d903f5 | 5069 | we may need to re-do the PROMOTE_MODE signed/unsigned |
ae39498f | 5070 | extension. */ |
05d18e8b | 5071 | else if (GET_MODE (real_decl_rtl) != GET_MODE (decl_rtl)) |
ae39498f | 5072 | { |
78a8ed03 | 5073 | int unsignedp = TYPE_UNSIGNED (TREE_TYPE (decl_result)); |
3b2411a8 | 5074 | promote_function_mode (TREE_TYPE (decl_result), |
5075 | GET_MODE (decl_rtl), &unsignedp, | |
5076 | TREE_TYPE (current_function_decl), 1); | |
ae39498f | 5077 | |
5078 | convert_move (real_decl_rtl, decl_rtl, unsignedp); | |
5079 | } | |
3395ec76 | 5080 | else if (GET_CODE (real_decl_rtl) == PARALLEL) |
b566e2e5 | 5081 | { |
5082 | /* If expand_function_start has created a PARALLEL for decl_rtl, | |
5083 | move the result to the real return registers. Otherwise, do | |
5084 | a group load from decl_rtl for a named return. */ | |
5085 | if (GET_CODE (decl_rtl) == PARALLEL) | |
5086 | emit_group_move (real_decl_rtl, decl_rtl); | |
5087 | else | |
5088 | emit_group_load (real_decl_rtl, decl_rtl, | |
5f4cd670 | 5089 | TREE_TYPE (decl_result), |
b566e2e5 | 5090 | int_size_in_bytes (TREE_TYPE (decl_result))); |
5091 | } | |
80e467e2 | 5092 | /* In the case of complex integer modes smaller than a word, we'll |
5093 | need to generate some non-trivial bitfield insertions. Do that | |
5094 | on a pseudo and not the hard register. */ | |
5095 | else if (GET_CODE (decl_rtl) == CONCAT | |
5096 | && GET_MODE_CLASS (GET_MODE (decl_rtl)) == MODE_COMPLEX_INT | |
5097 | && GET_MODE_BITSIZE (GET_MODE (decl_rtl)) <= BITS_PER_WORD) | |
5098 | { | |
5099 | int old_generating_concat_p; | |
5100 | rtx tmp; | |
5101 | ||
5102 | old_generating_concat_p = generating_concat_p; | |
5103 | generating_concat_p = 0; | |
5104 | tmp = gen_reg_rtx (GET_MODE (decl_rtl)); | |
5105 | generating_concat_p = old_generating_concat_p; | |
5106 | ||
5107 | emit_move_insn (tmp, decl_rtl); | |
5108 | emit_move_insn (real_decl_rtl, tmp); | |
5109 | } | |
ae39498f | 5110 | else |
5111 | emit_move_insn (real_decl_rtl, decl_rtl); | |
ae39498f | 5112 | } |
897b77d6 | 5113 | } |
5114 | ||
5115 | /* If returning a structure, arrange to return the address of the value | |
5116 | in a place where debuggers expect to find it. | |
5117 | ||
5118 | If returning a structure PCC style, | |
5119 | the caller also depends on this value. | |
18d50ae6 | 5120 | And cfun->returns_pcc_struct is not necessarily set. */ |
5121 | if (cfun->returns_struct | |
5122 | || cfun->returns_pcc_struct) | |
897b77d6 | 5123 | { |
806e4c12 | 5124 | rtx value_address = DECL_RTL (DECL_RESULT (current_function_decl)); |
897b77d6 | 5125 | tree type = TREE_TYPE (DECL_RESULT (current_function_decl)); |
806e4c12 | 5126 | rtx outgoing; |
5127 | ||
5128 | if (DECL_BY_REFERENCE (DECL_RESULT (current_function_decl))) | |
5129 | type = TREE_TYPE (type); | |
5130 | else | |
5131 | value_address = XEXP (value_address, 0); | |
5132 | ||
46b3ff29 | 5133 | outgoing = targetm.calls.function_value (build_pointer_type (type), |
5134 | current_function_decl, true); | |
897b77d6 | 5135 | |
5136 | /* Mark this as a function return value so integrate will delete the | |
5137 | assignment and USE below when inlining this function. */ | |
5138 | REG_FUNCTION_VALUE_P (outgoing) = 1; | |
5139 | ||
c54c9422 | 5140 | /* The address may be ptr_mode and OUTGOING may be Pmode. */ |
85d654dd | 5141 | value_address = convert_memory_address (GET_MODE (outgoing), |
5142 | value_address); | |
c54c9422 | 5143 | |
897b77d6 | 5144 | emit_move_insn (outgoing, value_address); |
c54c9422 | 5145 | |
5146 | /* Show return register used to hold result (in this case the address | |
5147 | of the result. */ | |
abe32cce | 5148 | crtl->return_rtx = outgoing; |
897b77d6 | 5149 | } |
5150 | ||
9b56368f | 5151 | /* Emit the actual code to clobber return register. */ |
5152 | { | |
01628e06 | 5153 | rtx seq; |
60d903f5 | 5154 | |
9b56368f | 5155 | start_sequence (); |
5156 | clobber_return_register (); | |
31d3e01c | 5157 | seq = get_insns (); |
9b56368f | 5158 | end_sequence (); |
5159 | ||
01628e06 | 5160 | emit_insn_after (seq, clobber_after); |
9b56368f | 5161 | } |
5162 | ||
01628e06 | 5163 | /* Output the label for the naked return from the function. */ |
b2ee26d5 | 5164 | if (naked_return_label) |
5165 | emit_label (naked_return_label); | |
62380d2d | 5166 | |
1b7fd1d9 | 5167 | /* @@@ This is a kludge. We want to ensure that instructions that |
5168 | may trap are not moved into the epilogue by scheduling, because | |
d86df71c | 5169 | we don't always emit unwind information for the epilogue. */ |
cc7d6aed | 5170 | if (cfun->can_throw_non_call_exceptions |
218e3e4e | 5171 | && targetm_common.except_unwind_info (&global_options) != UI_SJLJ) |
d86df71c | 5172 | emit_insn (gen_blockage ()); |
1b7fd1d9 | 5173 | |
f1a0edff | 5174 | /* If stack protection is enabled for this function, check the guard. */ |
edb7afe8 | 5175 | if (crtl->stack_protect_guard) |
f1a0edff | 5176 | stack_protect_epilogue (); |
5177 | ||
6a7492e8 | 5178 | /* If we had calls to alloca, and this machine needs |
5179 | an accurate stack pointer to exit the function, | |
5180 | insert some code to save and restore the stack pointer. */ | |
5181 | if (! EXIT_IGNORE_STACK | |
18d50ae6 | 5182 | && cfun->calls_alloca) |
6a7492e8 | 5183 | { |
e9c97615 | 5184 | rtx tem = 0, seq; |
6a7492e8 | 5185 | |
e9c97615 | 5186 | start_sequence (); |
5187 | emit_stack_save (SAVE_FUNCTION, &tem); | |
5188 | seq = get_insns (); | |
5189 | end_sequence (); | |
5190 | emit_insn_before (seq, parm_birth_insn); | |
5191 | ||
5192 | emit_stack_restore (SAVE_FUNCTION, tem); | |
6a7492e8 | 5193 | } |
5194 | ||
2766437e | 5195 | /* ??? This should no longer be necessary since stupid is no longer with |
5196 | us, but there are some parts of the compiler (eg reload_combine, and | |
5197 | sh mach_dep_reorg) that still try and compute their own lifetime info | |
5198 | instead of using the general framework. */ | |
5199 | use_return_register (); | |
897b77d6 | 5200 | } |
05927e40 | 5201 | |
5202 | rtx | |
b079a207 | 5203 | get_arg_pointer_save_area (void) |
05927e40 | 5204 | { |
b079a207 | 5205 | rtx ret = arg_pointer_save_area; |
05927e40 | 5206 | |
5207 | if (! ret) | |
5208 | { | |
b079a207 | 5209 | ret = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0); |
5210 | arg_pointer_save_area = ret; | |
2032b31d | 5211 | } |
5212 | ||
18d50ae6 | 5213 | if (! crtl->arg_pointer_save_area_init) |
2032b31d | 5214 | { |
5215 | rtx seq; | |
05927e40 | 5216 | |
60d903f5 | 5217 | /* Save the arg pointer at the beginning of the function. The |
2032b31d | 5218 | generated stack slot may not be a valid memory address, so we |
05927e40 | 5219 | have to check it and fix it if necessary. */ |
5220 | start_sequence (); | |
27a7a23a | 5221 | emit_move_insn (validize_mem (ret), |
5222 | crtl->args.internal_arg_pointer); | |
31d3e01c | 5223 | seq = get_insns (); |
05927e40 | 5224 | end_sequence (); |
5225 | ||
2032b31d | 5226 | push_topmost_sequence (); |
c838448c | 5227 | emit_insn_after (seq, entry_of_function ()); |
2032b31d | 5228 | pop_topmost_sequence (); |
050f9ef1 | 5229 | |
5230 | crtl->arg_pointer_save_area_init = true; | |
05927e40 | 5231 | } |
5232 | ||
5233 | return ret; | |
5234 | } | |
b2c5602e | 5235 | \f |
25e880b1 | 5236 | /* Add a list of INSNS to the hash HASHP, possibly allocating HASHP |
5237 | for the first time. */ | |
b2c5602e | 5238 | |
60ecc450 | 5239 | static void |
25e880b1 | 5240 | record_insns (rtx insns, rtx end, htab_t *hashp) |
b2c5602e | 5241 | { |
31d3e01c | 5242 | rtx tmp; |
25e880b1 | 5243 | htab_t hash = *hashp; |
60ecc450 | 5244 | |
25e880b1 | 5245 | if (hash == NULL) |
5246 | *hashp = hash | |
5247 | = htab_create_ggc (17, htab_hash_pointer, htab_eq_pointer, NULL); | |
5248 | ||
5249 | for (tmp = insns; tmp != end; tmp = NEXT_INSN (tmp)) | |
5250 | { | |
5251 | void **slot = htab_find_slot (hash, tmp, INSERT); | |
5252 | gcc_assert (*slot == NULL); | |
5253 | *slot = tmp; | |
5254 | } | |
5255 | } | |
5256 | ||
1eefcaee | 5257 | /* INSN has been duplicated or replaced by as COPY, perhaps by duplicating a |
5258 | basic block, splitting or peepholes. If INSN is a prologue or epilogue | |
5259 | insn, then record COPY as well. */ | |
25e880b1 | 5260 | |
5261 | void | |
1eefcaee | 5262 | maybe_copy_prologue_epilogue_insn (rtx insn, rtx copy) |
25e880b1 | 5263 | { |
1eefcaee | 5264 | htab_t hash; |
25e880b1 | 5265 | void **slot; |
5266 | ||
1eefcaee | 5267 | hash = epilogue_insn_hash; |
5268 | if (!hash || !htab_find (hash, insn)) | |
5269 | { | |
5270 | hash = prologue_insn_hash; | |
5271 | if (!hash || !htab_find (hash, insn)) | |
5272 | return; | |
5273 | } | |
25e880b1 | 5274 | |
1eefcaee | 5275 | slot = htab_find_slot (hash, copy, INSERT); |
25e880b1 | 5276 | gcc_assert (*slot == NULL); |
5277 | *slot = copy; | |
b2c5602e | 5278 | } |
5279 | ||
e69efecb | 5280 | /* Set the locator of the insn chain starting at INSN to LOC. */ |
13751393 | 5281 | static void |
de1b648b | 5282 | set_insn_locators (rtx insn, int loc) |
13751393 | 5283 | { |
5284 | while (insn != NULL_RTX) | |
5285 | { | |
5286 | if (INSN_P (insn)) | |
5287 | INSN_LOCATOR (insn) = loc; | |
5288 | insn = NEXT_INSN (insn); | |
5289 | } | |
5290 | } | |
5291 | ||
25e880b1 | 5292 | /* Determine if any INSNs in HASH are, or are part of, INSN. Because |
5293 | we can be running after reorg, SEQUENCE rtl is possible. */ | |
b2c5602e | 5294 | |
25e880b1 | 5295 | static bool |
5296 | contains (const_rtx insn, htab_t hash) | |
b2c5602e | 5297 | { |
25e880b1 | 5298 | if (hash == NULL) |
5299 | return false; | |
b2c5602e | 5300 | |
25e880b1 | 5301 | if (NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE) |
b2c5602e | 5302 | { |
25e880b1 | 5303 | int i; |
b2c5602e | 5304 | for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--) |
25e880b1 | 5305 | if (htab_find (hash, XVECEXP (PATTERN (insn), 0, i))) |
5306 | return true; | |
5307 | return false; | |
b2c5602e | 5308 | } |
25e880b1 | 5309 | |
5310 | return htab_find (hash, insn) != NULL; | |
b2c5602e | 5311 | } |
a590d94d | 5312 | |
5313 | int | |
52d07779 | 5314 | prologue_epilogue_contains (const_rtx insn) |
a590d94d | 5315 | { |
25e880b1 | 5316 | if (contains (insn, prologue_insn_hash)) |
a590d94d | 5317 | return 1; |
25e880b1 | 5318 | if (contains (insn, epilogue_insn_hash)) |
a590d94d | 5319 | return 1; |
5320 | return 0; | |
5321 | } | |
b2c5602e | 5322 | |
1f021f97 | 5323 | #ifdef HAVE_simple_return |
5324 | ||
1f021f97 | 5325 | /* Return true if INSN requires the stack frame to be set up. |
5326 | PROLOGUE_USED contains the hard registers used in the function | |
f8e6666e | 5327 | prologue. SET_UP_BY_PROLOGUE is the set of registers we expect the |
5328 | prologue to set up for the function. */ | |
ca8f816f | 5329 | bool |
f8e6666e | 5330 | requires_stack_frame_p (rtx insn, HARD_REG_SET prologue_used, |
5331 | HARD_REG_SET set_up_by_prologue) | |
1f021f97 | 5332 | { |
f8e6666e | 5333 | df_ref *df_rec; |
1f021f97 | 5334 | HARD_REG_SET hardregs; |
5335 | unsigned regno; | |
5336 | ||
1f021f97 | 5337 | if (CALL_P (insn)) |
5338 | return !SIBLING_CALL_P (insn); | |
1f021f97 | 5339 | |
ec3aa8fe | 5340 | /* We need a frame to get the unique CFA expected by the unwinder. */ |
5341 | if (cfun->can_throw_non_call_exceptions && can_throw_internal (insn)) | |
5342 | return true; | |
5343 | ||
1f021f97 | 5344 | CLEAR_HARD_REG_SET (hardregs); |
f8e6666e | 5345 | for (df_rec = DF_INSN_DEFS (insn); *df_rec; df_rec++) |
1f021f97 | 5346 | { |
f8e6666e | 5347 | rtx dreg = DF_REF_REG (*df_rec); |
1f021f97 | 5348 | |
5349 | if (!REG_P (dreg)) | |
5350 | continue; | |
5351 | ||
5352 | add_to_hard_reg_set (&hardregs, GET_MODE (dreg), | |
5353 | REGNO (dreg)); | |
5354 | } | |
5355 | if (hard_reg_set_intersect_p (hardregs, prologue_used)) | |
5356 | return true; | |
5357 | AND_COMPL_HARD_REG_SET (hardregs, call_used_reg_set); | |
5358 | for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) | |
5359 | if (TEST_HARD_REG_BIT (hardregs, regno) | |
5360 | && df_regs_ever_live_p (regno)) | |
5361 | return true; | |
f8e6666e | 5362 | |
5363 | for (df_rec = DF_INSN_USES (insn); *df_rec; df_rec++) | |
5364 | { | |
5365 | rtx reg = DF_REF_REG (*df_rec); | |
5366 | ||
5367 | if (!REG_P (reg)) | |
5368 | continue; | |
5369 | ||
5370 | add_to_hard_reg_set (&hardregs, GET_MODE (reg), | |
5371 | REGNO (reg)); | |
5372 | } | |
5373 | if (hard_reg_set_intersect_p (hardregs, set_up_by_prologue)) | |
5374 | return true; | |
5375 | ||
1f021f97 | 5376 | return false; |
5377 | } | |
cde48de6 | 5378 | |
018f0595 | 5379 | /* See whether BB has a single successor that uses [REGNO, END_REGNO), |
5380 | and if BB is its only predecessor. Return that block if so, | |
5381 | otherwise return null. */ | |
cde48de6 | 5382 | |
018f0595 | 5383 | static basic_block |
5384 | next_block_for_reg (basic_block bb, int regno, int end_regno) | |
cde48de6 | 5385 | { |
018f0595 | 5386 | edge e, live_edge; |
5387 | edge_iterator ei; | |
5388 | bitmap live; | |
5389 | int i; | |
5390 | ||
5391 | live_edge = NULL; | |
5392 | FOR_EACH_EDGE (e, ei, bb->succs) | |
cde48de6 | 5393 | { |
018f0595 | 5394 | live = df_get_live_in (e->dest); |
5395 | for (i = regno; i < end_regno; i++) | |
5396 | if (REGNO_REG_SET_P (live, i)) | |
5397 | { | |
5398 | if (live_edge && live_edge != e) | |
5399 | return NULL; | |
5400 | live_edge = e; | |
5401 | } | |
5402 | } | |
cde48de6 | 5403 | |
018f0595 | 5404 | /* We can sometimes encounter dead code. Don't try to move it |
5405 | into the exit block. */ | |
5406 | if (!live_edge || live_edge->dest == EXIT_BLOCK_PTR) | |
5407 | return NULL; | |
cde48de6 | 5408 | |
018f0595 | 5409 | /* Reject targets of abnormal edges. This is needed for correctness |
5410 | on ports like Alpha and MIPS, whose pic_offset_table_rtx can die on | |
5411 | exception edges even though it is generally treated as call-saved | |
5412 | for the majority of the compilation. Moving across abnormal edges | |
5413 | isn't going to be interesting for shrink-wrap usage anyway. */ | |
5414 | if (live_edge->flags & EDGE_ABNORMAL) | |
5415 | return NULL; | |
5416 | ||
5417 | if (EDGE_COUNT (live_edge->dest->preds) > 1) | |
5418 | return NULL; | |
cde48de6 | 5419 | |
018f0595 | 5420 | return live_edge->dest; |
5421 | } | |
5422 | ||
5423 | /* Try to move INSN from BB to a successor. Return true on success. | |
5424 | USES and DEFS are the set of registers that are used and defined | |
5425 | after INSN in BB. */ | |
cde48de6 | 5426 | |
018f0595 | 5427 | static bool |
5428 | move_insn_for_shrink_wrap (basic_block bb, rtx insn, | |
5429 | const HARD_REG_SET uses, | |
5430 | const HARD_REG_SET defs) | |
5431 | { | |
5432 | rtx set, src, dest; | |
5433 | bitmap live_out, live_in, bb_uses, bb_defs; | |
5434 | unsigned int i, dregno, end_dregno, sregno, end_sregno; | |
5435 | basic_block next_block; | |
5436 | ||
5437 | /* Look for a simple register copy. */ | |
5438 | set = single_set (insn); | |
5439 | if (!set) | |
5440 | return false; | |
5441 | src = SET_SRC (set); | |
5442 | dest = SET_DEST (set); | |
5443 | if (!REG_P (dest) || !REG_P (src)) | |
5444 | return false; | |
5445 | ||
5446 | /* Make sure that the source register isn't defined later in BB. */ | |
5447 | sregno = REGNO (src); | |
5448 | end_sregno = END_REGNO (src); | |
5449 | if (overlaps_hard_reg_set_p (defs, GET_MODE (src), sregno)) | |
5450 | return false; | |
5451 | ||
5452 | /* Make sure that the destination register isn't referenced later in BB. */ | |
5453 | dregno = REGNO (dest); | |
5454 | end_dregno = END_REGNO (dest); | |
5455 | if (overlaps_hard_reg_set_p (uses, GET_MODE (dest), dregno) | |
5456 | || overlaps_hard_reg_set_p (defs, GET_MODE (dest), dregno)) | |
5457 | return false; | |
5458 | ||
5459 | /* See whether there is a successor block to which we could move INSN. */ | |
5460 | next_block = next_block_for_reg (bb, dregno, end_dregno); | |
5461 | if (!next_block) | |
5462 | return false; | |
5463 | ||
5464 | /* At this point we are committed to moving INSN, but let's try to | |
5465 | move it as far as we can. */ | |
5466 | do | |
5467 | { | |
5468 | live_out = df_get_live_out (bb); | |
5469 | live_in = df_get_live_in (next_block); | |
5470 | bb = next_block; | |
5471 | ||
5472 | /* Check whether BB uses DEST or clobbers DEST. We need to add | |
5473 | INSN to BB if so. Either way, DEST is no longer live on entry, | |
5474 | except for any part that overlaps SRC (next loop). */ | |
5475 | bb_uses = &DF_LR_BB_INFO (bb)->use; | |
5476 | bb_defs = &DF_LR_BB_INFO (bb)->def; | |
5477 | for (i = dregno; i < end_dregno; i++) | |
cde48de6 | 5478 | { |
018f0595 | 5479 | if (REGNO_REG_SET_P (bb_uses, i) || REGNO_REG_SET_P (bb_defs, i)) |
5480 | next_block = NULL; | |
5481 | CLEAR_REGNO_REG_SET (live_out, i); | |
5482 | CLEAR_REGNO_REG_SET (live_in, i); | |
cde48de6 | 5483 | } |
5484 | ||
018f0595 | 5485 | /* Check whether BB clobbers SRC. We need to add INSN to BB if so. |
5486 | Either way, SRC is now live on entry. */ | |
5487 | for (i = sregno; i < end_sregno; i++) | |
cde48de6 | 5488 | { |
018f0595 | 5489 | if (REGNO_REG_SET_P (bb_defs, i)) |
5490 | next_block = NULL; | |
5491 | SET_REGNO_REG_SET (live_out, i); | |
5492 | SET_REGNO_REG_SET (live_in, i); | |
cde48de6 | 5493 | } |
018f0595 | 5494 | |
5495 | /* If we don't need to add the move to BB, look for a single | |
5496 | successor block. */ | |
5497 | if (next_block) | |
5498 | next_block = next_block_for_reg (next_block, dregno, end_dregno); | |
cde48de6 | 5499 | } |
018f0595 | 5500 | while (next_block); |
5501 | ||
5502 | /* BB now defines DEST. It only uses the parts of DEST that overlap SRC | |
5503 | (next loop). */ | |
5504 | for (i = dregno; i < end_dregno; i++) | |
5505 | { | |
5506 | CLEAR_REGNO_REG_SET (bb_uses, i); | |
5507 | SET_REGNO_REG_SET (bb_defs, i); | |
5508 | } | |
5509 | ||
5510 | /* BB now uses SRC. */ | |
5511 | for (i = sregno; i < end_sregno; i++) | |
5512 | SET_REGNO_REG_SET (bb_uses, i); | |
5513 | ||
5514 | emit_insn_after (PATTERN (insn), bb_note (bb)); | |
5515 | delete_insn (insn); | |
5516 | return true; | |
5517 | } | |
5518 | ||
5519 | /* Look for register copies in the first block of the function, and move | |
5520 | them down into successor blocks if the register is used only on one | |
5521 | path. This exposes more opportunities for shrink-wrapping. These | |
5522 | kinds of sets often occur when incoming argument registers are moved | |
5523 | to call-saved registers because their values are live across one or | |
5524 | more calls during the function. */ | |
5525 | ||
5526 | static void | |
5527 | prepare_shrink_wrap (basic_block entry_block) | |
5528 | { | |
5529 | rtx insn, curr, x; | |
5530 | HARD_REG_SET uses, defs; | |
5531 | df_ref *ref; | |
5532 | ||
5533 | CLEAR_HARD_REG_SET (uses); | |
5534 | CLEAR_HARD_REG_SET (defs); | |
5535 | FOR_BB_INSNS_REVERSE_SAFE (entry_block, insn, curr) | |
5536 | if (NONDEBUG_INSN_P (insn) | |
5537 | && !move_insn_for_shrink_wrap (entry_block, insn, uses, defs)) | |
5538 | { | |
5539 | /* Add all defined registers to DEFs. */ | |
5540 | for (ref = DF_INSN_DEFS (insn); *ref; ref++) | |
5541 | { | |
5542 | x = DF_REF_REG (*ref); | |
5543 | if (REG_P (x) && HARD_REGISTER_P (x)) | |
5544 | SET_HARD_REG_BIT (defs, REGNO (x)); | |
5545 | } | |
5546 | ||
5547 | /* Add all used registers to USESs. */ | |
5548 | for (ref = DF_INSN_USES (insn); *ref; ref++) | |
5549 | { | |
5550 | x = DF_REF_REG (*ref); | |
5551 | if (REG_P (x) && HARD_REGISTER_P (x)) | |
5552 | SET_HARD_REG_BIT (uses, REGNO (x)); | |
5553 | } | |
5554 | } | |
cde48de6 | 5555 | } |
5556 | ||
1f021f97 | 5557 | #endif |
5558 | ||
bcf58f16 | 5559 | #ifdef HAVE_return |
f2c8a251 | 5560 | /* Insert use of return register before the end of BB. */ |
5561 | ||
5562 | static void | |
5563 | emit_use_return_register_into_block (basic_block bb) | |
5564 | { | |
5565 | rtx seq; | |
5566 | start_sequence (); | |
5567 | use_return_register (); | |
5568 | seq = get_insns (); | |
5569 | end_sequence (); | |
5570 | emit_insn_before (seq, BB_END (bb)); | |
5571 | } | |
5572 | ||
1f021f97 | 5573 | |
5574 | /* Create a return pattern, either simple_return or return, depending on | |
5575 | simple_p. */ | |
5576 | ||
5577 | static rtx | |
5578 | gen_return_pattern (bool simple_p) | |
5579 | { | |
5580 | #ifdef HAVE_simple_return | |
5581 | return simple_p ? gen_simple_return () : gen_return (); | |
5582 | #else | |
5583 | gcc_assert (!simple_p); | |
5584 | return gen_return (); | |
5585 | #endif | |
5586 | } | |
5587 | ||
5588 | /* Insert an appropriate return pattern at the end of block BB. This | |
5589 | also means updating block_for_insn appropriately. SIMPLE_P is | |
5590 | the same as in gen_return_pattern and passed to it. */ | |
2215ca0d | 5591 | |
5592 | static void | |
1f021f97 | 5593 | emit_return_into_block (bool simple_p, basic_block bb) |
2215ca0d | 5594 | { |
1f021f97 | 5595 | rtx jump, pat; |
5596 | jump = emit_jump_insn_after (gen_return_pattern (simple_p), BB_END (bb)); | |
5597 | pat = PATTERN (jump); | |
9cb2517e | 5598 | if (GET_CODE (pat) == PARALLEL) |
5599 | pat = XVECEXP (pat, 0, 0); | |
5600 | gcc_assert (ANY_RETURN_P (pat)); | |
5601 | JUMP_LABEL (jump) = pat; | |
2215ca0d | 5602 | } |
1f021f97 | 5603 | #endif |
2215ca0d | 5604 | |
31a53363 | 5605 | /* Set JUMP_LABEL for a return insn. */ |
5606 | ||
5607 | void | |
5608 | set_return_jump_label (rtx returnjump) | |
5609 | { | |
5610 | rtx pat = PATTERN (returnjump); | |
5611 | if (GET_CODE (pat) == PARALLEL) | |
5612 | pat = XVECEXP (pat, 0, 0); | |
5613 | if (ANY_RETURN_P (pat)) | |
5614 | JUMP_LABEL (returnjump) = pat; | |
5615 | else | |
5616 | JUMP_LABEL (returnjump) = ret_rtx; | |
5617 | } | |
5618 | ||
0a55d497 | 5619 | #ifdef HAVE_simple_return |
5620 | /* Create a copy of BB instructions and insert at BEFORE. Redirect | |
5621 | preds of BB to COPY_BB if they don't appear in NEED_PROLOGUE. */ | |
5622 | static void | |
5623 | dup_block_and_redirect (basic_block bb, basic_block copy_bb, rtx before, | |
5624 | bitmap_head *need_prologue) | |
5625 | { | |
5626 | edge_iterator ei; | |
5627 | edge e; | |
5628 | rtx insn = BB_END (bb); | |
5629 | ||
5630 | /* We know BB has a single successor, so there is no need to copy a | |
5631 | simple jump at the end of BB. */ | |
5632 | if (simplejump_p (insn)) | |
5633 | insn = PREV_INSN (insn); | |
5634 | ||
5635 | start_sequence (); | |
5636 | duplicate_insn_chain (BB_HEAD (bb), insn); | |
5637 | if (dump_file) | |
5638 | { | |
5639 | unsigned count = 0; | |
5640 | for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) | |
5641 | if (active_insn_p (insn)) | |
5642 | ++count; | |
5643 | fprintf (dump_file, "Duplicating bb %d to bb %d, %u active insns.\n", | |
5644 | bb->index, copy_bb->index, count); | |
5645 | } | |
5646 | insn = get_insns (); | |
5647 | end_sequence (); | |
5648 | emit_insn_before (insn, before); | |
5649 | ||
5650 | /* Redirect all the paths that need no prologue into copy_bb. */ | |
5651 | for (ei = ei_start (bb->preds); (e = ei_safe_edge (ei)); ) | |
5652 | if (!bitmap_bit_p (need_prologue, e->src->index)) | |
5653 | { | |
5654 | redirect_edge_and_branch_force (e, copy_bb); | |
5655 | continue; | |
5656 | } | |
5657 | else | |
5658 | ei_next (&ei); | |
5659 | } | |
5660 | #endif | |
5661 | ||
5662 | #if defined (HAVE_return) || defined (HAVE_simple_return) | |
5663 | /* Return true if there are any active insns between HEAD and TAIL. */ | |
cde48de6 | 5664 | static bool |
0a55d497 | 5665 | active_insn_between (rtx head, rtx tail) |
cde48de6 | 5666 | { |
0a55d497 | 5667 | while (tail) |
5668 | { | |
5669 | if (active_insn_p (tail)) | |
5670 | return true; | |
5671 | if (tail == head) | |
5672 | return false; | |
5673 | tail = PREV_INSN (tail); | |
5674 | } | |
5675 | return false; | |
5676 | } | |
5677 | ||
5678 | /* LAST_BB is a block that exits, and empty of active instructions. | |
5679 | Examine its predecessors for jumps that can be converted to | |
5680 | (conditional) returns. */ | |
5681 | static VEC (edge, heap) * | |
5682 | convert_jumps_to_returns (basic_block last_bb, bool simple_p, | |
5683 | VEC (edge, heap) *unconverted ATTRIBUTE_UNUSED) | |
5684 | { | |
5685 | int i; | |
5686 | basic_block bb; | |
cde48de6 | 5687 | rtx label; |
0a55d497 | 5688 | edge_iterator ei; |
5689 | edge e; | |
5690 | VEC(basic_block,heap) *src_bbs; | |
cde48de6 | 5691 | |
0a55d497 | 5692 | src_bbs = VEC_alloc (basic_block, heap, EDGE_COUNT (last_bb->preds)); |
5693 | FOR_EACH_EDGE (e, ei, last_bb->preds) | |
5694 | if (e->src != ENTRY_BLOCK_PTR) | |
5695 | VEC_quick_push (basic_block, src_bbs, e->src); | |
5696 | ||
5697 | label = BB_HEAD (last_bb); | |
5698 | ||
5699 | FOR_EACH_VEC_ELT (basic_block, src_bbs, i, bb) | |
cde48de6 | 5700 | { |
0a55d497 | 5701 | rtx jump = BB_END (bb); |
5702 | ||
5703 | if (!JUMP_P (jump) || JUMP_LABEL (jump) != label) | |
5704 | continue; | |
5705 | ||
5706 | e = find_edge (bb, last_bb); | |
5707 | ||
5708 | /* If we have an unconditional jump, we can replace that | |
5709 | with a simple return instruction. */ | |
5710 | if (simplejump_p (jump)) | |
5711 | { | |
5712 | /* The use of the return register might be present in the exit | |
5713 | fallthru block. Either: | |
5714 | - removing the use is safe, and we should remove the use in | |
5715 | the exit fallthru block, or | |
5716 | - removing the use is not safe, and we should add it here. | |
5717 | For now, we conservatively choose the latter. Either of the | |
5718 | 2 helps in crossjumping. */ | |
5719 | emit_use_return_register_into_block (bb); | |
5720 | ||
5721 | emit_return_into_block (simple_p, bb); | |
5722 | delete_insn (jump); | |
5723 | } | |
5724 | ||
5725 | /* If we have a conditional jump branching to the last | |
5726 | block, we can try to replace that with a conditional | |
5727 | return instruction. */ | |
5728 | else if (condjump_p (jump)) | |
5729 | { | |
5730 | rtx dest; | |
5731 | ||
5732 | if (simple_p) | |
5733 | dest = simple_return_rtx; | |
5734 | else | |
5735 | dest = ret_rtx; | |
5736 | if (!redirect_jump (jump, dest, 0)) | |
5737 | { | |
5738 | #ifdef HAVE_simple_return | |
5739 | if (simple_p) | |
5740 | { | |
5741 | if (dump_file) | |
5742 | fprintf (dump_file, | |
5743 | "Failed to redirect bb %d branch.\n", bb->index); | |
5744 | VEC_safe_push (edge, heap, unconverted, e); | |
5745 | } | |
5746 | #endif | |
5747 | continue; | |
5748 | } | |
5749 | ||
5750 | /* See comment in simplejump_p case above. */ | |
5751 | emit_use_return_register_into_block (bb); | |
5752 | ||
5753 | /* If this block has only one successor, it both jumps | |
5754 | and falls through to the fallthru block, so we can't | |
5755 | delete the edge. */ | |
5756 | if (single_succ_p (bb)) | |
5757 | continue; | |
5758 | } | |
5759 | else | |
5760 | { | |
5761 | #ifdef HAVE_simple_return | |
5762 | if (simple_p) | |
5763 | { | |
5764 | if (dump_file) | |
5765 | fprintf (dump_file, | |
5766 | "Failed to redirect bb %d branch.\n", bb->index); | |
5767 | VEC_safe_push (edge, heap, unconverted, e); | |
5768 | } | |
5769 | #endif | |
5770 | continue; | |
5771 | } | |
5772 | ||
5773 | /* Fix up the CFG for the successful change we just made. */ | |
5774 | redirect_edge_succ (e, EXIT_BLOCK_PTR); | |
ebb58a45 | 5775 | e->flags &= ~EDGE_CROSSING; |
cde48de6 | 5776 | } |
0a55d497 | 5777 | VEC_free (basic_block, heap, src_bbs); |
5778 | return unconverted; | |
cde48de6 | 5779 | } |
5780 | ||
0a55d497 | 5781 | /* Emit a return insn for the exit fallthru block. */ |
5782 | static basic_block | |
5783 | emit_return_for_exit (edge exit_fallthru_edge, bool simple_p) | |
5784 | { | |
5785 | basic_block last_bb = exit_fallthru_edge->src; | |
5786 | ||
5787 | if (JUMP_P (BB_END (last_bb))) | |
5788 | { | |
5789 | last_bb = split_edge (exit_fallthru_edge); | |
5790 | exit_fallthru_edge = single_succ_edge (last_bb); | |
5791 | } | |
5792 | emit_barrier_after (BB_END (last_bb)); | |
5793 | emit_return_into_block (simple_p, last_bb); | |
5794 | exit_fallthru_edge->flags &= ~EDGE_FALLTHRU; | |
5795 | return last_bb; | |
5796 | } | |
5797 | #endif | |
5798 | ||
5799 | ||
c3418f42 | 5800 | /* Generate the prologue and epilogue RTL if the machine supports it. Thread |
b2c5602e | 5801 | this into place with notes indicating where the prologue ends and where |
1f021f97 | 5802 | the epilogue begins. Update the basic block information when possible. |
5803 | ||
5804 | Notes on epilogue placement: | |
5805 | There are several kinds of edges to the exit block: | |
5806 | * a single fallthru edge from LAST_BB | |
5807 | * possibly, edges from blocks containing sibcalls | |
5808 | * possibly, fake edges from infinite loops | |
5809 | ||
5810 | The epilogue is always emitted on the fallthru edge from the last basic | |
5811 | block in the function, LAST_BB, into the exit block. | |
5812 | ||
5813 | If LAST_BB is empty except for a label, it is the target of every | |
5814 | other basic block in the function that ends in a return. If a | |
5815 | target has a return or simple_return pattern (possibly with | |
5816 | conditional variants), these basic blocks can be changed so that a | |
5817 | return insn is emitted into them, and their target is adjusted to | |
5818 | the real exit block. | |
5819 | ||
5820 | Notes on shrink wrapping: We implement a fairly conservative | |
5821 | version of shrink-wrapping rather than the textbook one. We only | |
5822 | generate a single prologue and a single epilogue. This is | |
5823 | sufficient to catch a number of interesting cases involving early | |
5824 | exits. | |
5825 | ||
5826 | First, we identify the blocks that require the prologue to occur before | |
5827 | them. These are the ones that modify a call-saved register, or reference | |
5828 | any of the stack or frame pointer registers. To simplify things, we then | |
5829 | mark everything reachable from these blocks as also requiring a prologue. | |
5830 | This takes care of loops automatically, and avoids the need to examine | |
5831 | whether MEMs reference the frame, since it is sufficient to check for | |
5832 | occurrences of the stack or frame pointer. | |
5833 | ||
5834 | We then compute the set of blocks for which the need for a prologue | |
5835 | is anticipatable (borrowing terminology from the shrink-wrapping | |
5836 | description in Muchnick's book). These are the blocks which either | |
5837 | require a prologue themselves, or those that have only successors | |
5838 | where the prologue is anticipatable. The prologue needs to be | |
5839 | inserted on all edges from BB1->BB2 where BB2 is in ANTIC and BB1 | |
5840 | is not. For the moment, we ensure that only one such edge exists. | |
5841 | ||
5842 | The epilogue is placed as described above, but we make a | |
5843 | distinction between inserting return and simple_return patterns | |
5844 | when modifying other blocks that end in a return. Blocks that end | |
5845 | in a sibcall omit the sibcall_epilogue if the block is not in | |
5846 | ANTIC. */ | |
b2c5602e | 5847 | |
3072d30e | 5848 | static void |
5849 | thread_prologue_and_epilogue_insns (void) | |
b2c5602e | 5850 | { |
48b14f50 | 5851 | bool inserted; |
1f021f97 | 5852 | #ifdef HAVE_simple_return |
0a55d497 | 5853 | VEC (edge, heap) *unconverted_simple_returns = NULL; |
1f021f97 | 5854 | bool nonempty_prologue; |
0a55d497 | 5855 | bitmap_head bb_flags; |
5856 | unsigned max_grow_size; | |
1f021f97 | 5857 | #endif |
0a55d497 | 5858 | rtx returnjump; |
f2b0107d | 5859 | rtx seq ATTRIBUTE_UNUSED, epilogue_end ATTRIBUTE_UNUSED; |
1f021f97 | 5860 | rtx prologue_seq ATTRIBUTE_UNUSED, split_prologue_seq ATTRIBUTE_UNUSED; |
5861 | edge e, entry_edge, orig_entry_edge, exit_fallthru_edge; | |
cd665a06 | 5862 | edge_iterator ei; |
1f021f97 | 5863 | |
5864 | df_analyze (); | |
71caadc0 | 5865 | |
c107ab96 | 5866 | rtl_profile_for_bb (ENTRY_BLOCK_PTR); |
48b14f50 | 5867 | |
5868 | inserted = false; | |
5869 | seq = NULL_RTX; | |
5870 | epilogue_end = NULL_RTX; | |
1f021f97 | 5871 | returnjump = NULL_RTX; |
48b14f50 | 5872 | |
5873 | /* Can't deal with multiple successors of the entry block at the | |
5874 | moment. Function should always have at least one entry | |
5875 | point. */ | |
5876 | gcc_assert (single_succ_p (ENTRY_BLOCK_PTR)); | |
5877 | entry_edge = single_succ_edge (ENTRY_BLOCK_PTR); | |
1f021f97 | 5878 | orig_entry_edge = entry_edge; |
5879 | ||
1f021f97 | 5880 | split_prologue_seq = NULL_RTX; |
48b14f50 | 5881 | if (flag_split_stack |
5882 | && (lookup_attribute ("no_split_stack", DECL_ATTRIBUTES (cfun->decl)) | |
5883 | == NULL)) | |
5884 | { | |
5885 | #ifndef HAVE_split_stack_prologue | |
5886 | gcc_unreachable (); | |
5887 | #else | |
5888 | gcc_assert (HAVE_split_stack_prologue); | |
5889 | ||
5890 | start_sequence (); | |
5891 | emit_insn (gen_split_stack_prologue ()); | |
1f021f97 | 5892 | split_prologue_seq = get_insns (); |
48b14f50 | 5893 | end_sequence (); |
5894 | ||
1f021f97 | 5895 | record_insns (split_prologue_seq, NULL, &prologue_insn_hash); |
5896 | set_insn_locators (split_prologue_seq, prologue_locator); | |
48b14f50 | 5897 | #endif |
5898 | } | |
5899 | ||
1f021f97 | 5900 | prologue_seq = NULL_RTX; |
b2c5602e | 5901 | #ifdef HAVE_prologue |
5902 | if (HAVE_prologue) | |
5903 | { | |
71caadc0 | 5904 | start_sequence (); |
06ebc183 | 5905 | seq = gen_prologue (); |
71caadc0 | 5906 | emit_insn (seq); |
b2c5602e | 5907 | |
48e1416a | 5908 | /* Insert an explicit USE for the frame pointer |
3072d30e | 5909 | if the profiling is on and the frame pointer is required. */ |
18d50ae6 | 5910 | if (crtl->profile && frame_pointer_needed) |
18b42941 | 5911 | emit_use (hard_frame_pointer_rtx); |
3072d30e | 5912 | |
b2c5602e | 5913 | /* Retain a map of the prologue insns. */ |
25e880b1 | 5914 | record_insns (seq, NULL, &prologue_insn_hash); |
d86df71c | 5915 | emit_note (NOTE_INSN_PROLOGUE_END); |
48e1416a | 5916 | |
d86df71c | 5917 | /* Ensure that instructions are not moved into the prologue when |
5918 | profiling is on. The call to the profiling routine can be | |
5919 | emitted within the live range of a call-clobbered register. */ | |
8637d6a2 | 5920 | if (!targetm.profile_before_prologue () && crtl->profile) |
d86df71c | 5921 | emit_insn (gen_blockage ()); |
3b934b09 | 5922 | |
1f021f97 | 5923 | prologue_seq = get_insns (); |
71caadc0 | 5924 | end_sequence (); |
1f021f97 | 5925 | set_insn_locators (prologue_seq, prologue_locator); |
5926 | } | |
5927 | #endif | |
71caadc0 | 5928 | |
0a55d497 | 5929 | #ifdef HAVE_simple_return |
1f021f97 | 5930 | bitmap_initialize (&bb_flags, &bitmap_default_obstack); |
5931 | ||
1f021f97 | 5932 | /* Try to perform a kind of shrink-wrapping, making sure the |
5933 | prologue/epilogue is emitted only around those parts of the | |
5934 | function that require it. */ | |
5935 | ||
5936 | nonempty_prologue = false; | |
5937 | for (seq = prologue_seq; seq; seq = NEXT_INSN (seq)) | |
5938 | if (!NOTE_P (seq) || NOTE_KIND (seq) != NOTE_INSN_PROLOGUE_END) | |
5939 | { | |
5940 | nonempty_prologue = true; | |
5941 | break; | |
5942 | } | |
5943 | ||
5944 | if (flag_shrink_wrap && HAVE_simple_return | |
5effe287 | 5945 | && (targetm.profile_before_prologue () || !crtl->profile) |
1f021f97 | 5946 | && nonempty_prologue && !crtl->calls_eh_return) |
5947 | { | |
5948 | HARD_REG_SET prologue_clobbered, prologue_used, live_on_edge; | |
2e851bb8 | 5949 | struct hard_reg_set_container set_up_by_prologue; |
1f021f97 | 5950 | rtx p_insn; |
1f021f97 | 5951 | VEC(basic_block, heap) *vec; |
5952 | basic_block bb; | |
5953 | bitmap_head bb_antic_flags; | |
5954 | bitmap_head bb_on_list; | |
0a55d497 | 5955 | bitmap_head bb_tail; |
1f021f97 | 5956 | |
5957 | if (dump_file) | |
5958 | fprintf (dump_file, "Attempting shrink-wrapping optimization.\n"); | |
5959 | ||
5960 | /* Compute the registers set and used in the prologue. */ | |
5961 | CLEAR_HARD_REG_SET (prologue_clobbered); | |
5962 | CLEAR_HARD_REG_SET (prologue_used); | |
5963 | for (p_insn = prologue_seq; p_insn; p_insn = NEXT_INSN (p_insn)) | |
5964 | { | |
5965 | HARD_REG_SET this_used; | |
5966 | if (!NONDEBUG_INSN_P (p_insn)) | |
5967 | continue; | |
5968 | ||
5969 | CLEAR_HARD_REG_SET (this_used); | |
5970 | note_uses (&PATTERN (p_insn), record_hard_reg_uses, | |
5971 | &this_used); | |
5972 | AND_COMPL_HARD_REG_SET (this_used, prologue_clobbered); | |
5973 | IOR_HARD_REG_SET (prologue_used, this_used); | |
5974 | note_stores (PATTERN (p_insn), record_hard_reg_sets, | |
5975 | &prologue_clobbered); | |
5976 | } | |
1f021f97 | 5977 | |
cde48de6 | 5978 | prepare_shrink_wrap (entry_edge->dest); |
5979 | ||
1f021f97 | 5980 | bitmap_initialize (&bb_antic_flags, &bitmap_default_obstack); |
5981 | bitmap_initialize (&bb_on_list, &bitmap_default_obstack); | |
0a55d497 | 5982 | bitmap_initialize (&bb_tail, &bitmap_default_obstack); |
1f021f97 | 5983 | |
0a55d497 | 5984 | /* Find the set of basic blocks that require a stack frame, |
5985 | and blocks that are too big to be duplicated. */ | |
1f021f97 | 5986 | |
5987 | vec = VEC_alloc (basic_block, heap, n_basic_blocks); | |
5988 | ||
2e851bb8 | 5989 | CLEAR_HARD_REG_SET (set_up_by_prologue.set); |
5990 | add_to_hard_reg_set (&set_up_by_prologue.set, Pmode, | |
5991 | STACK_POINTER_REGNUM); | |
5992 | add_to_hard_reg_set (&set_up_by_prologue.set, Pmode, ARG_POINTER_REGNUM); | |
f8e6666e | 5993 | if (frame_pointer_needed) |
2e851bb8 | 5994 | add_to_hard_reg_set (&set_up_by_prologue.set, Pmode, |
f8e6666e | 5995 | HARD_FRAME_POINTER_REGNUM); |
5996 | if (pic_offset_table_rtx) | |
2e851bb8 | 5997 | add_to_hard_reg_set (&set_up_by_prologue.set, Pmode, |
f8e6666e | 5998 | PIC_OFFSET_TABLE_REGNUM); |
0c3a5ef6 | 5999 | if (stack_realign_drap && crtl->drap_reg) |
2e851bb8 | 6000 | add_to_hard_reg_set (&set_up_by_prologue.set, |
6001 | GET_MODE (crtl->drap_reg), | |
0c3a5ef6 | 6002 | REGNO (crtl->drap_reg)); |
2e851bb8 | 6003 | if (targetm.set_up_by_prologue) |
6004 | targetm.set_up_by_prologue (&set_up_by_prologue); | |
f8e6666e | 6005 | |
0a55d497 | 6006 | /* We don't use a different max size depending on |
6007 | optimize_bb_for_speed_p because increasing shrink-wrapping | |
6008 | opportunities by duplicating tail blocks can actually result | |
6009 | in an overall decrease in code size. */ | |
6010 | max_grow_size = get_uncond_jump_length (); | |
6011 | max_grow_size *= PARAM_VALUE (PARAM_MAX_GROW_COPY_BB_INSNS); | |
6012 | ||
1f021f97 | 6013 | FOR_EACH_BB (bb) |
6014 | { | |
6015 | rtx insn; | |
0a55d497 | 6016 | unsigned size = 0; |
6017 | ||
6018 | FOR_BB_INSNS (bb, insn) | |
6019 | if (NONDEBUG_INSN_P (insn)) | |
6020 | { | |
6021 | if (requires_stack_frame_p (insn, prologue_used, | |
2e851bb8 | 6022 | set_up_by_prologue.set)) |
0a55d497 | 6023 | { |
6024 | if (bb == entry_edge->dest) | |
6025 | goto fail_shrinkwrap; | |
6026 | bitmap_set_bit (&bb_flags, bb->index); | |
6027 | VEC_quick_push (basic_block, vec, bb); | |
6028 | break; | |
6029 | } | |
6030 | else if (size <= max_grow_size) | |
6031 | { | |
6032 | size += get_attr_min_length (insn); | |
6033 | if (size > max_grow_size) | |
6034 | bitmap_set_bit (&bb_on_list, bb->index); | |
6035 | } | |
6036 | } | |
1f021f97 | 6037 | } |
6038 | ||
0a55d497 | 6039 | /* Blocks that really need a prologue, or are too big for tails. */ |
6040 | bitmap_ior_into (&bb_on_list, &bb_flags); | |
6041 | ||
1f021f97 | 6042 | /* For every basic block that needs a prologue, mark all blocks |
6043 | reachable from it, so as to ensure they are also seen as | |
6044 | requiring a prologue. */ | |
6045 | while (!VEC_empty (basic_block, vec)) | |
6046 | { | |
6047 | basic_block tmp_bb = VEC_pop (basic_block, vec); | |
0a55d497 | 6048 | |
1f021f97 | 6049 | FOR_EACH_EDGE (e, ei, tmp_bb->succs) |
6050 | if (e->dest != EXIT_BLOCK_PTR | |
6051 | && bitmap_set_bit (&bb_flags, e->dest->index)) | |
6052 | VEC_quick_push (basic_block, vec, e->dest); | |
6053 | } | |
0a55d497 | 6054 | |
6055 | /* Find the set of basic blocks that need no prologue, have a | |
6056 | single successor, can be duplicated, meet a max size | |
6057 | requirement, and go to the exit via like blocks. */ | |
6058 | VEC_quick_push (basic_block, vec, EXIT_BLOCK_PTR); | |
6059 | while (!VEC_empty (basic_block, vec)) | |
1f021f97 | 6060 | { |
0a55d497 | 6061 | basic_block tmp_bb = VEC_pop (basic_block, vec); |
6062 | ||
6063 | FOR_EACH_EDGE (e, ei, tmp_bb->preds) | |
6064 | if (single_succ_p (e->src) | |
6065 | && !bitmap_bit_p (&bb_on_list, e->src->index) | |
dc15d51e | 6066 | && can_duplicate_block_p (e->src)) |
6067 | { | |
6068 | edge pe; | |
6069 | edge_iterator pei; | |
6070 | ||
6071 | /* If there is predecessor of e->src which doesn't | |
6072 | need prologue and the edge is complex, | |
6073 | we might not be able to redirect the branch | |
6074 | to a copy of e->src. */ | |
6075 | FOR_EACH_EDGE (pe, pei, e->src->preds) | |
6076 | if ((pe->flags & EDGE_COMPLEX) != 0 | |
6077 | && !bitmap_bit_p (&bb_flags, pe->src->index)) | |
6078 | break; | |
6079 | if (pe == NULL && bitmap_set_bit (&bb_tail, e->src->index)) | |
6080 | VEC_quick_push (basic_block, vec, e->src); | |
6081 | } | |
1f021f97 | 6082 | } |
6083 | ||
6084 | /* Now walk backwards from every block that is marked as needing | |
0a55d497 | 6085 | a prologue to compute the bb_antic_flags bitmap. Exclude |
6086 | tail blocks; They can be duplicated to be used on paths not | |
6087 | needing a prologue. */ | |
6088 | bitmap_clear (&bb_on_list); | |
6089 | bitmap_and_compl (&bb_antic_flags, &bb_flags, &bb_tail); | |
1f021f97 | 6090 | FOR_EACH_BB (bb) |
6091 | { | |
0a55d497 | 6092 | if (!bitmap_bit_p (&bb_antic_flags, bb->index)) |
1f021f97 | 6093 | continue; |
6094 | FOR_EACH_EDGE (e, ei, bb->preds) | |
6095 | if (!bitmap_bit_p (&bb_antic_flags, e->src->index) | |
6096 | && bitmap_set_bit (&bb_on_list, e->src->index)) | |
6097 | VEC_quick_push (basic_block, vec, e->src); | |
6098 | } | |
6099 | while (!VEC_empty (basic_block, vec)) | |
6100 | { | |
6101 | basic_block tmp_bb = VEC_pop (basic_block, vec); | |
1f021f97 | 6102 | bool all_set = true; |
6103 | ||
6104 | bitmap_clear_bit (&bb_on_list, tmp_bb->index); | |
6105 | FOR_EACH_EDGE (e, ei, tmp_bb->succs) | |
6106 | if (!bitmap_bit_p (&bb_antic_flags, e->dest->index)) | |
6107 | { | |
6108 | all_set = false; | |
6109 | break; | |
6110 | } | |
6111 | ||
6112 | if (all_set) | |
6113 | { | |
6114 | bitmap_set_bit (&bb_antic_flags, tmp_bb->index); | |
6115 | FOR_EACH_EDGE (e, ei, tmp_bb->preds) | |
6116 | if (!bitmap_bit_p (&bb_antic_flags, e->src->index) | |
6117 | && bitmap_set_bit (&bb_on_list, e->src->index)) | |
6118 | VEC_quick_push (basic_block, vec, e->src); | |
6119 | } | |
6120 | } | |
6121 | /* Find exactly one edge that leads to a block in ANTIC from | |
6122 | a block that isn't. */ | |
6123 | if (!bitmap_bit_p (&bb_antic_flags, entry_edge->dest->index)) | |
6124 | FOR_EACH_BB (bb) | |
6125 | { | |
6126 | if (!bitmap_bit_p (&bb_antic_flags, bb->index)) | |
6127 | continue; | |
6128 | FOR_EACH_EDGE (e, ei, bb->preds) | |
6129 | if (!bitmap_bit_p (&bb_antic_flags, e->src->index)) | |
6130 | { | |
6131 | if (entry_edge != orig_entry_edge) | |
6132 | { | |
6133 | entry_edge = orig_entry_edge; | |
6134 | if (dump_file) | |
6135 | fprintf (dump_file, "More than one candidate edge.\n"); | |
6136 | goto fail_shrinkwrap; | |
6137 | } | |
6138 | if (dump_file) | |
6139 | fprintf (dump_file, "Found candidate edge for " | |
6140 | "shrink-wrapping, %d->%d.\n", e->src->index, | |
6141 | e->dest->index); | |
6142 | entry_edge = e; | |
6143 | } | |
6144 | } | |
6145 | ||
0a55d497 | 6146 | if (entry_edge != orig_entry_edge) |
1f021f97 | 6147 | { |
0a55d497 | 6148 | /* Test whether the prologue is known to clobber any register |
6149 | (other than FP or SP) which are live on the edge. */ | |
6150 | CLEAR_HARD_REG_BIT (prologue_clobbered, STACK_POINTER_REGNUM); | |
6151 | if (frame_pointer_needed) | |
6152 | CLEAR_HARD_REG_BIT (prologue_clobbered, HARD_FRAME_POINTER_REGNUM); | |
6153 | CLEAR_HARD_REG_SET (live_on_edge); | |
6154 | reg_set_to_hard_reg_set (&live_on_edge, | |
6155 | df_get_live_in (entry_edge->dest)); | |
6156 | if (hard_reg_set_intersect_p (live_on_edge, prologue_clobbered)) | |
6157 | { | |
6158 | entry_edge = orig_entry_edge; | |
6159 | if (dump_file) | |
6160 | fprintf (dump_file, | |
6161 | "Shrink-wrapping aborted due to clobber.\n"); | |
6162 | } | |
1f021f97 | 6163 | } |
0a55d497 | 6164 | if (entry_edge != orig_entry_edge) |
1f021f97 | 6165 | { |
6166 | crtl->shrink_wrapped = true; | |
7022dadd | 6167 | if (dump_file) |
6168 | fprintf (dump_file, "Performing shrink-wrapping.\n"); | |
0a55d497 | 6169 | |
6170 | /* Find tail blocks reachable from both blocks needing a | |
6171 | prologue and blocks not needing a prologue. */ | |
6172 | if (!bitmap_empty_p (&bb_tail)) | |
6173 | FOR_EACH_BB (bb) | |
6174 | { | |
6175 | bool some_pro, some_no_pro; | |
6176 | if (!bitmap_bit_p (&bb_tail, bb->index)) | |
6177 | continue; | |
6178 | some_pro = some_no_pro = false; | |
6179 | FOR_EACH_EDGE (e, ei, bb->preds) | |
6180 | { | |
6181 | if (bitmap_bit_p (&bb_flags, e->src->index)) | |
6182 | some_pro = true; | |
6183 | else | |
6184 | some_no_pro = true; | |
6185 | } | |
6186 | if (some_pro && some_no_pro) | |
6187 | VEC_quick_push (basic_block, vec, bb); | |
6188 | else | |
6189 | bitmap_clear_bit (&bb_tail, bb->index); | |
6190 | } | |
6191 | /* Find the head of each tail. */ | |
6192 | while (!VEC_empty (basic_block, vec)) | |
6193 | { | |
6194 | basic_block tbb = VEC_pop (basic_block, vec); | |
6195 | ||
6196 | if (!bitmap_bit_p (&bb_tail, tbb->index)) | |
6197 | continue; | |
6198 | ||
6199 | while (single_succ_p (tbb)) | |
6200 | { | |
6201 | tbb = single_succ (tbb); | |
6202 | bitmap_clear_bit (&bb_tail, tbb->index); | |
6203 | } | |
6204 | } | |
6205 | /* Now duplicate the tails. */ | |
6206 | if (!bitmap_empty_p (&bb_tail)) | |
6207 | FOR_EACH_BB_REVERSE (bb) | |
6208 | { | |
6209 | basic_block copy_bb, tbb; | |
6210 | rtx insert_point; | |
6211 | int eflags; | |
6212 | ||
6213 | if (!bitmap_clear_bit (&bb_tail, bb->index)) | |
6214 | continue; | |
6215 | ||
6216 | /* Create a copy of BB, instructions and all, for | |
6217 | use on paths that don't need a prologue. | |
6218 | Ideal placement of the copy is on a fall-thru edge | |
6219 | or after a block that would jump to the copy. */ | |
6220 | FOR_EACH_EDGE (e, ei, bb->preds) | |
6221 | if (!bitmap_bit_p (&bb_flags, e->src->index) | |
6222 | && single_succ_p (e->src)) | |
6223 | break; | |
6224 | if (e) | |
6225 | { | |
6226 | copy_bb = create_basic_block (NEXT_INSN (BB_END (e->src)), | |
6227 | NULL_RTX, e->src); | |
6228 | BB_COPY_PARTITION (copy_bb, e->src); | |
6229 | } | |
6230 | else | |
6231 | { | |
6232 | /* Otherwise put the copy at the end of the function. */ | |
6233 | copy_bb = create_basic_block (NULL_RTX, NULL_RTX, | |
6234 | EXIT_BLOCK_PTR->prev_bb); | |
6235 | BB_COPY_PARTITION (copy_bb, bb); | |
6236 | } | |
6237 | ||
6238 | insert_point = emit_note_after (NOTE_INSN_DELETED, | |
6239 | BB_END (copy_bb)); | |
6240 | emit_barrier_after (BB_END (copy_bb)); | |
6241 | ||
6242 | tbb = bb; | |
6243 | while (1) | |
6244 | { | |
6245 | dup_block_and_redirect (tbb, copy_bb, insert_point, | |
6246 | &bb_flags); | |
6247 | tbb = single_succ (tbb); | |
6248 | if (tbb == EXIT_BLOCK_PTR) | |
6249 | break; | |
6250 | e = split_block (copy_bb, PREV_INSN (insert_point)); | |
6251 | copy_bb = e->dest; | |
6252 | } | |
6253 | ||
6254 | /* Quiet verify_flow_info by (ab)using EDGE_FAKE. | |
6255 | We have yet to add a simple_return to the tails, | |
6256 | as we'd like to first convert_jumps_to_returns in | |
6257 | case the block is no longer used after that. */ | |
6258 | eflags = EDGE_FAKE; | |
6259 | if (CALL_P (PREV_INSN (insert_point)) | |
6260 | && SIBLING_CALL_P (PREV_INSN (insert_point))) | |
6261 | eflags = EDGE_SIBCALL | EDGE_ABNORMAL; | |
6262 | make_single_succ_edge (copy_bb, EXIT_BLOCK_PTR, eflags); | |
6263 | ||
6264 | /* verify_flow_info doesn't like a note after a | |
6265 | sibling call. */ | |
6266 | delete_insn (insert_point); | |
6267 | if (bitmap_empty_p (&bb_tail)) | |
6268 | break; | |
6269 | } | |
1f021f97 | 6270 | } |
6271 | ||
6272 | fail_shrinkwrap: | |
0a55d497 | 6273 | bitmap_clear (&bb_tail); |
1f021f97 | 6274 | bitmap_clear (&bb_antic_flags); |
6275 | bitmap_clear (&bb_on_list); | |
6276 | VEC_free (basic_block, heap, vec); | |
b2c5602e | 6277 | } |
b2c5602e | 6278 | #endif |
b2c5602e | 6279 | |
1f021f97 | 6280 | if (split_prologue_seq != NULL_RTX) |
6281 | { | |
4db91b33 | 6282 | insert_insn_on_edge (split_prologue_seq, orig_entry_edge); |
1f021f97 | 6283 | inserted = true; |
6284 | } | |
6285 | if (prologue_seq != NULL_RTX) | |
6286 | { | |
6287 | insert_insn_on_edge (prologue_seq, entry_edge); | |
6288 | inserted = true; | |
6289 | } | |
6290 | ||
777e249a | 6291 | /* If the exit block has no non-fake predecessors, we don't need |
6292 | an epilogue. */ | |
cd665a06 | 6293 | FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) |
777e249a | 6294 | if ((e->flags & EDGE_FAKE) == 0) |
6295 | break; | |
6296 | if (e == NULL) | |
6297 | goto epilogue_done; | |
6298 | ||
c107ab96 | 6299 | rtl_profile_for_bb (EXIT_BLOCK_PTR); |
1f021f97 | 6300 | |
0a55d497 | 6301 | exit_fallthru_edge = find_fallthru_edge (EXIT_BLOCK_PTR->preds); |
6302 | ||
1f021f97 | 6303 | /* If we're allowed to generate a simple return instruction, then by |
6304 | definition we don't need a full epilogue. If the last basic | |
6305 | block before the exit block does not contain active instructions, | |
6306 | examine its predecessors and try to emit (conditional) return | |
6307 | instructions. */ | |
0a55d497 | 6308 | #ifdef HAVE_simple_return |
6309 | if (entry_edge != orig_entry_edge) | |
2215ca0d | 6310 | { |
0a55d497 | 6311 | if (optimize) |
2215ca0d | 6312 | { |
0a55d497 | 6313 | unsigned i, last; |
2215ca0d | 6314 | |
0a55d497 | 6315 | /* convert_jumps_to_returns may add to EXIT_BLOCK_PTR->preds |
6316 | (but won't remove). Stop at end of current preds. */ | |
6317 | last = EDGE_COUNT (EXIT_BLOCK_PTR->preds); | |
6318 | for (i = 0; i < last; i++) | |
1f021f97 | 6319 | { |
0a55d497 | 6320 | e = EDGE_I (EXIT_BLOCK_PTR->preds, i); |
6321 | if (LABEL_P (BB_HEAD (e->src)) | |
6322 | && !bitmap_bit_p (&bb_flags, e->src->index) | |
6323 | && !active_insn_between (BB_HEAD (e->src), BB_END (e->src))) | |
6324 | unconverted_simple_returns | |
6325 | = convert_jumps_to_returns (e->src, true, | |
6326 | unconverted_simple_returns); | |
1f021f97 | 6327 | } |
0a55d497 | 6328 | } |
1f021f97 | 6329 | |
0a55d497 | 6330 | if (exit_fallthru_edge != NULL |
6331 | && EDGE_COUNT (exit_fallthru_edge->src->preds) != 0 | |
6332 | && !bitmap_bit_p (&bb_flags, exit_fallthru_edge->src->index)) | |
6333 | { | |
6334 | basic_block last_bb; | |
f2c8a251 | 6335 | |
0a55d497 | 6336 | last_bb = emit_return_for_exit (exit_fallthru_edge, true); |
6337 | returnjump = BB_END (last_bb); | |
6338 | exit_fallthru_edge = NULL; | |
6339 | } | |
6340 | } | |
1f021f97 | 6341 | #endif |
0a55d497 | 6342 | #ifdef HAVE_return |
6343 | if (HAVE_return) | |
6344 | { | |
6345 | if (exit_fallthru_edge == NULL) | |
6346 | goto epilogue_done; | |
2215ca0d | 6347 | |
0a55d497 | 6348 | if (optimize) |
6349 | { | |
6350 | basic_block last_bb = exit_fallthru_edge->src; | |
1f021f97 | 6351 | |
0a55d497 | 6352 | if (LABEL_P (BB_HEAD (last_bb)) |
6353 | && !active_insn_between (BB_HEAD (last_bb), BB_END (last_bb))) | |
6354 | convert_jumps_to_returns (last_bb, false, NULL); | |
6355 | ||
3c4ca362 | 6356 | if (EDGE_COUNT (last_bb->preds) != 0 |
6357 | && single_succ_p (last_bb)) | |
1f021f97 | 6358 | { |
0a55d497 | 6359 | last_bb = emit_return_for_exit (exit_fallthru_edge, false); |
6360 | epilogue_end = returnjump = BB_END (last_bb); | |
1f021f97 | 6361 | #ifdef HAVE_simple_return |
0a55d497 | 6362 | /* Emitting the return may add a basic block. |
6363 | Fix bb_flags for the added block. */ | |
6364 | if (last_bb != exit_fallthru_edge->src) | |
6365 | bitmap_set_bit (&bb_flags, last_bb->index); | |
1f021f97 | 6366 | #endif |
0a55d497 | 6367 | goto epilogue_done; |
2215ca0d | 6368 | } |
ffb61627 | 6369 | } |
2215ca0d | 6370 | } |
6371 | #endif | |
25e880b1 | 6372 | |
6373 | /* A small fib -- epilogue is not yet completed, but we wish to re-use | |
6374 | this marker for the splits of EH_RETURN patterns, and nothing else | |
6375 | uses the flag in the meantime. */ | |
6376 | epilogue_completed = 1; | |
6377 | ||
6378 | #ifdef HAVE_eh_return | |
6379 | /* Find non-fallthru edges that end with EH_RETURN instructions. On | |
6380 | some targets, these get split to a special version of the epilogue | |
6381 | code. In order to be able to properly annotate these with unwind | |
6382 | info, try to split them now. If we get a valid split, drop an | |
6383 | EPILOGUE_BEG note and mark the insns as epilogue insns. */ | |
6384 | FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) | |
6385 | { | |
6386 | rtx prev, last, trial; | |
6387 | ||
6388 | if (e->flags & EDGE_FALLTHRU) | |
6389 | continue; | |
6390 | last = BB_END (e->src); | |
6391 | if (!eh_returnjump_p (last)) | |
6392 | continue; | |
6393 | ||
6394 | prev = PREV_INSN (last); | |
6395 | trial = try_split (PATTERN (last), last, 1); | |
6396 | if (trial == last) | |
6397 | continue; | |
6398 | ||
6399 | record_insns (NEXT_INSN (prev), NEXT_INSN (trial), &epilogue_insn_hash); | |
6400 | emit_note_after (NOTE_INSN_EPILOGUE_BEG, prev); | |
6401 | } | |
6402 | #endif | |
6403 | ||
1f021f97 | 6404 | /* If nothing falls through into the exit block, we don't need an |
6405 | epilogue. */ | |
9bb8a4af | 6406 | |
1f021f97 | 6407 | if (exit_fallthru_edge == NULL) |
9bb8a4af | 6408 | goto epilogue_done; |
6409 | ||
b2c5602e | 6410 | #ifdef HAVE_epilogue |
6411 | if (HAVE_epilogue) | |
6412 | { | |
777e249a | 6413 | start_sequence (); |
31b97e8f | 6414 | epilogue_end = emit_note (NOTE_INSN_EPILOGUE_BEG); |
777e249a | 6415 | seq = gen_epilogue (); |
11efe736 | 6416 | if (seq) |
6417 | emit_jump_insn (seq); | |
b2c5602e | 6418 | |
777e249a | 6419 | /* Retain a map of the epilogue insns. */ |
25e880b1 | 6420 | record_insns (seq, NULL, &epilogue_insn_hash); |
13751393 | 6421 | set_insn_locators (seq, epilogue_locator); |
b2c5602e | 6422 | |
31d3e01c | 6423 | seq = get_insns (); |
1f021f97 | 6424 | returnjump = get_last_insn (); |
06ebc183 | 6425 | end_sequence (); |
71caadc0 | 6426 | |
1f021f97 | 6427 | insert_insn_on_edge (seq, exit_fallthru_edge); |
48b14f50 | 6428 | inserted = true; |
4115ac36 | 6429 | |
6430 | if (JUMP_P (returnjump)) | |
31a53363 | 6431 | set_return_jump_label (returnjump); |
b2c5602e | 6432 | } |
9bb8a4af | 6433 | else |
b2c5602e | 6434 | #endif |
9bb8a4af | 6435 | { |
6436 | basic_block cur_bb; | |
6437 | ||
1f021f97 | 6438 | if (! next_active_insn (BB_END (exit_fallthru_edge->src))) |
9bb8a4af | 6439 | goto epilogue_done; |
6440 | /* We have a fall-through edge to the exit block, the source is not | |
6441 | at the end of the function, and there will be an assembler epilogue | |
6442 | at the end of the function. | |
6443 | We can't use force_nonfallthru here, because that would try to | |
1f021f97 | 6444 | use return. Inserting a jump 'by hand' is extremely messy, so |
9bb8a4af | 6445 | we take advantage of cfg_layout_finalize using |
1f021f97 | 6446 | fixup_fallthru_exit_predecessor. */ |
d2ed6106 | 6447 | cfg_layout_initialize (0); |
9bb8a4af | 6448 | FOR_EACH_BB (cur_bb) |
4d2e5d52 | 6449 | if (cur_bb->index >= NUM_FIXED_BLOCKS |
6450 | && cur_bb->next_bb->index >= NUM_FIXED_BLOCKS) | |
bc5f266a | 6451 | cur_bb->aux = cur_bb->next_bb; |
9bb8a4af | 6452 | cfg_layout_finalize (); |
6453 | } | |
202bbc06 | 6454 | |
777e249a | 6455 | epilogue_done: |
1f021f97 | 6456 | |
c107ab96 | 6457 | default_rtl_profile (); |
71caadc0 | 6458 | |
58d5b39c | 6459 | if (inserted) |
e08b2eb8 | 6460 | { |
202bbc06 | 6461 | sbitmap blocks; |
6462 | ||
e08b2eb8 | 6463 | commit_edge_insertions (); |
6464 | ||
202bbc06 | 6465 | /* Look for basic blocks within the prologue insns. */ |
6466 | blocks = sbitmap_alloc (last_basic_block); | |
6467 | sbitmap_zero (blocks); | |
6468 | SET_BIT (blocks, entry_edge->dest->index); | |
f8e6666e | 6469 | SET_BIT (blocks, orig_entry_edge->dest->index); |
202bbc06 | 6470 | find_many_sub_basic_blocks (blocks); |
6471 | sbitmap_free (blocks); | |
6472 | ||
e08b2eb8 | 6473 | /* The epilogue insns we inserted may cause the exit edge to no longer |
6474 | be fallthru. */ | |
6475 | FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) | |
6476 | { | |
6477 | if (((e->flags & EDGE_FALLTHRU) != 0) | |
6478 | && returnjump_p (BB_END (e->src))) | |
6479 | e->flags &= ~EDGE_FALLTHRU; | |
6480 | } | |
6481 | } | |
60ecc450 | 6482 | |
1f021f97 | 6483 | #ifdef HAVE_simple_return |
6484 | /* If there were branches to an empty LAST_BB which we tried to | |
6485 | convert to conditional simple_returns, but couldn't for some | |
6486 | reason, create a block to hold a simple_return insn and redirect | |
6487 | those remaining edges. */ | |
0a55d497 | 6488 | if (!VEC_empty (edge, unconverted_simple_returns)) |
1f021f97 | 6489 | { |
0a55d497 | 6490 | basic_block simple_return_block_hot = NULL; |
6491 | basic_block simple_return_block_cold = NULL; | |
6492 | edge pending_edge_hot = NULL; | |
6493 | edge pending_edge_cold = NULL; | |
1f021f97 | 6494 | basic_block exit_pred = EXIT_BLOCK_PTR->prev_bb; |
7f61fb27 | 6495 | int i; |
1f021f97 | 6496 | |
6497 | gcc_assert (entry_edge != orig_entry_edge); | |
6498 | ||
6499 | /* See if we can reuse the last insn that was emitted for the | |
6500 | epilogue. */ | |
6501 | if (returnjump != NULL_RTX | |
6502 | && JUMP_LABEL (returnjump) == simple_return_rtx) | |
6503 | { | |
0a55d497 | 6504 | e = split_block (BLOCK_FOR_INSN (returnjump), PREV_INSN (returnjump)); |
1f021f97 | 6505 | if (BB_PARTITION (e->src) == BB_HOT_PARTITION) |
6506 | simple_return_block_hot = e->dest; | |
6507 | else | |
6508 | simple_return_block_cold = e->dest; | |
6509 | } | |
6510 | ||
0a55d497 | 6511 | /* Also check returns we might need to add to tail blocks. */ |
6512 | FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) | |
6513 | if (EDGE_COUNT (e->src->preds) != 0 | |
6514 | && (e->flags & EDGE_FAKE) != 0 | |
6515 | && !bitmap_bit_p (&bb_flags, e->src->index)) | |
6516 | { | |
6517 | if (BB_PARTITION (e->src) == BB_HOT_PARTITION) | |
6518 | pending_edge_hot = e; | |
6519 | else | |
6520 | pending_edge_cold = e; | |
6521 | } | |
6522 | ||
6523 | FOR_EACH_VEC_ELT (edge, unconverted_simple_returns, i, e) | |
1f021f97 | 6524 | { |
1f021f97 | 6525 | basic_block *pdest_bb; |
0a55d497 | 6526 | edge pending; |
1f021f97 | 6527 | |
0a55d497 | 6528 | if (BB_PARTITION (e->src) == BB_HOT_PARTITION) |
6529 | { | |
6530 | pdest_bb = &simple_return_block_hot; | |
6531 | pending = pending_edge_hot; | |
6532 | } | |
1f021f97 | 6533 | else |
0a55d497 | 6534 | { |
6535 | pdest_bb = &simple_return_block_cold; | |
6536 | pending = pending_edge_cold; | |
6537 | } | |
6538 | ||
6539 | if (*pdest_bb == NULL && pending != NULL) | |
6540 | { | |
6541 | emit_return_into_block (true, pending->src); | |
6542 | pending->flags &= ~(EDGE_FALLTHRU | EDGE_FAKE); | |
6543 | *pdest_bb = pending->src; | |
6544 | } | |
6545 | else if (*pdest_bb == NULL) | |
1f021f97 | 6546 | { |
6547 | basic_block bb; | |
6548 | rtx start; | |
6549 | ||
6550 | bb = create_basic_block (NULL, NULL, exit_pred); | |
6551 | BB_COPY_PARTITION (bb, e->src); | |
6552 | start = emit_jump_insn_after (gen_simple_return (), | |
6553 | BB_END (bb)); | |
6554 | JUMP_LABEL (start) = simple_return_rtx; | |
6555 | emit_barrier_after (start); | |
6556 | ||
6557 | *pdest_bb = bb; | |
6558 | make_edge (bb, EXIT_BLOCK_PTR, 0); | |
6559 | } | |
6560 | redirect_edge_and_branch_force (e, *pdest_bb); | |
1f021f97 | 6561 | } |
0a55d497 | 6562 | VEC_free (edge, heap, unconverted_simple_returns); |
6563 | } | |
6564 | ||
6565 | if (entry_edge != orig_entry_edge) | |
6566 | { | |
6567 | FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) | |
6568 | if (EDGE_COUNT (e->src->preds) != 0 | |
6569 | && (e->flags & EDGE_FAKE) != 0 | |
6570 | && !bitmap_bit_p (&bb_flags, e->src->index)) | |
6571 | { | |
6572 | emit_return_into_block (true, e->src); | |
6573 | e->flags &= ~(EDGE_FALLTHRU | EDGE_FAKE); | |
6574 | } | |
1f021f97 | 6575 | } |
6576 | #endif | |
6577 | ||
60ecc450 | 6578 | #ifdef HAVE_sibcall_epilogue |
6579 | /* Emit sibling epilogues before any sibling call sites. */ | |
cd665a06 | 6580 | for (ei = ei_start (EXIT_BLOCK_PTR->preds); (e = ei_safe_edge (ei)); ) |
60ecc450 | 6581 | { |
6582 | basic_block bb = e->src; | |
5496dbfc | 6583 | rtx insn = BB_END (bb); |
1f021f97 | 6584 | rtx ep_seq; |
60ecc450 | 6585 | |
6d7dc5b9 | 6586 | if (!CALL_P (insn) |
1f021f97 | 6587 | || ! SIBLING_CALL_P (insn) |
0a55d497 | 6588 | #ifdef HAVE_simple_return |
1f021f97 | 6589 | || (entry_edge != orig_entry_edge |
0a55d497 | 6590 | && !bitmap_bit_p (&bb_flags, bb->index)) |
6591 | #endif | |
6592 | ) | |
cd665a06 | 6593 | { |
6594 | ei_next (&ei); | |
6595 | continue; | |
6596 | } | |
60ecc450 | 6597 | |
1f021f97 | 6598 | ep_seq = gen_sibcall_epilogue (); |
6599 | if (ep_seq) | |
6600 | { | |
6601 | start_sequence (); | |
6602 | emit_note (NOTE_INSN_EPILOGUE_BEG); | |
6603 | emit_insn (ep_seq); | |
6604 | seq = get_insns (); | |
6605 | end_sequence (); | |
60ecc450 | 6606 | |
1f021f97 | 6607 | /* Retain a map of the epilogue insns. Used in life analysis to |
6608 | avoid getting rid of sibcall epilogue insns. Do this before we | |
6609 | actually emit the sequence. */ | |
6610 | record_insns (seq, NULL, &epilogue_insn_hash); | |
6611 | set_insn_locators (seq, epilogue_locator); | |
31d3e01c | 6612 | |
1f021f97 | 6613 | emit_insn_before (seq, insn); |
6614 | } | |
cd665a06 | 6615 | ei_next (&ei); |
60ecc450 | 6616 | } |
6617 | #endif | |
58d5b39c | 6618 | |
142e7d22 | 6619 | #ifdef HAVE_epilogue |
6620 | if (epilogue_end) | |
6621 | { | |
6622 | rtx insn, next; | |
6623 | ||
6624 | /* Similarly, move any line notes that appear after the epilogue. | |
424da949 | 6625 | There is no need, however, to be quite so anal about the existence |
737251e7 | 6626 | of such a note. Also possibly move |
dc8def52 | 6627 | NOTE_INSN_FUNCTION_BEG notes, as those can be relevant for debug |
6628 | info generation. */ | |
06ebc183 | 6629 | for (insn = epilogue_end; insn; insn = next) |
142e7d22 | 6630 | { |
6631 | next = NEXT_INSN (insn); | |
48e1416a | 6632 | if (NOTE_P (insn) |
ad4583d9 | 6633 | && (NOTE_KIND (insn) == NOTE_INSN_FUNCTION_BEG)) |
142e7d22 | 6634 | reorder_insns (insn, insn, PREV_INSN (epilogue_end)); |
6635 | } | |
6636 | } | |
6637 | #endif | |
3072d30e | 6638 | |
0a55d497 | 6639 | #ifdef HAVE_simple_return |
1f021f97 | 6640 | bitmap_clear (&bb_flags); |
0a55d497 | 6641 | #endif |
1f021f97 | 6642 | |
3072d30e | 6643 | /* Threading the prologue and epilogue changes the artificial refs |
6644 | in the entry and exit blocks. */ | |
6645 | epilogue_completed = 1; | |
6646 | df_update_entry_exit_and_calls (); | |
b2c5602e | 6647 | } |
6648 | ||
25e880b1 | 6649 | /* Reposition the prologue-end and epilogue-begin notes after |
6650 | instruction scheduling. */ | |
b2c5602e | 6651 | |
6652 | void | |
3072d30e | 6653 | reposition_prologue_and_epilogue_notes (void) |
b2c5602e | 6654 | { |
25e880b1 | 6655 | #if defined (HAVE_prologue) || defined (HAVE_epilogue) \ |
6656 | || defined (HAVE_sibcall_epilogue) | |
25e880b1 | 6657 | /* Since the hash table is created on demand, the fact that it is |
6658 | non-null is a signal that it is non-empty. */ | |
6659 | if (prologue_insn_hash != NULL) | |
b2c5602e | 6660 | { |
25e880b1 | 6661 | size_t len = htab_elements (prologue_insn_hash); |
c009a3ec | 6662 | rtx insn, last = NULL, note = NULL; |
b2c5602e | 6663 | |
25e880b1 | 6664 | /* Scan from the beginning until we reach the last prologue insn. */ |
6665 | /* ??? While we do have the CFG intact, there are two problems: | |
6666 | (1) The prologue can contain loops (typically probing the stack), | |
6667 | which means that the end of the prologue isn't in the first bb. | |
6668 | (2) Sometimes the PROLOGUE_END note gets pushed into the next bb. */ | |
3072d30e | 6669 | for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) |
b2c5602e | 6670 | { |
6d7dc5b9 | 6671 | if (NOTE_P (insn)) |
12d1c03c | 6672 | { |
ad4583d9 | 6673 | if (NOTE_KIND (insn) == NOTE_INSN_PROLOGUE_END) |
60ecc450 | 6674 | note = insn; |
6675 | } | |
25e880b1 | 6676 | else if (contains (insn, prologue_insn_hash)) |
60ecc450 | 6677 | { |
5c0913b4 | 6678 | last = insn; |
6679 | if (--len == 0) | |
6680 | break; | |
6681 | } | |
6682 | } | |
60d903f5 | 6683 | |
5c0913b4 | 6684 | if (last) |
6685 | { | |
25e880b1 | 6686 | if (note == NULL) |
5c0913b4 | 6687 | { |
25e880b1 | 6688 | /* Scan forward looking for the PROLOGUE_END note. It should |
6689 | be right at the beginning of the block, possibly with other | |
6690 | insn notes that got moved there. */ | |
6691 | for (note = NEXT_INSN (last); ; note = NEXT_INSN (note)) | |
6692 | { | |
6693 | if (NOTE_P (note) | |
6694 | && NOTE_KIND (note) == NOTE_INSN_PROLOGUE_END) | |
6695 | break; | |
6696 | } | |
5c0913b4 | 6697 | } |
2a588794 | 6698 | |
5c0913b4 | 6699 | /* Avoid placing note between CODE_LABEL and BASIC_BLOCK note. */ |
6d7dc5b9 | 6700 | if (LABEL_P (last)) |
5c0913b4 | 6701 | last = NEXT_INSN (last); |
6702 | reorder_insns (note, note, last); | |
b2c5602e | 6703 | } |
60ecc450 | 6704 | } |
6705 | ||
25e880b1 | 6706 | if (epilogue_insn_hash != NULL) |
60ecc450 | 6707 | { |
25e880b1 | 6708 | edge_iterator ei; |
6709 | edge e; | |
b2c5602e | 6710 | |
25e880b1 | 6711 | FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) |
b2c5602e | 6712 | { |
c009a3ec | 6713 | rtx insn, first = NULL, note = NULL; |
6714 | basic_block bb = e->src; | |
2a588794 | 6715 | |
c009a3ec | 6716 | /* Scan from the beginning until we reach the first epilogue insn. */ |
25e880b1 | 6717 | FOR_BB_INSNS (bb, insn) |
5c0913b4 | 6718 | { |
25e880b1 | 6719 | if (NOTE_P (insn)) |
6720 | { | |
6721 | if (NOTE_KIND (insn) == NOTE_INSN_EPILOGUE_BEG) | |
6722 | { | |
6723 | note = insn; | |
c009a3ec | 6724 | if (first != NULL) |
25e880b1 | 6725 | break; |
6726 | } | |
6727 | } | |
c009a3ec | 6728 | else if (first == NULL && contains (insn, epilogue_insn_hash)) |
25e880b1 | 6729 | { |
c009a3ec | 6730 | first = insn; |
25e880b1 | 6731 | if (note != NULL) |
6732 | break; | |
6733 | } | |
12d1c03c | 6734 | } |
c009a3ec | 6735 | |
6736 | if (note) | |
6737 | { | |
6738 | /* If the function has a single basic block, and no real | |
48e1416a | 6739 | epilogue insns (e.g. sibcall with no cleanup), the |
c009a3ec | 6740 | epilogue note can get scheduled before the prologue |
6741 | note. If we have frame related prologue insns, having | |
6742 | them scanned during the epilogue will result in a crash. | |
6743 | In this case re-order the epilogue note to just before | |
6744 | the last insn in the block. */ | |
6745 | if (first == NULL) | |
6746 | first = BB_END (bb); | |
6747 | ||
6748 | if (PREV_INSN (first) != note) | |
6749 | reorder_insns (note, note, PREV_INSN (first)); | |
6750 | } | |
b2c5602e | 6751 | } |
6752 | } | |
6753 | #endif /* HAVE_prologue or HAVE_epilogue */ | |
6754 | } | |
a7b0c170 | 6755 | |
9631926a | 6756 | /* Returns the name of function declared by FNDECL. */ |
6757 | const char * | |
6758 | fndecl_name (tree fndecl) | |
6759 | { | |
6760 | if (fndecl == NULL) | |
6761 | return "(nofn)"; | |
6762 | return lang_hooks.decl_printable_name (fndecl, 2); | |
6763 | } | |
6764 | ||
4a020a8c | 6765 | /* Returns the name of function FN. */ |
6766 | const char * | |
6767 | function_name (struct function *fn) | |
6768 | { | |
9631926a | 6769 | tree fndecl = (fn == NULL) ? NULL : fn->decl; |
6770 | return fndecl_name (fndecl); | |
4a020a8c | 6771 | } |
6772 | ||
35901471 | 6773 | /* Returns the name of the current function. */ |
6774 | const char * | |
6775 | current_function_name (void) | |
6776 | { | |
4a020a8c | 6777 | return function_name (cfun); |
35901471 | 6778 | } |
77fce4cd | 6779 | \f |
6780 | ||
2a1990e9 | 6781 | static unsigned int |
77fce4cd | 6782 | rest_of_handle_check_leaf_regs (void) |
6783 | { | |
6784 | #ifdef LEAF_REGISTERS | |
d5bf7b64 | 6785 | crtl->uses_only_leaf_regs |
77fce4cd | 6786 | = optimize > 0 && only_leaf_regs_used () && leaf_function_p (); |
6787 | #endif | |
2a1990e9 | 6788 | return 0; |
77fce4cd | 6789 | } |
6790 | ||
35df6eb4 | 6791 | /* Insert a TYPE into the used types hash table of CFUN. */ |
1a4c44c5 | 6792 | |
35df6eb4 | 6793 | static void |
6794 | used_types_insert_helper (tree type, struct function *func) | |
f6e59711 | 6795 | { |
35df6eb4 | 6796 | if (type != NULL && func != NULL) |
f6e59711 | 6797 | { |
6798 | void **slot; | |
6799 | ||
6800 | if (func->used_types_hash == NULL) | |
6801 | func->used_types_hash = htab_create_ggc (37, htab_hash_pointer, | |
35df6eb4 | 6802 | htab_eq_pointer, NULL); |
6803 | slot = htab_find_slot (func->used_types_hash, type, INSERT); | |
f6e59711 | 6804 | if (*slot == NULL) |
35df6eb4 | 6805 | *slot = type; |
f6e59711 | 6806 | } |
6807 | } | |
6808 | ||
35df6eb4 | 6809 | /* Given a type, insert it into the used hash table in cfun. */ |
6810 | void | |
6811 | used_types_insert (tree t) | |
6812 | { | |
6813 | while (POINTER_TYPE_P (t) || TREE_CODE (t) == ARRAY_TYPE) | |
bd564c29 | 6814 | if (TYPE_NAME (t)) |
6815 | break; | |
6816 | else | |
6817 | t = TREE_TYPE (t); | |
26ee9e7a | 6818 | if (TREE_CODE (t) == ERROR_MARK) |
6819 | return; | |
bd564c29 | 6820 | if (TYPE_NAME (t) == NULL_TREE |
6821 | || TYPE_NAME (t) == TYPE_NAME (TYPE_MAIN_VARIANT (t))) | |
6822 | t = TYPE_MAIN_VARIANT (t); | |
35df6eb4 | 6823 | if (debug_info_level > DINFO_LEVEL_NONE) |
1a4c44c5 | 6824 | { |
6825 | if (cfun) | |
6826 | used_types_insert_helper (t, cfun); | |
6827 | else | |
6828 | /* So this might be a type referenced by a global variable. | |
6829 | Record that type so that we can later decide to emit its debug | |
6830 | information. */ | |
aef48c9a | 6831 | VEC_safe_push (tree, gc, types_used_by_cur_var_decl, t); |
1a4c44c5 | 6832 | } |
6833 | } | |
6834 | ||
6835 | /* Helper to Hash a struct types_used_by_vars_entry. */ | |
6836 | ||
6837 | static hashval_t | |
6838 | hash_types_used_by_vars_entry (const struct types_used_by_vars_entry *entry) | |
6839 | { | |
6840 | gcc_assert (entry && entry->var_decl && entry->type); | |
6841 | ||
6842 | return iterative_hash_object (entry->type, | |
6843 | iterative_hash_object (entry->var_decl, 0)); | |
6844 | } | |
6845 | ||
6846 | /* Hash function of the types_used_by_vars_entry hash table. */ | |
6847 | ||
6848 | hashval_t | |
6849 | types_used_by_vars_do_hash (const void *x) | |
6850 | { | |
6851 | const struct types_used_by_vars_entry *entry = | |
6852 | (const struct types_used_by_vars_entry *) x; | |
6853 | ||
6854 | return hash_types_used_by_vars_entry (entry); | |
6855 | } | |
6856 | ||
6857 | /*Equality function of the types_used_by_vars_entry hash table. */ | |
6858 | ||
6859 | int | |
6860 | types_used_by_vars_eq (const void *x1, const void *x2) | |
6861 | { | |
6862 | const struct types_used_by_vars_entry *e1 = | |
6863 | (const struct types_used_by_vars_entry *) x1; | |
6864 | const struct types_used_by_vars_entry *e2 = | |
6865 | (const struct types_used_by_vars_entry *)x2; | |
6866 | ||
6867 | return (e1->var_decl == e2->var_decl && e1->type == e2->type); | |
6868 | } | |
6869 | ||
6870 | /* Inserts an entry into the types_used_by_vars_hash hash table. */ | |
6871 | ||
6872 | void | |
6873 | types_used_by_var_decl_insert (tree type, tree var_decl) | |
6874 | { | |
6875 | if (type != NULL && var_decl != NULL) | |
6876 | { | |
6877 | void **slot; | |
6878 | struct types_used_by_vars_entry e; | |
6879 | e.var_decl = var_decl; | |
6880 | e.type = type; | |
6881 | if (types_used_by_vars_hash == NULL) | |
6882 | types_used_by_vars_hash = | |
6883 | htab_create_ggc (37, types_used_by_vars_do_hash, | |
6884 | types_used_by_vars_eq, NULL); | |
6885 | slot = htab_find_slot_with_hash (types_used_by_vars_hash, &e, | |
6886 | hash_types_used_by_vars_entry (&e), INSERT); | |
6887 | if (*slot == NULL) | |
6888 | { | |
6889 | struct types_used_by_vars_entry *entry; | |
ba72912a | 6890 | entry = ggc_alloc_types_used_by_vars_entry (); |
1a4c44c5 | 6891 | entry->type = type; |
6892 | entry->var_decl = var_decl; | |
6893 | *slot = entry; | |
6894 | } | |
6895 | } | |
35df6eb4 | 6896 | } |
6897 | ||
20099e35 | 6898 | struct rtl_opt_pass pass_leaf_regs = |
77fce4cd | 6899 | { |
20099e35 | 6900 | { |
6901 | RTL_PASS, | |
0c297edc | 6902 | "*leaf_regs", /* name */ |
77fce4cd | 6903 | NULL, /* gate */ |
6904 | rest_of_handle_check_leaf_regs, /* execute */ | |
6905 | NULL, /* sub */ | |
6906 | NULL, /* next */ | |
6907 | 0, /* static_pass_number */ | |
0b1615c1 | 6908 | TV_NONE, /* tv_id */ |
77fce4cd | 6909 | 0, /* properties_required */ |
6910 | 0, /* properties_provided */ | |
6911 | 0, /* properties_destroyed */ | |
6912 | 0, /* todo_flags_start */ | |
20099e35 | 6913 | 0 /* todo_flags_finish */ |
6914 | } | |
77fce4cd | 6915 | }; |
6916 | ||
3072d30e | 6917 | static unsigned int |
6918 | rest_of_handle_thread_prologue_and_epilogue (void) | |
6919 | { | |
6920 | if (optimize) | |
6921 | cleanup_cfg (CLEANUP_EXPENSIVE); | |
990495a7 | 6922 | |
3072d30e | 6923 | /* On some machines, the prologue and epilogue code, or parts thereof, |
6924 | can be represented as RTL. Doing so lets us schedule insns between | |
6925 | it and the rest of the code and also allows delayed branch | |
6926 | scheduling to operate in the epilogue. */ | |
3072d30e | 6927 | thread_prologue_and_epilogue_insns (); |
990495a7 | 6928 | |
6929 | /* The stack usage info is finalized during prologue expansion. */ | |
8c0dd614 | 6930 | if (flag_stack_usage_info) |
990495a7 | 6931 | output_stack_usage (); |
6932 | ||
3072d30e | 6933 | return 0; |
6934 | } | |
6935 | ||
20099e35 | 6936 | struct rtl_opt_pass pass_thread_prologue_and_epilogue = |
3072d30e | 6937 | { |
20099e35 | 6938 | { |
6939 | RTL_PASS, | |
3072d30e | 6940 | "pro_and_epilogue", /* name */ |
6941 | NULL, /* gate */ | |
6942 | rest_of_handle_thread_prologue_and_epilogue, /* execute */ | |
6943 | NULL, /* sub */ | |
6944 | NULL, /* next */ | |
6945 | 0, /* static_pass_number */ | |
6946 | TV_THREAD_PROLOGUE_AND_EPILOGUE, /* tv_id */ | |
6947 | 0, /* properties_required */ | |
6948 | 0, /* properties_provided */ | |
6949 | 0, /* properties_destroyed */ | |
6950 | TODO_verify_flow, /* todo_flags_start */ | |
314966f4 | 6951 | TODO_df_verify | |
0806b508 | 6952 | TODO_df_finish | TODO_verify_rtl_sharing | |
20099e35 | 6953 | TODO_ggc_collect /* todo_flags_finish */ |
6954 | } | |
3072d30e | 6955 | }; |
9dc6d5bb | 6956 | \f |
6957 | ||
6958 | /* This mini-pass fixes fall-out from SSA in asm statements that have | |
48e1416a | 6959 | in-out constraints. Say you start with |
9dc6d5bb | 6960 | |
6961 | orig = inout; | |
6962 | asm ("": "+mr" (inout)); | |
6963 | use (orig); | |
6964 | ||
6965 | which is transformed very early to use explicit output and match operands: | |
6966 | ||
6967 | orig = inout; | |
6968 | asm ("": "=mr" (inout) : "0" (inout)); | |
6969 | use (orig); | |
6970 | ||
6971 | Or, after SSA and copyprop, | |
6972 | ||
6973 | asm ("": "=mr" (inout_2) : "0" (inout_1)); | |
6974 | use (inout_1); | |
6975 | ||
6976 | Clearly inout_2 and inout_1 can't be coalesced easily anymore, as | |
6977 | they represent two separate values, so they will get different pseudo | |
6978 | registers during expansion. Then, since the two operands need to match | |
6979 | per the constraints, but use different pseudo registers, reload can | |
6980 | only register a reload for these operands. But reloads can only be | |
6981 | satisfied by hardregs, not by memory, so we need a register for this | |
6982 | reload, just because we are presented with non-matching operands. | |
6983 | So, even though we allow memory for this operand, no memory can be | |
6984 | used for it, just because the two operands don't match. This can | |
6985 | cause reload failures on register-starved targets. | |
6986 | ||
6987 | So it's a symptom of reload not being able to use memory for reloads | |
6988 | or, alternatively it's also a symptom of both operands not coming into | |
6989 | reload as matching (in which case the pseudo could go to memory just | |
6990 | fine, as the alternative allows it, and no reload would be necessary). | |
6991 | We fix the latter problem here, by transforming | |
6992 | ||
6993 | asm ("": "=mr" (inout_2) : "0" (inout_1)); | |
6994 | ||
6995 | back to | |
6996 | ||
6997 | inout_2 = inout_1; | |
6998 | asm ("": "=mr" (inout_2) : "0" (inout_2)); */ | |
6999 | ||
7000 | static void | |
7001 | match_asm_constraints_1 (rtx insn, rtx *p_sets, int noutputs) | |
7002 | { | |
7003 | int i; | |
7004 | bool changed = false; | |
7005 | rtx op = SET_SRC (p_sets[0]); | |
7006 | int ninputs = ASM_OPERANDS_INPUT_LENGTH (op); | |
7007 | rtvec inputs = ASM_OPERANDS_INPUT_VEC (op); | |
2457c754 | 7008 | bool *output_matched = XALLOCAVEC (bool, noutputs); |
9dc6d5bb | 7009 | |
3f982e5a | 7010 | memset (output_matched, 0, noutputs * sizeof (bool)); |
9dc6d5bb | 7011 | for (i = 0; i < ninputs; i++) |
7012 | { | |
7013 | rtx input, output, insns; | |
7014 | const char *constraint = ASM_OPERANDS_INPUT_CONSTRAINT (op, i); | |
7015 | char *end; | |
d069e0d3 | 7016 | int match, j; |
9dc6d5bb | 7017 | |
fbcb9be4 | 7018 | if (*constraint == '%') |
7019 | constraint++; | |
7020 | ||
9dc6d5bb | 7021 | match = strtoul (constraint, &end, 10); |
7022 | if (end == constraint) | |
7023 | continue; | |
7024 | ||
7025 | gcc_assert (match < noutputs); | |
7026 | output = SET_DEST (p_sets[match]); | |
7027 | input = RTVEC_ELT (inputs, i); | |
d069e0d3 | 7028 | /* Only do the transformation for pseudos. */ |
7029 | if (! REG_P (output) | |
7030 | || rtx_equal_p (output, input) | |
9dc6d5bb | 7031 | || (GET_MODE (input) != VOIDmode |
7032 | && GET_MODE (input) != GET_MODE (output))) | |
7033 | continue; | |
7034 | ||
d069e0d3 | 7035 | /* We can't do anything if the output is also used as input, |
7036 | as we're going to overwrite it. */ | |
7037 | for (j = 0; j < ninputs; j++) | |
7038 | if (reg_overlap_mentioned_p (output, RTVEC_ELT (inputs, j))) | |
7039 | break; | |
7040 | if (j != ninputs) | |
7041 | continue; | |
7042 | ||
3f982e5a | 7043 | /* Avoid changing the same input several times. For |
7044 | asm ("" : "=mr" (out1), "=mr" (out2) : "0" (in), "1" (in)); | |
7045 | only change in once (to out1), rather than changing it | |
7046 | first to out1 and afterwards to out2. */ | |
7047 | if (i > 0) | |
7048 | { | |
7049 | for (j = 0; j < noutputs; j++) | |
7050 | if (output_matched[j] && input == SET_DEST (p_sets[j])) | |
7051 | break; | |
7052 | if (j != noutputs) | |
7053 | continue; | |
7054 | } | |
7055 | output_matched[match] = true; | |
7056 | ||
9dc6d5bb | 7057 | start_sequence (); |
d069e0d3 | 7058 | emit_move_insn (output, input); |
9dc6d5bb | 7059 | insns = get_insns (); |
7060 | end_sequence (); | |
9dc6d5bb | 7061 | emit_insn_before (insns, insn); |
d069e0d3 | 7062 | |
7063 | /* Now replace all mentions of the input with output. We can't | |
f0b5f617 | 7064 | just replace the occurrence in inputs[i], as the register might |
d069e0d3 | 7065 | also be used in some other input (or even in an address of an |
7066 | output), which would mean possibly increasing the number of | |
7067 | inputs by one (namely 'output' in addition), which might pose | |
7068 | a too complicated problem for reload to solve. E.g. this situation: | |
7069 | ||
7070 | asm ("" : "=r" (output), "=m" (input) : "0" (input)) | |
7071 | ||
c7684b8e | 7072 | Here 'input' is used in two occurrences as input (once for the |
d069e0d3 | 7073 | input operand, once for the address in the second output operand). |
f0b5f617 | 7074 | If we would replace only the occurrence of the input operand (to |
d069e0d3 | 7075 | make the matching) we would be left with this: |
7076 | ||
7077 | output = input | |
7078 | asm ("" : "=r" (output), "=m" (input) : "0" (output)) | |
7079 | ||
7080 | Now we suddenly have two different input values (containing the same | |
7081 | value, but different pseudos) where we formerly had only one. | |
7082 | With more complicated asms this might lead to reload failures | |
7083 | which wouldn't have happen without this pass. So, iterate over | |
c7684b8e | 7084 | all operands and replace all occurrences of the register used. */ |
d069e0d3 | 7085 | for (j = 0; j < noutputs; j++) |
f211ad17 | 7086 | if (!rtx_equal_p (SET_DEST (p_sets[j]), input) |
d069e0d3 | 7087 | && reg_overlap_mentioned_p (input, SET_DEST (p_sets[j]))) |
7088 | SET_DEST (p_sets[j]) = replace_rtx (SET_DEST (p_sets[j]), | |
7089 | input, output); | |
7090 | for (j = 0; j < ninputs; j++) | |
7091 | if (reg_overlap_mentioned_p (input, RTVEC_ELT (inputs, j))) | |
7092 | RTVEC_ELT (inputs, j) = replace_rtx (RTVEC_ELT (inputs, j), | |
7093 | input, output); | |
7094 | ||
9dc6d5bb | 7095 | changed = true; |
7096 | } | |
7097 | ||
7098 | if (changed) | |
7099 | df_insn_rescan (insn); | |
7100 | } | |
7101 | ||
7102 | static unsigned | |
7103 | rest_of_match_asm_constraints (void) | |
7104 | { | |
7105 | basic_block bb; | |
7106 | rtx insn, pat, *p_sets; | |
7107 | int noutputs; | |
7108 | ||
18d50ae6 | 7109 | if (!crtl->has_asm_statement) |
9dc6d5bb | 7110 | return 0; |
7111 | ||
7112 | df_set_flags (DF_DEFER_INSN_RESCAN); | |
7113 | FOR_EACH_BB (bb) | |
7114 | { | |
7115 | FOR_BB_INSNS (bb, insn) | |
7116 | { | |
7117 | if (!INSN_P (insn)) | |
7118 | continue; | |
7119 | ||
7120 | pat = PATTERN (insn); | |
7121 | if (GET_CODE (pat) == PARALLEL) | |
7122 | p_sets = &XVECEXP (pat, 0, 0), noutputs = XVECLEN (pat, 0); | |
7123 | else if (GET_CODE (pat) == SET) | |
7124 | p_sets = &PATTERN (insn), noutputs = 1; | |
7125 | else | |
7126 | continue; | |
7127 | ||
7128 | if (GET_CODE (*p_sets) == SET | |
7129 | && GET_CODE (SET_SRC (*p_sets)) == ASM_OPERANDS) | |
7130 | match_asm_constraints_1 (insn, p_sets, noutputs); | |
7131 | } | |
7132 | } | |
7133 | ||
7134 | return TODO_df_finish; | |
7135 | } | |
7136 | ||
20099e35 | 7137 | struct rtl_opt_pass pass_match_asm_constraints = |
9dc6d5bb | 7138 | { |
20099e35 | 7139 | { |
7140 | RTL_PASS, | |
9dc6d5bb | 7141 | "asmcons", /* name */ |
7142 | NULL, /* gate */ | |
7143 | rest_of_match_asm_constraints, /* execute */ | |
7144 | NULL, /* sub */ | |
7145 | NULL, /* next */ | |
7146 | 0, /* static_pass_number */ | |
0b1615c1 | 7147 | TV_NONE, /* tv_id */ |
9dc6d5bb | 7148 | 0, /* properties_required */ |
7149 | 0, /* properties_provided */ | |
7150 | 0, /* properties_destroyed */ | |
7151 | 0, /* todo_flags_start */ | |
771e2890 | 7152 | 0 /* todo_flags_finish */ |
20099e35 | 7153 | } |
9dc6d5bb | 7154 | }; |
3072d30e | 7155 | |
35901471 | 7156 | |
1f3233d1 | 7157 | #include "gt-function.h" |