OSDN Git Service

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