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