OSDN Git Service

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