OSDN Git Service

2058d754080646d4705b206573dceedc7fafd4fb
[pf3gnuchains/gcc-fork.git] / gcc / function.c
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  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
69 /* So we can assign to cfun in this file.  */
70 #undef cfun
71
72 #ifndef STACK_ALIGNMENT_NEEDED
73 #define STACK_ALIGNMENT_NEEDED 1
74 #endif
75
76 #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
77
78 /* Some systems use __main in a way incompatible with its use in gcc, in these
79    cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
80    give the same symbol without quotes for an alternative entry point.  You
81    must define both, or neither.  */
82 #ifndef NAME__MAIN
83 #define NAME__MAIN "__main"
84 #endif
85
86 /* Round a value to the lowest integer less than it that is a multiple of
87    the required alignment.  Avoid using division in case the value is
88    negative.  Assume the alignment is a power of two.  */
89 #define FLOOR_ROUND(VALUE,ALIGN) ((VALUE) & ~((ALIGN) - 1))
90
91 /* Similar, but round to the next highest integer that meets the
92    alignment.  */
93 #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
94
95 /* Nonzero if function being compiled doesn't contain any calls
96    (ignoring the prologue and epilogue).  This is set prior to
97    local register allocation and is valid for the remaining
98    compiler passes.  */
99 int current_function_is_leaf;
100
101 /* Nonzero if function being compiled doesn't modify the stack pointer
102    (ignoring the prologue and epilogue).  This is only valid after
103    pass_stack_ptr_mod has run.  */
104 int current_function_sp_is_unchanging;
105
106 /* Nonzero if the function being compiled is a leaf function which only
107    uses leaf registers.  This is valid after reload (specifically after
108    sched2) and is useful only if the port defines LEAF_REGISTERS.  */
109 int current_function_uses_only_leaf_regs;
110
111 /* Nonzero once virtual register instantiation has been done.
112    assign_stack_local uses frame_pointer_rtx when this is nonzero.
113    calls.c:emit_library_call_value_1 uses it to set up
114    post-instantiation libcalls.  */
115 int virtuals_instantiated;
116
117 /* Assign unique numbers to labels generated for profiling, debugging, etc.  */
118 static GTY(()) int funcdef_no;
119
120 /* These variables hold pointers to functions to create and destroy
121    target specific, per-function data structures.  */
122 struct machine_function * (*init_machine_status) (void);
123
124 /* The currently compiled function.  */
125 struct function *cfun = 0;
126
127 /* These hashes record the prologue and epilogue insns.  */
128 static GTY((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
129   htab_t prologue_insn_hash;
130 static GTY((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
131   htab_t epilogue_insn_hash;
132 \f
133
134 htab_t types_used_by_vars_hash = NULL;
135 VEC(tree,gc) *types_used_by_cur_var_decl;
136
137 /* Forward declarations.  */
138
139 static struct temp_slot *find_temp_slot_from_address (rtx);
140 static void pad_to_arg_alignment (struct args_size *, int, struct args_size *);
141 static void pad_below (struct args_size *, enum machine_mode, tree);
142 static void reorder_blocks_1 (rtx, tree, VEC(tree,heap) **);
143 static int all_blocks (tree, tree *);
144 static tree *get_block_vector (tree, int *);
145 extern tree debug_find_var_in_block_tree (tree, tree);
146 /* We always define `record_insns' even if it's not used so that we
147    can always export `prologue_epilogue_contains'.  */
148 static void record_insns (rtx, rtx, htab_t *) ATTRIBUTE_UNUSED;
149 static bool contains (const_rtx, htab_t);
150 static void prepare_function_start (void);
151 static void do_clobber_return_reg (rtx, void *);
152 static void do_use_return_reg (rtx, void *);
153 static void set_insn_locators (rtx, int) ATTRIBUTE_UNUSED;
154 \f
155 /* Stack of nested functions.  */
156 /* Keep track of the cfun stack.  */
157
158 typedef struct function *function_p;
159
160 DEF_VEC_P(function_p);
161 DEF_VEC_ALLOC_P(function_p,heap);
162 static VEC(function_p,heap) *function_context_stack;
163
164 /* Save the current context for compilation of a nested function.
165    This is called from language-specific code.  */
166
167 void
168 push_function_context (void)
169 {
170   if (cfun == 0)
171     allocate_struct_function (NULL, false);
172
173   VEC_safe_push (function_p, heap, function_context_stack, cfun);
174   set_cfun (NULL);
175 }
176
177 /* Restore the last saved context, at the end of a nested function.
178    This function is called from language-specific code.  */
179
180 void
181 pop_function_context (void)
182 {
183   struct function *p = VEC_pop (function_p, function_context_stack);
184   set_cfun (p);
185   current_function_decl = p->decl;
186
187   /* Reset variables that have known state during rtx generation.  */
188   virtuals_instantiated = 0;
189   generating_concat_p = 1;
190 }
191
192 /* Clear out all parts of the state in F that can safely be discarded
193    after the function has been parsed, but not compiled, to let
194    garbage collection reclaim the memory.  */
195
196 void
197 free_after_parsing (struct function *f)
198 {
199   f->language = 0;
200 }
201
202 /* Clear out all parts of the state in F that can safely be discarded
203    after the function has been compiled, to let garbage collection
204    reclaim the memory.  */
205
206 void
207 free_after_compilation (struct function *f)
208 {
209   prologue_insn_hash = NULL;
210   epilogue_insn_hash = NULL;
211
212   free (crtl->emit.regno_pointer_align);
213
214   memset (crtl, 0, sizeof (struct rtl_data));
215   f->eh = NULL;
216   f->machine = NULL;
217   f->cfg = NULL;
218
219   regno_reg_rtx = NULL;
220   insn_locators_free ();
221 }
222 \f
223 /* Return size needed for stack frame based on slots so far allocated.
224    This size counts from zero.  It is not rounded to PREFERRED_STACK_BOUNDARY;
225    the caller may have to do that.  */
226
227 HOST_WIDE_INT
228 get_frame_size (void)
229 {
230   if (FRAME_GROWS_DOWNWARD)
231     return -frame_offset;
232   else
233     return frame_offset;
234 }
235
236 /* Issue an error message and return TRUE if frame OFFSET overflows in
237    the signed target pointer arithmetics for function FUNC.  Otherwise
238    return FALSE.  */
239
240 bool
241 frame_offset_overflow (HOST_WIDE_INT offset, tree func)
242 {
243   unsigned HOST_WIDE_INT size = FRAME_GROWS_DOWNWARD ? -offset : offset;
244
245   if (size > ((unsigned HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (Pmode) - 1))
246                /* Leave room for the fixed part of the frame.  */
247                - 64 * UNITS_PER_WORD)
248     {
249       error_at (DECL_SOURCE_LOCATION (func),
250                 "total size of local objects too large");
251       return TRUE;
252     }
253
254   return FALSE;
255 }
256
257 /* Return stack slot alignment in bits for TYPE and MODE.  */
258
259 static unsigned int
260 get_stack_local_alignment (tree type, enum machine_mode mode)
261 {
262   unsigned int alignment;
263
264   if (mode == BLKmode)
265     alignment = BIGGEST_ALIGNMENT;
266   else
267     alignment = GET_MODE_ALIGNMENT (mode);
268
269   /* Allow the frond-end to (possibly) increase the alignment of this
270      stack slot.  */
271   if (! type)
272     type = lang_hooks.types.type_for_mode (mode, 0);
273
274   return STACK_SLOT_ALIGNMENT (type, mode, alignment);
275 }
276
277 /* Determine whether it is possible to fit a stack slot of size SIZE and
278    alignment ALIGNMENT into an area in the stack frame that starts at
279    frame offset START and has a length of LENGTH.  If so, store the frame
280    offset to be used for the stack slot in *POFFSET and return true;
281    return false otherwise.  This function will extend the frame size when
282    given a start/length pair that lies at the end of the frame.  */
283
284 static bool
285 try_fit_stack_local (HOST_WIDE_INT start, HOST_WIDE_INT length,
286                      HOST_WIDE_INT size, unsigned int alignment,
287                      HOST_WIDE_INT *poffset)
288 {
289   HOST_WIDE_INT this_frame_offset;
290   int frame_off, frame_alignment, frame_phase;
291
292   /* Calculate how many bytes the start of local variables is off from
293      stack alignment.  */
294   frame_alignment = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
295   frame_off = STARTING_FRAME_OFFSET % frame_alignment;
296   frame_phase = frame_off ? frame_alignment - frame_off : 0;
297
298   /* Round the frame offset to the specified alignment.  */
299
300   /*  We must be careful here, since FRAME_OFFSET might be negative and
301       division with a negative dividend isn't as well defined as we might
302       like.  So we instead assume that ALIGNMENT is a power of two and
303       use logical operations which are unambiguous.  */
304   if (FRAME_GROWS_DOWNWARD)
305     this_frame_offset
306       = (FLOOR_ROUND (start + length - size - frame_phase,
307                       (unsigned HOST_WIDE_INT) alignment)
308          + frame_phase);
309   else
310     this_frame_offset
311       = (CEIL_ROUND (start - frame_phase,
312                      (unsigned HOST_WIDE_INT) alignment)
313          + frame_phase);
314
315   /* See if it fits.  If this space is at the edge of the frame,
316      consider extending the frame to make it fit.  Our caller relies on
317      this when allocating a new slot.  */
318   if (frame_offset == start && this_frame_offset < frame_offset)
319     frame_offset = this_frame_offset;
320   else if (this_frame_offset < start)
321     return false;
322   else if (start + length == frame_offset
323            && this_frame_offset + size > start + length)
324     frame_offset = this_frame_offset + size;
325   else if (this_frame_offset + size > start + length)
326     return false;
327
328   *poffset = this_frame_offset;
329   return true;
330 }
331
332 /* Create a new frame_space structure describing free space in the stack
333    frame beginning at START and ending at END, and chain it into the
334    function's frame_space_list.  */
335
336 static void
337 add_frame_space (HOST_WIDE_INT start, HOST_WIDE_INT end)
338 {
339   struct frame_space *space = ggc_alloc_frame_space ();
340   space->next = crtl->frame_space_list;
341   crtl->frame_space_list = space;
342   space->start = start;
343   space->length = end - start;
344 }
345
346 /* Allocate a stack slot of SIZE bytes and return a MEM rtx for it
347    with machine mode MODE.
348
349    ALIGN controls the amount of alignment for the address of the slot:
350    0 means according to MODE,
351    -1 means use BIGGEST_ALIGNMENT and round size to multiple of that,
352    -2 means use BITS_PER_UNIT,
353    positive specifies alignment boundary in bits.
354
355    KIND has ASLK_REDUCE_ALIGN bit set if it is OK to reduce
356    alignment and ASLK_RECORD_PAD bit set if we should remember
357    extra space we allocated for alignment purposes.  When we are
358    called from assign_stack_temp_for_type, it is not set so we don't
359    track the same stack slot in two independent lists.
360
361    We do not round to stack_boundary here.  */
362
363 rtx
364 assign_stack_local_1 (enum machine_mode mode, HOST_WIDE_INT size,
365                       int align, int kind)
366 {
367   rtx x, addr;
368   int bigend_correction = 0;
369   HOST_WIDE_INT slot_offset = 0, old_frame_offset;
370   unsigned int alignment, alignment_in_bits;
371
372   if (align == 0)
373     {
374       alignment = get_stack_local_alignment (NULL, mode);
375       alignment /= BITS_PER_UNIT;
376     }
377   else if (align == -1)
378     {
379       alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
380       size = CEIL_ROUND (size, alignment);
381     }
382   else if (align == -2)
383     alignment = 1; /* BITS_PER_UNIT / BITS_PER_UNIT */
384   else
385     alignment = align / BITS_PER_UNIT;
386
387   alignment_in_bits = alignment * BITS_PER_UNIT;
388
389   /* Ignore alignment if it exceeds MAX_SUPPORTED_STACK_ALIGNMENT.  */
390   if (alignment_in_bits > MAX_SUPPORTED_STACK_ALIGNMENT)
391     {
392       alignment_in_bits = MAX_SUPPORTED_STACK_ALIGNMENT;
393       alignment = alignment_in_bits / BITS_PER_UNIT;
394     }
395
396   if (SUPPORTS_STACK_ALIGNMENT)
397     {
398       if (crtl->stack_alignment_estimated < alignment_in_bits)
399         {
400           if (!crtl->stack_realign_processed)
401             crtl->stack_alignment_estimated = alignment_in_bits;
402           else
403             {
404               /* If stack is realigned and stack alignment value
405                  hasn't been finalized, it is OK not to increase
406                  stack_alignment_estimated.  The bigger alignment
407                  requirement is recorded in stack_alignment_needed
408                  below.  */
409               gcc_assert (!crtl->stack_realign_finalized);
410               if (!crtl->stack_realign_needed)
411                 {
412                   /* It is OK to reduce the alignment as long as the
413                      requested size is 0 or the estimated stack
414                      alignment >= mode alignment.  */
415                   gcc_assert ((kind & ASLK_REDUCE_ALIGN)
416                               || size == 0
417                               || (crtl->stack_alignment_estimated
418                                   >= GET_MODE_ALIGNMENT (mode)));
419                   alignment_in_bits = crtl->stack_alignment_estimated;
420                   alignment = alignment_in_bits / BITS_PER_UNIT;
421                 }
422             }
423         }
424     }
425
426   if (crtl->stack_alignment_needed < alignment_in_bits)
427     crtl->stack_alignment_needed = alignment_in_bits;
428   if (crtl->max_used_stack_slot_alignment < alignment_in_bits)
429     crtl->max_used_stack_slot_alignment = alignment_in_bits;
430
431   if (mode != BLKmode || size != 0)
432     {
433       if (kind & ASLK_RECORD_PAD)
434         {
435           struct frame_space **psp;
436
437           for (psp = &crtl->frame_space_list; *psp; psp = &(*psp)->next)
438             {
439               struct frame_space *space = *psp;
440               if (!try_fit_stack_local (space->start, space->length, size,
441                                         alignment, &slot_offset))
442                 continue;
443               *psp = space->next;
444               if (slot_offset > space->start)
445                 add_frame_space (space->start, slot_offset);
446               if (slot_offset + size < space->start + space->length)
447                 add_frame_space (slot_offset + size,
448                                  space->start + space->length);
449               goto found_space;
450             }
451         }
452     }
453   else if (!STACK_ALIGNMENT_NEEDED)
454     {
455       slot_offset = frame_offset;
456       goto found_space;
457     }
458
459   old_frame_offset = frame_offset;
460
461   if (FRAME_GROWS_DOWNWARD)
462     {
463       frame_offset -= size;
464       try_fit_stack_local (frame_offset, size, size, alignment, &slot_offset);
465
466       if (kind & ASLK_RECORD_PAD)
467         {
468           if (slot_offset > frame_offset)
469             add_frame_space (frame_offset, slot_offset);
470           if (slot_offset + size < old_frame_offset)
471             add_frame_space (slot_offset + size, old_frame_offset);
472         }
473     }
474   else
475     {
476       frame_offset += size;
477       try_fit_stack_local (old_frame_offset, size, size, alignment, &slot_offset);
478
479       if (kind & ASLK_RECORD_PAD)
480         {
481           if (slot_offset > old_frame_offset)
482             add_frame_space (old_frame_offset, slot_offset);
483           if (slot_offset + size < frame_offset)
484             add_frame_space (slot_offset + size, frame_offset);
485         }
486     }
487
488  found_space:
489   /* On a big-endian machine, if we are allocating more space than we will use,
490      use the least significant bytes of those that are allocated.  */
491   if (BYTES_BIG_ENDIAN && mode != BLKmode && GET_MODE_SIZE (mode) < size)
492     bigend_correction = size - GET_MODE_SIZE (mode);
493
494   /* If we have already instantiated virtual registers, return the actual
495      address relative to the frame pointer.  */
496   if (virtuals_instantiated)
497     addr = plus_constant (frame_pointer_rtx,
498                           trunc_int_for_mode
499                           (slot_offset + bigend_correction
500                            + STARTING_FRAME_OFFSET, Pmode));
501   else
502     addr = plus_constant (virtual_stack_vars_rtx,
503                           trunc_int_for_mode
504                           (slot_offset + bigend_correction,
505                            Pmode));
506
507   x = gen_rtx_MEM (mode, addr);
508   set_mem_align (x, alignment_in_bits);
509   MEM_NOTRAP_P (x) = 1;
510
511   stack_slot_list
512     = gen_rtx_EXPR_LIST (VOIDmode, x, stack_slot_list);
513
514   if (frame_offset_overflow (frame_offset, current_function_decl))
515     frame_offset = 0;
516
517   return x;
518 }
519
520 /* Wrap up assign_stack_local_1 with last parameter as false.  */
521
522 rtx
523 assign_stack_local (enum machine_mode mode, HOST_WIDE_INT size, int align)
524 {
525   return assign_stack_local_1 (mode, size, align, ASLK_RECORD_PAD);
526 }
527 \f
528 \f
529 /* In order to evaluate some expressions, such as function calls returning
530    structures in memory, we need to temporarily allocate stack locations.
531    We record each allocated temporary in the following structure.
532
533    Associated with each temporary slot is a nesting level.  When we pop up
534    one level, all temporaries associated with the previous level are freed.
535    Normally, all temporaries are freed after the execution of the statement
536    in which they were created.  However, if we are inside a ({...}) grouping,
537    the result may be in a temporary and hence must be preserved.  If the
538    result could be in a temporary, we preserve it if we can determine which
539    one it is in.  If we cannot determine which temporary may contain the
540    result, all temporaries are preserved.  A temporary is preserved by
541    pretending it was allocated at the previous nesting level.
542
543    Automatic variables are also assigned temporary slots, at the nesting
544    level where they are defined.  They are marked a "kept" so that
545    free_temp_slots will not free them.  */
546
547 struct GTY(()) temp_slot {
548   /* Points to next temporary slot.  */
549   struct temp_slot *next;
550   /* Points to previous temporary slot.  */
551   struct temp_slot *prev;
552   /* The rtx to used to reference the slot.  */
553   rtx slot;
554   /* The size, in units, of the slot.  */
555   HOST_WIDE_INT size;
556   /* The type of the object in the slot, or zero if it doesn't correspond
557      to a type.  We use this to determine whether a slot can be reused.
558      It can be reused if objects of the type of the new slot will always
559      conflict with objects of the type of the old slot.  */
560   tree type;
561   /* The alignment (in bits) of the slot.  */
562   unsigned int align;
563   /* Nonzero if this temporary is currently in use.  */
564   char in_use;
565   /* Nonzero if this temporary has its address taken.  */
566   char addr_taken;
567   /* Nesting level at which this slot is being used.  */
568   int level;
569   /* Nonzero if this should survive a call to free_temp_slots.  */
570   int keep;
571   /* The offset of the slot from the frame_pointer, including extra space
572      for alignment.  This info is for combine_temp_slots.  */
573   HOST_WIDE_INT base_offset;
574   /* The size of the slot, including extra space for alignment.  This
575      info is for combine_temp_slots.  */
576   HOST_WIDE_INT full_size;
577 };
578
579 /* A table of addresses that represent a stack slot.  The table is a mapping
580    from address RTXen to a temp slot.  */
581 static GTY((param_is(struct temp_slot_address_entry))) htab_t temp_slot_address_table;
582
583 /* Entry for the above hash table.  */
584 struct GTY(()) temp_slot_address_entry {
585   hashval_t hash;
586   rtx address;
587   struct temp_slot *temp_slot;
588 };
589
590 /* Removes temporary slot TEMP from LIST.  */
591
592 static void
593 cut_slot_from_list (struct temp_slot *temp, struct temp_slot **list)
594 {
595   if (temp->next)
596     temp->next->prev = temp->prev;
597   if (temp->prev)
598     temp->prev->next = temp->next;
599   else
600     *list = temp->next;
601
602   temp->prev = temp->next = NULL;
603 }
604
605 /* Inserts temporary slot TEMP to LIST.  */
606
607 static void
608 insert_slot_to_list (struct temp_slot *temp, struct temp_slot **list)
609 {
610   temp->next = *list;
611   if (*list)
612     (*list)->prev = temp;
613   temp->prev = NULL;
614   *list = temp;
615 }
616
617 /* Returns the list of used temp slots at LEVEL.  */
618
619 static struct temp_slot **
620 temp_slots_at_level (int level)
621 {
622   if (level >= (int) VEC_length (temp_slot_p, used_temp_slots))
623     VEC_safe_grow_cleared (temp_slot_p, gc, used_temp_slots, level + 1);
624
625   return &(VEC_address (temp_slot_p, used_temp_slots)[level]);
626 }
627
628 /* Returns the maximal temporary slot level.  */
629
630 static int
631 max_slot_level (void)
632 {
633   if (!used_temp_slots)
634     return -1;
635
636   return VEC_length (temp_slot_p, used_temp_slots) - 1;
637 }
638
639 /* Moves temporary slot TEMP to LEVEL.  */
640
641 static void
642 move_slot_to_level (struct temp_slot *temp, int level)
643 {
644   cut_slot_from_list (temp, temp_slots_at_level (temp->level));
645   insert_slot_to_list (temp, temp_slots_at_level (level));
646   temp->level = level;
647 }
648
649 /* Make temporary slot TEMP available.  */
650
651 static void
652 make_slot_available (struct temp_slot *temp)
653 {
654   cut_slot_from_list (temp, temp_slots_at_level (temp->level));
655   insert_slot_to_list (temp, &avail_temp_slots);
656   temp->in_use = 0;
657   temp->level = -1;
658 }
659
660 /* Compute the hash value for an address -> temp slot mapping.
661    The value is cached on the mapping entry.  */
662 static hashval_t
663 temp_slot_address_compute_hash (struct temp_slot_address_entry *t)
664 {
665   int do_not_record = 0;
666   return hash_rtx (t->address, GET_MODE (t->address),
667                    &do_not_record, NULL, false);
668 }
669
670 /* Return the hash value for an address -> temp slot mapping.  */
671 static hashval_t
672 temp_slot_address_hash (const void *p)
673 {
674   const struct temp_slot_address_entry *t;
675   t = (const struct temp_slot_address_entry *) p;
676   return t->hash;
677 }
678
679 /* Compare two address -> temp slot mapping entries.  */
680 static int
681 temp_slot_address_eq (const void *p1, const void *p2)
682 {
683   const struct temp_slot_address_entry *t1, *t2;
684   t1 = (const struct temp_slot_address_entry *) p1;
685   t2 = (const struct temp_slot_address_entry *) p2;
686   return exp_equiv_p (t1->address, t2->address, 0, true);
687 }
688
689 /* Add ADDRESS as an alias of TEMP_SLOT to the addess -> temp slot mapping.  */
690 static void
691 insert_temp_slot_address (rtx address, struct temp_slot *temp_slot)
692 {
693   void **slot;
694   struct temp_slot_address_entry *t = ggc_alloc_temp_slot_address_entry ();
695   t->address = address;
696   t->temp_slot = temp_slot;
697   t->hash = temp_slot_address_compute_hash (t);
698   slot = htab_find_slot_with_hash (temp_slot_address_table, t, t->hash, INSERT);
699   *slot = t;
700 }
701
702 /* Remove an address -> temp slot mapping entry if the temp slot is
703    not in use anymore.  Callback for remove_unused_temp_slot_addresses.  */
704 static int
705 remove_unused_temp_slot_addresses_1 (void **slot, void *data ATTRIBUTE_UNUSED)
706 {
707   const struct temp_slot_address_entry *t;
708   t = (const struct temp_slot_address_entry *) *slot;
709   if (! t->temp_slot->in_use)
710     *slot = NULL;
711   return 1;
712 }
713
714 /* Remove all mappings of addresses to unused temp slots.  */
715 static void
716 remove_unused_temp_slot_addresses (void)
717 {
718   htab_traverse (temp_slot_address_table,
719                  remove_unused_temp_slot_addresses_1,
720                  NULL);
721 }
722
723 /* Find the temp slot corresponding to the object at address X.  */
724
725 static struct temp_slot *
726 find_temp_slot_from_address (rtx x)
727 {
728   struct temp_slot *p;
729   struct temp_slot_address_entry tmp, *t;
730
731   /* First try the easy way:
732      See if X exists in the address -> temp slot mapping.  */
733   tmp.address = x;
734   tmp.temp_slot = NULL;
735   tmp.hash = temp_slot_address_compute_hash (&tmp);
736   t = (struct temp_slot_address_entry *)
737     htab_find_with_hash (temp_slot_address_table, &tmp, tmp.hash);
738   if (t)
739     return t->temp_slot;
740
741   /* If we have a sum involving a register, see if it points to a temp
742      slot.  */
743   if (GET_CODE (x) == PLUS && REG_P (XEXP (x, 0))
744       && (p = find_temp_slot_from_address (XEXP (x, 0))) != 0)
745     return p;
746   else if (GET_CODE (x) == PLUS && REG_P (XEXP (x, 1))
747            && (p = find_temp_slot_from_address (XEXP (x, 1))) != 0)
748     return p;
749
750   /* Last resort: Address is a virtual stack var address.  */
751   if (GET_CODE (x) == PLUS
752       && XEXP (x, 0) == virtual_stack_vars_rtx
753       && CONST_INT_P (XEXP (x, 1)))
754     {
755       int i;
756       for (i = max_slot_level (); i >= 0; i--)
757         for (p = *temp_slots_at_level (i); p; p = p->next)
758           {
759             if (INTVAL (XEXP (x, 1)) >= p->base_offset
760                 && INTVAL (XEXP (x, 1)) < p->base_offset + p->full_size)
761               return p;
762           }
763     }
764
765   return NULL;
766 }
767 \f
768 /* Allocate a temporary stack slot and record it for possible later
769    reuse.
770
771    MODE is the machine mode to be given to the returned rtx.
772
773    SIZE is the size in units of the space required.  We do no rounding here
774    since assign_stack_local will do any required rounding.
775
776    KEEP is 1 if this slot is to be retained after a call to
777    free_temp_slots.  Automatic variables for a block are allocated
778    with this flag.  KEEP values of 2 or 3 were needed respectively
779    for variables whose lifetime is controlled by CLEANUP_POINT_EXPRs
780    or for SAVE_EXPRs, but they are now unused.
781
782    TYPE is the type that will be used for the stack slot.  */
783
784 rtx
785 assign_stack_temp_for_type (enum machine_mode mode, HOST_WIDE_INT size,
786                             int keep, tree type)
787 {
788   unsigned int align;
789   struct temp_slot *p, *best_p = 0, *selected = NULL, **pp;
790   rtx slot;
791
792   /* If SIZE is -1 it means that somebody tried to allocate a temporary
793      of a variable size.  */
794   gcc_assert (size != -1);
795
796   /* These are now unused.  */
797   gcc_assert (keep <= 1);
798
799   align = get_stack_local_alignment (type, mode);
800
801   /* Try to find an available, already-allocated temporary of the proper
802      mode which meets the size and alignment requirements.  Choose the
803      smallest one with the closest alignment.
804
805      If assign_stack_temp is called outside of the tree->rtl expansion,
806      we cannot reuse the stack slots (that may still refer to
807      VIRTUAL_STACK_VARS_REGNUM).  */
808   if (!virtuals_instantiated)
809     {
810       for (p = avail_temp_slots; p; p = p->next)
811         {
812           if (p->align >= align && p->size >= size
813               && GET_MODE (p->slot) == mode
814               && objects_must_conflict_p (p->type, type)
815               && (best_p == 0 || best_p->size > p->size
816                   || (best_p->size == p->size && best_p->align > p->align)))
817             {
818               if (p->align == align && p->size == size)
819                 {
820                   selected = p;
821                   cut_slot_from_list (selected, &avail_temp_slots);
822                   best_p = 0;
823                   break;
824                 }
825               best_p = p;
826             }
827         }
828     }
829
830   /* Make our best, if any, the one to use.  */
831   if (best_p)
832     {
833       selected = best_p;
834       cut_slot_from_list (selected, &avail_temp_slots);
835
836       /* If there are enough aligned bytes left over, make them into a new
837          temp_slot so that the extra bytes don't get wasted.  Do this only
838          for BLKmode slots, so that we can be sure of the alignment.  */
839       if (GET_MODE (best_p->slot) == BLKmode)
840         {
841           int alignment = best_p->align / BITS_PER_UNIT;
842           HOST_WIDE_INT rounded_size = CEIL_ROUND (size, alignment);
843
844           if (best_p->size - rounded_size >= alignment)
845             {
846               p = ggc_alloc_temp_slot ();
847               p->in_use = p->addr_taken = 0;
848               p->size = best_p->size - rounded_size;
849               p->base_offset = best_p->base_offset + rounded_size;
850               p->full_size = best_p->full_size - rounded_size;
851               p->slot = adjust_address_nv (best_p->slot, BLKmode, rounded_size);
852               p->align = best_p->align;
853               p->type = best_p->type;
854               insert_slot_to_list (p, &avail_temp_slots);
855
856               stack_slot_list = gen_rtx_EXPR_LIST (VOIDmode, p->slot,
857                                                    stack_slot_list);
858
859               best_p->size = rounded_size;
860               best_p->full_size = rounded_size;
861             }
862         }
863     }
864
865   /* If we still didn't find one, make a new temporary.  */
866   if (selected == 0)
867     {
868       HOST_WIDE_INT frame_offset_old = frame_offset;
869
870       p = ggc_alloc_temp_slot ();
871
872       /* We are passing an explicit alignment request to assign_stack_local.
873          One side effect of that is assign_stack_local will not round SIZE
874          to ensure the frame offset remains suitably aligned.
875
876          So for requests which depended on the rounding of SIZE, we go ahead
877          and round it now.  We also make sure ALIGNMENT is at least
878          BIGGEST_ALIGNMENT.  */
879       gcc_assert (mode != BLKmode || align == BIGGEST_ALIGNMENT);
880       p->slot = assign_stack_local_1 (mode,
881                                       (mode == BLKmode
882                                        ? CEIL_ROUND (size,
883                                                      (int) align
884                                                      / BITS_PER_UNIT)
885                                        : size),
886                                       align, 0);
887
888       p->align = align;
889
890       /* The following slot size computation is necessary because we don't
891          know the actual size of the temporary slot until assign_stack_local
892          has performed all the frame alignment and size rounding for the
893          requested temporary.  Note that extra space added for alignment
894          can be either above or below this stack slot depending on which
895          way the frame grows.  We include the extra space if and only if it
896          is above this slot.  */
897       if (FRAME_GROWS_DOWNWARD)
898         p->size = frame_offset_old - frame_offset;
899       else
900         p->size = size;
901
902       /* Now define the fields used by combine_temp_slots.  */
903       if (FRAME_GROWS_DOWNWARD)
904         {
905           p->base_offset = frame_offset;
906           p->full_size = frame_offset_old - frame_offset;
907         }
908       else
909         {
910           p->base_offset = frame_offset_old;
911           p->full_size = frame_offset - frame_offset_old;
912         }
913
914       selected = p;
915     }
916
917   p = selected;
918   p->in_use = 1;
919   p->addr_taken = 0;
920   p->type = type;
921   p->level = temp_slot_level;
922   p->keep = keep;
923
924   pp = temp_slots_at_level (p->level);
925   insert_slot_to_list (p, pp);
926   insert_temp_slot_address (XEXP (p->slot, 0), p);
927
928   /* Create a new MEM rtx to avoid clobbering MEM flags of old slots.  */
929   slot = gen_rtx_MEM (mode, XEXP (p->slot, 0));
930   stack_slot_list = gen_rtx_EXPR_LIST (VOIDmode, slot, stack_slot_list);
931
932   /* If we know the alias set for the memory that will be used, use
933      it.  If there's no TYPE, then we don't know anything about the
934      alias set for the memory.  */
935   set_mem_alias_set (slot, type ? get_alias_set (type) : 0);
936   set_mem_align (slot, align);
937
938   /* If a type is specified, set the relevant flags.  */
939   if (type != 0)
940     {
941       MEM_VOLATILE_P (slot) = TYPE_VOLATILE (type);
942       gcc_checking_assert (!MEM_SCALAR_P (slot) && !MEM_IN_STRUCT_P (slot));
943       if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE)
944         MEM_IN_STRUCT_P (slot) = 1;
945       else
946         MEM_SCALAR_P (slot) = 1;
947     }
948   MEM_NOTRAP_P (slot) = 1;
949
950   return slot;
951 }
952
953 /* Allocate a temporary stack slot and record it for possible later
954    reuse.  First three arguments are same as in preceding function.  */
955
956 rtx
957 assign_stack_temp (enum machine_mode mode, HOST_WIDE_INT size, int keep)
958 {
959   return assign_stack_temp_for_type (mode, size, keep, NULL_TREE);
960 }
961 \f
962 /* Assign a temporary.
963    If TYPE_OR_DECL is a decl, then we are doing it on behalf of the decl
964    and so that should be used in error messages.  In either case, we
965    allocate of the given type.
966    KEEP is as for assign_stack_temp.
967    MEMORY_REQUIRED is 1 if the result must be addressable stack memory;
968    it is 0 if a register is OK.
969    DONT_PROMOTE is 1 if we should not promote values in register
970    to wider modes.  */
971
972 rtx
973 assign_temp (tree type_or_decl, int keep, int memory_required,
974              int dont_promote ATTRIBUTE_UNUSED)
975 {
976   tree type, decl;
977   enum machine_mode mode;
978 #ifdef PROMOTE_MODE
979   int unsignedp;
980 #endif
981
982   if (DECL_P (type_or_decl))
983     decl = type_or_decl, type = TREE_TYPE (decl);
984   else
985     decl = NULL, type = type_or_decl;
986
987   mode = TYPE_MODE (type);
988 #ifdef PROMOTE_MODE
989   unsignedp = TYPE_UNSIGNED (type);
990 #endif
991
992   if (mode == BLKmode || memory_required)
993     {
994       HOST_WIDE_INT size = int_size_in_bytes (type);
995       rtx tmp;
996
997       /* Zero sized arrays are GNU C extension.  Set size to 1 to avoid
998          problems with allocating the stack space.  */
999       if (size == 0)
1000         size = 1;
1001
1002       /* Unfortunately, we don't yet know how to allocate variable-sized
1003          temporaries.  However, sometimes we can find a fixed upper limit on
1004          the size, so try that instead.  */
1005       else if (size == -1)
1006         size = max_int_size_in_bytes (type);
1007
1008       /* The size of the temporary may be too large to fit into an integer.  */
1009       /* ??? Not sure this should happen except for user silliness, so limit
1010          this to things that aren't compiler-generated temporaries.  The
1011          rest of the time we'll die in assign_stack_temp_for_type.  */
1012       if (decl && size == -1
1013           && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST)
1014         {
1015           error ("size of variable %q+D is too large", decl);
1016           size = 1;
1017         }
1018
1019       tmp = assign_stack_temp_for_type (mode, size, keep, type);
1020       return tmp;
1021     }
1022
1023 #ifdef PROMOTE_MODE
1024   if (! dont_promote)
1025     mode = promote_mode (type, mode, &unsignedp);
1026 #endif
1027
1028   return gen_reg_rtx (mode);
1029 }
1030 \f
1031 /* Combine temporary stack slots which are adjacent on the stack.
1032
1033    This allows for better use of already allocated stack space.  This is only
1034    done for BLKmode slots because we can be sure that we won't have alignment
1035    problems in this case.  */
1036
1037 static void
1038 combine_temp_slots (void)
1039 {
1040   struct temp_slot *p, *q, *next, *next_q;
1041   int num_slots;
1042
1043   /* We can't combine slots, because the information about which slot
1044      is in which alias set will be lost.  */
1045   if (flag_strict_aliasing)
1046     return;
1047
1048   /* If there are a lot of temp slots, don't do anything unless
1049      high levels of optimization.  */
1050   if (! flag_expensive_optimizations)
1051     for (p = avail_temp_slots, num_slots = 0; p; p = p->next, num_slots++)
1052       if (num_slots > 100 || (num_slots > 10 && optimize == 0))
1053         return;
1054
1055   for (p = avail_temp_slots; p; p = next)
1056     {
1057       int delete_p = 0;
1058
1059       next = p->next;
1060
1061       if (GET_MODE (p->slot) != BLKmode)
1062         continue;
1063
1064       for (q = p->next; q; q = next_q)
1065         {
1066           int delete_q = 0;
1067
1068           next_q = q->next;
1069
1070           if (GET_MODE (q->slot) != BLKmode)
1071             continue;
1072
1073           if (p->base_offset + p->full_size == q->base_offset)
1074             {
1075               /* Q comes after P; combine Q into P.  */
1076               p->size += q->size;
1077               p->full_size += q->full_size;
1078               delete_q = 1;
1079             }
1080           else if (q->base_offset + q->full_size == p->base_offset)
1081             {
1082               /* P comes after Q; combine P into Q.  */
1083               q->size += p->size;
1084               q->full_size += p->full_size;
1085               delete_p = 1;
1086               break;
1087             }
1088           if (delete_q)
1089             cut_slot_from_list (q, &avail_temp_slots);
1090         }
1091
1092       /* Either delete P or advance past it.  */
1093       if (delete_p)
1094         cut_slot_from_list (p, &avail_temp_slots);
1095     }
1096 }
1097 \f
1098 /* Indicate that NEW_RTX is an alternate way of referring to the temp
1099    slot that previously was known by OLD_RTX.  */
1100
1101 void
1102 update_temp_slot_address (rtx old_rtx, rtx new_rtx)
1103 {
1104   struct temp_slot *p;
1105
1106   if (rtx_equal_p (old_rtx, new_rtx))
1107     return;
1108
1109   p = find_temp_slot_from_address (old_rtx);
1110
1111   /* If we didn't find one, see if both OLD_RTX is a PLUS.  If so, and
1112      NEW_RTX is a register, see if one operand of the PLUS is a
1113      temporary location.  If so, NEW_RTX points into it.  Otherwise,
1114      if both OLD_RTX and NEW_RTX are a PLUS and if there is a register
1115      in common between them.  If so, try a recursive call on those
1116      values.  */
1117   if (p == 0)
1118     {
1119       if (GET_CODE (old_rtx) != PLUS)
1120         return;
1121
1122       if (REG_P (new_rtx))
1123         {
1124           update_temp_slot_address (XEXP (old_rtx, 0), new_rtx);
1125           update_temp_slot_address (XEXP (old_rtx, 1), new_rtx);
1126           return;
1127         }
1128       else if (GET_CODE (new_rtx) != PLUS)
1129         return;
1130
1131       if (rtx_equal_p (XEXP (old_rtx, 0), XEXP (new_rtx, 0)))
1132         update_temp_slot_address (XEXP (old_rtx, 1), XEXP (new_rtx, 1));
1133       else if (rtx_equal_p (XEXP (old_rtx, 1), XEXP (new_rtx, 0)))
1134         update_temp_slot_address (XEXP (old_rtx, 0), XEXP (new_rtx, 1));
1135       else if (rtx_equal_p (XEXP (old_rtx, 0), XEXP (new_rtx, 1)))
1136         update_temp_slot_address (XEXP (old_rtx, 1), XEXP (new_rtx, 0));
1137       else if (rtx_equal_p (XEXP (old_rtx, 1), XEXP (new_rtx, 1)))
1138         update_temp_slot_address (XEXP (old_rtx, 0), XEXP (new_rtx, 0));
1139
1140       return;
1141     }
1142
1143   /* Otherwise add an alias for the temp's address.  */
1144   insert_temp_slot_address (new_rtx, p);
1145 }
1146
1147 /* If X could be a reference to a temporary slot, mark the fact that its
1148    address was taken.  */
1149
1150 void
1151 mark_temp_addr_taken (rtx x)
1152 {
1153   struct temp_slot *p;
1154
1155   if (x == 0)
1156     return;
1157
1158   /* If X is not in memory or is at a constant address, it cannot be in
1159      a temporary slot.  */
1160   if (!MEM_P (x) || CONSTANT_P (XEXP (x, 0)))
1161     return;
1162
1163   p = find_temp_slot_from_address (XEXP (x, 0));
1164   if (p != 0)
1165     p->addr_taken = 1;
1166 }
1167
1168 /* If X could be a reference to a temporary slot, mark that slot as
1169    belonging to the to one level higher than the current level.  If X
1170    matched one of our slots, just mark that one.  Otherwise, we can't
1171    easily predict which it is, so upgrade all of them.  Kept slots
1172    need not be touched.
1173
1174    This is called when an ({...}) construct occurs and a statement
1175    returns a value in memory.  */
1176
1177 void
1178 preserve_temp_slots (rtx x)
1179 {
1180   struct temp_slot *p = 0, *next;
1181
1182   /* If there is no result, we still might have some objects whose address
1183      were taken, so we need to make sure they stay around.  */
1184   if (x == 0)
1185     {
1186       for (p = *temp_slots_at_level (temp_slot_level); p; p = next)
1187         {
1188           next = p->next;
1189
1190           if (p->addr_taken)
1191             move_slot_to_level (p, temp_slot_level - 1);
1192         }
1193
1194       return;
1195     }
1196
1197   /* If X is a register that is being used as a pointer, see if we have
1198      a temporary slot we know it points to.  To be consistent with
1199      the code below, we really should preserve all non-kept slots
1200      if we can't find a match, but that seems to be much too costly.  */
1201   if (REG_P (x) && REG_POINTER (x))
1202     p = find_temp_slot_from_address (x);
1203
1204   /* If X is not in memory or is at a constant address, it cannot be in
1205      a temporary slot, but it can contain something whose address was
1206      taken.  */
1207   if (p == 0 && (!MEM_P (x) || CONSTANT_P (XEXP (x, 0))))
1208     {
1209       for (p = *temp_slots_at_level (temp_slot_level); p; p = next)
1210         {
1211           next = p->next;
1212
1213           if (p->addr_taken)
1214             move_slot_to_level (p, temp_slot_level - 1);
1215         }
1216
1217       return;
1218     }
1219
1220   /* First see if we can find a match.  */
1221   if (p == 0)
1222     p = find_temp_slot_from_address (XEXP (x, 0));
1223
1224   if (p != 0)
1225     {
1226       /* Move everything at our level whose address was taken to our new
1227          level in case we used its address.  */
1228       struct temp_slot *q;
1229
1230       if (p->level == temp_slot_level)
1231         {
1232           for (q = *temp_slots_at_level (temp_slot_level); q; q = next)
1233             {
1234               next = q->next;
1235
1236               if (p != q && q->addr_taken)
1237                 move_slot_to_level (q, temp_slot_level - 1);
1238             }
1239
1240           move_slot_to_level (p, temp_slot_level - 1);
1241           p->addr_taken = 0;
1242         }
1243       return;
1244     }
1245
1246   /* Otherwise, preserve all non-kept slots at this level.  */
1247   for (p = *temp_slots_at_level (temp_slot_level); p; p = next)
1248     {
1249       next = p->next;
1250
1251       if (!p->keep)
1252         move_slot_to_level (p, temp_slot_level - 1);
1253     }
1254 }
1255
1256 /* Free all temporaries used so far.  This is normally called at the
1257    end of generating code for a statement.  */
1258
1259 void
1260 free_temp_slots (void)
1261 {
1262   struct temp_slot *p, *next;
1263   bool some_available = false;
1264
1265   for (p = *temp_slots_at_level (temp_slot_level); p; p = next)
1266     {
1267       next = p->next;
1268
1269       if (!p->keep)
1270         {
1271           make_slot_available (p);
1272           some_available = true;
1273         }
1274     }
1275
1276   if (some_available)
1277     {
1278       remove_unused_temp_slot_addresses ();
1279       combine_temp_slots ();
1280     }
1281 }
1282
1283 /* Push deeper into the nesting level for stack temporaries.  */
1284
1285 void
1286 push_temp_slots (void)
1287 {
1288   temp_slot_level++;
1289 }
1290
1291 /* Pop a temporary nesting level.  All slots in use in the current level
1292    are freed.  */
1293
1294 void
1295 pop_temp_slots (void)
1296 {
1297   struct temp_slot *p, *next;
1298   bool some_available = false;
1299
1300   for (p = *temp_slots_at_level (temp_slot_level); p; p = next)
1301     {
1302       next = p->next;
1303       make_slot_available (p);
1304       some_available = true;
1305     }
1306
1307   if (some_available)
1308     {
1309       remove_unused_temp_slot_addresses ();
1310       combine_temp_slots ();
1311     }
1312
1313   temp_slot_level--;
1314 }
1315
1316 /* Initialize temporary slots.  */
1317
1318 void
1319 init_temp_slots (void)
1320 {
1321   /* We have not allocated any temporaries yet.  */
1322   avail_temp_slots = 0;
1323   used_temp_slots = 0;
1324   temp_slot_level = 0;
1325
1326   /* Set up the table to map addresses to temp slots.  */
1327   if (! temp_slot_address_table)
1328     temp_slot_address_table = htab_create_ggc (32,
1329                                                temp_slot_address_hash,
1330                                                temp_slot_address_eq,
1331                                                NULL);
1332   else
1333     htab_empty (temp_slot_address_table);
1334 }
1335 \f
1336 /* These routines are responsible for converting virtual register references
1337    to the actual hard register references once RTL generation is complete.
1338
1339    The following four variables are used for communication between the
1340    routines.  They contain the offsets of the virtual registers from their
1341    respective hard registers.  */
1342
1343 static int in_arg_offset;
1344 static int var_offset;
1345 static int dynamic_offset;
1346 static int out_arg_offset;
1347 static int cfa_offset;
1348
1349 /* In most machines, the stack pointer register is equivalent to the bottom
1350    of the stack.  */
1351
1352 #ifndef STACK_POINTER_OFFSET
1353 #define STACK_POINTER_OFFSET    0
1354 #endif
1355
1356 /* If not defined, pick an appropriate default for the offset of dynamically
1357    allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS,
1358    REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE.  */
1359
1360 #ifndef STACK_DYNAMIC_OFFSET
1361
1362 /* The bottom of the stack points to the actual arguments.  If
1363    REG_PARM_STACK_SPACE is defined, this includes the space for the register
1364    parameters.  However, if OUTGOING_REG_PARM_STACK space is not defined,
1365    stack space for register parameters is not pushed by the caller, but
1366    rather part of the fixed stack areas and hence not included in
1367    `crtl->outgoing_args_size'.  Nevertheless, we must allow
1368    for it when allocating stack dynamic objects.  */
1369
1370 #if defined(REG_PARM_STACK_SPACE)
1371 #define STACK_DYNAMIC_OFFSET(FNDECL)    \
1372 ((ACCUMULATE_OUTGOING_ARGS                                                    \
1373   ? (crtl->outgoing_args_size                                 \
1374      + (OUTGOING_REG_PARM_STACK_SPACE ((!(FNDECL) ? NULL_TREE : TREE_TYPE (FNDECL))) ? 0 \
1375                                                : REG_PARM_STACK_SPACE (FNDECL))) \
1376   : 0) + (STACK_POINTER_OFFSET))
1377 #else
1378 #define STACK_DYNAMIC_OFFSET(FNDECL)    \
1379 ((ACCUMULATE_OUTGOING_ARGS ? crtl->outgoing_args_size : 0)            \
1380  + (STACK_POINTER_OFFSET))
1381 #endif
1382 #endif
1383
1384 \f
1385 /* Given a piece of RTX and a pointer to a HOST_WIDE_INT, if the RTX
1386    is a virtual register, return the equivalent hard register and set the
1387    offset indirectly through the pointer.  Otherwise, return 0.  */
1388
1389 static rtx
1390 instantiate_new_reg (rtx x, HOST_WIDE_INT *poffset)
1391 {
1392   rtx new_rtx;
1393   HOST_WIDE_INT offset;
1394
1395   if (x == virtual_incoming_args_rtx)
1396     {
1397       if (stack_realign_drap)
1398         {
1399           /* Replace virtual_incoming_args_rtx with internal arg
1400              pointer if DRAP is used to realign stack.  */
1401           new_rtx = crtl->args.internal_arg_pointer;
1402           offset = 0;
1403         }
1404       else
1405         new_rtx = arg_pointer_rtx, offset = in_arg_offset;
1406     }
1407   else if (x == virtual_stack_vars_rtx)
1408     new_rtx = frame_pointer_rtx, offset = var_offset;
1409   else if (x == virtual_stack_dynamic_rtx)
1410     new_rtx = stack_pointer_rtx, offset = dynamic_offset;
1411   else if (x == virtual_outgoing_args_rtx)
1412     new_rtx = stack_pointer_rtx, offset = out_arg_offset;
1413   else if (x == virtual_cfa_rtx)
1414     {
1415 #ifdef FRAME_POINTER_CFA_OFFSET
1416       new_rtx = frame_pointer_rtx;
1417 #else
1418       new_rtx = arg_pointer_rtx;
1419 #endif
1420       offset = cfa_offset;
1421     }
1422   else if (x == virtual_preferred_stack_boundary_rtx)
1423     {
1424       new_rtx = GEN_INT (crtl->preferred_stack_boundary / BITS_PER_UNIT);
1425       offset = 0;
1426     }
1427   else
1428     return NULL_RTX;
1429
1430   *poffset = offset;
1431   return new_rtx;
1432 }
1433
1434 /* A subroutine of instantiate_virtual_regs, called via for_each_rtx.
1435    Instantiate any virtual registers present inside of *LOC.  The expression
1436    is simplified, as much as possible, but is not to be considered "valid"
1437    in any sense implied by the target.  If any change is made, set CHANGED
1438    to true.  */
1439
1440 static int
1441 instantiate_virtual_regs_in_rtx (rtx *loc, void *data)
1442 {
1443   HOST_WIDE_INT offset;
1444   bool *changed = (bool *) data;
1445   rtx x, new_rtx;
1446
1447   x = *loc;
1448   if (x == 0)
1449     return 0;
1450
1451   switch (GET_CODE (x))
1452     {
1453     case REG:
1454       new_rtx = instantiate_new_reg (x, &offset);
1455       if (new_rtx)
1456         {
1457           *loc = plus_constant (new_rtx, offset);
1458           if (changed)
1459             *changed = true;
1460         }
1461       return -1;
1462
1463     case PLUS:
1464       new_rtx = instantiate_new_reg (XEXP (x, 0), &offset);
1465       if (new_rtx)
1466         {
1467           new_rtx = plus_constant (new_rtx, offset);
1468           *loc = simplify_gen_binary (PLUS, GET_MODE (x), new_rtx, XEXP (x, 1));
1469           if (changed)
1470             *changed = true;
1471           return -1;
1472         }
1473
1474       /* FIXME -- from old code */
1475           /* If we have (plus (subreg (virtual-reg)) (const_int)), we know
1476              we can commute the PLUS and SUBREG because pointers into the
1477              frame are well-behaved.  */
1478       break;
1479
1480     default:
1481       break;
1482     }
1483
1484   return 0;
1485 }
1486
1487 /* A subroutine of instantiate_virtual_regs_in_insn.  Return true if X
1488    matches the predicate for insn CODE operand OPERAND.  */
1489
1490 static int
1491 safe_insn_predicate (int code, int operand, rtx x)
1492 {
1493   return code < 0 || insn_operand_matches ((enum insn_code) code, operand, x);
1494 }
1495
1496 /* A subroutine of instantiate_virtual_regs.  Instantiate any virtual
1497    registers present inside of insn.  The result will be a valid insn.  */
1498
1499 static void
1500 instantiate_virtual_regs_in_insn (rtx insn)
1501 {
1502   HOST_WIDE_INT offset;
1503   int insn_code, i;
1504   bool any_change = false;
1505   rtx set, new_rtx, x, seq;
1506
1507   /* There are some special cases to be handled first.  */
1508   set = single_set (insn);
1509   if (set)
1510     {
1511       /* We're allowed to assign to a virtual register.  This is interpreted
1512          to mean that the underlying register gets assigned the inverse
1513          transformation.  This is used, for example, in the handling of
1514          non-local gotos.  */
1515       new_rtx = instantiate_new_reg (SET_DEST (set), &offset);
1516       if (new_rtx)
1517         {
1518           start_sequence ();
1519
1520           for_each_rtx (&SET_SRC (set), instantiate_virtual_regs_in_rtx, NULL);
1521           x = simplify_gen_binary (PLUS, GET_MODE (new_rtx), SET_SRC (set),
1522                                    GEN_INT (-offset));
1523           x = force_operand (x, new_rtx);
1524           if (x != new_rtx)
1525             emit_move_insn (new_rtx, x);
1526
1527           seq = get_insns ();
1528           end_sequence ();
1529
1530           emit_insn_before (seq, insn);
1531           delete_insn (insn);
1532           return;
1533         }
1534
1535       /* Handle a straight copy from a virtual register by generating a
1536          new add insn.  The difference between this and falling through
1537          to the generic case is avoiding a new pseudo and eliminating a
1538          move insn in the initial rtl stream.  */
1539       new_rtx = instantiate_new_reg (SET_SRC (set), &offset);
1540       if (new_rtx && offset != 0
1541           && REG_P (SET_DEST (set))
1542           && REGNO (SET_DEST (set)) > LAST_VIRTUAL_REGISTER)
1543         {
1544           start_sequence ();
1545
1546           x = expand_simple_binop (GET_MODE (SET_DEST (set)), PLUS,
1547                                    new_rtx, GEN_INT (offset), SET_DEST (set),
1548                                    1, OPTAB_LIB_WIDEN);
1549           if (x != SET_DEST (set))
1550             emit_move_insn (SET_DEST (set), x);
1551
1552           seq = get_insns ();
1553           end_sequence ();
1554
1555           emit_insn_before (seq, insn);
1556           delete_insn (insn);
1557           return;
1558         }
1559
1560       extract_insn (insn);
1561       insn_code = INSN_CODE (insn);
1562
1563       /* Handle a plus involving a virtual register by determining if the
1564          operands remain valid if they're modified in place.  */
1565       if (GET_CODE (SET_SRC (set)) == PLUS
1566           && recog_data.n_operands >= 3
1567           && recog_data.operand_loc[1] == &XEXP (SET_SRC (set), 0)
1568           && recog_data.operand_loc[2] == &XEXP (SET_SRC (set), 1)
1569           && CONST_INT_P (recog_data.operand[2])
1570           && (new_rtx = instantiate_new_reg (recog_data.operand[1], &offset)))
1571         {
1572           offset += INTVAL (recog_data.operand[2]);
1573
1574           /* If the sum is zero, then replace with a plain move.  */
1575           if (offset == 0
1576               && REG_P (SET_DEST (set))
1577               && REGNO (SET_DEST (set)) > LAST_VIRTUAL_REGISTER)
1578             {
1579               start_sequence ();
1580               emit_move_insn (SET_DEST (set), new_rtx);
1581               seq = get_insns ();
1582               end_sequence ();
1583
1584               emit_insn_before (seq, insn);
1585               delete_insn (insn);
1586               return;
1587             }
1588
1589           x = gen_int_mode (offset, recog_data.operand_mode[2]);
1590
1591           /* Using validate_change and apply_change_group here leaves
1592              recog_data in an invalid state.  Since we know exactly what
1593              we want to check, do those two by hand.  */
1594           if (safe_insn_predicate (insn_code, 1, new_rtx)
1595               && safe_insn_predicate (insn_code, 2, x))
1596             {
1597               *recog_data.operand_loc[1] = recog_data.operand[1] = new_rtx;
1598               *recog_data.operand_loc[2] = recog_data.operand[2] = x;
1599               any_change = true;
1600
1601               /* Fall through into the regular operand fixup loop in
1602                  order to take care of operands other than 1 and 2.  */
1603             }
1604         }
1605     }
1606   else
1607     {
1608       extract_insn (insn);
1609       insn_code = INSN_CODE (insn);
1610     }
1611
1612   /* In the general case, we expect virtual registers to appear only in
1613      operands, and then only as either bare registers or inside memories.  */
1614   for (i = 0; i < recog_data.n_operands; ++i)
1615     {
1616       x = recog_data.operand[i];
1617       switch (GET_CODE (x))
1618         {
1619         case MEM:
1620           {
1621             rtx addr = XEXP (x, 0);
1622             bool changed = false;
1623
1624             for_each_rtx (&addr, instantiate_virtual_regs_in_rtx, &changed);
1625             if (!changed)
1626               continue;
1627
1628             start_sequence ();
1629             x = replace_equiv_address (x, addr);
1630             /* It may happen that the address with the virtual reg
1631                was valid (e.g. based on the virtual stack reg, which might
1632                be acceptable to the predicates with all offsets), whereas
1633                the address now isn't anymore, for instance when the address
1634                is still offsetted, but the base reg isn't virtual-stack-reg
1635                anymore.  Below we would do a force_reg on the whole operand,
1636                but this insn might actually only accept memory.  Hence,
1637                before doing that last resort, try to reload the address into
1638                a register, so this operand stays a MEM.  */
1639             if (!safe_insn_predicate (insn_code, i, x))
1640               {
1641                 addr = force_reg (GET_MODE (addr), addr);
1642                 x = replace_equiv_address (x, addr);
1643               }
1644             seq = get_insns ();
1645             end_sequence ();
1646             if (seq)
1647               emit_insn_before (seq, insn);
1648           }
1649           break;
1650
1651         case REG:
1652           new_rtx = instantiate_new_reg (x, &offset);
1653           if (new_rtx == NULL)
1654             continue;
1655           if (offset == 0)
1656             x = new_rtx;
1657           else
1658             {
1659               start_sequence ();
1660
1661               /* Careful, special mode predicates may have stuff in
1662                  insn_data[insn_code].operand[i].mode that isn't useful
1663                  to us for computing a new value.  */
1664               /* ??? Recognize address_operand and/or "p" constraints
1665                  to see if (plus new offset) is a valid before we put
1666                  this through expand_simple_binop.  */
1667               x = expand_simple_binop (GET_MODE (x), PLUS, new_rtx,
1668                                        GEN_INT (offset), NULL_RTX,
1669                                        1, OPTAB_LIB_WIDEN);
1670               seq = get_insns ();
1671               end_sequence ();
1672               emit_insn_before (seq, insn);
1673             }
1674           break;
1675
1676         case SUBREG:
1677           new_rtx = instantiate_new_reg (SUBREG_REG (x), &offset);
1678           if (new_rtx == NULL)
1679             continue;
1680           if (offset != 0)
1681             {
1682               start_sequence ();
1683               new_rtx = expand_simple_binop (GET_MODE (new_rtx), PLUS, new_rtx,
1684                                          GEN_INT (offset), NULL_RTX,
1685                                          1, OPTAB_LIB_WIDEN);
1686               seq = get_insns ();
1687               end_sequence ();
1688               emit_insn_before (seq, insn);
1689             }
1690           x = simplify_gen_subreg (recog_data.operand_mode[i], new_rtx,
1691                                    GET_MODE (new_rtx), SUBREG_BYTE (x));
1692           gcc_assert (x);
1693           break;
1694
1695         default:
1696           continue;
1697         }
1698
1699       /* At this point, X contains the new value for the operand.
1700          Validate the new value vs the insn predicate.  Note that
1701          asm insns will have insn_code -1 here.  */
1702       if (!safe_insn_predicate (insn_code, i, x))
1703         {
1704           start_sequence ();
1705           if (REG_P (x))
1706             {
1707               gcc_assert (REGNO (x) <= LAST_VIRTUAL_REGISTER);
1708               x = copy_to_reg (x);
1709             }
1710           else
1711             x = force_reg (insn_data[insn_code].operand[i].mode, x);
1712           seq = get_insns ();
1713           end_sequence ();
1714           if (seq)
1715             emit_insn_before (seq, insn);
1716         }
1717
1718       *recog_data.operand_loc[i] = recog_data.operand[i] = x;
1719       any_change = true;
1720     }
1721
1722   if (any_change)
1723     {
1724       /* Propagate operand changes into the duplicates.  */
1725       for (i = 0; i < recog_data.n_dups; ++i)
1726         *recog_data.dup_loc[i]
1727           = copy_rtx (recog_data.operand[(unsigned)recog_data.dup_num[i]]);
1728
1729       /* Force re-recognition of the instruction for validation.  */
1730       INSN_CODE (insn) = -1;
1731     }
1732
1733   if (asm_noperands (PATTERN (insn)) >= 0)
1734     {
1735       if (!check_asm_operands (PATTERN (insn)))
1736         {
1737           error_for_asm (insn, "impossible constraint in %<asm%>");
1738           delete_insn (insn);
1739         }
1740     }
1741   else
1742     {
1743       if (recog_memoized (insn) < 0)
1744         fatal_insn_not_found (insn);
1745     }
1746 }
1747
1748 /* Subroutine of instantiate_decls.  Given RTL representing a decl,
1749    do any instantiation required.  */
1750
1751 void
1752 instantiate_decl_rtl (rtx x)
1753 {
1754   rtx addr;
1755
1756   if (x == 0)
1757     return;
1758
1759   /* If this is a CONCAT, recurse for the pieces.  */
1760   if (GET_CODE (x) == CONCAT)
1761     {
1762       instantiate_decl_rtl (XEXP (x, 0));
1763       instantiate_decl_rtl (XEXP (x, 1));
1764       return;
1765     }
1766
1767   /* If this is not a MEM, no need to do anything.  Similarly if the
1768      address is a constant or a register that is not a virtual register.  */
1769   if (!MEM_P (x))
1770     return;
1771
1772   addr = XEXP (x, 0);
1773   if (CONSTANT_P (addr)
1774       || (REG_P (addr)
1775           && (REGNO (addr) < FIRST_VIRTUAL_REGISTER
1776               || REGNO (addr) > LAST_VIRTUAL_REGISTER)))
1777     return;
1778
1779   for_each_rtx (&XEXP (x, 0), instantiate_virtual_regs_in_rtx, NULL);
1780 }
1781
1782 /* Helper for instantiate_decls called via walk_tree: Process all decls
1783    in the given DECL_VALUE_EXPR.  */
1784
1785 static tree
1786 instantiate_expr (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
1787 {
1788   tree t = *tp;
1789   if (! EXPR_P (t))
1790     {
1791       *walk_subtrees = 0;
1792       if (DECL_P (t))
1793         {
1794           if (DECL_RTL_SET_P (t))
1795             instantiate_decl_rtl (DECL_RTL (t));
1796           if (TREE_CODE (t) == PARM_DECL && DECL_NAMELESS (t)
1797               && DECL_INCOMING_RTL (t))
1798             instantiate_decl_rtl (DECL_INCOMING_RTL (t));
1799           if ((TREE_CODE (t) == VAR_DECL
1800                || TREE_CODE (t) == RESULT_DECL)
1801               && DECL_HAS_VALUE_EXPR_P (t))
1802             {
1803               tree v = DECL_VALUE_EXPR (t);
1804               walk_tree (&v, instantiate_expr, NULL, NULL);
1805             }
1806         }
1807     }
1808   return NULL;
1809 }
1810
1811 /* Subroutine of instantiate_decls: Process all decls in the given
1812    BLOCK node and all its subblocks.  */
1813
1814 static void
1815 instantiate_decls_1 (tree let)
1816 {
1817   tree t;
1818
1819   for (t = BLOCK_VARS (let); t; t = DECL_CHAIN (t))
1820     {
1821       if (DECL_RTL_SET_P (t))
1822         instantiate_decl_rtl (DECL_RTL (t));
1823       if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
1824         {
1825           tree v = DECL_VALUE_EXPR (t);
1826           walk_tree (&v, instantiate_expr, NULL, NULL);
1827         }
1828     }
1829
1830   /* Process all subblocks.  */
1831   for (t = BLOCK_SUBBLOCKS (let); t; t = BLOCK_CHAIN (t))
1832     instantiate_decls_1 (t);
1833 }
1834
1835 /* Scan all decls in FNDECL (both variables and parameters) and instantiate
1836    all virtual registers in their DECL_RTL's.  */
1837
1838 static void
1839 instantiate_decls (tree fndecl)
1840 {
1841   tree decl;
1842   unsigned ix;
1843
1844   /* Process all parameters of the function.  */
1845   for (decl = DECL_ARGUMENTS (fndecl); decl; decl = DECL_CHAIN (decl))
1846     {
1847       instantiate_decl_rtl (DECL_RTL (decl));
1848       instantiate_decl_rtl (DECL_INCOMING_RTL (decl));
1849       if (DECL_HAS_VALUE_EXPR_P (decl))
1850         {
1851           tree v = DECL_VALUE_EXPR (decl);
1852           walk_tree (&v, instantiate_expr, NULL, NULL);
1853         }
1854     }
1855
1856   if ((decl = DECL_RESULT (fndecl))
1857       && TREE_CODE (decl) == RESULT_DECL)
1858     {
1859       if (DECL_RTL_SET_P (decl))
1860         instantiate_decl_rtl (DECL_RTL (decl));
1861       if (DECL_HAS_VALUE_EXPR_P (decl))
1862         {
1863           tree v = DECL_VALUE_EXPR (decl);
1864           walk_tree (&v, instantiate_expr, NULL, NULL);
1865         }
1866     }
1867
1868   /* Now process all variables defined in the function or its subblocks.  */
1869   instantiate_decls_1 (DECL_INITIAL (fndecl));
1870
1871   FOR_EACH_LOCAL_DECL (cfun, ix, decl)
1872     if (DECL_RTL_SET_P (decl))
1873       instantiate_decl_rtl (DECL_RTL (decl));
1874   VEC_free (tree, gc, cfun->local_decls);
1875 }
1876
1877 /* Pass through the INSNS of function FNDECL and convert virtual register
1878    references to hard register references.  */
1879
1880 static unsigned int
1881 instantiate_virtual_regs (void)
1882 {
1883   rtx insn;
1884
1885   /* Compute the offsets to use for this function.  */
1886   in_arg_offset = FIRST_PARM_OFFSET (current_function_decl);
1887   var_offset = STARTING_FRAME_OFFSET;
1888   dynamic_offset = STACK_DYNAMIC_OFFSET (current_function_decl);
1889   out_arg_offset = STACK_POINTER_OFFSET;
1890 #ifdef FRAME_POINTER_CFA_OFFSET
1891   cfa_offset = FRAME_POINTER_CFA_OFFSET (current_function_decl);
1892 #else
1893   cfa_offset = ARG_POINTER_CFA_OFFSET (current_function_decl);
1894 #endif
1895
1896   /* Initialize recognition, indicating that volatile is OK.  */
1897   init_recog ();
1898
1899   /* Scan through all the insns, instantiating every virtual register still
1900      present.  */
1901   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
1902     if (INSN_P (insn))
1903       {
1904         /* These patterns in the instruction stream can never be recognized.
1905            Fortunately, they shouldn't contain virtual registers either.  */
1906         if (GET_CODE (PATTERN (insn)) == USE
1907             || GET_CODE (PATTERN (insn)) == CLOBBER
1908             || GET_CODE (PATTERN (insn)) == ADDR_VEC
1909             || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC
1910             || GET_CODE (PATTERN (insn)) == ASM_INPUT)
1911           continue;
1912         else if (DEBUG_INSN_P (insn))
1913           for_each_rtx (&INSN_VAR_LOCATION (insn),
1914                         instantiate_virtual_regs_in_rtx, NULL);
1915         else
1916           instantiate_virtual_regs_in_insn (insn);
1917
1918         if (INSN_DELETED_P (insn))
1919           continue;
1920
1921         for_each_rtx (&REG_NOTES (insn), instantiate_virtual_regs_in_rtx, NULL);
1922
1923         /* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE.  */
1924         if (CALL_P (insn))
1925           for_each_rtx (&CALL_INSN_FUNCTION_USAGE (insn),
1926                         instantiate_virtual_regs_in_rtx, NULL);
1927       }
1928
1929   /* Instantiate the virtual registers in the DECLs for debugging purposes.  */
1930   instantiate_decls (current_function_decl);
1931
1932   targetm.instantiate_decls ();
1933
1934   /* Indicate that, from now on, assign_stack_local should use
1935      frame_pointer_rtx.  */
1936   virtuals_instantiated = 1;
1937
1938   return 0;
1939 }
1940
1941 struct rtl_opt_pass pass_instantiate_virtual_regs =
1942 {
1943  {
1944   RTL_PASS,
1945   "vregs",                              /* name */
1946   NULL,                                 /* gate */
1947   instantiate_virtual_regs,             /* execute */
1948   NULL,                                 /* sub */
1949   NULL,                                 /* next */
1950   0,                                    /* static_pass_number */
1951   TV_NONE,                              /* tv_id */
1952   0,                                    /* properties_required */
1953   0,                                    /* properties_provided */
1954   0,                                    /* properties_destroyed */
1955   0,                                    /* todo_flags_start */
1956   0                                     /* todo_flags_finish */
1957  }
1958 };
1959
1960 \f
1961 /* Return 1 if EXP is an aggregate type (or a value with aggregate type).
1962    This means a type for which function calls must pass an address to the
1963    function or get an address back from the function.
1964    EXP may be a type node or an expression (whose type is tested).  */
1965
1966 int
1967 aggregate_value_p (const_tree exp, const_tree fntype)
1968 {
1969   const_tree type = (TYPE_P (exp)) ? exp : TREE_TYPE (exp);
1970   int i, regno, nregs;
1971   rtx reg;
1972
1973   if (fntype)
1974     switch (TREE_CODE (fntype))
1975       {
1976       case CALL_EXPR:
1977         {
1978           tree fndecl = get_callee_fndecl (fntype);
1979           fntype = (fndecl
1980                     ? TREE_TYPE (fndecl)
1981                     : TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (fntype))));
1982         }
1983         break;
1984       case FUNCTION_DECL:
1985         fntype = TREE_TYPE (fntype);
1986         break;
1987       case FUNCTION_TYPE:
1988       case METHOD_TYPE:
1989         break;
1990       case IDENTIFIER_NODE:
1991         fntype = NULL_TREE;
1992         break;
1993       default:
1994         /* We don't expect other tree types here.  */
1995         gcc_unreachable ();
1996       }
1997
1998   if (VOID_TYPE_P (type))
1999     return 0;
2000
2001   /* If a record should be passed the same as its first (and only) member
2002      don't pass it as an aggregate.  */
2003   if (TREE_CODE (type) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type))
2004     return aggregate_value_p (first_field (type), fntype);
2005
2006   /* If the front end has decided that this needs to be passed by
2007      reference, do so.  */
2008   if ((TREE_CODE (exp) == PARM_DECL || TREE_CODE (exp) == RESULT_DECL)
2009       && DECL_BY_REFERENCE (exp))
2010     return 1;
2011
2012   /* Function types that are TREE_ADDRESSABLE force return in memory.  */
2013   if (fntype && TREE_ADDRESSABLE (fntype))
2014     return 1;
2015
2016   /* Types that are TREE_ADDRESSABLE must be constructed in memory,
2017      and thus can't be returned in registers.  */
2018   if (TREE_ADDRESSABLE (type))
2019     return 1;
2020
2021   if (flag_pcc_struct_return && AGGREGATE_TYPE_P (type))
2022     return 1;
2023
2024   if (targetm.calls.return_in_memory (type, fntype))
2025     return 1;
2026
2027   /* Make sure we have suitable call-clobbered regs to return
2028      the value in; if not, we must return it in memory.  */
2029   reg = hard_function_value (type, 0, fntype, 0);
2030
2031   /* If we have something other than a REG (e.g. a PARALLEL), then assume
2032      it is OK.  */
2033   if (!REG_P (reg))
2034     return 0;
2035
2036   regno = REGNO (reg);
2037   nregs = hard_regno_nregs[regno][TYPE_MODE (type)];
2038   for (i = 0; i < nregs; i++)
2039     if (! call_used_regs[regno + i])
2040       return 1;
2041
2042   return 0;
2043 }
2044 \f
2045 /* Return true if we should assign DECL a pseudo register; false if it
2046    should live on the local stack.  */
2047
2048 bool
2049 use_register_for_decl (const_tree decl)
2050 {
2051   if (!targetm.calls.allocate_stack_slots_for_args())
2052     return true;
2053
2054   /* Honor volatile.  */
2055   if (TREE_SIDE_EFFECTS (decl))
2056     return false;
2057
2058   /* Honor addressability.  */
2059   if (TREE_ADDRESSABLE (decl))
2060     return false;
2061
2062   /* Only register-like things go in registers.  */
2063   if (DECL_MODE (decl) == BLKmode)
2064     return false;
2065
2066   /* If -ffloat-store specified, don't put explicit float variables
2067      into registers.  */
2068   /* ??? This should be checked after DECL_ARTIFICIAL, but tree-ssa
2069      propagates values across these stores, and it probably shouldn't.  */
2070   if (flag_float_store && FLOAT_TYPE_P (TREE_TYPE (decl)))
2071     return false;
2072
2073   /* If we're not interested in tracking debugging information for
2074      this decl, then we can certainly put it in a register.  */
2075   if (DECL_IGNORED_P (decl))
2076     return true;
2077
2078   if (optimize)
2079     return true;
2080
2081   if (!DECL_REGISTER (decl))
2082     return false;
2083
2084   switch (TREE_CODE (TREE_TYPE (decl)))
2085     {
2086     case RECORD_TYPE:
2087     case UNION_TYPE:
2088     case QUAL_UNION_TYPE:
2089       /* When not optimizing, disregard register keyword for variables with
2090          types containing methods, otherwise the methods won't be callable
2091          from the debugger.  */
2092       if (TYPE_METHODS (TREE_TYPE (decl)))
2093         return false;
2094       break;
2095     default:
2096       break;
2097     }
2098
2099   return true;
2100 }
2101
2102 /* Return true if TYPE should be passed by invisible reference.  */
2103
2104 bool
2105 pass_by_reference (CUMULATIVE_ARGS *ca, enum machine_mode mode,
2106                    tree type, bool named_arg)
2107 {
2108   if (type)
2109     {
2110       /* If this type contains non-trivial constructors, then it is
2111          forbidden for the middle-end to create any new copies.  */
2112       if (TREE_ADDRESSABLE (type))
2113         return true;
2114
2115       /* GCC post 3.4 passes *all* variable sized types by reference.  */
2116       if (!TYPE_SIZE (type) || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
2117         return true;
2118
2119       /* If a record type should be passed the same as its first (and only)
2120          member, use the type and mode of that member.  */
2121       if (TREE_CODE (type) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type))
2122         {
2123           type = TREE_TYPE (first_field (type));
2124           mode = TYPE_MODE (type);
2125         }
2126     }
2127
2128   return targetm.calls.pass_by_reference (pack_cumulative_args (ca), mode,
2129                                           type, named_arg);
2130 }
2131
2132 /* Return true if TYPE, which is passed by reference, should be callee
2133    copied instead of caller copied.  */
2134
2135 bool
2136 reference_callee_copied (CUMULATIVE_ARGS *ca, enum machine_mode mode,
2137                          tree type, bool named_arg)
2138 {
2139   if (type && TREE_ADDRESSABLE (type))
2140     return false;
2141   return targetm.calls.callee_copies (pack_cumulative_args (ca), mode, type,
2142                                       named_arg);
2143 }
2144
2145 /* Structures to communicate between the subroutines of assign_parms.
2146    The first holds data persistent across all parameters, the second
2147    is cleared out for each parameter.  */
2148
2149 struct assign_parm_data_all
2150 {
2151   /* When INIT_CUMULATIVE_ARGS gets revamped, allocating CUMULATIVE_ARGS
2152      should become a job of the target or otherwise encapsulated.  */
2153   CUMULATIVE_ARGS args_so_far_v;
2154   cumulative_args_t args_so_far;
2155   struct args_size stack_args_size;
2156   tree function_result_decl;
2157   tree orig_fnargs;
2158   rtx first_conversion_insn;
2159   rtx last_conversion_insn;
2160   HOST_WIDE_INT pretend_args_size;
2161   HOST_WIDE_INT extra_pretend_bytes;
2162   int reg_parm_stack_space;
2163 };
2164
2165 struct assign_parm_data_one
2166 {
2167   tree nominal_type;
2168   tree passed_type;
2169   rtx entry_parm;
2170   rtx stack_parm;
2171   enum machine_mode nominal_mode;
2172   enum machine_mode passed_mode;
2173   enum machine_mode promoted_mode;
2174   struct locate_and_pad_arg_data locate;
2175   int partial;
2176   BOOL_BITFIELD named_arg : 1;
2177   BOOL_BITFIELD passed_pointer : 1;
2178   BOOL_BITFIELD on_stack : 1;
2179   BOOL_BITFIELD loaded_in_reg : 1;
2180 };
2181
2182 /* A subroutine of assign_parms.  Initialize ALL.  */
2183
2184 static void
2185 assign_parms_initialize_all (struct assign_parm_data_all *all)
2186 {
2187   tree fntype ATTRIBUTE_UNUSED;
2188
2189   memset (all, 0, sizeof (*all));
2190
2191   fntype = TREE_TYPE (current_function_decl);
2192
2193 #ifdef INIT_CUMULATIVE_INCOMING_ARGS
2194   INIT_CUMULATIVE_INCOMING_ARGS (all->args_so_far_v, fntype, NULL_RTX);
2195 #else
2196   INIT_CUMULATIVE_ARGS (all->args_so_far_v, fntype, NULL_RTX,
2197                         current_function_decl, -1);
2198 #endif
2199   all->args_so_far = pack_cumulative_args (&all->args_so_far_v);
2200
2201 #ifdef REG_PARM_STACK_SPACE
2202   all->reg_parm_stack_space = REG_PARM_STACK_SPACE (current_function_decl);
2203 #endif
2204 }
2205
2206 /* If ARGS contains entries with complex types, split the entry into two
2207    entries of the component type.  Return a new list of substitutions are
2208    needed, else the old list.  */
2209
2210 static void
2211 split_complex_args (VEC(tree, heap) **args)
2212 {
2213   unsigned i;
2214   tree p;
2215
2216   FOR_EACH_VEC_ELT (tree, *args, i, p)
2217     {
2218       tree type = TREE_TYPE (p);
2219       if (TREE_CODE (type) == COMPLEX_TYPE
2220           && targetm.calls.split_complex_arg (type))
2221         {
2222           tree decl;
2223           tree subtype = TREE_TYPE (type);
2224           bool addressable = TREE_ADDRESSABLE (p);
2225
2226           /* Rewrite the PARM_DECL's type with its component.  */
2227           p = copy_node (p);
2228           TREE_TYPE (p) = subtype;
2229           DECL_ARG_TYPE (p) = TREE_TYPE (DECL_ARG_TYPE (p));
2230           DECL_MODE (p) = VOIDmode;
2231           DECL_SIZE (p) = NULL;
2232           DECL_SIZE_UNIT (p) = NULL;
2233           /* If this arg must go in memory, put it in a pseudo here.
2234              We can't allow it to go in memory as per normal parms,
2235              because the usual place might not have the imag part
2236              adjacent to the real part.  */
2237           DECL_ARTIFICIAL (p) = addressable;
2238           DECL_IGNORED_P (p) = addressable;
2239           TREE_ADDRESSABLE (p) = 0;
2240           layout_decl (p, 0);
2241           VEC_replace (tree, *args, i, p);
2242
2243           /* Build a second synthetic decl.  */
2244           decl = build_decl (EXPR_LOCATION (p),
2245                              PARM_DECL, NULL_TREE, subtype);
2246           DECL_ARG_TYPE (decl) = DECL_ARG_TYPE (p);
2247           DECL_ARTIFICIAL (decl) = addressable;
2248           DECL_IGNORED_P (decl) = addressable;
2249           layout_decl (decl, 0);
2250           VEC_safe_insert (tree, heap, *args, ++i, decl);
2251         }
2252     }
2253 }
2254
2255 /* A subroutine of assign_parms.  Adjust the parameter list to incorporate
2256    the hidden struct return argument, and (abi willing) complex args.
2257    Return the new parameter list.  */
2258
2259 static VEC(tree, heap) *
2260 assign_parms_augmented_arg_list (struct assign_parm_data_all *all)
2261 {
2262   tree fndecl = current_function_decl;
2263   tree fntype = TREE_TYPE (fndecl);
2264   VEC(tree, heap) *fnargs = NULL;
2265   tree arg;
2266
2267   for (arg = DECL_ARGUMENTS (fndecl); arg; arg = DECL_CHAIN (arg))
2268     VEC_safe_push (tree, heap, fnargs, arg);
2269
2270   all->orig_fnargs = DECL_ARGUMENTS (fndecl);
2271
2272   /* If struct value address is treated as the first argument, make it so.  */
2273   if (aggregate_value_p (DECL_RESULT (fndecl), fndecl)
2274       && ! cfun->returns_pcc_struct
2275       && targetm.calls.struct_value_rtx (TREE_TYPE (fndecl), 1) == 0)
2276     {
2277       tree type = build_pointer_type (TREE_TYPE (fntype));
2278       tree decl;
2279
2280       decl = build_decl (DECL_SOURCE_LOCATION (fndecl),
2281                          PARM_DECL, get_identifier (".result_ptr"), type);
2282       DECL_ARG_TYPE (decl) = type;
2283       DECL_ARTIFICIAL (decl) = 1;
2284       DECL_NAMELESS (decl) = 1;
2285       TREE_CONSTANT (decl) = 1;
2286
2287       DECL_CHAIN (decl) = all->orig_fnargs;
2288       all->orig_fnargs = decl;
2289       VEC_safe_insert (tree, heap, fnargs, 0, decl);
2290
2291       all->function_result_decl = decl;
2292     }
2293
2294   /* If the target wants to split complex arguments into scalars, do so.  */
2295   if (targetm.calls.split_complex_arg)
2296     split_complex_args (&fnargs);
2297
2298   return fnargs;
2299 }
2300
2301 /* A subroutine of assign_parms.  Examine PARM and pull out type and mode
2302    data for the parameter.  Incorporate ABI specifics such as pass-by-
2303    reference and type promotion.  */
2304
2305 static void
2306 assign_parm_find_data_types (struct assign_parm_data_all *all, tree parm,
2307                              struct assign_parm_data_one *data)
2308 {
2309   tree nominal_type, passed_type;
2310   enum machine_mode nominal_mode, passed_mode, promoted_mode;
2311   int unsignedp;
2312
2313   memset (data, 0, sizeof (*data));
2314
2315   /* NAMED_ARG is a misnomer.  We really mean 'non-variadic'. */
2316   if (!cfun->stdarg)
2317     data->named_arg = 1;  /* No variadic parms.  */
2318   else if (DECL_CHAIN (parm))
2319     data->named_arg = 1;  /* Not the last non-variadic parm. */
2320   else if (targetm.calls.strict_argument_naming (all->args_so_far))
2321     data->named_arg = 1;  /* Only variadic ones are unnamed.  */
2322   else
2323     data->named_arg = 0;  /* Treat as variadic.  */
2324
2325   nominal_type = TREE_TYPE (parm);
2326   passed_type = DECL_ARG_TYPE (parm);
2327
2328   /* Look out for errors propagating this far.  Also, if the parameter's
2329      type is void then its value doesn't matter.  */
2330   if (TREE_TYPE (parm) == error_mark_node
2331       /* This can happen after weird syntax errors
2332          or if an enum type is defined among the parms.  */
2333       || TREE_CODE (parm) != PARM_DECL
2334       || passed_type == NULL
2335       || VOID_TYPE_P (nominal_type))
2336     {
2337       nominal_type = passed_type = void_type_node;
2338       nominal_mode = passed_mode = promoted_mode = VOIDmode;
2339       goto egress;
2340     }
2341
2342   /* Find mode of arg as it is passed, and mode of arg as it should be
2343      during execution of this function.  */
2344   passed_mode = TYPE_MODE (passed_type);
2345   nominal_mode = TYPE_MODE (nominal_type);
2346
2347   /* If the parm is to be passed as a transparent union or record, use the
2348      type of the first field for the tests below.  We have already verified
2349      that the modes are the same.  */
2350   if ((TREE_CODE (passed_type) == UNION_TYPE
2351        || TREE_CODE (passed_type) == RECORD_TYPE)
2352       && TYPE_TRANSPARENT_AGGR (passed_type))
2353     passed_type = TREE_TYPE (first_field (passed_type));
2354
2355   /* See if this arg was passed by invisible reference.  */
2356   if (pass_by_reference (&all->args_so_far_v, passed_mode,
2357                          passed_type, data->named_arg))
2358     {
2359       passed_type = nominal_type = build_pointer_type (passed_type);
2360       data->passed_pointer = true;
2361       passed_mode = nominal_mode = Pmode;
2362     }
2363
2364   /* Find mode as it is passed by the ABI.  */
2365   unsignedp = TYPE_UNSIGNED (passed_type);
2366   promoted_mode = promote_function_mode (passed_type, passed_mode, &unsignedp,
2367                                          TREE_TYPE (current_function_decl), 0);
2368
2369  egress:
2370   data->nominal_type = nominal_type;
2371   data->passed_type = passed_type;
2372   data->nominal_mode = nominal_mode;
2373   data->passed_mode = passed_mode;
2374   data->promoted_mode = promoted_mode;
2375 }
2376
2377 /* A subroutine of assign_parms.  Invoke setup_incoming_varargs.  */
2378
2379 static void
2380 assign_parms_setup_varargs (struct assign_parm_data_all *all,
2381                             struct assign_parm_data_one *data, bool no_rtl)
2382 {
2383   int varargs_pretend_bytes = 0;
2384
2385   targetm.calls.setup_incoming_varargs (all->args_so_far,
2386                                         data->promoted_mode,
2387                                         data->passed_type,
2388                                         &varargs_pretend_bytes, no_rtl);
2389
2390   /* If the back-end has requested extra stack space, record how much is
2391      needed.  Do not change pretend_args_size otherwise since it may be
2392      nonzero from an earlier partial argument.  */
2393   if (varargs_pretend_bytes > 0)
2394     all->pretend_args_size = varargs_pretend_bytes;
2395 }
2396
2397 /* A subroutine of assign_parms.  Set DATA->ENTRY_PARM corresponding to
2398    the incoming location of the current parameter.  */
2399
2400 static void
2401 assign_parm_find_entry_rtl (struct assign_parm_data_all *all,
2402                             struct assign_parm_data_one *data)
2403 {
2404   HOST_WIDE_INT pretend_bytes = 0;
2405   rtx entry_parm;
2406   bool in_regs;
2407
2408   if (data->promoted_mode == VOIDmode)
2409     {
2410       data->entry_parm = data->stack_parm = const0_rtx;
2411       return;
2412     }
2413
2414   entry_parm = targetm.calls.function_incoming_arg (all->args_so_far,
2415                                                     data->promoted_mode,
2416                                                     data->passed_type,
2417                                                     data->named_arg);
2418
2419   if (entry_parm == 0)
2420     data->promoted_mode = data->passed_mode;
2421
2422   /* Determine parm's home in the stack, in case it arrives in the stack
2423      or we should pretend it did.  Compute the stack position and rtx where
2424      the argument arrives and its size.
2425
2426      There is one complexity here:  If this was a parameter that would
2427      have been passed in registers, but wasn't only because it is
2428      __builtin_va_alist, we want locate_and_pad_parm to treat it as if
2429      it came in a register so that REG_PARM_STACK_SPACE isn't skipped.
2430      In this case, we call FUNCTION_ARG with NAMED set to 1 instead of 0
2431      as it was the previous time.  */
2432   in_regs = entry_parm != 0;
2433 #ifdef STACK_PARMS_IN_REG_PARM_AREA
2434   in_regs = true;
2435 #endif
2436   if (!in_regs && !data->named_arg)
2437     {
2438       if (targetm.calls.pretend_outgoing_varargs_named (all->args_so_far))
2439         {
2440           rtx tem;
2441           tem = targetm.calls.function_incoming_arg (all->args_so_far,
2442                                                      data->promoted_mode,
2443                                                      data->passed_type, true);
2444           in_regs = tem != NULL;
2445         }
2446     }
2447
2448   /* If this parameter was passed both in registers and in the stack, use
2449      the copy on the stack.  */
2450   if (targetm.calls.must_pass_in_stack (data->promoted_mode,
2451                                         data->passed_type))
2452     entry_parm = 0;
2453
2454   if (entry_parm)
2455     {
2456       int partial;
2457
2458       partial = targetm.calls.arg_partial_bytes (all->args_so_far,
2459                                                  data->promoted_mode,
2460                                                  data->passed_type,
2461                                                  data->named_arg);
2462       data->partial = partial;
2463
2464       /* The caller might already have allocated stack space for the
2465          register parameters.  */
2466       if (partial != 0 && all->reg_parm_stack_space == 0)
2467         {
2468           /* Part of this argument is passed in registers and part
2469              is passed on the stack.  Ask the prologue code to extend
2470              the stack part so that we can recreate the full value.
2471
2472              PRETEND_BYTES is the size of the registers we need to store.
2473              CURRENT_FUNCTION_PRETEND_ARGS_SIZE is the amount of extra
2474              stack space that the prologue should allocate.
2475
2476              Internally, gcc assumes that the argument pointer is aligned
2477              to STACK_BOUNDARY bits.  This is used both for alignment
2478              optimizations (see init_emit) and to locate arguments that are
2479              aligned to more than PARM_BOUNDARY bits.  We must preserve this
2480              invariant by rounding CURRENT_FUNCTION_PRETEND_ARGS_SIZE up to
2481              a stack boundary.  */
2482
2483           /* We assume at most one partial arg, and it must be the first
2484              argument on the stack.  */
2485           gcc_assert (!all->extra_pretend_bytes && !all->pretend_args_size);
2486
2487           pretend_bytes = partial;
2488           all->pretend_args_size = CEIL_ROUND (pretend_bytes, STACK_BYTES);
2489
2490           /* We want to align relative to the actual stack pointer, so
2491              don't include this in the stack size until later.  */
2492           all->extra_pretend_bytes = all->pretend_args_size;
2493         }
2494     }
2495
2496   locate_and_pad_parm (data->promoted_mode, data->passed_type, in_regs,
2497                        entry_parm ? data->partial : 0, current_function_decl,
2498                        &all->stack_args_size, &data->locate);
2499
2500   /* Update parm_stack_boundary if this parameter is passed in the
2501      stack.  */
2502   if (!in_regs && crtl->parm_stack_boundary < data->locate.boundary)
2503     crtl->parm_stack_boundary = data->locate.boundary;
2504
2505   /* Adjust offsets to include the pretend args.  */
2506   pretend_bytes = all->extra_pretend_bytes - pretend_bytes;
2507   data->locate.slot_offset.constant += pretend_bytes;
2508   data->locate.offset.constant += pretend_bytes;
2509
2510   data->entry_parm = entry_parm;
2511 }
2512
2513 /* A subroutine of assign_parms.  If there is actually space on the stack
2514    for this parm, count it in stack_args_size and return true.  */
2515
2516 static bool
2517 assign_parm_is_stack_parm (struct assign_parm_data_all *all,
2518                            struct assign_parm_data_one *data)
2519 {
2520   /* Trivially true if we've no incoming register.  */
2521   if (data->entry_parm == NULL)
2522     ;
2523   /* Also true if we're partially in registers and partially not,
2524      since we've arranged to drop the entire argument on the stack.  */
2525   else if (data->partial != 0)
2526     ;
2527   /* Also true if the target says that it's passed in both registers
2528      and on the stack.  */
2529   else if (GET_CODE (data->entry_parm) == PARALLEL
2530            && XEXP (XVECEXP (data->entry_parm, 0, 0), 0) == NULL_RTX)
2531     ;
2532   /* Also true if the target says that there's stack allocated for
2533      all register parameters.  */
2534   else if (all->reg_parm_stack_space > 0)
2535     ;
2536   /* Otherwise, no, this parameter has no ABI defined stack slot.  */
2537   else
2538     return false;
2539
2540   all->stack_args_size.constant += data->locate.size.constant;
2541   if (data->locate.size.var)
2542     ADD_PARM_SIZE (all->stack_args_size, data->locate.size.var);
2543
2544   return true;
2545 }
2546
2547 /* A subroutine of assign_parms.  Given that this parameter is allocated
2548    stack space by the ABI, find it.  */
2549
2550 static void
2551 assign_parm_find_stack_rtl (tree parm, struct assign_parm_data_one *data)
2552 {
2553   rtx offset_rtx, stack_parm;
2554   unsigned int align, boundary;
2555
2556   /* If we're passing this arg using a reg, make its stack home the
2557      aligned stack slot.  */
2558   if (data->entry_parm)
2559     offset_rtx = ARGS_SIZE_RTX (data->locate.slot_offset);
2560   else
2561     offset_rtx = ARGS_SIZE_RTX (data->locate.offset);
2562
2563   stack_parm = crtl->args.internal_arg_pointer;
2564   if (offset_rtx != const0_rtx)
2565     stack_parm = gen_rtx_PLUS (Pmode, stack_parm, offset_rtx);
2566   stack_parm = gen_rtx_MEM (data->promoted_mode, stack_parm);
2567
2568   if (!data->passed_pointer)
2569     {
2570       set_mem_attributes (stack_parm, parm, 1);
2571       /* set_mem_attributes could set MEM_SIZE to the passed mode's size,
2572          while promoted mode's size is needed.  */
2573       if (data->promoted_mode != BLKmode
2574           && data->promoted_mode != DECL_MODE (parm))
2575         {
2576           set_mem_size (stack_parm, GET_MODE_SIZE (data->promoted_mode));
2577           if (MEM_EXPR (stack_parm) && MEM_OFFSET_KNOWN_P (stack_parm))
2578             {
2579               int offset = subreg_lowpart_offset (DECL_MODE (parm),
2580                                                   data->promoted_mode);
2581               if (offset)
2582                 set_mem_offset (stack_parm, MEM_OFFSET (stack_parm) - offset);
2583             }
2584         }
2585     }
2586
2587   boundary = data->locate.boundary;
2588   align = BITS_PER_UNIT;
2589
2590   /* If we're padding upward, we know that the alignment of the slot
2591      is TARGET_FUNCTION_ARG_BOUNDARY.  If we're using slot_offset, we're
2592      intentionally forcing upward padding.  Otherwise we have to come
2593      up with a guess at the alignment based on OFFSET_RTX.  */
2594   if (data->locate.where_pad != downward || data->entry_parm)
2595     align = boundary;
2596   else if (CONST_INT_P (offset_rtx))
2597     {
2598       align = INTVAL (offset_rtx) * BITS_PER_UNIT | boundary;
2599       align = align & -align;
2600     }
2601   set_mem_align (stack_parm, align);
2602
2603   if (data->entry_parm)
2604     set_reg_attrs_for_parm (data->entry_parm, stack_parm);
2605
2606   data->stack_parm = stack_parm;
2607 }
2608
2609 /* A subroutine of assign_parms.  Adjust DATA->ENTRY_RTL such that it's
2610    always valid and contiguous.  */
2611
2612 static void
2613 assign_parm_adjust_entry_rtl (struct assign_parm_data_one *data)
2614 {
2615   rtx entry_parm = data->entry_parm;
2616   rtx stack_parm = data->stack_parm;
2617
2618   /* If this parm was passed part in regs and part in memory, pretend it
2619      arrived entirely in memory by pushing the register-part onto the stack.
2620      In the special case of a DImode or DFmode that is split, we could put
2621      it together in a pseudoreg directly, but for now that's not worth
2622      bothering with.  */
2623   if (data->partial != 0)
2624     {
2625       /* Handle calls that pass values in multiple non-contiguous
2626          locations.  The Irix 6 ABI has examples of this.  */
2627       if (GET_CODE (entry_parm) == PARALLEL)
2628         emit_group_store (validize_mem (stack_parm), entry_parm,
2629                           data->passed_type,
2630                           int_size_in_bytes (data->passed_type));
2631       else
2632         {
2633           gcc_assert (data->partial % UNITS_PER_WORD == 0);
2634           move_block_from_reg (REGNO (entry_parm), validize_mem (stack_parm),
2635                                data->partial / UNITS_PER_WORD);
2636         }
2637
2638       entry_parm = stack_parm;
2639     }
2640
2641   /* If we didn't decide this parm came in a register, by default it came
2642      on the stack.  */
2643   else if (entry_parm == NULL)
2644     entry_parm = stack_parm;
2645
2646   /* When an argument is passed in multiple locations, we can't make use
2647      of this information, but we can save some copying if the whole argument
2648      is passed in a single register.  */
2649   else if (GET_CODE (entry_parm) == PARALLEL
2650            && data->nominal_mode != BLKmode
2651            && data->passed_mode != BLKmode)
2652     {
2653       size_t i, len = XVECLEN (entry_parm, 0);
2654
2655       for (i = 0; i < len; i++)
2656         if (XEXP (XVECEXP (entry_parm, 0, i), 0) != NULL_RTX
2657             && REG_P (XEXP (XVECEXP (entry_parm, 0, i), 0))
2658             && (GET_MODE (XEXP (XVECEXP (entry_parm, 0, i), 0))
2659                 == data->passed_mode)
2660             && INTVAL (XEXP (XVECEXP (entry_parm, 0, i), 1)) == 0)
2661           {
2662             entry_parm = XEXP (XVECEXP (entry_parm, 0, i), 0);
2663             break;
2664           }
2665     }
2666
2667   data->entry_parm = entry_parm;
2668 }
2669
2670 /* A subroutine of assign_parms.  Reconstitute any values which were
2671    passed in multiple registers and would fit in a single register.  */
2672
2673 static void
2674 assign_parm_remove_parallels (struct assign_parm_data_one *data)
2675 {
2676   rtx entry_parm = data->entry_parm;
2677
2678   /* Convert the PARALLEL to a REG of the same mode as the parallel.
2679      This can be done with register operations rather than on the
2680      stack, even if we will store the reconstituted parameter on the
2681      stack later.  */
2682   if (GET_CODE (entry_parm) == PARALLEL && GET_MODE (entry_parm) != BLKmode)
2683     {
2684       rtx parmreg = gen_reg_rtx (GET_MODE (entry_parm));
2685       emit_group_store (parmreg, entry_parm, data->passed_type,
2686                         GET_MODE_SIZE (GET_MODE (entry_parm)));
2687       entry_parm = parmreg;
2688     }
2689
2690   data->entry_parm = entry_parm;
2691 }
2692
2693 /* A subroutine of assign_parms.  Adjust DATA->STACK_RTL such that it's
2694    always valid and properly aligned.  */
2695
2696 static void
2697 assign_parm_adjust_stack_rtl (struct assign_parm_data_one *data)
2698 {
2699   rtx stack_parm = data->stack_parm;
2700
2701   /* If we can't trust the parm stack slot to be aligned enough for its
2702      ultimate type, don't use that slot after entry.  We'll make another
2703      stack slot, if we need one.  */
2704   if (stack_parm
2705       && ((STRICT_ALIGNMENT
2706            && GET_MODE_ALIGNMENT (data->nominal_mode) > MEM_ALIGN (stack_parm))
2707           || (data->nominal_type
2708               && TYPE_ALIGN (data->nominal_type) > MEM_ALIGN (stack_parm)
2709               && MEM_ALIGN (stack_parm) < PREFERRED_STACK_BOUNDARY)))
2710     stack_parm = NULL;
2711
2712   /* If parm was passed in memory, and we need to convert it on entry,
2713      don't store it back in that same slot.  */
2714   else if (data->entry_parm == stack_parm
2715            && data->nominal_mode != BLKmode
2716            && data->nominal_mode != data->passed_mode)
2717     stack_parm = NULL;
2718
2719   /* If stack protection is in effect for this function, don't leave any
2720      pointers in their passed stack slots.  */
2721   else if (crtl->stack_protect_guard
2722            && (flag_stack_protect == 2
2723                || data->passed_pointer
2724                || POINTER_TYPE_P (data->nominal_type)))
2725     stack_parm = NULL;
2726
2727   data->stack_parm = stack_parm;
2728 }
2729
2730 /* A subroutine of assign_parms.  Return true if the current parameter
2731    should be stored as a BLKmode in the current frame.  */
2732
2733 static bool
2734 assign_parm_setup_block_p (struct assign_parm_data_one *data)
2735 {
2736   if (data->nominal_mode == BLKmode)
2737     return true;
2738   if (GET_MODE (data->entry_parm) == BLKmode)
2739     return true;
2740
2741 #ifdef BLOCK_REG_PADDING
2742   /* Only assign_parm_setup_block knows how to deal with register arguments
2743      that are padded at the least significant end.  */
2744   if (REG_P (data->entry_parm)
2745       && GET_MODE_SIZE (data->promoted_mode) < UNITS_PER_WORD
2746       && (BLOCK_REG_PADDING (data->passed_mode, data->passed_type, 1)
2747           == (BYTES_BIG_ENDIAN ? upward : downward)))
2748     return true;
2749 #endif
2750
2751   return false;
2752 }
2753
2754 /* A subroutine of assign_parms.  Arrange for the parameter to be
2755    present and valid in DATA->STACK_RTL.  */
2756
2757 static void
2758 assign_parm_setup_block (struct assign_parm_data_all *all,
2759                          tree parm, struct assign_parm_data_one *data)
2760 {
2761   rtx entry_parm = data->entry_parm;
2762   rtx stack_parm = data->stack_parm;
2763   HOST_WIDE_INT size;
2764   HOST_WIDE_INT size_stored;
2765
2766   if (GET_CODE (entry_parm) == PARALLEL)
2767     entry_parm = emit_group_move_into_temps (entry_parm);
2768
2769   size = int_size_in_bytes (data->passed_type);
2770   size_stored = CEIL_ROUND (size, UNITS_PER_WORD);
2771   if (stack_parm == 0)
2772     {
2773       DECL_ALIGN (parm) = MAX (DECL_ALIGN (parm), BITS_PER_WORD);
2774       stack_parm = assign_stack_local (BLKmode, size_stored,
2775                                        DECL_ALIGN (parm));
2776       if (GET_MODE_SIZE (GET_MODE (entry_parm)) == size)
2777         PUT_MODE (stack_parm, GET_MODE (entry_parm));
2778       set_mem_attributes (stack_parm, parm, 1);
2779     }
2780
2781   /* If a BLKmode arrives in registers, copy it to a stack slot.  Handle
2782      calls that pass values in multiple non-contiguous locations.  */
2783   if (REG_P (entry_parm) || GET_CODE (entry_parm) == PARALLEL)
2784     {
2785       rtx mem;
2786
2787       /* Note that we will be storing an integral number of words.
2788          So we have to be careful to ensure that we allocate an
2789          integral number of words.  We do this above when we call
2790          assign_stack_local if space was not allocated in the argument
2791          list.  If it was, this will not work if PARM_BOUNDARY is not
2792          a multiple of BITS_PER_WORD.  It isn't clear how to fix this
2793          if it becomes a problem.  Exception is when BLKmode arrives
2794          with arguments not conforming to word_mode.  */
2795
2796       if (data->stack_parm == 0)
2797         ;
2798       else if (GET_CODE (entry_parm) == PARALLEL)
2799         ;
2800       else
2801         gcc_assert (!size || !(PARM_BOUNDARY % BITS_PER_WORD));
2802
2803       mem = validize_mem (stack_parm);
2804
2805       /* Handle values in multiple non-contiguous locations.  */
2806       if (GET_CODE (entry_parm) == PARALLEL)
2807         {
2808           push_to_sequence2 (all->first_conversion_insn,
2809                              all->last_conversion_insn);
2810           emit_group_store (mem, entry_parm, data->passed_type, size);
2811           all->first_conversion_insn = get_insns ();
2812           all->last_conversion_insn = get_last_insn ();
2813           end_sequence ();
2814         }
2815
2816       else if (size == 0)
2817         ;
2818
2819       /* If SIZE is that of a mode no bigger than a word, just use
2820          that mode's store operation.  */
2821       else if (size <= UNITS_PER_WORD)
2822         {
2823           enum machine_mode mode
2824             = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
2825
2826           if (mode != BLKmode
2827 #ifdef BLOCK_REG_PADDING
2828               && (size == UNITS_PER_WORD
2829                   || (BLOCK_REG_PADDING (mode, data->passed_type, 1)
2830                       != (BYTES_BIG_ENDIAN ? upward : downward)))
2831 #endif
2832               )
2833             {
2834               rtx reg;
2835
2836               /* We are really truncating a word_mode value containing
2837                  SIZE bytes into a value of mode MODE.  If such an
2838                  operation requires no actual instructions, we can refer
2839                  to the value directly in mode MODE, otherwise we must
2840                  start with the register in word_mode and explicitly
2841                  convert it.  */
2842               if (TRULY_NOOP_TRUNCATION (size * BITS_PER_UNIT, BITS_PER_WORD))
2843                 reg = gen_rtx_REG (mode, REGNO (entry_parm));
2844               else
2845                 {
2846                   reg = gen_rtx_REG (word_mode, REGNO (entry_parm));
2847                   reg = convert_to_mode (mode, copy_to_reg (reg), 1);
2848                 }
2849               emit_move_insn (change_address (mem, mode, 0), reg);
2850             }
2851
2852           /* Blocks smaller than a word on a BYTES_BIG_ENDIAN
2853              machine must be aligned to the left before storing
2854              to memory.  Note that the previous test doesn't
2855              handle all cases (e.g. SIZE == 3).  */
2856           else if (size != UNITS_PER_WORD
2857 #ifdef BLOCK_REG_PADDING
2858                    && (BLOCK_REG_PADDING (mode, data->passed_type, 1)
2859                        == downward)
2860 #else
2861                    && BYTES_BIG_ENDIAN
2862 #endif
2863                    )
2864             {
2865               rtx tem, x;
2866               int by = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
2867               rtx reg = gen_rtx_REG (word_mode, REGNO (entry_parm));
2868
2869               x = expand_shift (LSHIFT_EXPR, word_mode, reg, by, NULL_RTX, 1);
2870               tem = change_address (mem, word_mode, 0);
2871               emit_move_insn (tem, x);
2872             }
2873           else
2874             move_block_from_reg (REGNO (entry_parm), mem,
2875                                  size_stored / UNITS_PER_WORD);
2876         }
2877       else
2878         move_block_from_reg (REGNO (entry_parm), mem,
2879                              size_stored / UNITS_PER_WORD);
2880     }
2881   else if (data->stack_parm == 0)
2882     {
2883       push_to_sequence2 (all->first_conversion_insn, all->last_conversion_insn);
2884       emit_block_move (stack_parm, data->entry_parm, GEN_INT (size),
2885                        BLOCK_OP_NORMAL);
2886       all->first_conversion_insn = get_insns ();
2887       all->last_conversion_insn = get_last_insn ();
2888       end_sequence ();
2889     }
2890
2891   data->stack_parm = stack_parm;
2892   SET_DECL_RTL (parm, stack_parm);
2893 }
2894
2895 /* A subroutine of assign_parms.  Allocate a pseudo to hold the current
2896    parameter.  Get it there.  Perform all ABI specified conversions.  */
2897
2898 static void
2899 assign_parm_setup_reg (struct assign_parm_data_all *all, tree parm,
2900                        struct assign_parm_data_one *data)
2901 {
2902   rtx parmreg, validated_mem;
2903   rtx equiv_stack_parm;
2904   enum machine_mode promoted_nominal_mode;
2905   int unsignedp = TYPE_UNSIGNED (TREE_TYPE (parm));
2906   bool did_conversion = false;
2907   bool need_conversion, moved;
2908
2909   /* Store the parm in a pseudoregister during the function, but we may
2910      need to do it in a wider mode.  Using 2 here makes the result
2911      consistent with promote_decl_mode and thus expand_expr_real_1.  */
2912   promoted_nominal_mode
2913     = promote_function_mode (data->nominal_type, data->nominal_mode, &unsignedp,
2914                              TREE_TYPE (current_function_decl), 2);
2915
2916   parmreg = gen_reg_rtx (promoted_nominal_mode);
2917
2918   if (!DECL_ARTIFICIAL (parm))
2919     mark_user_reg (parmreg);
2920
2921   /* If this was an item that we received a pointer to,
2922      set DECL_RTL appropriately.  */
2923   if (data->passed_pointer)
2924     {
2925       rtx x = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data->passed_type)), parmreg);
2926       set_mem_attributes (x, parm, 1);
2927       SET_DECL_RTL (parm, x);
2928     }
2929   else
2930     SET_DECL_RTL (parm, parmreg);
2931
2932   assign_parm_remove_parallels (data);
2933
2934   /* Copy the value into the register, thus bridging between
2935      assign_parm_find_data_types and expand_expr_real_1.  */
2936
2937   equiv_stack_parm = data->stack_parm;
2938   validated_mem = validize_mem (data->entry_parm);
2939
2940   need_conversion = (data->nominal_mode != data->passed_mode
2941                      || promoted_nominal_mode != data->promoted_mode);
2942   moved = false;
2943
2944   if (need_conversion
2945       && GET_MODE_CLASS (data->nominal_mode) == MODE_INT
2946       && data->nominal_mode == data->passed_mode
2947       && data->nominal_mode == GET_MODE (data->entry_parm))
2948     {
2949       /* ENTRY_PARM has been converted to PROMOTED_MODE, its
2950          mode, by the caller.  We now have to convert it to
2951          NOMINAL_MODE, if different.  However, PARMREG may be in
2952          a different mode than NOMINAL_MODE if it is being stored
2953          promoted.
2954
2955          If ENTRY_PARM is a hard register, it might be in a register
2956          not valid for operating in its mode (e.g., an odd-numbered
2957          register for a DFmode).  In that case, moves are the only
2958          thing valid, so we can't do a convert from there.  This
2959          occurs when the calling sequence allow such misaligned
2960          usages.
2961
2962          In addition, the conversion may involve a call, which could
2963          clobber parameters which haven't been copied to pseudo
2964          registers yet.
2965
2966          First, we try to emit an insn which performs the necessary
2967          conversion.  We verify that this insn does not clobber any
2968          hard registers.  */
2969
2970       enum insn_code icode;
2971       rtx op0, op1;
2972
2973       icode = can_extend_p (promoted_nominal_mode, data->passed_mode,
2974                             unsignedp);
2975
2976       op0 = parmreg;
2977       op1 = validated_mem;
2978       if (icode != CODE_FOR_nothing
2979           && insn_operand_matches (icode, 0, op0)
2980           && insn_operand_matches (icode, 1, op1))
2981         {
2982           enum rtx_code code = unsignedp ? ZERO_EXTEND : SIGN_EXTEND;
2983           rtx insn, insns;
2984           HARD_REG_SET hardregs;
2985
2986           start_sequence ();
2987           insn = gen_extend_insn (op0, op1, promoted_nominal_mode,
2988                                   data->passed_mode, unsignedp);
2989           emit_insn (insn);
2990           insns = get_insns ();
2991
2992           moved = true;
2993           CLEAR_HARD_REG_SET (hardregs);
2994           for (insn = insns; insn && moved; insn = NEXT_INSN (insn))
2995             {
2996               if (INSN_P (insn))
2997                 note_stores (PATTERN (insn), record_hard_reg_sets,
2998                              &hardregs);
2999               if (!hard_reg_set_empty_p (hardregs))
3000                 moved = false;
3001             }
3002
3003           end_sequence ();
3004
3005           if (moved)
3006             {
3007               emit_insn (insns);
3008               if (equiv_stack_parm != NULL_RTX)
3009                 equiv_stack_parm = gen_rtx_fmt_e (code, GET_MODE (parmreg),
3010                                                   equiv_stack_parm);
3011             }
3012         }
3013     }
3014
3015   if (moved)
3016     /* Nothing to do.  */
3017     ;
3018   else if (need_conversion)
3019     {
3020       /* We did not have an insn to convert directly, or the sequence
3021          generated appeared unsafe.  We must first copy the parm to a
3022          pseudo reg, and save the conversion until after all
3023          parameters have been moved.  */
3024
3025       int save_tree_used;
3026       rtx tempreg = gen_reg_rtx (GET_MODE (data->entry_parm));
3027
3028       emit_move_insn (tempreg, validated_mem);
3029
3030       push_to_sequence2 (all->first_conversion_insn, all->last_conversion_insn);
3031       tempreg = convert_to_mode (data->nominal_mode, tempreg, unsignedp);
3032
3033       if (GET_CODE (tempreg) == SUBREG
3034           && GET_MODE (tempreg) == data->nominal_mode
3035           && REG_P (SUBREG_REG (tempreg))
3036           && data->nominal_mode == data->passed_mode
3037           && GET_MODE (SUBREG_REG (tempreg)) == GET_MODE (data->entry_parm)
3038           && GET_MODE_SIZE (GET_MODE (tempreg))
3039              < GET_MODE_SIZE (GET_MODE (data->entry_parm)))
3040         {
3041           /* The argument is already sign/zero extended, so note it
3042              into the subreg.  */
3043           SUBREG_PROMOTED_VAR_P (tempreg) = 1;
3044           SUBREG_PROMOTED_UNSIGNED_SET (tempreg, unsignedp);
3045         }
3046
3047       /* TREE_USED gets set erroneously during expand_assignment.  */
3048       save_tree_used = TREE_USED (parm);
3049       expand_assignment (parm, make_tree (data->nominal_type, tempreg), false);
3050       TREE_USED (parm) = save_tree_used;
3051       all->first_conversion_insn = get_insns ();
3052       all->last_conversion_insn = get_last_insn ();
3053       end_sequence ();
3054
3055       did_conversion = true;
3056     }
3057   else
3058     emit_move_insn (parmreg, validated_mem);
3059
3060   /* If we were passed a pointer but the actual value can safely live
3061      in a register, put it in one.  */
3062   if (data->passed_pointer
3063       && TYPE_MODE (TREE_TYPE (parm)) != BLKmode
3064       /* If by-reference argument was promoted, demote it.  */
3065       && (TYPE_MODE (TREE_TYPE (parm)) != GET_MODE (DECL_RTL (parm))
3066           || use_register_for_decl (parm)))
3067     {
3068       /* We can't use nominal_mode, because it will have been set to
3069          Pmode above.  We must use the actual mode of the parm.  */
3070       parmreg = gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm)));
3071       mark_user_reg (parmreg);
3072
3073       if (GET_MODE (parmreg) != GET_MODE (DECL_RTL (parm)))
3074         {
3075           rtx tempreg = gen_reg_rtx (GET_MODE (DECL_RTL (parm)));
3076           int unsigned_p = TYPE_UNSIGNED (TREE_TYPE (parm));
3077
3078           push_to_sequence2 (all->first_conversion_insn,
3079                              all->last_conversion_insn);
3080           emit_move_insn (tempreg, DECL_RTL (parm));
3081           tempreg = convert_to_mode (GET_MODE (parmreg), tempreg, unsigned_p);
3082           emit_move_insn (parmreg, tempreg);
3083           all->first_conversion_insn = get_insns ();
3084           all->last_conversion_insn = get_last_insn ();
3085           end_sequence ();
3086
3087           did_conversion = true;
3088         }
3089       else
3090         emit_move_insn (parmreg, DECL_RTL (parm));
3091
3092       SET_DECL_RTL (parm, parmreg);
3093
3094       /* STACK_PARM is the pointer, not the parm, and PARMREG is
3095          now the parm.  */
3096       data->stack_parm = NULL;
3097     }
3098
3099   /* Mark the register as eliminable if we did no conversion and it was
3100      copied from memory at a fixed offset, and the arg pointer was not
3101      copied to a pseudo-reg.  If the arg pointer is a pseudo reg or the
3102      offset formed an invalid address, such memory-equivalences as we
3103      make here would screw up life analysis for it.  */
3104   if (data->nominal_mode == data->passed_mode
3105       && !did_conversion
3106       && data->stack_parm != 0
3107       && MEM_P (data->stack_parm)
3108       && data->locate.offset.var == 0
3109       && reg_mentioned_p (virtual_incoming_args_rtx,
3110                           XEXP (data->stack_parm, 0)))
3111     {
3112       rtx linsn = get_last_insn ();
3113       rtx sinsn, set;
3114
3115       /* Mark complex types separately.  */
3116       if (GET_CODE (parmreg) == CONCAT)
3117         {
3118           enum machine_mode submode
3119             = GET_MODE_INNER (GET_MODE (parmreg));
3120           int regnor = REGNO (XEXP (parmreg, 0));
3121           int regnoi = REGNO (XEXP (parmreg, 1));
3122           rtx stackr = adjust_address_nv (data->stack_parm, submode, 0);
3123           rtx stacki = adjust_address_nv (data->stack_parm, submode,
3124                                           GET_MODE_SIZE (submode));
3125
3126           /* Scan backwards for the set of the real and
3127              imaginary parts.  */
3128           for (sinsn = linsn; sinsn != 0;
3129                sinsn = prev_nonnote_insn (sinsn))
3130             {
3131               set = single_set (sinsn);
3132               if (set == 0)
3133                 continue;
3134
3135               if (SET_DEST (set) == regno_reg_rtx [regnoi])
3136                 set_unique_reg_note (sinsn, REG_EQUIV, stacki);
3137               else if (SET_DEST (set) == regno_reg_rtx [regnor])
3138                 set_unique_reg_note (sinsn, REG_EQUIV, stackr);
3139             }
3140         }
3141       else if ((set = single_set (linsn)) != 0
3142                && SET_DEST (set) == parmreg)
3143         set_unique_reg_note (linsn, REG_EQUIV, equiv_stack_parm);
3144     }
3145
3146   /* For pointer data type, suggest pointer register.  */
3147   if (POINTER_TYPE_P (TREE_TYPE (parm)))
3148     mark_reg_pointer (parmreg,
3149                       TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm))));
3150 }
3151
3152 /* A subroutine of assign_parms.  Allocate stack space to hold the current
3153    parameter.  Get it there.  Perform all ABI specified conversions.  */
3154
3155 static void
3156 assign_parm_setup_stack (struct assign_parm_data_all *all, tree parm,
3157                          struct assign_parm_data_one *data)
3158 {
3159   /* Value must be stored in the stack slot STACK_PARM during function
3160      execution.  */
3161   bool to_conversion = false;
3162
3163   assign_parm_remove_parallels (data);
3164
3165   if (data->promoted_mode != data->nominal_mode)
3166     {
3167       /* Conversion is required.  */
3168       rtx tempreg = gen_reg_rtx (GET_MODE (data->entry_parm));
3169
3170       emit_move_insn (tempreg, validize_mem (data->entry_parm));
3171
3172       push_to_sequence2 (all->first_conversion_insn, all->last_conversion_insn);
3173       to_conversion = true;
3174
3175       data->entry_parm = convert_to_mode (data->nominal_mode, tempreg,
3176                                           TYPE_UNSIGNED (TREE_TYPE (parm)));
3177
3178       if (data->stack_parm)
3179         {
3180           int offset = subreg_lowpart_offset (data->nominal_mode,
3181                                               GET_MODE (data->stack_parm));
3182           /* ??? This may need a big-endian conversion on sparc64.  */
3183           data->stack_parm
3184             = adjust_address (data->stack_parm, data->nominal_mode, 0);
3185           if (offset && MEM_OFFSET_KNOWN_P (data->stack_parm))
3186             set_mem_offset (data->stack_parm,
3187                             MEM_OFFSET (data->stack_parm) + offset);
3188         }
3189     }
3190
3191   if (data->entry_parm != data->stack_parm)
3192     {
3193       rtx src, dest;
3194
3195       if (data->stack_parm == 0)
3196         {
3197           int align = STACK_SLOT_ALIGNMENT (data->passed_type,
3198                                             GET_MODE (data->entry_parm),
3199                                             TYPE_ALIGN (data->passed_type));
3200           data->stack_parm
3201             = assign_stack_local (GET_MODE (data->entry_parm),
3202                                   GET_MODE_SIZE (GET_MODE (data->entry_parm)),
3203                                   align);
3204           set_mem_attributes (data->stack_parm, parm, 1);
3205         }
3206
3207       dest = validize_mem (data->stack_parm);
3208       src = validize_mem (data->entry_parm);
3209
3210       if (MEM_P (src))
3211         {
3212           /* Use a block move to handle potentially misaligned entry_parm.  */
3213           if (!to_conversion)
3214             push_to_sequence2 (all->first_conversion_insn,
3215                                all->last_conversion_insn);
3216           to_conversion = true;
3217
3218           emit_block_move (dest, src,
3219                            GEN_INT (int_size_in_bytes (data->passed_type)),
3220                            BLOCK_OP_NORMAL);
3221         }
3222       else
3223         emit_move_insn (dest, src);
3224     }
3225
3226   if (to_conversion)
3227     {
3228       all->first_conversion_insn = get_insns ();
3229       all->last_conversion_insn = get_last_insn ();
3230       end_sequence ();
3231     }
3232
3233   SET_DECL_RTL (parm, data->stack_parm);
3234 }
3235
3236 /* A subroutine of assign_parms.  If the ABI splits complex arguments, then
3237    undo the frobbing that we did in assign_parms_augmented_arg_list.  */
3238
3239 static void
3240 assign_parms_unsplit_complex (struct assign_parm_data_all *all,
3241                               VEC(tree, heap) *fnargs)
3242 {
3243   tree parm;
3244   tree orig_fnargs = all->orig_fnargs;
3245   unsigned i = 0;
3246
3247   for (parm = orig_fnargs; parm; parm = TREE_CHAIN (parm), ++i)
3248     {
3249       if (TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE
3250           && targetm.calls.split_complex_arg (TREE_TYPE (parm)))
3251         {
3252           rtx tmp, real, imag;
3253           enum machine_mode inner = GET_MODE_INNER (DECL_MODE (parm));
3254
3255           real = DECL_RTL (VEC_index (tree, fnargs, i));
3256           imag = DECL_RTL (VEC_index (tree, fnargs, i + 1));
3257           if (inner != GET_MODE (real))
3258             {
3259               real = gen_lowpart_SUBREG (inner, real);
3260               imag = gen_lowpart_SUBREG (inner, imag);
3261             }
3262
3263           if (TREE_ADDRESSABLE (parm))
3264             {
3265               rtx rmem, imem;
3266               HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (parm));
3267               int align = STACK_SLOT_ALIGNMENT (TREE_TYPE (parm),
3268                                                 DECL_MODE (parm),
3269                                                 TYPE_ALIGN (TREE_TYPE (parm)));
3270
3271               /* split_complex_arg put the real and imag parts in
3272                  pseudos.  Move them to memory.  */
3273               tmp = assign_stack_local (DECL_MODE (parm), size, align);
3274               set_mem_attributes (tmp, parm, 1);
3275               rmem = adjust_address_nv (tmp, inner, 0);
3276               imem = adjust_address_nv (tmp, inner, GET_MODE_SIZE (inner));
3277               push_to_sequence2 (all->first_conversion_insn,
3278                                  all->last_conversion_insn);
3279               emit_move_insn (rmem, real);
3280               emit_move_insn (imem, imag);
3281               all->first_conversion_insn = get_insns ();
3282               all->last_conversion_insn = get_last_insn ();
3283               end_sequence ();
3284             }
3285           else
3286             tmp = gen_rtx_CONCAT (DECL_MODE (parm), real, imag);
3287           SET_DECL_RTL (parm, tmp);
3288
3289           real = DECL_INCOMING_RTL (VEC_index (tree, fnargs, i));
3290           imag = DECL_INCOMING_RTL (VEC_index (tree, fnargs, i + 1));
3291           if (inner != GET_MODE (real))
3292             {
3293               real = gen_lowpart_SUBREG (inner, real);
3294               imag = gen_lowpart_SUBREG (inner, imag);
3295             }
3296           tmp = gen_rtx_CONCAT (DECL_MODE (parm), real, imag);
3297           set_decl_incoming_rtl (parm, tmp, false);
3298           i++;
3299         }
3300     }
3301 }
3302
3303 /* Assign RTL expressions to the function's parameters.  This may involve
3304    copying them into registers and using those registers as the DECL_RTL.  */
3305
3306 static void
3307 assign_parms (tree fndecl)
3308 {
3309   struct assign_parm_data_all all;
3310   tree parm;
3311   VEC(tree, heap) *fnargs;
3312   unsigned i;
3313
3314   crtl->args.internal_arg_pointer
3315     = targetm.calls.internal_arg_pointer ();
3316
3317   assign_parms_initialize_all (&all);
3318   fnargs = assign_parms_augmented_arg_list (&all);
3319
3320   FOR_EACH_VEC_ELT (tree, fnargs, i, parm)
3321     {
3322       struct assign_parm_data_one data;
3323
3324       /* Extract the type of PARM; adjust it according to ABI.  */
3325       assign_parm_find_data_types (&all, parm, &data);
3326
3327       /* Early out for errors and void parameters.  */
3328       if (data.passed_mode == VOIDmode)
3329         {
3330           SET_DECL_RTL (parm, const0_rtx);
3331           DECL_INCOMING_RTL (parm) = DECL_RTL (parm);
3332           continue;
3333         }
3334
3335       /* Estimate stack alignment from parameter alignment.  */
3336       if (SUPPORTS_STACK_ALIGNMENT)
3337         {
3338           unsigned int align
3339             = targetm.calls.function_arg_boundary (data.promoted_mode,
3340                                                    data.passed_type);
3341           align = MINIMUM_ALIGNMENT (data.passed_type, data.promoted_mode,
3342                                      align);
3343           if (TYPE_ALIGN (data.nominal_type) > align)
3344             align = MINIMUM_ALIGNMENT (data.nominal_type,
3345                                        TYPE_MODE (data.nominal_type),
3346                                        TYPE_ALIGN (data.nominal_type));
3347           if (crtl->stack_alignment_estimated < align)
3348             {
3349               gcc_assert (!crtl->stack_realign_processed);
3350               crtl->stack_alignment_estimated = align;
3351             }
3352         }
3353
3354       if (cfun->stdarg && !DECL_CHAIN (parm))
3355         assign_parms_setup_varargs (&all, &data, false);
3356
3357       /* Find out where the parameter arrives in this function.  */
3358       assign_parm_find_entry_rtl (&all, &data);
3359
3360       /* Find out where stack space for this parameter might be.  */
3361       if (assign_parm_is_stack_parm (&all, &data))
3362         {
3363           assign_parm_find_stack_rtl (parm, &data);
3364           assign_parm_adjust_entry_rtl (&data);
3365         }
3366
3367       /* Record permanently how this parm was passed.  */
3368       if (data.passed_pointer)
3369         {
3370           rtx incoming_rtl
3371             = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data.passed_type)),
3372                            data.entry_parm);
3373           set_decl_incoming_rtl (parm, incoming_rtl, true);
3374         }
3375       else
3376         set_decl_incoming_rtl (parm, data.entry_parm, false);
3377
3378       /* Update info on where next arg arrives in registers.  */
3379       targetm.calls.function_arg_advance (all.args_so_far, data.promoted_mode,
3380                                           data.passed_type, data.named_arg);
3381
3382       assign_parm_adjust_stack_rtl (&data);
3383
3384       if (assign_parm_setup_block_p (&data))
3385         assign_parm_setup_block (&all, parm, &data);
3386       else if (data.passed_pointer || use_register_for_decl (parm))
3387         assign_parm_setup_reg (&all, parm, &data);
3388       else
3389         assign_parm_setup_stack (&all, parm, &data);
3390     }
3391
3392   if (targetm.calls.split_complex_arg)
3393     assign_parms_unsplit_complex (&all, fnargs);
3394
3395   VEC_free (tree, heap, fnargs);
3396
3397   /* Output all parameter conversion instructions (possibly including calls)
3398      now that all parameters have been copied out of hard registers.  */
3399   emit_insn (all.first_conversion_insn);
3400
3401   /* Estimate reload stack alignment from scalar return mode.  */
3402   if (SUPPORTS_STACK_ALIGNMENT)
3403     {
3404       if (DECL_RESULT (fndecl))
3405         {
3406           tree type = TREE_TYPE (DECL_RESULT (fndecl));
3407           enum machine_mode mode = TYPE_MODE (type);
3408
3409           if (mode != BLKmode
3410               && mode != VOIDmode
3411               && !AGGREGATE_TYPE_P (type))
3412             {
3413               unsigned int align = GET_MODE_ALIGNMENT (mode);
3414               if (crtl->stack_alignment_estimated < align)
3415                 {
3416                   gcc_assert (!crtl->stack_realign_processed);
3417                   crtl->stack_alignment_estimated = align;
3418                 }
3419             }
3420         }
3421     }
3422
3423   /* If we are receiving a struct value address as the first argument, set up
3424      the RTL for the function result. As this might require code to convert
3425      the transmitted address to Pmode, we do this here to ensure that possible
3426      preliminary conversions of the address have been emitted already.  */
3427   if (all.function_result_decl)
3428     {
3429       tree result = DECL_RESULT (current_function_decl);
3430       rtx addr = DECL_RTL (all.function_result_decl);
3431       rtx x;
3432
3433       if (DECL_BY_REFERENCE (result))
3434         {
3435           SET_DECL_VALUE_EXPR (result, all.function_result_decl);
3436           x = addr;
3437         }
3438       else
3439         {
3440           SET_DECL_VALUE_EXPR (result,
3441                                build1 (INDIRECT_REF, TREE_TYPE (result),
3442                                        all.function_result_decl));
3443           addr = convert_memory_address (Pmode, addr);
3444           x = gen_rtx_MEM (DECL_MODE (result), addr);
3445           set_mem_attributes (x, result, 1);
3446         }
3447
3448       DECL_HAS_VALUE_EXPR_P (result) = 1;
3449
3450       SET_DECL_RTL (result, x);
3451     }
3452
3453   /* We have aligned all the args, so add space for the pretend args.  */
3454   crtl->args.pretend_args_size = all.pretend_args_size;
3455   all.stack_args_size.constant += all.extra_pretend_bytes;
3456   crtl->args.size = all.stack_args_size.constant;
3457
3458   /* Adjust function incoming argument size for alignment and
3459      minimum length.  */
3460
3461 #ifdef REG_PARM_STACK_SPACE
3462   crtl->args.size = MAX (crtl->args.size,
3463                                     REG_PARM_STACK_SPACE (fndecl));
3464 #endif
3465
3466   crtl->args.size = CEIL_ROUND (crtl->args.size,
3467                                            PARM_BOUNDARY / BITS_PER_UNIT);
3468
3469 #ifdef ARGS_GROW_DOWNWARD
3470   crtl->args.arg_offset_rtx
3471     = (all.stack_args_size.var == 0 ? GEN_INT (-all.stack_args_size.constant)
3472        : expand_expr (size_diffop (all.stack_args_size.var,
3473                                    size_int (-all.stack_args_size.constant)),
3474                       NULL_RTX, VOIDmode, EXPAND_NORMAL));
3475 #else
3476   crtl->args.arg_offset_rtx = ARGS_SIZE_RTX (all.stack_args_size);
3477 #endif
3478
3479   /* See how many bytes, if any, of its args a function should try to pop
3480      on return.  */
3481
3482   crtl->args.pops_args = targetm.calls.return_pops_args (fndecl,
3483                                                          TREE_TYPE (fndecl),
3484                                                          crtl->args.size);
3485
3486   /* For stdarg.h function, save info about
3487      regs and stack space used by the named args.  */
3488
3489   crtl->args.info = all.args_so_far_v;
3490
3491   /* Set the rtx used for the function return value.  Put this in its
3492      own variable so any optimizers that need this information don't have
3493      to include tree.h.  Do this here so it gets done when an inlined
3494      function gets output.  */
3495
3496   crtl->return_rtx
3497     = (DECL_RTL_SET_P (DECL_RESULT (fndecl))
3498        ? DECL_RTL (DECL_RESULT (fndecl)) : NULL_RTX);
3499
3500   /* If scalar return value was computed in a pseudo-reg, or was a named
3501      return value that got dumped to the stack, copy that to the hard
3502      return register.  */
3503   if (DECL_RTL_SET_P (DECL_RESULT (fndecl)))
3504     {
3505       tree decl_result = DECL_RESULT (fndecl);
3506       rtx decl_rtl = DECL_RTL (decl_result);
3507
3508       if (REG_P (decl_rtl)
3509           ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER
3510           : DECL_REGISTER (decl_result))
3511         {
3512           rtx real_decl_rtl;
3513
3514           real_decl_rtl = targetm.calls.function_value (TREE_TYPE (decl_result),
3515                                                         fndecl, true);
3516           REG_FUNCTION_VALUE_P (real_decl_rtl) = 1;
3517           /* The delay slot scheduler assumes that crtl->return_rtx
3518              holds the hard register containing the return value, not a
3519              temporary pseudo.  */
3520           crtl->return_rtx = real_decl_rtl;
3521         }
3522     }
3523 }
3524
3525 /* A subroutine of gimplify_parameters, invoked via walk_tree.
3526    For all seen types, gimplify their sizes.  */
3527
3528 static tree
3529 gimplify_parm_type (tree *tp, int *walk_subtrees, void *data)
3530 {
3531   tree t = *tp;
3532
3533   *walk_subtrees = 0;
3534   if (TYPE_P (t))
3535     {
3536       if (POINTER_TYPE_P (t))
3537         *walk_subtrees = 1;
3538       else if (TYPE_SIZE (t) && !TREE_CONSTANT (TYPE_SIZE (t))
3539                && !TYPE_SIZES_GIMPLIFIED (t))
3540         {
3541           gimplify_type_sizes (t, (gimple_seq *) data);
3542           *walk_subtrees = 1;
3543         }
3544     }
3545
3546   return NULL;
3547 }
3548
3549 /* Gimplify the parameter list for current_function_decl.  This involves
3550    evaluating SAVE_EXPRs of variable sized parameters and generating code
3551    to implement callee-copies reference parameters.  Returns a sequence of
3552    statements to add to the beginning of the function.  */
3553
3554 gimple_seq
3555 gimplify_parameters (void)
3556 {
3557   struct assign_parm_data_all all;
3558   tree parm;
3559   gimple_seq stmts = NULL;
3560   VEC(tree, heap) *fnargs;
3561   unsigned i;
3562
3563   assign_parms_initialize_all (&all);
3564   fnargs = assign_parms_augmented_arg_list (&all);
3565
3566   FOR_EACH_VEC_ELT (tree, fnargs, i, parm)
3567     {
3568       struct assign_parm_data_one data;
3569
3570       /* Extract the type of PARM; adjust it according to ABI.  */
3571       assign_parm_find_data_types (&all, parm, &data);
3572
3573       /* Early out for errors and void parameters.  */
3574       if (data.passed_mode == VOIDmode || DECL_SIZE (parm) == NULL)
3575         continue;
3576
3577       /* Update info on where next arg arrives in registers.  */
3578       targetm.calls.function_arg_advance (all.args_so_far, data.promoted_mode,
3579                                           data.passed_type, data.named_arg);
3580
3581       /* ??? Once upon a time variable_size stuffed parameter list
3582          SAVE_EXPRs (amongst others) onto a pending sizes list.  This
3583          turned out to be less than manageable in the gimple world.
3584          Now we have to hunt them down ourselves.  */
3585       walk_tree_without_duplicates (&data.passed_type,
3586                                     gimplify_parm_type, &stmts);
3587
3588       if (TREE_CODE (DECL_SIZE_UNIT (parm)) != INTEGER_CST)
3589         {
3590           gimplify_one_sizepos (&DECL_SIZE (parm), &stmts);
3591           gimplify_one_sizepos (&DECL_SIZE_UNIT (parm), &stmts);
3592         }
3593
3594       if (data.passed_pointer)
3595         {
3596           tree type = TREE_TYPE (data.passed_type);
3597           if (reference_callee_copied (&all.args_so_far_v, TYPE_MODE (type),
3598                                        type, data.named_arg))
3599             {
3600               tree local, t;
3601
3602               /* For constant-sized objects, this is trivial; for
3603                  variable-sized objects, we have to play games.  */
3604               if (TREE_CODE (DECL_SIZE_UNIT (parm)) == INTEGER_CST
3605                   && !(flag_stack_check == GENERIC_STACK_CHECK
3606                        && compare_tree_int (DECL_SIZE_UNIT (parm),
3607                                             STACK_CHECK_MAX_VAR_SIZE) > 0))
3608                 {
3609                   local = create_tmp_var (type, get_name (parm));
3610                   DECL_IGNORED_P (local) = 0;
3611                   /* If PARM was addressable, move that flag over
3612                      to the local copy, as its address will be taken,
3613                      not the PARMs.  Keep the parms address taken
3614                      as we'll query that flag during gimplification.  */
3615                   if (TREE_ADDRESSABLE (parm))
3616                     TREE_ADDRESSABLE (local) = 1;
3617                   else if (TREE_CODE (type) == COMPLEX_TYPE
3618                            || TREE_CODE (type) == VECTOR_TYPE)
3619                     DECL_GIMPLE_REG_P (local) = 1;
3620                 }
3621               else
3622                 {
3623                   tree ptr_type, addr;
3624
3625                   ptr_type = build_pointer_type (type);
3626                   addr = create_tmp_reg (ptr_type, get_name (parm));
3627                   DECL_IGNORED_P (addr) = 0;
3628                   local = build_fold_indirect_ref (addr);
3629
3630                   t = builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN);
3631                   t = build_call_expr (t, 2, DECL_SIZE_UNIT (parm),
3632                                        size_int (DECL_ALIGN (parm)));
3633
3634                   /* The call has been built for a variable-sized object.  */
3635                   CALL_ALLOCA_FOR_VAR_P (t) = 1;
3636                   t = fold_convert (ptr_type, t);
3637                   t = build2 (MODIFY_EXPR, TREE_TYPE (addr), addr, t);
3638                   gimplify_and_add (t, &stmts);
3639                 }
3640
3641               gimplify_assign (local, parm, &stmts);
3642
3643               SET_DECL_VALUE_EXPR (parm, local);
3644               DECL_HAS_VALUE_EXPR_P (parm) = 1;
3645             }
3646         }
3647     }
3648
3649   VEC_free (tree, heap, fnargs);
3650
3651   return stmts;
3652 }
3653 \f
3654 /* Compute the size and offset from the start of the stacked arguments for a
3655    parm passed in mode PASSED_MODE and with type TYPE.
3656
3657    INITIAL_OFFSET_PTR points to the current offset into the stacked
3658    arguments.
3659
3660    The starting offset and size for this parm are returned in
3661    LOCATE->OFFSET and LOCATE->SIZE, respectively.  When IN_REGS is
3662    nonzero, the offset is that of stack slot, which is returned in
3663    LOCATE->SLOT_OFFSET.  LOCATE->ALIGNMENT_PAD is the amount of
3664    padding required from the initial offset ptr to the stack slot.
3665
3666    IN_REGS is nonzero if the argument will be passed in registers.  It will
3667    never be set if REG_PARM_STACK_SPACE is not defined.
3668
3669    FNDECL is the function in which the argument was defined.
3670
3671    There are two types of rounding that are done.  The first, controlled by
3672    TARGET_FUNCTION_ARG_BOUNDARY, forces the offset from the start of the
3673    argument list to be aligned to the specific boundary (in bits).  This
3674    rounding affects the initial and starting offsets, but not the argument
3675    size.
3676
3677    The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY,
3678    optionally rounds the size of the parm to PARM_BOUNDARY.  The
3679    initial offset is not affected by this rounding, while the size always
3680    is and the starting offset may be.  */
3681
3682 /*  LOCATE->OFFSET will be negative for ARGS_GROW_DOWNWARD case;
3683     INITIAL_OFFSET_PTR is positive because locate_and_pad_parm's
3684     callers pass in the total size of args so far as
3685     INITIAL_OFFSET_PTR.  LOCATE->SIZE is always positive.  */
3686
3687 void
3688 locate_and_pad_parm (enum machine_mode passed_mode, tree type, int in_regs,
3689                      int partial, tree fndecl ATTRIBUTE_UNUSED,
3690                      struct args_size *initial_offset_ptr,
3691                      struct locate_and_pad_arg_data *locate)
3692 {
3693   tree sizetree;
3694   enum direction where_pad;
3695   unsigned int boundary, round_boundary;
3696   int reg_parm_stack_space = 0;
3697   int part_size_in_regs;
3698
3699 #ifdef REG_PARM_STACK_SPACE
3700   reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
3701
3702   /* If we have found a stack parm before we reach the end of the
3703      area reserved for registers, skip that area.  */
3704   if (! in_regs)
3705     {
3706       if (reg_parm_stack_space > 0)
3707         {
3708           if (initial_offset_ptr->var)
3709             {
3710               initial_offset_ptr->var
3711                 = size_binop (MAX_EXPR, ARGS_SIZE_TREE (*initial_offset_ptr),
3712                               ssize_int (reg_parm_stack_space));
3713               initial_offset_ptr->constant = 0;
3714             }
3715           else if (initial_offset_ptr->constant < reg_parm_stack_space)
3716             initial_offset_ptr->constant = reg_parm_stack_space;
3717         }
3718     }
3719 #endif /* REG_PARM_STACK_SPACE */
3720
3721   part_size_in_regs = (reg_parm_stack_space == 0 ? partial : 0);
3722
3723   sizetree
3724     = type ? size_in_bytes (type) : size_int (GET_MODE_SIZE (passed_mode));
3725   where_pad = FUNCTION_ARG_PADDING (passed_mode, type);
3726   boundary = targetm.calls.function_arg_boundary (passed_mode, type);
3727   round_boundary = targetm.calls.function_arg_round_boundary (passed_mode,
3728                                                               type);
3729   locate->where_pad = where_pad;
3730
3731   /* Alignment can't exceed MAX_SUPPORTED_STACK_ALIGNMENT.  */
3732   if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
3733     boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
3734
3735   locate->boundary = boundary;
3736
3737   if (SUPPORTS_STACK_ALIGNMENT)
3738     {
3739       /* stack_alignment_estimated can't change after stack has been
3740          realigned.  */
3741       if (crtl->stack_alignment_estimated < boundary)
3742         {
3743           if (!crtl->stack_realign_processed)
3744             crtl->stack_alignment_estimated = boundary;
3745           else
3746             {
3747               /* If stack is realigned and stack alignment value
3748                  hasn't been finalized, it is OK not to increase
3749                  stack_alignment_estimated.  The bigger alignment
3750                  requirement is recorded in stack_alignment_needed
3751                  below.  */
3752               gcc_assert (!crtl->stack_realign_finalized
3753                           && crtl->stack_realign_needed);
3754             }
3755         }
3756     }
3757
3758   /* Remember if the outgoing parameter requires extra alignment on the
3759      calling function side.  */
3760   if (crtl->stack_alignment_needed < boundary)
3761     crtl->stack_alignment_needed = boundary;
3762   if (crtl->preferred_stack_boundary < boundary)
3763     crtl->preferred_stack_boundary = boundary;
3764
3765 #ifdef ARGS_GROW_DOWNWARD
3766   locate->slot_offset.constant = -initial_offset_ptr->constant;
3767   if (initial_offset_ptr->var)
3768     locate->slot_offset.var = size_binop (MINUS_EXPR, ssize_int (0),
3769                                           initial_offset_ptr->var);
3770
3771   {
3772     tree s2 = sizetree;
3773     if (where_pad != none
3774         && (!host_integerp (sizetree, 1)
3775             || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % round_boundary))
3776       s2 = round_up (s2, round_boundary / BITS_PER_UNIT);
3777     SUB_PARM_SIZE (locate->slot_offset, s2);
3778   }
3779
3780   locate->slot_offset.constant += part_size_in_regs;
3781
3782   if (!in_regs
3783 #ifdef REG_PARM_STACK_SPACE
3784       || REG_PARM_STACK_SPACE (fndecl) > 0
3785 #endif
3786      )
3787     pad_to_arg_alignment (&locate->slot_offset, boundary,
3788                           &locate->alignment_pad);
3789
3790   locate->size.constant = (-initial_offset_ptr->constant
3791                            - locate->slot_offset.constant);
3792   if (initial_offset_ptr->var)
3793     locate->size.var = size_binop (MINUS_EXPR,
3794                                    size_binop (MINUS_EXPR,
3795                                                ssize_int (0),
3796                                                initial_offset_ptr->var),
3797                                    locate->slot_offset.var);
3798
3799   /* Pad_below needs the pre-rounded size to know how much to pad
3800      below.  */
3801   locate->offset = locate->slot_offset;
3802   if (where_pad == downward)
3803     pad_below (&locate->offset, passed_mode, sizetree);
3804
3805 #else /* !ARGS_GROW_DOWNWARD */
3806   if (!in_regs
3807 #ifdef REG_PARM_STACK_SPACE
3808       || REG_PARM_STACK_SPACE (fndecl) > 0
3809 #endif
3810       )
3811     pad_to_arg_alignment (initial_offset_ptr, boundary,
3812                           &locate->alignment_pad);
3813   locate->slot_offset = *initial_offset_ptr;
3814
3815 #ifdef PUSH_ROUNDING
3816   if (passed_mode != BLKmode)
3817     sizetree = size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree)));
3818 #endif
3819
3820   /* Pad_below needs the pre-rounded size to know how much to pad below
3821      so this must be done before rounding up.  */
3822   locate->offset = locate->slot_offset;
3823   if (where_pad == downward)
3824     pad_below (&locate->offset, passed_mode, sizetree);
3825
3826   if (where_pad != none
3827       && (!host_integerp (sizetree, 1)
3828           || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % round_boundary))
3829     sizetree = round_up (sizetree, round_boundary / BITS_PER_UNIT);
3830
3831   ADD_PARM_SIZE (locate->size, sizetree);
3832
3833   locate->size.constant -= part_size_in_regs;
3834 #endif /* ARGS_GROW_DOWNWARD */
3835
3836 #ifdef FUNCTION_ARG_OFFSET
3837   locate->offset.constant += FUNCTION_ARG_OFFSET (passed_mode, type);
3838 #endif
3839 }
3840
3841 /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY.
3842    BOUNDARY is measured in bits, but must be a multiple of a storage unit.  */
3843
3844 static void
3845 pad_to_arg_alignment (struct args_size *offset_ptr, int boundary,
3846                       struct args_size *alignment_pad)
3847 {
3848   tree save_var = NULL_TREE;
3849   HOST_WIDE_INT save_constant = 0;
3850   int boundary_in_bytes = boundary / BITS_PER_UNIT;
3851   HOST_WIDE_INT sp_offset = STACK_POINTER_OFFSET;
3852
3853 #ifdef SPARC_STACK_BOUNDARY_HACK
3854   /* ??? The SPARC port may claim a STACK_BOUNDARY higher than
3855      the real alignment of %sp.  However, when it does this, the
3856      alignment of %sp+STACK_POINTER_OFFSET is STACK_BOUNDARY.  */
3857   if (SPARC_STACK_BOUNDARY_HACK)
3858     sp_offset = 0;
3859 #endif
3860
3861   if (boundary > PARM_BOUNDARY)
3862     {
3863       save_var = offset_ptr->var;
3864       save_constant = offset_ptr->constant;
3865     }
3866
3867   alignment_pad->var = NULL_TREE;
3868   alignment_pad->constant = 0;
3869
3870   if (boundary > BITS_PER_UNIT)
3871     {
3872       if (offset_ptr->var)
3873         {
3874           tree sp_offset_tree = ssize_int (sp_offset);
3875           tree offset = size_binop (PLUS_EXPR,
3876                                     ARGS_SIZE_TREE (*offset_ptr),
3877                                     sp_offset_tree);
3878 #ifdef ARGS_GROW_DOWNWARD
3879           tree rounded = round_down (offset, boundary / BITS_PER_UNIT);
3880 #else
3881           tree rounded = round_up   (offset, boundary / BITS_PER_UNIT);
3882 #endif
3883
3884           offset_ptr->var = size_binop (MINUS_EXPR, rounded, sp_offset_tree);
3885           /* ARGS_SIZE_TREE includes constant term.  */
3886           offset_ptr->constant = 0;
3887           if (boundary > PARM_BOUNDARY)
3888             alignment_pad->var = size_binop (MINUS_EXPR, offset_ptr->var,
3889                                              save_var);
3890         }
3891       else
3892         {
3893           offset_ptr->constant = -sp_offset +
3894 #ifdef ARGS_GROW_DOWNWARD
3895             FLOOR_ROUND (offset_ptr->constant + sp_offset, boundary_in_bytes);
3896 #else
3897             CEIL_ROUND (offset_ptr->constant + sp_offset, boundary_in_bytes);
3898 #endif
3899             if (boundary > PARM_BOUNDARY)
3900               alignment_pad->constant = offset_ptr->constant - save_constant;
3901         }
3902     }
3903 }
3904
3905 static void
3906 pad_below (struct args_size *offset_ptr, enum machine_mode passed_mode, tree sizetree)
3907 {
3908   if (passed_mode != BLKmode)
3909     {
3910       if (GET_MODE_BITSIZE (passed_mode) % PARM_BOUNDARY)
3911         offset_ptr->constant
3912           += (((GET_MODE_BITSIZE (passed_mode) + PARM_BOUNDARY - 1)
3913                / PARM_BOUNDARY * PARM_BOUNDARY / BITS_PER_UNIT)
3914               - GET_MODE_SIZE (passed_mode));
3915     }
3916   else
3917     {
3918       if (TREE_CODE (sizetree) != INTEGER_CST
3919           || (TREE_INT_CST_LOW (sizetree) * BITS_PER_UNIT) % PARM_BOUNDARY)
3920         {
3921           /* Round the size up to multiple of PARM_BOUNDARY bits.  */
3922           tree s2 = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT);
3923           /* Add it in.  */
3924           ADD_PARM_SIZE (*offset_ptr, s2);
3925           SUB_PARM_SIZE (*offset_ptr, sizetree);
3926         }
3927     }
3928 }
3929 \f
3930
3931 /* True if register REGNO was alive at a place where `setjmp' was
3932    called and was set more than once or is an argument.  Such regs may
3933    be clobbered by `longjmp'.  */
3934
3935 static bool
3936 regno_clobbered_at_setjmp (bitmap setjmp_crosses, int regno)
3937 {
3938   /* There appear to be cases where some local vars never reach the
3939      backend but have bogus regnos.  */
3940   if (regno >= max_reg_num ())
3941     return false;
3942
3943   return ((REG_N_SETS (regno) > 1
3944            || REGNO_REG_SET_P (df_get_live_out (ENTRY_BLOCK_PTR), regno))
3945           && REGNO_REG_SET_P (setjmp_crosses, regno));
3946 }
3947
3948 /* Walk the tree of blocks describing the binding levels within a
3949    function and warn about variables the might be killed by setjmp or
3950    vfork.  This is done after calling flow_analysis before register
3951    allocation since that will clobber the pseudo-regs to hard
3952    regs.  */
3953
3954 static void
3955 setjmp_vars_warning (bitmap setjmp_crosses, tree block)
3956 {
3957   tree decl, sub;
3958
3959   for (decl = BLOCK_VARS (block); decl; decl = DECL_CHAIN (decl))
3960     {
3961       if (TREE_CODE (decl) == VAR_DECL
3962           && DECL_RTL_SET_P (decl)
3963           && REG_P (DECL_RTL (decl))
3964           && regno_clobbered_at_setjmp (setjmp_crosses, REGNO (DECL_RTL (decl))))
3965         warning (OPT_Wclobbered, "variable %q+D might be clobbered by"
3966                  " %<longjmp%> or %<vfork%>", decl);
3967     }
3968
3969   for (sub = BLOCK_SUBBLOCKS (block); sub; sub = BLOCK_CHAIN (sub))
3970     setjmp_vars_warning (setjmp_crosses, sub);
3971 }
3972
3973 /* Do the appropriate part of setjmp_vars_warning
3974    but for arguments instead of local variables.  */
3975
3976 static void
3977 setjmp_args_warning (bitmap setjmp_crosses)
3978 {
3979   tree decl;
3980   for (decl = DECL_ARGUMENTS (current_function_decl);
3981        decl; decl = DECL_CHAIN (decl))
3982     if (DECL_RTL (decl) != 0
3983         && REG_P (DECL_RTL (decl))
3984         && regno_clobbered_at_setjmp (setjmp_crosses, REGNO (DECL_RTL (decl))))
3985       warning (OPT_Wclobbered,
3986                "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>",
3987                decl);
3988 }
3989
3990 /* Generate warning messages for variables live across setjmp.  */
3991
3992 void
3993 generate_setjmp_warnings (void)
3994 {
3995   bitmap setjmp_crosses = regstat_get_setjmp_crosses ();
3996
3997   if (n_basic_blocks == NUM_FIXED_BLOCKS
3998       || bitmap_empty_p (setjmp_crosses))
3999     return;
4000
4001   setjmp_vars_warning (setjmp_crosses, DECL_INITIAL (current_function_decl));
4002   setjmp_args_warning (setjmp_crosses);
4003 }
4004
4005 \f
4006 /* Reverse the order of elements in the fragment chain T of blocks,
4007    and return the new head of the chain (old last element).  */
4008
4009 static tree
4010 block_fragments_nreverse (tree t)
4011 {
4012   tree prev = 0, block, next;
4013   for (block = t; block; block = next)
4014     {
4015       next = BLOCK_FRAGMENT_CHAIN (block);
4016       BLOCK_FRAGMENT_CHAIN (block) = prev;
4017       prev = block;
4018     }
4019   return prev;
4020 }
4021
4022 /* Reverse the order of elements in the chain T of blocks,
4023    and return the new head of the chain (old last element).
4024    Also do the same on subblocks and reverse the order of elements
4025    in BLOCK_FRAGMENT_CHAIN as well.  */
4026
4027 static tree
4028 blocks_nreverse_all (tree t)
4029 {
4030   tree prev = 0, block, next;
4031   for (block = t; block; block = next)
4032     {
4033       next = BLOCK_CHAIN (block);
4034       BLOCK_CHAIN (block) = prev;
4035       BLOCK_SUBBLOCKS (block) = blocks_nreverse_all (BLOCK_SUBBLOCKS (block));
4036       if (BLOCK_FRAGMENT_CHAIN (block)
4037           && BLOCK_FRAGMENT_ORIGIN (block) == NULL_TREE)
4038         BLOCK_FRAGMENT_CHAIN (block)
4039           = block_fragments_nreverse (BLOCK_FRAGMENT_CHAIN (block));
4040       prev = block;
4041     }
4042   return prev;
4043 }
4044
4045
4046 /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
4047    and create duplicate blocks.  */
4048 /* ??? Need an option to either create block fragments or to create
4049    abstract origin duplicates of a source block.  It really depends
4050    on what optimization has been performed.  */
4051
4052 void
4053 reorder_blocks (void)
4054 {
4055   tree block = DECL_INITIAL (current_function_decl);
4056   VEC(tree,heap) *block_stack;
4057
4058   if (block == NULL_TREE)
4059     return;
4060
4061   block_stack = VEC_alloc (tree, heap, 10);
4062
4063   /* Reset the TREE_ASM_WRITTEN bit for all blocks.  */
4064   clear_block_marks (block);
4065
4066   /* Prune the old trees away, so that they don't get in the way.  */
4067   BLOCK_SUBBLOCKS (block) = NULL_TREE;
4068   BLOCK_CHAIN (block) = NULL_TREE;
4069
4070   /* Recreate the block tree from the note nesting.  */
4071   reorder_blocks_1 (get_insns (), block, &block_stack);
4072   BLOCK_SUBBLOCKS (block) = blocks_nreverse_all (BLOCK_SUBBLOCKS (block));
4073
4074   VEC_free (tree, heap, block_stack);
4075 }
4076
4077 /* Helper function for reorder_blocks.  Reset TREE_ASM_WRITTEN.  */
4078
4079 void
4080 clear_block_marks (tree block)
4081 {
4082   while (block)
4083     {
4084       TREE_ASM_WRITTEN (block) = 0;
4085       clear_block_marks (BLOCK_SUBBLOCKS (block));
4086       block = BLOCK_CHAIN (block);
4087     }
4088 }
4089
4090 static void
4091 reorder_blocks_1 (rtx insns, tree current_block, VEC(tree,heap) **p_block_stack)
4092 {
4093   rtx insn;
4094
4095   for (insn = insns; insn; insn = NEXT_INSN (insn))
4096     {
4097       if (NOTE_P (insn))
4098         {
4099           if (NOTE_KIND (insn) == NOTE_INSN_BLOCK_BEG)
4100             {
4101               tree block = NOTE_BLOCK (insn);
4102               tree origin;
4103
4104               gcc_assert (BLOCK_FRAGMENT_ORIGIN (block) == NULL_TREE);
4105               origin = block;
4106
4107               /* If we have seen this block before, that means it now
4108                  spans multiple address regions.  Create a new fragment.  */
4109               if (TREE_ASM_WRITTEN (block))
4110                 {
4111                   tree new_block = copy_node (block);
4112
4113                   BLOCK_FRAGMENT_ORIGIN (new_block) = origin;
4114                   BLOCK_FRAGMENT_CHAIN (new_block)
4115                     = BLOCK_FRAGMENT_CHAIN (origin);
4116                   BLOCK_FRAGMENT_CHAIN (origin) = new_block;
4117
4118                   NOTE_BLOCK (insn) = new_block;
4119                   block = new_block;
4120                 }
4121
4122               BLOCK_SUBBLOCKS (block) = 0;
4123               TREE_ASM_WRITTEN (block) = 1;
4124               /* When there's only one block for the entire function,
4125                  current_block == block and we mustn't do this, it
4126                  will cause infinite recursion.  */
4127               if (block != current_block)
4128                 {
4129                   if (block != origin)
4130                     gcc_assert (BLOCK_SUPERCONTEXT (origin) == current_block);
4131
4132     &n