OSDN Git Service

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