OSDN Git Service

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