OSDN Git Service

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