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