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