OSDN Git Service

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