OSDN Git Service

2003-11-20 Fariborz Jahanian <fjahanian@apple.com>
[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 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.  */
21
22 /* This file handles the generation of rtl code from tree structure
23    at the level of the function as a whole.
24    It creates the rtl expressions for parameters and auto variables
25    and has full responsibility for allocating stack slots.
26
27    `expand_function_start' is called at the beginning of a function,
28    before the function body is parsed, and `expand_function_end' is
29    called after parsing the body.
30
31    Call `assign_stack_local' to allocate a stack slot for a local variable.
32    This is usually done during the RTL generation for the function body,
33    but it can also be done in the reload pass when a pseudo-register does
34    not get a hard register.
35
36    Call `put_var_into_stack' when you learn, belatedly, that a variable
37    previously given a pseudo-register must in fact go in the stack.
38    This function changes the DECL_RTL to be a stack slot instead of a reg
39    then scans all the RTL instructions so far generated to correct them.  */
40
41 #include "config.h"
42 #include "system.h"
43 #include "coretypes.h"
44 #include "tm.h"
45 #include "rtl.h"
46 #include "tree.h"
47 #include "flags.h"
48 #include "except.h"
49 #include "function.h"
50 #include "expr.h"
51 #include "optabs.h"
52 #include "libfuncs.h"
53 #include "regs.h"
54 #include "hard-reg-set.h"
55 #include "insn-config.h"
56 #include "recog.h"
57 #include "output.h"
58 #include "basic-block.h"
59 #include "toplev.h"
60 #include "hashtab.h"
61 #include "ggc.h"
62 #include "tm_p.h"
63 #include "integrate.h"
64 #include "langhooks.h"
65 #include "target.h"
66
67 #ifndef TRAMPOLINE_ALIGNMENT
68 #define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY
69 #endif
70
71 #ifndef LOCAL_ALIGNMENT
72 #define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT
73 #endif
74
75 #ifndef STACK_ALIGNMENT_NEEDED
76 #define STACK_ALIGNMENT_NEEDED 1
77 #endif
78
79 #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
80
81 /* Some systems use __main in a way incompatible with its use in gcc, in these
82    cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
83    give the same symbol without quotes for an alternative entry point.  You
84    must define both, or neither.  */
85 #ifndef NAME__MAIN
86 #define NAME__MAIN "__main"
87 #endif
88
89 /* Round a value to the lowest integer less than it that is a multiple of
90    the required alignment.  Avoid using division in case the value is
91    negative.  Assume the alignment is a power of two.  */
92 #define FLOOR_ROUND(VALUE,ALIGN) ((VALUE) & ~((ALIGN) - 1))
93
94 /* Similar, but round to the next highest integer that meets the
95    alignment.  */
96 #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
97
98 /* NEED_SEPARATE_AP means that we cannot derive ap from the value of fp
99    during rtl generation.  If they are different register numbers, this is
100    always true.  It may also be true if
101    FIRST_PARM_OFFSET - STARTING_FRAME_OFFSET is not a constant during rtl
102    generation.  See fix_lexical_addr for details.  */
103
104 #if ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM
105 #define NEED_SEPARATE_AP
106 #endif
107
108 /* Nonzero if function being compiled doesn't contain any calls
109    (ignoring the prologue and epilogue).  This is set prior to
110    local register allocation and is valid for the remaining
111    compiler passes.  */
112 int current_function_is_leaf;
113
114 /* Nonzero if function being compiled doesn't contain any instructions
115    that can throw an exception.  This is set prior to final.  */
116
117 int current_function_nothrow;
118
119 /* Nonzero if function being compiled doesn't modify the stack pointer
120    (ignoring the prologue and epilogue).  This is only valid after
121    life_analysis has run.  */
122 int current_function_sp_is_unchanging;
123
124 /* Nonzero if the function being compiled is a leaf function which only
125    uses leaf registers.  This is valid after reload (specifically after
126    sched2) and is useful only if the port defines LEAF_REGISTERS.  */
127 int current_function_uses_only_leaf_regs;
128
129 /* Nonzero once virtual register instantiation has been done.
130    assign_stack_local uses frame_pointer_rtx when this is nonzero.
131    calls.c:emit_library_call_value_1 uses it to set up
132    post-instantiation libcalls.  */
133 int virtuals_instantiated;
134
135 /* Nonzero if at least one trampoline has been created.  */
136 int trampolines_created;
137
138 /* Assign unique numbers to labels generated for profiling, debugging, etc.  */
139 static GTY(()) int funcdef_no;
140
141 /* These variables hold pointers to functions to create and destroy
142    target specific, per-function data structures.  */
143 struct machine_function * (*init_machine_status) (void);
144
145 /* The FUNCTION_DECL for an inline function currently being expanded.  */
146 tree inline_function_decl;
147
148 /* The currently compiled function.  */
149 struct function *cfun = 0;
150
151 /* These arrays record the INSN_UIDs of the prologue and epilogue insns.  */
152 static GTY(()) varray_type prologue;
153 static GTY(()) varray_type epilogue;
154
155 /* Array of INSN_UIDs to hold the INSN_UIDs for each sibcall epilogue
156    in this function.  */
157 static GTY(()) varray_type sibcall_epilogue;
158 \f
159 /* In order to evaluate some expressions, such as function calls returning
160    structures in memory, we need to temporarily allocate stack locations.
161    We record each allocated temporary in the following structure.
162
163    Associated with each temporary slot is a nesting level.  When we pop up
164    one level, all temporaries associated with the previous level are freed.
165    Normally, all temporaries are freed after the execution of the statement
166    in which they were created.  However, if we are inside a ({...}) grouping,
167    the result may be in a temporary and hence must be preserved.  If the
168    result could be in a temporary, we preserve it if we can determine which
169    one it is in.  If we cannot determine which temporary may contain the
170    result, all temporaries are preserved.  A temporary is preserved by
171    pretending it was allocated at the previous nesting level.
172
173    Automatic variables are also assigned temporary slots, at the nesting
174    level where they are defined.  They are marked a "kept" so that
175    free_temp_slots will not free them.  */
176
177 struct temp_slot GTY(())
178 {
179   /* Points to next temporary slot.  */
180   struct temp_slot *next;
181   /* The rtx to used to reference the slot.  */
182   rtx slot;
183   /* The rtx used to represent the address if not the address of the
184      slot above.  May be an EXPR_LIST if multiple addresses exist.  */
185   rtx address;
186   /* The alignment (in bits) of the slot.  */
187   unsigned int align;
188   /* The size, in units, of the slot.  */
189   HOST_WIDE_INT size;
190   /* The type of the object in the slot, or zero if it doesn't correspond
191      to a type.  We use this to determine whether a slot can be reused.
192      It can be reused if objects of the type of the new slot will always
193      conflict with objects of the type of the old slot.  */
194   tree type;
195   /* The value of `sequence_rtl_expr' when this temporary is allocated.  */
196   tree rtl_expr;
197   /* Nonzero if this temporary is currently in use.  */
198   char in_use;
199   /* Nonzero if this temporary has its address taken.  */
200   char addr_taken;
201   /* Nesting level at which this slot is being used.  */
202   int level;
203   /* Nonzero if this should survive a call to free_temp_slots.  */
204   int keep;
205   /* The offset of the slot from the frame_pointer, including extra space
206      for alignment.  This info is for combine_temp_slots.  */
207   HOST_WIDE_INT base_offset;
208   /* The size of the slot, including extra space for alignment.  This
209      info is for combine_temp_slots.  */
210   HOST_WIDE_INT full_size;
211 };
212 \f
213 /* This structure is used to record MEMs or pseudos used to replace VAR, any
214    SUBREGs of VAR, and any MEMs containing VAR as an address.  We need to
215    maintain this list in case two operands of an insn were required to match;
216    in that case we must ensure we use the same replacement.  */
217
218 struct fixup_replacement GTY(())
219 {
220   rtx old;
221   rtx new;
222   struct fixup_replacement *next;
223 };
224
225 struct insns_for_mem_entry
226 {
227   /* A MEM.  */
228   rtx key;
229   /* These are the INSNs which reference the MEM.  */
230   rtx insns;
231 };
232
233 /* Forward declarations.  */
234
235 static rtx assign_stack_local_1 (enum machine_mode, HOST_WIDE_INT, int,
236                                  struct function *);
237 static struct temp_slot *find_temp_slot_from_address (rtx);
238 static void put_reg_into_stack (struct function *, rtx, tree, enum machine_mode,
239                                 enum machine_mode, int, unsigned int, int, htab_t);
240 static void schedule_fixup_var_refs (struct function *, rtx, tree, enum machine_mode,
241                                      htab_t);
242 static void fixup_var_refs (rtx, enum machine_mode, int, rtx, htab_t);
243 static struct fixup_replacement
244   *find_fixup_replacement (struct fixup_replacement **, rtx);
245 static void fixup_var_refs_insns (rtx, rtx, enum machine_mode, int, int, rtx);
246 static void fixup_var_refs_insns_with_hash (htab_t, rtx, enum machine_mode, int, rtx);
247 static void fixup_var_refs_insn (rtx, rtx, enum machine_mode, int, int, rtx);
248 static void fixup_var_refs_1 (rtx, enum machine_mode, rtx *, rtx,
249                               struct fixup_replacement **, rtx);
250 static rtx fixup_memory_subreg (rtx, rtx, enum machine_mode, int);
251 static rtx walk_fixup_memory_subreg (rtx, rtx, enum machine_mode, int);
252 static rtx fixup_stack_1 (rtx, rtx);
253 static void optimize_bit_field (rtx, rtx, rtx *);
254 static void instantiate_decls (tree, int);
255 static void instantiate_decls_1 (tree, int);
256 static void instantiate_decl (rtx, HOST_WIDE_INT, int);
257 static rtx instantiate_new_reg (rtx, HOST_WIDE_INT *);
258 static int instantiate_virtual_regs_1 (rtx *, rtx, int);
259 static void delete_handlers (void);
260 static void pad_to_arg_alignment (struct args_size *, int, struct args_size *);
261 static void pad_below (struct args_size *, enum machine_mode, tree);
262 static rtx round_trampoline_addr (rtx);
263 static rtx adjust_trampoline_addr (rtx);
264 static tree *identify_blocks_1 (rtx, tree *, tree *, tree *);
265 static void reorder_blocks_0 (tree);
266 static void reorder_blocks_1 (rtx, tree, varray_type *);
267 static void reorder_fix_fragments (tree);
268 static tree blocks_nreverse (tree);
269 static int all_blocks (tree, tree *);
270 static tree *get_block_vector (tree, int *);
271 extern tree debug_find_var_in_block_tree (tree, tree);
272 /* We always define `record_insns' even if its not used so that we
273    can always export `prologue_epilogue_contains'.  */
274 static void record_insns (rtx, varray_type *) ATTRIBUTE_UNUSED;
275 static int contains (rtx, varray_type);
276 #ifdef HAVE_return
277 static void emit_return_into_block (basic_block, rtx);
278 #endif
279 static void put_addressof_into_stack (rtx, htab_t);
280 static bool purge_addressof_1 (rtx *, rtx, int, int, int, htab_t);
281 static void purge_single_hard_subreg_set (rtx);
282 #if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX)
283 static rtx keep_stack_depressed (rtx);
284 #endif
285 static int is_addressof (rtx *, void *);
286 static hashval_t insns_for_mem_hash (const void *);
287 static int insns_for_mem_comp (const void *, const void *);
288 static int insns_for_mem_walk (rtx *, void *);
289 static void compute_insns_for_mem (rtx, rtx, htab_t);
290 static void prepare_function_start (tree);
291 static void do_clobber_return_reg (rtx, void *);
292 static void do_use_return_reg (rtx, void *);
293 static void instantiate_virtual_regs_lossage (rtx);
294 static tree split_complex_args (tree);
295 static void set_insn_locators (rtx, int) ATTRIBUTE_UNUSED;
296 \f
297 /* Pointer to chain of `struct function' for containing functions.  */
298 static GTY(()) struct function *outer_function_chain;
299
300 /* List of insns that were postponed by purge_addressof_1.  */
301 static rtx postponed_insns;
302
303 /* Given a function decl for a containing function,
304    return the `struct function' for it.  */
305
306 struct function *
307 find_function_data (tree decl)
308 {
309   struct function *p;
310
311   for (p = outer_function_chain; p; p = p->outer)
312     if (p->decl == decl)
313       return p;
314
315   abort ();
316 }
317
318 /* Save the current context for compilation of a nested function.
319    This is called from language-specific code.  The caller should use
320    the enter_nested langhook to save any language-specific state,
321    since this function knows only about language-independent
322    variables.  */
323
324 void
325 push_function_context_to (tree context)
326 {
327   struct function *p;
328
329   if (context)
330     {
331       if (context == current_function_decl)
332         cfun->contains_functions = 1;
333       else
334         {
335           struct function *containing = find_function_data (context);
336           containing->contains_functions = 1;
337         }
338     }
339
340   if (cfun == 0)
341     init_dummy_function_start ();
342   p = cfun;
343
344   p->outer = outer_function_chain;
345   outer_function_chain = p;
346   p->fixup_var_refs_queue = 0;
347
348   (*lang_hooks.function.enter_nested) (p);
349
350   cfun = 0;
351 }
352
353 void
354 push_function_context (void)
355 {
356   push_function_context_to (current_function_decl);
357 }
358
359 /* Restore the last saved context, at the end of a nested function.
360    This function is called from language-specific code.  */
361
362 void
363 pop_function_context_from (tree context ATTRIBUTE_UNUSED)
364 {
365   struct function *p = outer_function_chain;
366   struct var_refs_queue *queue;
367
368   cfun = p;
369   outer_function_chain = p->outer;
370
371   current_function_decl = p->decl;
372   reg_renumber = 0;
373
374   restore_emit_status (p);
375
376   (*lang_hooks.function.leave_nested) (p);
377
378   /* Finish doing put_var_into_stack for any of our variables which became
379      addressable during the nested function.  If only one entry has to be
380      fixed up, just do that one.  Otherwise, first make a list of MEMs that
381      are not to be unshared.  */
382   if (p->fixup_var_refs_queue == 0)
383     ;
384   else if (p->fixup_var_refs_queue->next == 0)
385     fixup_var_refs (p->fixup_var_refs_queue->modified,
386                     p->fixup_var_refs_queue->promoted_mode,
387                     p->fixup_var_refs_queue->unsignedp,
388                     p->fixup_var_refs_queue->modified, 0);
389   else
390     {
391       rtx list = 0;
392
393       for (queue = p->fixup_var_refs_queue; queue; queue = queue->next)
394         list = gen_rtx_EXPR_LIST (VOIDmode, queue->modified, list);
395
396       for (queue = p->fixup_var_refs_queue; queue; queue = queue->next)
397         fixup_var_refs (queue->modified, queue->promoted_mode,
398                         queue->unsignedp, list, 0);
399
400     }
401
402   p->fixup_var_refs_queue = 0;
403
404   /* Reset variables that have known state during rtx generation.  */
405   rtx_equal_function_value_matters = 1;
406   virtuals_instantiated = 0;
407   generating_concat_p = 1;
408 }
409
410 void
411 pop_function_context (void)
412 {
413   pop_function_context_from (current_function_decl);
414 }
415
416 /* Clear out all parts of the state in F that can safely be discarded
417    after the function has been parsed, but not compiled, to let
418    garbage collection reclaim the memory.  */
419
420 void
421 free_after_parsing (struct function *f)
422 {
423   /* f->expr->forced_labels is used by code generation.  */
424   /* f->emit->regno_reg_rtx is used by code generation.  */
425   /* f->varasm is used by code generation.  */
426   /* f->eh->eh_return_stub_label is used by code generation.  */
427
428   (*lang_hooks.function.final) (f);
429   f->stmt = NULL;
430 }
431
432 /* Clear out all parts of the state in F that can safely be discarded
433    after the function has been compiled, to let garbage collection
434    reclaim the memory.  */
435
436 void
437 free_after_compilation (struct function *f)
438 {
439   f->eh = NULL;
440   f->expr = NULL;
441   f->emit = NULL;
442   f->varasm = NULL;
443   f->machine = NULL;
444
445   f->x_temp_slots = NULL;
446   f->arg_offset_rtx = NULL;
447   f->return_rtx = NULL;
448   f->internal_arg_pointer = NULL;
449   f->x_nonlocal_labels = NULL;
450   f->x_nonlocal_goto_handler_slots = NULL;
451   f->x_nonlocal_goto_handler_labels = NULL;
452   f->x_nonlocal_goto_stack_level = NULL;
453   f->x_cleanup_label = NULL;
454   f->x_return_label = NULL;
455   f->computed_goto_common_label = NULL;
456   f->computed_goto_common_reg = NULL;
457   f->x_save_expr_regs = NULL;
458   f->x_stack_slot_list = NULL;
459   f->x_rtl_expr_chain = NULL;
460   f->x_tail_recursion_label = NULL;
461   f->x_tail_recursion_reentry = NULL;
462   f->x_arg_pointer_save_area = NULL;
463   f->x_clobber_return_insn = NULL;
464   f->x_context_display = NULL;
465   f->x_trampoline_list = NULL;
466   f->x_parm_birth_insn = NULL;
467   f->x_last_parm_insn = NULL;
468   f->x_parm_reg_stack_loc = NULL;
469   f->fixup_var_refs_queue = NULL;
470   f->original_arg_vector = NULL;
471   f->original_decl_initial = NULL;
472   f->inl_last_parm_insn = NULL;
473   f->epilogue_delay_list = NULL;
474 }
475 \f
476 /* Allocate fixed slots in the stack frame of the current function.  */
477
478 /* Return size needed for stack frame based on slots so far allocated in
479    function F.
480    This size counts from zero.  It is not rounded to PREFERRED_STACK_BOUNDARY;
481    the caller may have to do that.  */
482
483 HOST_WIDE_INT
484 get_func_frame_size (struct function *f)
485 {
486 #ifdef FRAME_GROWS_DOWNWARD
487   return -f->x_frame_offset;
488 #else
489   return f->x_frame_offset;
490 #endif
491 }
492
493 /* Return size needed for stack frame based on slots so far allocated.
494    This size counts from zero.  It is not rounded to PREFERRED_STACK_BOUNDARY;
495    the caller may have to do that.  */
496 HOST_WIDE_INT
497 get_frame_size (void)
498 {
499   return get_func_frame_size (cfun);
500 }
501
502 /* Allocate a stack slot of SIZE bytes and return a MEM rtx for it
503    with machine mode MODE.
504
505    ALIGN controls the amount of alignment for the address of the slot:
506    0 means according to MODE,
507    -1 means use BIGGEST_ALIGNMENT and round size to multiple of that,
508    positive specifies alignment boundary in bits.
509
510    We do not round to stack_boundary here.
511
512    FUNCTION specifies the function to allocate in.  */
513
514 static rtx
515 assign_stack_local_1 (enum machine_mode mode, HOST_WIDE_INT size, int align,
516                       struct function *function)
517 {
518   rtx x, addr;
519   int bigend_correction = 0;
520   int alignment;
521   int frame_off, frame_alignment, frame_phase;
522
523   if (align == 0)
524     {
525       tree type;
526
527       if (mode == BLKmode)
528         alignment = BIGGEST_ALIGNMENT;
529       else
530         alignment = GET_MODE_ALIGNMENT (mode);
531
532       /* Allow the target to (possibly) increase the alignment of this
533          stack slot.  */
534       type = (*lang_hooks.types.type_for_mode) (mode, 0);
535       if (type)
536         alignment = LOCAL_ALIGNMENT (type, alignment);
537
538       alignment /= BITS_PER_UNIT;
539     }
540   else if (align == -1)
541     {
542       alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
543       size = CEIL_ROUND (size, alignment);
544     }
545   else
546     alignment = align / BITS_PER_UNIT;
547
548 #ifdef FRAME_GROWS_DOWNWARD
549   function->x_frame_offset -= size;
550 #endif
551
552   /* Ignore alignment we can't do with expected alignment of the boundary.  */
553   if (alignment * BITS_PER_UNIT > PREFERRED_STACK_BOUNDARY)
554     alignment = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
555
556   if (function->stack_alignment_needed < alignment * BITS_PER_UNIT)
557     function->stack_alignment_needed = alignment * BITS_PER_UNIT;
558
559   /* Calculate how many bytes the start of local variables is off from
560      stack alignment.  */
561   frame_alignment = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
562   frame_off = STARTING_FRAME_OFFSET % frame_alignment;
563   frame_phase = frame_off ? frame_alignment - frame_off : 0;
564
565   /* Round the frame offset to the specified alignment.  The default is
566      to always honor requests to align the stack but a port may choose to
567      do its own stack alignment by defining STACK_ALIGNMENT_NEEDED.  */
568   if (STACK_ALIGNMENT_NEEDED
569       || mode != BLKmode
570       || size != 0)
571     {
572       /*  We must be careful here, since FRAME_OFFSET might be negative and
573           division with a negative dividend isn't as well defined as we might
574           like.  So we instead assume that ALIGNMENT is a power of two and
575           use logical operations which are unambiguous.  */
576 #ifdef FRAME_GROWS_DOWNWARD
577       function->x_frame_offset
578         = (FLOOR_ROUND (function->x_frame_offset - frame_phase, alignment)
579            + frame_phase);
580 #else
581       function->x_frame_offset
582         = (CEIL_ROUND (function->x_frame_offset - frame_phase, alignment)
583            + frame_phase);
584 #endif
585     }
586
587   /* On a big-endian machine, if we are allocating more space than we will use,
588      use the least significant bytes of those that are allocated.  */
589   if (BYTES_BIG_ENDIAN && mode != BLKmode)
590     bigend_correction = size - GET_MODE_SIZE (mode);
591
592   /* If we have already instantiated virtual registers, return the actual
593      address relative to the frame pointer.  */
594   if (function == cfun && virtuals_instantiated)
595     addr = plus_constant (frame_pointer_rtx,
596                           trunc_int_for_mode
597                           (frame_offset + bigend_correction
598                            + STARTING_FRAME_OFFSET, Pmode));
599   else
600     addr = plus_constant (virtual_stack_vars_rtx,
601                           trunc_int_for_mode
602                           (function->x_frame_offset + bigend_correction,
603                            Pmode));
604
605 #ifndef FRAME_GROWS_DOWNWARD
606   function->x_frame_offset += size;
607 #endif
608
609   x = gen_rtx_MEM (mode, addr);
610
611   function->x_stack_slot_list
612     = gen_rtx_EXPR_LIST (VOIDmode, x, function->x_stack_slot_list);
613
614   return x;
615 }
616
617 /* Wrapper around assign_stack_local_1;  assign a local stack slot for the
618    current function.  */
619
620 rtx
621 assign_stack_local (enum machine_mode mode, HOST_WIDE_INT size, int align)
622 {
623   return assign_stack_local_1 (mode, size, align, cfun);
624 }
625 \f
626 /* Allocate a temporary stack slot and record it for possible later
627    reuse.
628
629    MODE is the machine mode to be given to the returned rtx.
630
631    SIZE is the size in units of the space required.  We do no rounding here
632    since assign_stack_local will do any required rounding.
633
634    KEEP is 1 if this slot is to be retained after a call to
635    free_temp_slots.  Automatic variables for a block are allocated
636    with this flag.  KEEP is 2 if we allocate a longer term temporary,
637    whose lifetime is controlled by CLEANUP_POINT_EXPRs.  KEEP is 3
638    if we are to allocate something at an inner level to be treated as
639    a variable in the block (e.g., a SAVE_EXPR).
640
641    TYPE is the type that will be used for the stack slot.  */
642
643 rtx
644 assign_stack_temp_for_type (enum machine_mode mode, HOST_WIDE_INT size, int keep,
645                             tree type)
646 {
647   unsigned int align;
648   struct temp_slot *p, *best_p = 0;
649   rtx slot;
650
651   /* If SIZE is -1 it means that somebody tried to allocate a temporary
652      of a variable size.  */
653   if (size == -1)
654     abort ();
655
656   if (mode == BLKmode)
657     align = BIGGEST_ALIGNMENT;
658   else
659     align = GET_MODE_ALIGNMENT (mode);
660
661   if (! type)
662     type = (*lang_hooks.types.type_for_mode) (mode, 0);
663
664   if (type)
665     align = LOCAL_ALIGNMENT (type, align);
666
667   /* Try to find an available, already-allocated temporary of the proper
668      mode which meets the size and alignment requirements.  Choose the
669      smallest one with the closest alignment.  */
670   for (p = temp_slots; p; p = p->next)
671     if (p->align >= align && p->size >= size && GET_MODE (p->slot) == mode
672         && ! p->in_use
673         && objects_must_conflict_p (p->type, type)
674         && (best_p == 0 || best_p->size > p->size
675             || (best_p->size == p->size && best_p->align > p->align)))
676       {
677         if (p->align == align && p->size == size)
678           {
679             best_p = 0;
680             break;
681           }
682         best_p = p;
683       }
684
685   /* Make our best, if any, the one to use.  */
686   if (best_p)
687     {
688       /* If there are enough aligned bytes left over, make them into a new
689          temp_slot so that the extra bytes don't get wasted.  Do this only
690          for BLKmode slots, so that we can be sure of the alignment.  */
691       if (GET_MODE (best_p->slot) == BLKmode)
692         {
693           int alignment = best_p->align / BITS_PER_UNIT;
694           HOST_WIDE_INT rounded_size = CEIL_ROUND (size, alignment);
695
696           if (best_p->size - rounded_size >= alignment)
697             {
698               p = ggc_alloc (sizeof (struct temp_slot));
699               p->in_use = p->addr_taken = 0;
700               p->size = best_p->size - rounded_size;
701               p->base_offset = best_p->base_offset + rounded_size;
702               p->full_size = best_p->full_size - rounded_size;
703               p->slot = gen_rtx_MEM (BLKmode,
704                                      plus_constant (XEXP (best_p->slot, 0),
705                                                     rounded_size));
706               p->align = best_p->align;
707               p->address = 0;
708               p->rtl_expr = 0;
709               p->type = best_p->type;
710               p->next = temp_slots;
711               temp_slots = p;
712
713               stack_slot_list = gen_rtx_EXPR_LIST (VOIDmode, p->slot,
714                                                    stack_slot_list);
715
716               best_p->size = rounded_size;
717               best_p->full_size = rounded_size;
718             }
719         }
720
721       p = best_p;
722     }
723
724   /* If we still didn't find one, make a new temporary.  */
725   if (p == 0)
726     {
727       HOST_WIDE_INT frame_offset_old = frame_offset;
728
729       p = ggc_alloc (sizeof (struct temp_slot));
730
731       /* We are passing an explicit alignment request to assign_stack_local.
732          One side effect of that is assign_stack_local will not round SIZE
733          to ensure the frame offset remains suitably aligned.
734
735          So for requests which depended on the rounding of SIZE, we go ahead
736          and round it now.  We also make sure ALIGNMENT is at least
737          BIGGEST_ALIGNMENT.  */
738       if (mode == BLKmode && align < BIGGEST_ALIGNMENT)
739         abort ();
740       p->slot = assign_stack_local (mode,
741                                     (mode == BLKmode
742                                      ? CEIL_ROUND (size, (int) align / BITS_PER_UNIT)
743                                      : size),
744                                     align);
745
746       p->align = align;
747
748       /* The following slot size computation is necessary because we don't
749          know the actual size of the temporary slot until assign_stack_local
750          has performed all the frame alignment and size rounding for the
751          requested temporary.  Note that extra space added for alignment
752          can be either above or below this stack slot depending on which
753          way the frame grows.  We include the extra space if and only if it
754          is above this slot.  */
755 #ifdef FRAME_GROWS_DOWNWARD
756       p->size = frame_offset_old - frame_offset;
757 #else
758       p->size = size;
759 #endif
760
761       /* Now define the fields used by combine_temp_slots.  */
762 #ifdef FRAME_GROWS_DOWNWARD
763       p->base_offset = frame_offset;
764       p->full_size = frame_offset_old - frame_offset;
765 #else
766       p->base_offset = frame_offset_old;
767       p->full_size = frame_offset - frame_offset_old;
768 #endif
769       p->address = 0;
770       p->next = temp_slots;
771       temp_slots = p;
772     }
773
774   p->in_use = 1;
775   p->addr_taken = 0;
776   p->rtl_expr = seq_rtl_expr;
777   p->type = type;
778
779   if (keep == 2)
780     {
781       p->level = target_temp_slot_level;
782       p->keep = 0;
783     }
784   else if (keep == 3)
785     {
786       p->level = var_temp_slot_level;
787       p->keep = 0;
788     }
789   else
790     {
791       p->level = temp_slot_level;
792       p->keep = keep;
793     }
794
795
796   /* Create a new MEM rtx to avoid clobbering MEM flags of old slots.  */
797   slot = gen_rtx_MEM (mode, XEXP (p->slot, 0));
798   stack_slot_list = gen_rtx_EXPR_LIST (VOIDmode, slot, stack_slot_list);
799
800   /* If we know the alias set for the memory that will be used, use
801      it.  If there's no TYPE, then we don't know anything about the
802      alias set for the memory.  */
803   set_mem_alias_set (slot, type ? get_alias_set (type) : 0);
804   set_mem_align (slot, align);
805
806   /* If a type is specified, set the relevant flags.  */
807   if (type != 0)
808     {
809       RTX_UNCHANGING_P (slot) = (lang_hooks.honor_readonly
810                                  && TYPE_READONLY (type));
811       MEM_VOLATILE_P (slot) = TYPE_VOLATILE (type);
812       MEM_SET_IN_STRUCT_P (slot, AGGREGATE_TYPE_P (type));
813     }
814
815   return slot;
816 }
817
818 /* Allocate a temporary stack slot and record it for possible later
819    reuse.  First three arguments are same as in preceding function.  */
820
821 rtx
822 assign_stack_temp (enum machine_mode mode, HOST_WIDE_INT size, int keep)
823 {
824   return assign_stack_temp_for_type (mode, size, keep, NULL_TREE);
825 }
826 \f
827 /* Assign a temporary.
828    If TYPE_OR_DECL is a decl, then we are doing it on behalf of the decl
829    and so that should be used in error messages.  In either case, we
830    allocate of the given type.
831    KEEP is as for assign_stack_temp.
832    MEMORY_REQUIRED is 1 if the result must be addressable stack memory;
833    it is 0 if a register is OK.
834    DONT_PROMOTE is 1 if we should not promote values in register
835    to wider modes.  */
836
837 rtx
838 assign_temp (tree type_or_decl, int keep, int memory_required,
839              int dont_promote ATTRIBUTE_UNUSED)
840 {
841   tree type, decl;
842   enum machine_mode mode;
843 #ifndef PROMOTE_FOR_CALL_ONLY
844   int unsignedp;
845 #endif
846
847   if (DECL_P (type_or_decl))
848     decl = type_or_decl, type = TREE_TYPE (decl);
849   else
850     decl = NULL, type = type_or_decl;
851
852   mode = TYPE_MODE (type);
853 #ifndef PROMOTE_FOR_CALL_ONLY
854   unsignedp = TREE_UNSIGNED (type);
855 #endif
856
857   if (mode == BLKmode || memory_required)
858     {
859       HOST_WIDE_INT size = int_size_in_bytes (type);
860       rtx tmp;
861
862       /* Zero sized arrays are GNU C extension.  Set size to 1 to avoid
863          problems with allocating the stack space.  */
864       if (size == 0)
865         size = 1;
866
867       /* Unfortunately, we don't yet know how to allocate variable-sized
868          temporaries.  However, sometimes we have a fixed upper limit on
869          the size (which is stored in TYPE_ARRAY_MAX_SIZE) and can use that
870          instead.  This is the case for Chill variable-sized strings.  */
871       if (size == -1 && TREE_CODE (type) == ARRAY_TYPE
872           && TYPE_ARRAY_MAX_SIZE (type) != NULL_TREE
873           && host_integerp (TYPE_ARRAY_MAX_SIZE (type), 1))
874         size = tree_low_cst (TYPE_ARRAY_MAX_SIZE (type), 1);
875
876       /* The size of the temporary may be too large to fit into an integer.  */
877       /* ??? Not sure this should happen except for user silliness, so limit
878          this to things that aren't compiler-generated temporaries.  The
879          rest of the time we'll abort in assign_stack_temp_for_type.  */
880       if (decl && size == -1
881           && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST)
882         {
883           error ("%Jsize of variable '%D' is too large", decl, decl);
884           size = 1;
885         }
886
887       tmp = assign_stack_temp_for_type (mode, size, keep, type);
888       return tmp;
889     }
890
891 #ifndef PROMOTE_FOR_CALL_ONLY
892   if (! dont_promote)
893     mode = promote_mode (type, mode, &unsignedp, 0);
894 #endif
895
896   return gen_reg_rtx (mode);
897 }
898 \f
899 /* Combine temporary stack slots which are adjacent on the stack.
900
901    This allows for better use of already allocated stack space.  This is only
902    done for BLKmode slots because we can be sure that we won't have alignment
903    problems in this case.  */
904
905 void
906 combine_temp_slots (void)
907 {
908   struct temp_slot *p, *q;
909   struct temp_slot *prev_p, *prev_q;
910   int num_slots;
911
912   /* We can't combine slots, because the information about which slot
913      is in which alias set will be lost.  */
914   if (flag_strict_aliasing)
915     return;
916
917   /* If there are a lot of temp slots, don't do anything unless
918      high levels of optimization.  */
919   if (! flag_expensive_optimizations)
920     for (p = temp_slots, num_slots = 0; p; p = p->next, num_slots++)
921       if (num_slots > 100 || (num_slots > 10 && optimize == 0))
922         return;
923
924   for (p = temp_slots, prev_p = 0; p; p = prev_p ? prev_p->next : temp_slots)
925     {
926       int delete_p = 0;
927
928       if (! p->in_use && GET_MODE (p->slot) == BLKmode)
929         for (q = p->next, prev_q = p; q; q = prev_q->next)
930           {
931             int delete_q = 0;
932             if (! q->in_use && GET_MODE (q->slot) == BLKmode)
933               {
934                 if (p->base_offset + p->full_size == q->base_offset)
935                   {
936                     /* Q comes after P; combine Q into P.  */
937                     p->size += q->size;
938                     p->full_size += q->full_size;
939                     delete_q = 1;
940                   }
941                 else if (q->base_offset + q->full_size == p->base_offset)
942                   {
943                     /* P comes after Q; combine P into Q.  */
944                     q->size += p->size;
945                     q->full_size += p->full_size;
946                     delete_p = 1;
947                     break;
948                   }
949               }
950             /* Either delete Q or advance past it.  */
951             if (delete_q)
952               prev_q->next = q->next;
953             else
954               prev_q = q;
955           }
956       /* Either delete P or advance past it.  */
957       if (delete_p)
958         {
959           if (prev_p)
960             prev_p->next = p->next;
961           else
962             temp_slots = p->next;
963         }
964       else
965         prev_p = p;
966     }
967 }
968 \f
969 /* Find the temp slot corresponding to the object at address X.  */
970
971 static struct temp_slot *
972 find_temp_slot_from_address (rtx x)
973 {
974   struct temp_slot *p;
975   rtx next;
976
977   for (p = temp_slots; p; p = p->next)
978     {
979       if (! p->in_use)
980         continue;
981
982       else if (XEXP (p->slot, 0) == x
983                || p->address == x
984                || (GET_CODE (x) == PLUS
985                    && XEXP (x, 0) == virtual_stack_vars_rtx
986                    && GET_CODE (XEXP (x, 1)) == CONST_INT
987                    && INTVAL (XEXP (x, 1)) >= p->base_offset
988                    && INTVAL (XEXP (x, 1)) < p->base_offset + p->full_size))
989         return p;
990
991       else if (p->address != 0 && GET_CODE (p->address) == EXPR_LIST)
992         for (next = p->address; next; next = XEXP (next, 1))
993           if (XEXP (next, 0) == x)
994             return p;
995     }
996
997   /* If we have a sum involving a register, see if it points to a temp
998      slot.  */
999   if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == REG
1000       && (p = find_temp_slot_from_address (XEXP (x, 0))) != 0)
1001     return p;
1002   else if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == REG
1003            && (p = find_temp_slot_from_address (XEXP (x, 1))) != 0)
1004     return p;
1005
1006   return 0;
1007 }
1008
1009 /* Indicate that NEW is an alternate way of referring to the temp slot
1010    that previously was known by OLD.  */
1011
1012 void
1013 update_temp_slot_address (rtx old, rtx new)
1014 {
1015   struct temp_slot *p;
1016
1017   if (rtx_equal_p (old, new))
1018     return;
1019
1020   p = find_temp_slot_from_address (old);
1021
1022   /* If we didn't find one, see if both OLD is a PLUS.  If so, and NEW
1023      is a register, see if one operand of the PLUS is a temporary
1024      location.  If so, NEW points into it.  Otherwise, if both OLD and
1025      NEW are a PLUS and if there is a register in common between them.
1026      If so, try a recursive call on those values.  */
1027   if (p == 0)
1028     {
1029       if (GET_CODE (old) != PLUS)
1030         return;
1031
1032       if (GET_CODE (new) == REG)
1033         {
1034           update_temp_slot_address (XEXP (old, 0), new);
1035           update_temp_slot_address (XEXP (old, 1), new);
1036           return;
1037         }
1038       else if (GET_CODE (new) != PLUS)
1039         return;
1040
1041       if (rtx_equal_p (XEXP (old, 0), XEXP (new, 0)))
1042         update_temp_slot_address (XEXP (old, 1), XEXP (new, 1));
1043       else if (rtx_equal_p (XEXP (old, 1), XEXP (new, 0)))
1044         update_temp_slot_address (XEXP (old, 0), XEXP (new, 1));
1045       else if (rtx_equal_p (XEXP (old, 0), XEXP (new, 1)))
1046         update_temp_slot_address (XEXP (old, 1), XEXP (new, 0));
1047       else if (rtx_equal_p (XEXP (old, 1), XEXP (new, 1)))
1048         update_temp_slot_address (XEXP (old, 0), XEXP (new, 0));
1049
1050       return;
1051     }
1052
1053   /* Otherwise add an alias for the temp's address.  */
1054   else if (p->address == 0)
1055     p->address = new;
1056   else
1057     {
1058       if (GET_CODE (p->address) != EXPR_LIST)
1059         p->address = gen_rtx_EXPR_LIST (VOIDmode, p->address, NULL_RTX);
1060
1061       p->address = gen_rtx_EXPR_LIST (VOIDmode, new, p->address);
1062     }
1063 }
1064
1065 /* If X could be a reference to a temporary slot, mark the fact that its
1066    address was taken.  */
1067
1068 void
1069 mark_temp_addr_taken (rtx x)
1070 {
1071   struct temp_slot *p;
1072
1073   if (x == 0)
1074     return;
1075
1076   /* If X is not in memory or is at a constant address, it cannot be in
1077      a temporary slot.  */
1078   if (GET_CODE (x) != MEM || CONSTANT_P (XEXP (x, 0)))
1079     return;
1080
1081   p = find_temp_slot_from_address (XEXP (x, 0));
1082   if (p != 0)
1083     p->addr_taken = 1;
1084 }
1085
1086 /* If X could be a reference to a temporary slot, mark that slot as
1087    belonging to the to one level higher than the current level.  If X
1088    matched one of our slots, just mark that one.  Otherwise, we can't
1089    easily predict which it is, so upgrade all of them.  Kept slots
1090    need not be touched.
1091
1092    This is called when an ({...}) construct occurs and a statement
1093    returns a value in memory.  */
1094
1095 void
1096 preserve_temp_slots (rtx x)
1097 {
1098   struct temp_slot *p = 0;
1099
1100   /* If there is no result, we still might have some objects whose address
1101      were taken, so we need to make sure they stay around.  */
1102   if (x == 0)
1103     {
1104       for (p = temp_slots; p; p = p->next)
1105         if (p->in_use && p->level == temp_slot_level && p->addr_taken)
1106           p->level--;
1107
1108       return;
1109     }
1110
1111   /* If X is a register that is being used as a pointer, see if we have
1112      a temporary slot we know it points to.  To be consistent with
1113      the code below, we really should preserve all non-kept slots
1114      if we can't find a match, but that seems to be much too costly.  */
1115   if (GET_CODE (x) == REG && REG_POINTER (x))
1116     p = find_temp_slot_from_address (x);
1117
1118   /* If X is not in memory or is at a constant address, it cannot be in
1119      a temporary slot, but it can contain something whose address was
1120      taken.  */
1121   if (p == 0 && (GET_CODE (x) != MEM || CONSTANT_P (XEXP (x, 0))))
1122     {
1123       for (p = temp_slots; p; p = p->next)
1124         if (p->in_use && p->level == temp_slot_level && p->addr_taken)
1125           p->level--;
1126
1127       return;
1128     }
1129
1130   /* First see if we can find a match.  */
1131   if (p == 0)
1132     p = find_temp_slot_from_address (XEXP (x, 0));
1133
1134   if (p != 0)
1135     {
1136       /* Move everything at our level whose address was taken to our new
1137          level in case we used its address.  */
1138       struct temp_slot *q;
1139
1140       if (p->level == temp_slot_level)
1141         {
1142           for (q = temp_slots; q; q = q->next)
1143             if (q != p && q->addr_taken && q->level == p->level)
1144               q->level--;
1145
1146           p->level--;
1147           p->addr_taken = 0;
1148         }
1149       return;
1150     }
1151
1152   /* Otherwise, preserve all non-kept slots at this level.  */
1153   for (p = temp_slots; p; p = p->next)
1154     if (p->in_use && p->level == temp_slot_level && ! p->keep)
1155       p->level--;
1156 }
1157
1158 /* X is the result of an RTL_EXPR.  If it is a temporary slot associated
1159    with that RTL_EXPR, promote it into a temporary slot at the present
1160    level so it will not be freed when we free slots made in the
1161    RTL_EXPR.  */
1162
1163 void
1164 preserve_rtl_expr_result (rtx x)
1165 {
1166   struct temp_slot *p;
1167
1168   /* If X is not in memory or is at a constant address, it cannot be in
1169      a temporary slot.  */
1170   if (x == 0 || GET_CODE (x) != MEM || CONSTANT_P (XEXP (x, 0)))
1171     return;
1172
1173   /* If we can find a match, move it to our level unless it is already at
1174      an upper level.  */
1175   p = find_temp_slot_from_address (XEXP (x, 0));
1176   if (p != 0)
1177     {
1178       p->level = MIN (p->level, temp_slot_level);
1179       p->rtl_expr = 0;
1180     }
1181
1182   return;
1183 }
1184
1185 /* Free all temporaries used so far.  This is normally called at the end
1186    of generating code for a statement.  Don't free any temporaries
1187    currently in use for an RTL_EXPR that hasn't yet been emitted.
1188    We could eventually do better than this since it can be reused while
1189    generating the same RTL_EXPR, but this is complex and probably not
1190    worthwhile.  */
1191
1192 void
1193 free_temp_slots (void)
1194 {
1195   struct temp_slot *p;
1196
1197   for (p = temp_slots; p; p = p->next)
1198     if (p->in_use && p->level == temp_slot_level && ! p->keep
1199         && p->rtl_expr == 0)
1200       p->in_use = 0;
1201
1202   combine_temp_slots ();
1203 }
1204
1205 /* Free all temporary slots used in T, an RTL_EXPR node.  */
1206
1207 void
1208 free_temps_for_rtl_expr (tree t)
1209 {
1210   struct temp_slot *p;
1211
1212   for (p = temp_slots; p; p = p->next)
1213     if (p->rtl_expr == t)
1214       {
1215         /* If this slot is below the current TEMP_SLOT_LEVEL, then it
1216            needs to be preserved.  This can happen if a temporary in
1217            the RTL_EXPR was addressed; preserve_temp_slots will move
1218            the temporary into a higher level.  */
1219         if (temp_slot_level <= p->level)
1220           p->in_use = 0;
1221         else
1222           p->rtl_expr = NULL_TREE;
1223       }
1224
1225   combine_temp_slots ();
1226 }
1227
1228 /* Mark all temporaries ever allocated in this function as not suitable
1229    for reuse until the current level is exited.  */
1230
1231 void
1232 mark_all_temps_used (void)
1233 {
1234   struct temp_slot *p;
1235
1236   for (p = temp_slots; p; p = p->next)
1237     {
1238       p->in_use = p->keep = 1;
1239       p->level = MIN (p->level, temp_slot_level);
1240     }
1241 }
1242
1243 /* Push deeper into the nesting level for stack temporaries.  */
1244
1245 void
1246 push_temp_slots (void)
1247 {
1248   temp_slot_level++;
1249 }
1250
1251 /* Pop a temporary nesting level.  All slots in use in the current level
1252    are freed.  */
1253
1254 void
1255 pop_temp_slots (void)
1256 {
1257   struct temp_slot *p;
1258
1259   for (p = temp_slots; p; p = p->next)
1260     if (p->in_use && p->level == temp_slot_level && p->rtl_expr == 0)
1261       p->in_use = 0;
1262
1263   combine_temp_slots ();
1264
1265   temp_slot_level--;
1266 }
1267
1268 /* Initialize temporary slots.  */
1269
1270 void
1271 init_temp_slots (void)
1272 {
1273   /* We have not allocated any temporaries yet.  */
1274   temp_slots = 0;
1275   temp_slot_level = 0;
1276   var_temp_slot_level = 0;
1277   target_temp_slot_level = 0;
1278 }
1279 \f
1280 /* Retroactively move an auto variable from a register to a stack
1281    slot.  This is done when an address-reference to the variable is
1282    seen.  If RESCAN is true, all previously emitted instructions are
1283    examined and modified to handle the fact that DECL is now
1284    addressable.  */
1285
1286 void
1287 put_var_into_stack (tree decl, int rescan)
1288 {
1289   rtx reg;
1290   enum machine_mode promoted_mode, decl_mode;
1291   struct function *function = 0;
1292   tree context;
1293   int can_use_addressof;
1294   int volatilep = TREE_CODE (decl) != SAVE_EXPR && TREE_THIS_VOLATILE (decl);
1295   int usedp = (TREE_USED (decl)
1296                || (TREE_CODE (decl) != SAVE_EXPR && DECL_INITIAL (decl) != 0));
1297
1298   context = decl_function_context (decl);
1299
1300   /* Get the current rtl used for this object and its original mode.  */
1301   reg = (TREE_CODE (decl) == SAVE_EXPR
1302          ? SAVE_EXPR_RTL (decl)
1303          : DECL_RTL_IF_SET (decl));
1304
1305   /* No need to do anything if decl has no rtx yet
1306      since in that case caller is setting TREE_ADDRESSABLE
1307      and a stack slot will be assigned when the rtl is made.  */
1308   if (reg == 0)
1309     return;
1310
1311   /* Get the declared mode for this object.  */
1312   decl_mode = (TREE_CODE (decl) == SAVE_EXPR ? TYPE_MODE (TREE_TYPE (decl))
1313                : DECL_MODE (decl));
1314   /* Get the mode it's actually stored in.  */
1315   promoted_mode = GET_MODE (reg);
1316
1317   /* If this variable comes from an outer function, find that
1318      function's saved context.  Don't use find_function_data here,
1319      because it might not be in any active function.
1320      FIXME: Is that really supposed to happen?
1321      It does in ObjC at least.  */
1322   if (context != current_function_decl && context != inline_function_decl)
1323     for (function = outer_function_chain; function; function = function->outer)
1324       if (function->decl == context)
1325         break;
1326
1327   /* If this is a variable-sized object or a structure passed by invisible
1328      reference, with a pseudo to address it, put that pseudo into the stack
1329      if the var is non-local.  */
1330   if (TREE_CODE (decl) != SAVE_EXPR && DECL_NONLOCAL (decl)
1331       && GET_CODE (reg) == MEM
1332       && GET_CODE (XEXP (reg, 0)) == REG
1333       && REGNO (XEXP (reg, 0)) > LAST_VIRTUAL_REGISTER)
1334     {
1335       reg = XEXP (reg, 0);
1336       decl_mode = promoted_mode = GET_MODE (reg);
1337     }
1338
1339   /* If this variable lives in the current function and we don't need to put it
1340      in the stack for the sake of setjmp or the non-locality, try to keep it in
1341      a register until we know we actually need the address.  */
1342   can_use_addressof
1343     = (function == 0
1344        && ! (TREE_CODE (decl) != SAVE_EXPR && DECL_NONLOCAL (decl))
1345        && optimize > 0
1346        /* FIXME make it work for promoted modes too */
1347        && decl_mode == promoted_mode
1348 #ifdef NON_SAVING_SETJMP
1349        && ! (NON_SAVING_SETJMP && current_function_calls_setjmp)
1350 #endif
1351        );
1352
1353   /* If we can't use ADDRESSOF, make sure we see through one we already
1354      generated.  */
1355   if (! can_use_addressof && GET_CODE (reg) == MEM
1356       && GET_CODE (XEXP (reg, 0)) == ADDRESSOF)
1357     reg = XEXP (XEXP (reg, 0), 0);
1358
1359   /* Now we should have a value that resides in one or more pseudo regs.  */
1360
1361   if (GET_CODE (reg) == REG)
1362     {
1363       if (can_use_addressof)
1364         gen_mem_addressof (reg, decl, rescan);
1365       else
1366         put_reg_into_stack (function, reg, TREE_TYPE (decl), promoted_mode,
1367                             decl_mode, volatilep, 0, usedp, 0);
1368     }
1369   else if (GET_CODE (reg) == CONCAT)
1370     {
1371       /* A CONCAT contains two pseudos; put them both in the stack.
1372          We do it so they end up consecutive.
1373          We fixup references to the parts only after we fixup references
1374          to the whole CONCAT, lest we do double fixups for the latter
1375          references.  */
1376       enum machine_mode part_mode = GET_MODE (XEXP (reg, 0));
1377       tree part_type = (*lang_hooks.types.type_for_mode) (part_mode, 0);
1378       rtx lopart = XEXP (reg, 0);
1379       rtx hipart = XEXP (reg, 1);
1380 #ifdef FRAME_GROWS_DOWNWARD
1381       /* Since part 0 should have a lower address, do it second.  */
1382       put_reg_into_stack (function, hipart, part_type, part_mode,
1383                           part_mode, volatilep, 0, 0, 0);
1384       put_reg_into_stack (function, lopart, part_type, part_mode,
1385                           part_mode, volatilep, 0, 0, 0);
1386 #else
1387       put_reg_into_stack (function, lopart, part_type, part_mode,
1388                           part_mode, volatilep, 0, 0, 0);
1389       put_reg_into_stack (function, hipart, part_type, part_mode,
1390                           part_mode, volatilep, 0, 0, 0);
1391 #endif
1392
1393       /* Change the CONCAT into a combined MEM for both parts.  */
1394       PUT_CODE (reg, MEM);
1395       MEM_ATTRS (reg) = 0;
1396
1397       /* set_mem_attributes uses DECL_RTL to avoid re-generating of
1398          already computed alias sets.  Here we want to re-generate.  */
1399       if (DECL_P (decl))
1400         SET_DECL_RTL (decl, NULL);
1401       set_mem_attributes (reg, decl, 1);
1402       if (DECL_P (decl))
1403         SET_DECL_RTL (decl, reg);
1404
1405       /* The two parts are in memory order already.
1406          Use the lower parts address as ours.  */
1407       XEXP (reg, 0) = XEXP (XEXP (reg, 0), 0);
1408       /* Prevent sharing of rtl that might lose.  */
1409       if (GET_CODE (XEXP (reg, 0)) == PLUS)
1410         XEXP (reg, 0) = copy_rtx (XEXP (reg, 0));
1411       if (usedp && rescan)
1412         {
1413           schedule_fixup_var_refs (function, reg, TREE_TYPE (decl),
1414                                    promoted_mode, 0);
1415           schedule_fixup_var_refs (function, lopart, part_type, part_mode, 0);
1416           schedule_fixup_var_refs (function, hipart, part_type, part_mode, 0);
1417         }
1418     }
1419   else
1420     return;
1421 }
1422
1423 /* Subroutine of put_var_into_stack.  This puts a single pseudo reg REG
1424    into the stack frame of FUNCTION (0 means the current function).
1425    DECL_MODE is the machine mode of the user-level data type.
1426    PROMOTED_MODE is the machine mode of the register.
1427    VOLATILE_P is nonzero if this is for a "volatile" decl.
1428    USED_P is nonzero if this reg might have already been used in an insn.  */
1429
1430 static void
1431 put_reg_into_stack (struct function *function, rtx reg, tree type,
1432                     enum machine_mode promoted_mode, enum machine_mode decl_mode,
1433                     int volatile_p, unsigned int original_regno, int used_p, htab_t ht)
1434 {
1435   struct function *func = function ? function : cfun;
1436   rtx new = 0;
1437   unsigned int regno = original_regno;
1438
1439   if (regno == 0)
1440     regno = REGNO (reg);
1441
1442   if (regno < func->x_max_parm_reg)
1443     new = func->x_parm_reg_stack_loc[regno];
1444
1445   if (new == 0)
1446     new = assign_stack_local_1 (decl_mode, GET_MODE_SIZE (decl_mode), 0, func);
1447
1448   PUT_CODE (reg, MEM);
1449   PUT_MODE (reg, decl_mode);
1450   XEXP (reg, 0) = XEXP (new, 0);
1451   MEM_ATTRS (reg) = 0;
1452   /* `volatil' bit means one thing for MEMs, another entirely for REGs.  */
1453   MEM_VOLATILE_P (reg) = volatile_p;
1454
1455   /* If this is a memory ref that contains aggregate components,
1456      mark it as such for cse and loop optimize.  If we are reusing a
1457      previously generated stack slot, then we need to copy the bit in
1458      case it was set for other reasons.  For instance, it is set for
1459      __builtin_va_alist.  */
1460   if (type)
1461     {
1462       MEM_SET_IN_STRUCT_P (reg,
1463                            AGGREGATE_TYPE_P (type) || MEM_IN_STRUCT_P (new));
1464       set_mem_alias_set (reg, get_alias_set (type));
1465     }
1466
1467   if (used_p)
1468     schedule_fixup_var_refs (function, reg, type, promoted_mode, ht);
1469 }
1470
1471 /* Make sure that all refs to the variable, previously made
1472    when it was a register, are fixed up to be valid again.
1473    See function above for meaning of arguments.  */
1474
1475 static void
1476 schedule_fixup_var_refs (struct function *function, rtx reg, tree type,
1477                          enum machine_mode promoted_mode, htab_t ht)
1478 {
1479   int unsigned_p = type ? TREE_UNSIGNED (type) : 0;
1480
1481   if (function != 0)
1482     {
1483       struct var_refs_queue *temp;
1484
1485       temp = ggc_alloc (sizeof (struct var_refs_queue));
1486       temp->modified = reg;
1487       temp->promoted_mode = promoted_mode;
1488       temp->unsignedp = unsigned_p;
1489       temp->next = function->fixup_var_refs_queue;
1490       function->fixup_var_refs_queue = temp;
1491     }
1492   else
1493     /* Variable is local; fix it up now.  */
1494     fixup_var_refs (reg, promoted_mode, unsigned_p, reg, ht);
1495 }
1496 \f
1497 static void
1498 fixup_var_refs (rtx var, enum machine_mode promoted_mode, int unsignedp,
1499                 rtx may_share, htab_t ht)
1500 {
1501   tree pending;
1502   rtx first_insn = get_insns ();
1503   struct sequence_stack *stack = seq_stack;
1504   tree rtl_exps = rtl_expr_chain;
1505
1506   /* If there's a hash table, it must record all uses of VAR.  */
1507   if (ht)
1508     {
1509       if (stack != 0)
1510         abort ();
1511       fixup_var_refs_insns_with_hash (ht, var, promoted_mode, unsignedp,
1512                                       may_share);
1513       return;
1514     }
1515
1516   fixup_var_refs_insns (first_insn, var, promoted_mode, unsignedp,
1517                         stack == 0, may_share);
1518
1519   /* Scan all pending sequences too.  */
1520   for (; stack; stack = stack->next)
1521     {
1522       push_to_full_sequence (stack->first, stack->last);
1523       fixup_var_refs_insns (stack->first, var, promoted_mode, unsignedp,
1524                             stack->next != 0, may_share);
1525       /* Update remembered end of sequence
1526          in case we added an insn at the end.  */
1527       stack->last = get_last_insn ();
1528       end_sequence ();
1529     }
1530
1531   /* Scan all waiting RTL_EXPRs too.  */
1532   for (pending = rtl_exps; pending; pending = TREE_CHAIN (pending))
1533     {
1534       rtx seq = RTL_EXPR_SEQUENCE (TREE_VALUE (pending));
1535       if (seq != const0_rtx && seq != 0)
1536         {
1537           push_to_sequence (seq);
1538           fixup_var_refs_insns (seq, var, promoted_mode, unsignedp, 0,
1539                                 may_share);
1540           end_sequence ();
1541         }
1542     }
1543 }
1544 \f
1545 /* REPLACEMENTS is a pointer to a list of the struct fixup_replacement and X is
1546    some part of an insn.  Return a struct fixup_replacement whose OLD
1547    value is equal to X.  Allocate a new structure if no such entry exists.  */
1548
1549 static struct fixup_replacement *
1550 find_fixup_replacement (struct fixup_replacement **replacements, rtx x)
1551 {
1552   struct fixup_replacement *p;
1553
1554   /* See if we have already replaced this.  */
1555   for (p = *replacements; p != 0 && ! rtx_equal_p (p->old, x); p = p->next)
1556     ;
1557
1558   if (p == 0)
1559     {
1560       p = xmalloc (sizeof (struct fixup_replacement));
1561       p->old = x;
1562       p->new = 0;
1563       p->next = *replacements;
1564       *replacements = p;
1565     }
1566
1567   return p;
1568 }
1569
1570 /* Scan the insn-chain starting with INSN for refs to VAR and fix them
1571    up.  TOPLEVEL is nonzero if this chain is the main chain of insns
1572    for the current function.  MAY_SHARE is either a MEM that is not
1573    to be unshared or a list of them.  */
1574
1575 static void
1576 fixup_var_refs_insns (rtx insn, rtx var, enum machine_mode promoted_mode,
1577                       int unsignedp, int toplevel, rtx may_share)
1578 {
1579   while (insn)
1580     {
1581       /* fixup_var_refs_insn might modify insn, so save its next
1582          pointer now.  */
1583       rtx next = NEXT_INSN (insn);
1584
1585       /* CALL_PLACEHOLDERs are special; we have to switch into each of
1586          the three sequences they (potentially) contain, and process
1587          them recursively.  The CALL_INSN itself is not interesting.  */
1588
1589       if (GET_CODE (insn) == CALL_INSN
1590           && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
1591         {
1592           int i;
1593
1594           /* Look at the Normal call, sibling call and tail recursion
1595              sequences attached to the CALL_PLACEHOLDER.  */
1596           for (i = 0; i < 3; i++)
1597             {
1598               rtx seq = XEXP (PATTERN (insn), i);
1599               if (seq)
1600                 {
1601                   push_to_sequence (seq);
1602                   fixup_var_refs_insns (seq, var, promoted_mode, unsignedp, 0,
1603                                         may_share);
1604                   XEXP (PATTERN (insn), i) = get_insns ();
1605                   end_sequence ();
1606                 }
1607             }
1608         }
1609
1610       else if (INSN_P (insn))
1611         fixup_var_refs_insn (insn, var, promoted_mode, unsignedp, toplevel,
1612                              may_share);
1613
1614       insn = next;
1615     }
1616 }
1617
1618 /* Look up the insns which reference VAR in HT and fix them up.  Other
1619    arguments are the same as fixup_var_refs_insns.
1620
1621    N.B. No need for special processing of CALL_PLACEHOLDERs here,
1622    because the hash table will point straight to the interesting insn
1623    (inside the CALL_PLACEHOLDER).  */
1624
1625 static void
1626 fixup_var_refs_insns_with_hash (htab_t ht, rtx var, enum machine_mode promoted_mode,
1627                                 int unsignedp, rtx may_share)
1628 {
1629   struct insns_for_mem_entry tmp;
1630   struct insns_for_mem_entry *ime;
1631   rtx insn_list;
1632
1633   tmp.key = var;
1634   ime = htab_find (ht, &tmp);
1635   for (insn_list = ime->insns; insn_list != 0; insn_list = XEXP (insn_list, 1))
1636     if (INSN_P (XEXP (insn_list, 0)))
1637       fixup_var_refs_insn (XEXP (insn_list, 0), var, promoted_mode,
1638                            unsignedp, 1, may_share);
1639 }
1640
1641
1642 /* Per-insn processing by fixup_var_refs_insns(_with_hash).  INSN is
1643    the insn under examination, VAR is the variable to fix up
1644    references to, PROMOTED_MODE and UNSIGNEDP describe VAR, and
1645    TOPLEVEL is nonzero if this is the main insn chain for this
1646    function.  */
1647
1648 static void
1649 fixup_var_refs_insn (rtx insn, rtx var, enum machine_mode promoted_mode,
1650                      int unsignedp, int toplevel, rtx no_share)
1651 {
1652   rtx call_dest = 0;
1653   rtx set, prev, prev_set;
1654   rtx note;
1655
1656   /* Remember the notes in case we delete the insn.  */
1657   note = REG_NOTES (insn);
1658
1659   /* If this is a CLOBBER of VAR, delete it.
1660
1661      If it has a REG_LIBCALL note, delete the REG_LIBCALL
1662      and REG_RETVAL notes too.  */
1663   if (GET_CODE (PATTERN (insn)) == CLOBBER
1664       && (XEXP (PATTERN (insn), 0) == var
1665           || (GET_CODE (XEXP (PATTERN (insn), 0)) == CONCAT
1666               && (XEXP (XEXP (PATTERN (insn), 0), 0) == var
1667                   || XEXP (XEXP (PATTERN (insn), 0), 1) == var))))
1668     {
1669       if ((note = find_reg_note (insn, REG_LIBCALL, NULL_RTX)) != 0)
1670         /* The REG_LIBCALL note will go away since we are going to
1671            turn INSN into a NOTE, so just delete the
1672            corresponding REG_RETVAL note.  */
1673         remove_note (XEXP (note, 0),
1674                      find_reg_note (XEXP (note, 0), REG_RETVAL,
1675                                     NULL_RTX));
1676
1677       delete_insn (insn);
1678     }
1679
1680   /* The insn to load VAR from a home in the arglist
1681      is now a no-op.  When we see it, just delete it.
1682      Similarly if this is storing VAR from a register from which
1683      it was loaded in the previous insn.  This will occur
1684      when an ADDRESSOF was made for an arglist slot.  */
1685   else if (toplevel
1686            && (set = single_set (insn)) != 0
1687            && SET_DEST (set) == var
1688            /* If this represents the result of an insn group,
1689               don't delete the insn.  */
1690            && find_reg_note (insn, REG_RETVAL, NULL_RTX) == 0
1691            && (rtx_equal_p (SET_SRC (set), var)
1692                || (GET_CODE (SET_SRC (set)) == REG
1693                    && (prev = prev_nonnote_insn (insn)) != 0
1694                    && (prev_set = single_set (prev)) != 0
1695                    && SET_DEST (prev_set) == SET_SRC (set)
1696                    && rtx_equal_p (SET_SRC (prev_set), var))))
1697     {
1698       delete_insn (insn);
1699     }
1700   else
1701     {
1702       struct fixup_replacement *replacements = 0;
1703       rtx next_insn = NEXT_INSN (insn);
1704
1705       if (SMALL_REGISTER_CLASSES)
1706         {
1707           /* If the insn that copies the results of a CALL_INSN
1708              into a pseudo now references VAR, we have to use an
1709              intermediate pseudo since we want the life of the
1710              return value register to be only a single insn.
1711
1712              If we don't use an intermediate pseudo, such things as
1713              address computations to make the address of VAR valid
1714              if it is not can be placed between the CALL_INSN and INSN.
1715
1716              To make sure this doesn't happen, we record the destination
1717              of the CALL_INSN and see if the next insn uses both that
1718              and VAR.  */
1719
1720           if (call_dest != 0 && GET_CODE (insn) == INSN
1721               && reg_mentioned_p (var, PATTERN (insn))
1722               && reg_mentioned_p (call_dest, PATTERN (insn)))
1723             {
1724               rtx temp = gen_reg_rtx (GET_MODE (call_dest));
1725
1726               emit_insn_before (gen_move_insn (temp, call_dest), insn);
1727
1728               PATTERN (insn) = replace_rtx (PATTERN (insn),
1729                                             call_dest, temp);
1730             }
1731
1732           if (GET_CODE (insn) == CALL_INSN
1733               && GET_CODE (PATTERN (insn)) == SET)
1734             call_dest = SET_DEST (PATTERN (insn));
1735           else if (GET_CODE (insn) == CALL_INSN
1736                    && GET_CODE (PATTERN (insn)) == PARALLEL
1737                    && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == SET)
1738             call_dest = SET_DEST (XVECEXP (PATTERN (insn), 0, 0));
1739           else
1740             call_dest = 0;
1741         }
1742
1743       /* See if we have to do anything to INSN now that VAR is in
1744          memory.  If it needs to be loaded into a pseudo, use a single
1745          pseudo for the entire insn in case there is a MATCH_DUP
1746          between two operands.  We pass a pointer to the head of
1747          a list of struct fixup_replacements.  If fixup_var_refs_1
1748          needs to allocate pseudos or replacement MEMs (for SUBREGs),
1749          it will record them in this list.
1750
1751          If it allocated a pseudo for any replacement, we copy into
1752          it here.  */
1753
1754       fixup_var_refs_1 (var, promoted_mode, &PATTERN (insn), insn,
1755                         &replacements, no_share);
1756
1757       /* If this is last_parm_insn, and any instructions were output
1758          after it to fix it up, then we must set last_parm_insn to
1759          the last such instruction emitted.  */
1760       if (insn == last_parm_insn)
1761         last_parm_insn = PREV_INSN (next_insn);
1762
1763       while (replacements)
1764         {
1765           struct fixup_replacement *next;
1766
1767           if (GET_CODE (replacements->new) == REG)
1768             {
1769               rtx insert_before;
1770               rtx seq;
1771
1772               /* OLD might be a (subreg (mem)).  */
1773               if (GET_CODE (replacements->old) == SUBREG)
1774                 replacements->old
1775                   = fixup_memory_subreg (replacements->old, insn,
1776                                          promoted_mode, 0);
1777               else
1778                 replacements->old
1779                   = fixup_stack_1 (replacements->old, insn);
1780
1781               insert_before = insn;
1782
1783               /* If we are changing the mode, do a conversion.
1784                  This might be wasteful, but combine.c will
1785                  eliminate much of the waste.  */
1786
1787               if (GET_MODE (replacements->new)
1788                   != GET_MODE (replacements->old))
1789                 {
1790                   start_sequence ();
1791                   convert_move (replacements->new,
1792                                 replacements->old, unsignedp);
1793                   seq = get_insns ();
1794                   end_sequence ();
1795                 }
1796               else
1797                 seq = gen_move_insn (replacements->new,
1798                                      replacements->old);
1799
1800               emit_insn_before (seq, insert_before);
1801             }
1802
1803           next = replacements->next;
1804           free (replacements);
1805           replacements = next;
1806         }
1807     }
1808
1809   /* Also fix up any invalid exprs in the REG_NOTES of this insn.
1810      But don't touch other insns referred to by reg-notes;
1811      we will get them elsewhere.  */
1812   while (note)
1813     {
1814       if (GET_CODE (note) != INSN_LIST)
1815         XEXP (note, 0)
1816           = walk_fixup_memory_subreg (XEXP (note, 0), insn,
1817                                       promoted_mode, 1);
1818       note = XEXP (note, 1);
1819     }
1820 }
1821 \f
1822 /* VAR is a MEM that used to be a pseudo register with mode PROMOTED_MODE.
1823    See if the rtx expression at *LOC in INSN needs to be changed.
1824
1825    REPLACEMENTS is a pointer to a list head that starts out zero, but may
1826    contain a list of original rtx's and replacements. If we find that we need
1827    to modify this insn by replacing a memory reference with a pseudo or by
1828    making a new MEM to implement a SUBREG, we consult that list to see if
1829    we have already chosen a replacement. If none has already been allocated,
1830    we allocate it and update the list.  fixup_var_refs_insn will copy VAR
1831    or the SUBREG, as appropriate, to the pseudo.  */
1832
1833 static void
1834 fixup_var_refs_1 (rtx var, enum machine_mode promoted_mode, rtx *loc, rtx insn,
1835                   struct fixup_replacement **replacements, rtx no_share)
1836 {
1837   int i;
1838   rtx x = *loc;
1839   RTX_CODE code = GET_CODE (x);
1840   const char *fmt;
1841   rtx tem, tem1;
1842   struct fixup_replacement *replacement;
1843
1844   switch (code)
1845     {
1846     case ADDRESSOF:
1847       if (XEXP (x, 0) == var)
1848         {
1849           /* Prevent sharing of rtl that might lose.  */
1850           rtx sub = copy_rtx (XEXP (var, 0));
1851
1852           if (! validate_change (insn, loc, sub, 0))
1853             {
1854               rtx y = gen_reg_rtx (GET_MODE (sub));
1855               rtx seq, new_insn;
1856
1857               /* We should be able to replace with a register or all is lost.
1858                  Note that we can't use validate_change to verify this, since
1859                  we're not caring for replacing all dups simultaneously.  */
1860               if (! validate_replace_rtx (*loc, y, insn))
1861                 abort ();
1862
1863               /* Careful!  First try to recognize a direct move of the
1864                  value, mimicking how things are done in gen_reload wrt
1865                  PLUS.  Consider what happens when insn is a conditional
1866                  move instruction and addsi3 clobbers flags.  */
1867
1868               start_sequence ();
1869               new_insn = emit_insn (gen_rtx_SET (VOIDmode, y, sub));
1870               seq = get_insns ();
1871               end_sequence ();
1872
1873               if (recog_memoized (new_insn) < 0)
1874                 {
1875                   /* That failed.  Fall back on force_operand and hope.  */
1876
1877                   start_sequence ();
1878                   sub = force_operand (sub, y);
1879                   if (sub != y)
1880                     emit_insn (gen_move_insn (y, sub));
1881                   seq = get_insns ();
1882                   end_sequence ();
1883                 }
1884
1885 #ifdef HAVE_cc0
1886               /* Don't separate setter from user.  */
1887               if (PREV_INSN (insn) && sets_cc0_p (PREV_INSN (insn)))
1888                 insn = PREV_INSN (insn);
1889 #endif
1890
1891               emit_insn_before (seq, insn);
1892             }
1893         }
1894       return;
1895
1896     case MEM:
1897       if (var == x)
1898         {
1899           /* If we already have a replacement, use it.  Otherwise,
1900              try to fix up this address in case it is invalid.  */
1901
1902           replacement = find_fixup_replacement (replacements, var);
1903           if (replacement->new)
1904             {
1905               *loc = replacement->new;
1906               return;
1907             }
1908
1909           *loc = replacement->new = x = fixup_stack_1 (x, insn);
1910
1911           /* Unless we are forcing memory to register or we changed the mode,
1912              we can leave things the way they are if the insn is valid.  */
1913
1914           INSN_CODE (insn) = -1;
1915           if (! flag_force_mem && GET_MODE (x) == promoted_mode
1916               && recog_memoized (insn) >= 0)
1917             return;
1918
1919           *loc = replacement->new = gen_reg_rtx (promoted_mode);
1920           return;
1921         }
1922
1923       /* If X contains VAR, we need to unshare it here so that we update
1924          each occurrence separately.  But all identical MEMs in one insn
1925          must be replaced with the same rtx because of the possibility of
1926          MATCH_DUPs.  */
1927
1928       if (reg_mentioned_p (var, x))
1929         {
1930           replacement = find_fixup_replacement (replacements, x);
1931           if (replacement->new == 0)
1932             replacement->new = copy_most_rtx (x, no_share);
1933
1934           *loc = x = replacement->new;
1935           code = GET_CODE (x);
1936         }
1937       break;
1938
1939     case REG:
1940     case CC0:
1941     case PC:
1942     case CONST_INT:
1943     case CONST:
1944     case SYMBOL_REF:
1945     case LABEL_REF:
1946     case CONST_DOUBLE:
1947     case CONST_VECTOR:
1948       return;
1949
1950     case SIGN_EXTRACT:
1951     case ZERO_EXTRACT:
1952       /* Note that in some cases those types of expressions are altered
1953          by optimize_bit_field, and do not survive to get here.  */
1954       if (XEXP (x, 0) == var
1955           || (GET_CODE (XEXP (x, 0)) == SUBREG
1956               && SUBREG_REG (XEXP (x, 0)) == var))
1957         {
1958           /* Get TEM as a valid MEM in the mode presently in the insn.
1959
1960              We don't worry about the possibility of MATCH_DUP here; it
1961              is highly unlikely and would be tricky to handle.  */
1962
1963           tem = XEXP (x, 0);
1964           if (GET_CODE (tem) == SUBREG)
1965             {
1966               if (GET_MODE_BITSIZE (GET_MODE (tem))
1967                   > GET_MODE_BITSIZE (GET_MODE (var)))
1968                 {
1969                   replacement = find_fixup_replacement (replacements, var);
1970                   if (replacement->new == 0)
1971                     replacement->new = gen_reg_rtx (GET_MODE (var));
1972                   SUBREG_REG (tem) = replacement->new;
1973
1974                   /* The following code works only if we have a MEM, so we
1975                      need to handle the subreg here.  We directly substitute
1976                      it assuming that a subreg must be OK here.  We already
1977                      scheduled a replacement to copy the mem into the
1978                      subreg.  */
1979                   XEXP (x, 0) = tem;
1980                   return;
1981                 }
1982               else
1983                 tem = fixup_memory_subreg (tem, insn, promoted_mode, 0);
1984             }
1985           else
1986             tem = fixup_stack_1 (tem, insn);
1987
1988           /* Unless we want to load from memory, get TEM into the proper mode
1989              for an extract from memory.  This can only be done if the
1990              extract is at a constant position and length.  */
1991
1992           if (! flag_force_mem && GET_CODE (XEXP (x, 1)) == CONST_INT
1993               && GET_CODE (XEXP (x, 2)) == CONST_INT
1994               && ! mode_dependent_address_p (XEXP (tem, 0))
1995               && ! MEM_VOLATILE_P (tem))
1996             {
1997               enum machine_mode wanted_mode = VOIDmode;
1998               enum machine_mode is_mode = GET_MODE (tem);
1999               HOST_WIDE_INT pos = INTVAL (XEXP (x, 2));
2000
2001               if (GET_CODE (x) == ZERO_EXTRACT)
2002                 {
2003                   enum machine_mode new_mode
2004                     = mode_for_extraction (EP_extzv, 1);
2005                   if (new_mode != MAX_MACHINE_MODE)
2006                     wanted_mode = new_mode;
2007                 }
2008               else if (GET_CODE (x) == SIGN_EXTRACT)
2009                 {
2010                   enum machine_mode new_mode
2011                     = mode_for_extraction (EP_extv, 1);
2012                   if (new_mode != MAX_MACHINE_MODE)
2013                     wanted_mode = new_mode;
2014                 }
2015
2016               /* If we have a narrower mode, we can do something.  */
2017               if (wanted_mode != VOIDmode
2018                   && GET_MODE_SIZE (wanted_mode) < GET_MODE_SIZE (is_mode))
2019                 {
2020                   HOST_WIDE_INT offset = pos / BITS_PER_UNIT;
2021                   rtx old_pos = XEXP (x, 2);
2022                   rtx newmem;
2023
2024                   /* If the bytes and bits are counted differently, we
2025                      must adjust the offset.  */
2026                   if (BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN)
2027                     offset = (GET_MODE_SIZE (is_mode)
2028                               - GET_MODE_SIZE (wanted_mode) - offset);
2029
2030                   pos %= GET_MODE_BITSIZE (wanted_mode);
2031
2032                   newmem = adjust_address_nv (tem, wanted_mode, offset);
2033
2034                   /* Make the change and see if the insn remains valid.  */
2035                   INSN_CODE (insn) = -1;
2036                   XEXP (x, 0) = newmem;
2037                   XEXP (x, 2) = GEN_INT (pos);
2038
2039                   if (recog_memoized (insn) >= 0)
2040                     return;
2041
2042                   /* Otherwise, restore old position.  XEXP (x, 0) will be
2043                      restored later.  */
2044                   XEXP (x, 2) = old_pos;
2045                 }
2046             }
2047
2048           /* If we get here, the bitfield extract insn can't accept a memory
2049              reference.  Copy the input into a register.  */
2050
2051           tem1 = gen_reg_rtx (GET_MODE (tem));
2052           emit_insn_before (gen_move_insn (tem1, tem), insn);
2053           XEXP (x, 0) = tem1;
2054           return;
2055         }
2056       break;
2057
2058     case SUBREG:
2059       if (SUBREG_REG (x) == var)
2060         {
2061           /* If this is a special SUBREG made because VAR was promoted
2062              from a wider mode, replace it with VAR and call ourself
2063              recursively, this time saying that the object previously
2064              had its current mode (by virtue of the SUBREG).  */
2065
2066           if (SUBREG_PROMOTED_VAR_P (x))
2067             {
2068               *loc = var;
2069               fixup_var_refs_1 (var, GET_MODE (var), loc, insn, replacements,
2070                                 no_share);
2071               return;
2072             }
2073
2074           /* If this SUBREG makes VAR wider, it has become a paradoxical
2075              SUBREG with VAR in memory, but these aren't allowed at this
2076              stage of the compilation.  So load VAR into a pseudo and take
2077              a SUBREG of that pseudo.  */
2078           if (GET_MODE_SIZE (GET_MODE (x)) > GET_MODE_SIZE (GET_MODE (var)))
2079             {
2080               replacement = find_fixup_replacement (replacements, var);
2081               if (replacement->new == 0)
2082                 replacement->new = gen_reg_rtx (promoted_mode);
2083               SUBREG_REG (x) = replacement->new;
2084               return;
2085             }
2086
2087           /* See if we have already found a replacement for this SUBREG.
2088              If so, use it.  Otherwise, make a MEM and see if the insn
2089              is recognized.  If not, or if we should force MEM into a register,
2090              make a pseudo for this SUBREG.  */
2091           replacement = find_fixup_replacement (replacements, x);
2092           if (replacement->new)
2093             {
2094               *loc = replacement->new;
2095               return;
2096             }
2097
2098           replacement->new = *loc = fixup_memory_subreg (x, insn,
2099                                                          promoted_mode, 0);
2100
2101           INSN_CODE (insn) = -1;
2102           if (! flag_force_mem && recog_memoized (insn) >= 0)
2103             return;
2104
2105           *loc = replacement->new = gen_reg_rtx (GET_MODE (x));
2106           return;
2107         }
2108       break;
2109
2110     case SET:
2111       /* First do special simplification of bit-field references.  */
2112       if (GET_CODE (SET_DEST (x)) == SIGN_EXTRACT
2113           || GET_CODE (SET_DEST (x)) == ZERO_EXTRACT)
2114         optimize_bit_field (x, insn, 0);
2115       if (GET_CODE (SET_SRC (x)) == SIGN_EXTRACT
2116           || GET_CODE (SET_SRC (x)) == ZERO_EXTRACT)
2117         optimize_bit_field (x, insn, 0);
2118
2119       /* For a paradoxical SUBREG inside a ZERO_EXTRACT, load the object
2120          into a register and then store it back out.  */
2121       if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT
2122           && GET_CODE (XEXP (SET_DEST (x), 0)) == SUBREG
2123           && SUBREG_REG (XEXP (SET_DEST (x), 0)) == var
2124           && (GET_MODE_SIZE (GET_MODE (XEXP (SET_DEST (x), 0)))
2125               > GET_MODE_SIZE (GET_MODE (var))))
2126         {
2127           replacement = find_fixup_replacement (replacements, var);
2128           if (replacement->new == 0)
2129             replacement->new = gen_reg_rtx (GET_MODE (var));
2130
2131           SUBREG_REG (XEXP (SET_DEST (x), 0)) = replacement->new;
2132           emit_insn_after (gen_move_insn (var, replacement->new), insn);
2133         }
2134
2135       /* If SET_DEST is now a paradoxical SUBREG, put the result of this
2136          insn into a pseudo and store the low part of the pseudo into VAR.  */
2137       if (GET_CODE (SET_DEST (x)) == SUBREG
2138           && SUBREG_REG (SET_DEST (x)) == var
2139           && (GET_MODE_SIZE (GET_MODE (SET_DEST (x)))
2140               > GET_MODE_SIZE (GET_MODE (var))))
2141         {
2142           SET_DEST (x) = tem = gen_reg_rtx (GET_MODE (SET_DEST (x)));
2143           emit_insn_after (gen_move_insn (var, gen_lowpart (GET_MODE (var),
2144                                                             tem)),
2145                            insn);
2146           break;
2147         }
2148
2149       {
2150         rtx dest = SET_DEST (x);
2151         rtx src = SET_SRC (x);
2152         rtx outerdest = dest;
2153
2154         while (GET_CODE (dest) == SUBREG || GET_CODE (dest) == STRICT_LOW_PART
2155                || GET_CODE (dest) == SIGN_EXTRACT
2156                || GET_CODE (dest) == ZERO_EXTRACT)
2157           dest = XEXP (dest, 0);
2158
2159         if (GET_CODE (src) == SUBREG)
2160           src = SUBREG_REG (src);
2161
2162         /* If VAR does not appear at the top level of the SET
2163            just scan the lower levels of the tree.  */
2164
2165         if (src != var && dest != var)
2166           break;
2167
2168         /* We will need to rerecognize this insn.  */
2169         INSN_CODE (insn) = -1;
2170
2171         if (GET_CODE (outerdest) == ZERO_EXTRACT && dest == var
2172             && mode_for_extraction (EP_insv, -1) != MAX_MACHINE_MODE)
2173           {
2174             /* Since this case will return, ensure we fixup all the
2175                operands here.  */
2176             fixup_var_refs_1 (var, promoted_mode, &XEXP (outerdest, 1),
2177                               insn, replacements, no_share);
2178             fixup_var_refs_1 (var, promoted_mode, &XEXP (outerdest, 2),
2179                               insn, replacements, no_share);
2180             fixup_var_refs_1 (var, promoted_mode, &SET_SRC (x),
2181                               insn, replacements, no_share);
2182
2183             tem = XEXP (outerdest, 0);
2184
2185             /* Clean up (SUBREG:SI (MEM:mode ...) 0)
2186                that may appear inside a ZERO_EXTRACT.
2187                This was legitimate when the MEM was a REG.  */
2188             if (GET_CODE (tem) == SUBREG
2189                 && SUBREG_REG (tem) == var)
2190               tem = fixup_memory_subreg (tem, insn, promoted_mode, 0);
2191             else
2192               tem = fixup_stack_1 (tem, insn);
2193
2194             if (GET_CODE (XEXP (outerdest, 1)) == CONST_INT
2195                 && GET_CODE (XEXP (outerdest, 2)) == CONST_INT
2196                 && ! mode_dependent_address_p (XEXP (tem, 0))
2197                 && ! MEM_VOLATILE_P (tem))
2198               {
2199                 enum machine_mode wanted_mode;
2200                 enum machine_mode is_mode = GET_MODE (tem);
2201                 HOST_WIDE_INT pos = INTVAL (XEXP (outerdest, 2));
2202
2203                 wanted_mode = mode_for_extraction (EP_insv, 0);
2204
2205                 /* If we have a narrower mode, we can do something.  */
2206                 if (GET_MODE_SIZE (wanted_mode) < GET_MODE_SIZE (is_mode))
2207                   {
2208                     HOST_WIDE_INT offset = pos / BITS_PER_UNIT;
2209                     rtx old_pos = XEXP (outerdest, 2);
2210                     rtx newmem;
2211
2212                     if (BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN)
2213                       offset = (GET_MODE_SIZE (is_mode)
2214                                 - GET_MODE_SIZE (wanted_mode) - offset);
2215
2216                     pos %= GET_MODE_BITSIZE (wanted_mode);
2217
2218                     newmem = adjust_address_nv (tem, wanted_mode, offset);
2219
2220                     /* Make the change and see if the insn remains valid.  */
2221                     INSN_CODE (insn) = -1;
2222                     XEXP (outerdest, 0) = newmem;
2223                     XEXP (outerdest, 2) = GEN_INT (pos);
2224
2225                     if (recog_memoized (insn) >= 0)
2226                       return;
2227
2228                     /* Otherwise, restore old position.  XEXP (x, 0) will be
2229                        restored later.  */
2230                     XEXP (outerdest, 2) = old_pos;
2231                   }
2232               }
2233
2234             /* If we get here, the bit-field store doesn't allow memory
2235                or isn't located at a constant position.  Load the value into
2236                a register, do the store, and put it back into memory.  */
2237
2238             tem1 = gen_reg_rtx (GET_MODE (tem));
2239             emit_insn_before (gen_move_insn (tem1, tem), insn);
2240             emit_insn_after (gen_move_insn (tem, tem1), insn);
2241             XEXP (outerdest, 0) = tem1;
2242             return;
2243           }
2244
2245         /* STRICT_LOW_PART is a no-op on memory references
2246            and it can cause combinations to be unrecognizable,
2247            so eliminate it.  */
2248
2249         if (dest == var && GET_CODE (SET_DEST (x)) == STRICT_LOW_PART)
2250           SET_DEST (x) = XEXP (SET_DEST (x), 0);
2251
2252         /* A valid insn to copy VAR into or out of a register
2253            must be left alone, to avoid an infinite loop here.
2254            If the reference to VAR is by a subreg, fix that up,
2255            since SUBREG is not valid for a memref.
2256            Also fix up the address of the stack slot.
2257
2258            Note that we must not try to recognize the insn until
2259            after we know that we have valid addresses and no
2260            (subreg (mem ...) ...) constructs, since these interfere
2261            with determining the validity of the insn.  */
2262
2263         if ((SET_SRC (x) == var
2264              || (GET_CODE (SET_SRC (x)) == SUBREG
2265                  && SUBREG_REG (SET_SRC (x)) == var))
2266             && (GET_CODE (SET_DEST (x)) == REG
2267                 || (GET_CODE (SET_DEST (x)) == SUBREG
2268                     && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG))
2269             && GET_MODE (var) == promoted_mode
2270             && x == single_set (insn))
2271           {
2272             rtx pat, last;
2273
2274             if (GET_CODE (SET_SRC (x)) == SUBREG
2275                 && (GET_MODE_SIZE (GET_MODE (SET_SRC (x)))
2276                     > GET_MODE_SIZE (GET_MODE (var))))
2277               {
2278                 /* This (subreg VAR) is now a paradoxical subreg.  We need
2279                    to replace VAR instead of the subreg.  */
2280                 replacement = find_fixup_replacement (replacements, var);
2281                 if (replacement->new == NULL_RTX)
2282                   replacement->new = gen_reg_rtx (GET_MODE (var));
2283                 SUBREG_REG (SET_SRC (x)) = replacement->new;
2284               }
2285             else
2286               {
2287                 replacement = find_fixup_replacement (replacements, SET_SRC (x));
2288                 if (replacement->new)
2289                   SET_SRC (x) = replacement->new;
2290                 else if (GET_CODE (SET_SRC (x)) == SUBREG)
2291                   SET_SRC (x) = replacement->new
2292                     = fixup_memory_subreg (SET_SRC (x), insn, promoted_mode,
2293                                            0);
2294                 else
2295                   SET_SRC (x) = replacement->new
2296                     = fixup_stack_1 (SET_SRC (x), insn);
2297               }
2298
2299             if (recog_memoized (insn) >= 0)
2300               return;
2301
2302             /* INSN is not valid, but we know that we want to
2303                copy SET_SRC (x) to SET_DEST (x) in some way.  So
2304                we generate the move and see whether it requires more
2305                than one insn.  If it does, we emit those insns and
2306                delete INSN.  Otherwise, we can just replace the pattern
2307                of INSN; we have already verified above that INSN has
2308                no other function that to do X.  */
2309
2310             pat = gen_move_insn (SET_DEST (x), SET_SRC (x));
2311             if (NEXT_INSN (pat) != NULL_RTX)
2312               {
2313                 last = emit_insn_before (pat, insn);
2314
2315                 /* INSN might have REG_RETVAL or other important notes, so
2316                    we need to store the pattern of the last insn in the
2317                    sequence into INSN similarly to the normal case.  LAST
2318                    should not have REG_NOTES, but we allow them if INSN has
2319                    no REG_NOTES.  */
2320                 if (REG_NOTES (last) && REG_NOTES (insn))
2321                   abort ();
2322                 if (REG_NOTES (last))
2323                   REG_NOTES (insn) = REG_NOTES (last);
2324                 PATTERN (insn) = PATTERN (last);
2325
2326                 delete_insn (last);
2327               }
2328             else
2329               PATTERN (insn) = PATTERN (pat);
2330
2331             return;
2332           }
2333
2334         if ((SET_DEST (x) == var
2335              || (GET_CODE (SET_DEST (x)) == SUBREG
2336                  && SUBREG_REG (SET_DEST (x)) == var))
2337             && (GET_CODE (SET_SRC (x)) == REG
2338                 || (GET_CODE (SET_SRC (x)) == SUBREG
2339                     && GET_CODE (SUBREG_REG (SET_SRC (x))) == REG))
2340             && GET_MODE (var) == promoted_mode
2341             && x == single_set (insn))
2342           {
2343             rtx pat, last;
2344
2345             if (GET_CODE (SET_DEST (x)) == SUBREG)
2346               SET_DEST (x) = fixup_memory_subreg (SET_DEST (x), insn,
2347                                                   promoted_mode, 0);
2348             else
2349               SET_DEST (x) = fixup_stack_1 (SET_DEST (x), insn);
2350
2351             if (recog_memoized (insn) >= 0)
2352               return;
2353
2354             pat = gen_move_insn (SET_DEST (x), SET_SRC (x));
2355             if (NEXT_INSN (pat) != NULL_RTX)
2356               {
2357                 last = emit_insn_before (pat, insn);
2358
2359                 /* INSN might have REG_RETVAL or other important notes, so
2360                    we need to store the pattern of the last insn in the
2361                    sequence into INSN similarly to the normal case.  LAST
2362                    should not have REG_NOTES, but we allow them if INSN has
2363                    no REG_NOTES.  */
2364                 if (REG_NOTES (last) && REG_NOTES (insn))
2365                   abort ();
2366                 if (REG_NOTES (last))
2367                   REG_NOTES (insn) = REG_NOTES (last);
2368                 PATTERN (insn) = PATTERN (last);
2369
2370                 delete_insn (last);
2371               }
2372             else
2373               PATTERN (insn) = PATTERN (pat);
2374
2375             return;
2376           }
2377
2378         /* Otherwise, storing into VAR must be handled specially
2379            by storing into a temporary and copying that into VAR
2380            with a new insn after this one.  Note that this case
2381            will be used when storing into a promoted scalar since
2382            the insn will now have different modes on the input
2383            and output and hence will be invalid (except for the case
2384            of setting it to a constant, which does not need any
2385            change if it is valid).  We generate extra code in that case,
2386            but combine.c will eliminate it.  */
2387
2388         if (dest == var)
2389           {
2390             rtx temp;
2391             rtx fixeddest = SET_DEST (x);
2392             enum machine_mode temp_mode;
2393
2394             /* STRICT_LOW_PART can be discarded, around a MEM.  */
2395             if (GET_CODE (fixeddest) == STRICT_LOW_PART)
2396               fixeddest = XEXP (fixeddest, 0);
2397             /* Convert (SUBREG (MEM)) to a MEM in a changed mode.  */
2398             if (GET_CODE (fixeddest) == SUBREG)
2399               {
2400                 fixeddest = fixup_memory_subreg (fixeddest, insn,
2401                                                  promoted_mode, 0);
2402                 temp_mode = GET_MODE (fixeddest);
2403               }
2404             else
2405               {
2406                 fixeddest = fixup_stack_1 (fixeddest, insn);
2407                 temp_mode = promoted_mode;
2408               }
2409
2410             temp = gen_reg_rtx (temp_mode);
2411
2412             emit_insn_after (gen_move_insn (fixeddest,
2413                                             gen_lowpart (GET_MODE (fixeddest),
2414                                                          temp)),
2415                              insn);
2416
2417             SET_DEST (x) = temp;
2418           }
2419       }
2420
2421     default:
2422       break;
2423     }
2424
2425   /* Nothing special about this RTX; fix its operands.  */
2426
2427   fmt = GET_RTX_FORMAT (code);
2428   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2429     {
2430       if (fmt[i] == 'e')
2431         fixup_var_refs_1 (var, promoted_mode, &XEXP (x, i), insn, replacements,
2432                           no_share);
2433       else if (fmt[i] == 'E')
2434         {
2435           int j;
2436           for (j = 0; j < XVECLEN (x, i); j++)
2437             fixup_var_refs_1 (var, promoted_mode, &XVECEXP (x, i, j),
2438                               insn, replacements, no_share);
2439         }
2440     }
2441 }
2442 \f
2443 /* Previously, X had the form (SUBREG:m1 (REG:PROMOTED_MODE ...)).
2444    The REG  was placed on the stack, so X now has the form (SUBREG:m1
2445    (MEM:m2 ...)).
2446
2447    Return an rtx (MEM:m1 newaddr) which is equivalent.  If any insns
2448    must be emitted to compute NEWADDR, put them before INSN.
2449
2450    UNCRITICAL nonzero means accept paradoxical subregs.
2451    This is used for subregs found inside REG_NOTES.  */
2452
2453 static rtx
2454 fixup_memory_subreg (rtx x, rtx insn, enum machine_mode promoted_mode, int uncritical)
2455 {
2456   int offset;
2457   rtx mem = SUBREG_REG (x);
2458   rtx addr = XEXP (mem, 0);
2459   enum machine_mode mode = GET_MODE (x);
2460   rtx result, seq;
2461
2462   /* Paradoxical SUBREGs are usually invalid during RTL generation.  */
2463   if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (mem)) && ! uncritical)
2464     abort ();
2465
2466   offset = SUBREG_BYTE (x);
2467   if (BYTES_BIG_ENDIAN)
2468     /* If the PROMOTED_MODE is wider than the mode of the MEM, adjust
2469        the offset so that it points to the right location within the
2470        MEM.  */
2471     offset -= (GET_MODE_SIZE (promoted_mode) - GET_MODE_SIZE (GET_MODE (mem)));
2472
2473   if (!flag_force_addr
2474       && memory_address_p (mode, plus_constant (addr, offset)))
2475     /* Shortcut if no insns need be emitted.  */
2476     return adjust_address (mem, mode, offset);
2477
2478   start_sequence ();
2479   result = adjust_address (mem, mode, offset);
2480   seq = get_insns ();
2481   end_sequence ();
2482
2483   emit_insn_before (seq, insn);
2484   return result;
2485 }
2486
2487 /* Do fixup_memory_subreg on all (SUBREG (MEM ...) ...) contained in X.
2488    Replace subexpressions of X in place.
2489    If X itself is a (SUBREG (MEM ...) ...), return the replacement expression.
2490    Otherwise return X, with its contents possibly altered.
2491
2492    INSN, PROMOTED_MODE and UNCRITICAL are as for
2493    fixup_memory_subreg.  */
2494
2495 static rtx
2496 walk_fixup_memory_subreg (rtx x, rtx insn, enum machine_mode promoted_mode,
2497                           int uncritical)
2498 {
2499   enum rtx_code code;
2500   const char *fmt;
2501   int i;
2502
2503   if (x == 0)
2504     return 0;
2505
2506   code = GET_CODE (x);
2507
2508   if (code == SUBREG && GET_CODE (SUBREG_REG (x)) == MEM)
2509     return fixup_memory_subreg (x, insn, promoted_mode, uncritical);
2510
2511   /* Nothing special about this RTX; fix its operands.  */
2512
2513   fmt = GET_RTX_FORMAT (code);
2514   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2515     {
2516       if (fmt[i] == 'e')
2517         XEXP (x, i) = walk_fixup_memory_subreg (XEXP (x, i), insn,
2518                                                 promoted_mode, uncritical);
2519       else if (fmt[i] == 'E')
2520         {
2521           int j;
2522           for (j = 0; j < XVECLEN (x, i); j++)
2523             XVECEXP (x, i, j)
2524               = walk_fixup_memory_subreg (XVECEXP (x, i, j), insn,
2525                                           promoted_mode, uncritical);
2526         }
2527     }
2528   return x;
2529 }
2530 \f
2531 /* For each memory ref within X, if it refers to a stack slot
2532    with an out of range displacement, put the address in a temp register
2533    (emitting new insns before INSN to load these registers)
2534    and alter the memory ref to use that register.
2535    Replace each such MEM rtx with a copy, to avoid clobberage.  */
2536
2537 static rtx
2538 fixup_stack_1 (rtx x, rtx insn)
2539 {
2540   int i;
2541   RTX_CODE code = GET_CODE (x);
2542   const char *fmt;
2543
2544   if (code == MEM)
2545     {
2546       rtx ad = XEXP (x, 0);
2547       /* If we have address of a stack slot but it's not valid
2548          (displacement is too large), compute the sum in a register.  */
2549       if (GET_CODE (ad) == PLUS
2550           && GET_CODE (XEXP (ad, 0)) == REG
2551           && ((REGNO (XEXP (ad, 0)) >= FIRST_VIRTUAL_REGISTER
2552                && REGNO (XEXP (ad, 0)) <= LAST_VIRTUAL_REGISTER)
2553               || REGNO (XEXP (ad, 0)) == FRAME_POINTER_REGNUM
2554 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
2555               || REGNO (XEXP (ad, 0)) == HARD_FRAME_POINTER_REGNUM
2556 #endif
2557               || REGNO (XEXP (ad, 0)) == STACK_POINTER_REGNUM
2558               || REGNO (XEXP (ad, 0)) == ARG_POINTER_REGNUM
2559               || XEXP (ad, 0) == current_function_internal_arg_pointer)
2560           && GET_CODE (XEXP (ad, 1)) == CONST_INT)
2561         {
2562           rtx temp, seq;
2563           if (memory_address_p (GET_MODE (x), ad))
2564             return x;
2565
2566           start_sequence ();
2567           temp = copy_to_reg (ad);
2568           seq = get_insns ();
2569           end_sequence ();
2570           emit_insn_before (seq, insn);
2571           return replace_equiv_address (x, temp);
2572         }
2573       return x;
2574     }
2575
2576   fmt = GET_RTX_FORMAT (code);
2577   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2578     {
2579       if (fmt[i] == 'e')
2580         XEXP (x, i) = fixup_stack_1 (XEXP (x, i), insn);
2581       else if (fmt[i] == 'E')
2582         {
2583           int j;
2584           for (j = 0; j < XVECLEN (x, i); j++)
2585             XVECEXP (x, i, j) = fixup_stack_1 (XVECEXP (x, i, j), insn);
2586         }
2587     }
2588   return x;
2589 }
2590 \f
2591 /* Optimization: a bit-field instruction whose field
2592    happens to be a byte or halfword in memory
2593    can be changed to a move instruction.
2594
2595    We call here when INSN is an insn to examine or store into a bit-field.
2596    BODY is the SET-rtx to be altered.
2597
2598    EQUIV_MEM is the table `reg_equiv_mem' if that is available; else 0.
2599    (Currently this is called only from function.c, and EQUIV_MEM
2600    is always 0.)  */
2601
2602 static void
2603 optimize_bit_field (rtx body, rtx insn, rtx *equiv_mem)
2604 {
2605   rtx bitfield;
2606   int destflag;
2607   rtx seq = 0;
2608   enum machine_mode mode;
2609
2610   if (GET_CODE (SET_DEST (body)) == SIGN_EXTRACT
2611       || GET_CODE (SET_DEST (body)) == ZERO_EXTRACT)
2612     bitfield = SET_DEST (body), destflag = 1;
2613   else
2614     bitfield = SET_SRC (body), destflag = 0;
2615
2616   /* First check that the field being stored has constant size and position
2617      and is in fact a byte or halfword suitably aligned.  */
2618
2619   if (GET_CODE (XEXP (bitfield, 1)) == CONST_INT
2620       && GET_CODE (XEXP (bitfield, 2)) == CONST_INT
2621       && ((mode = mode_for_size (INTVAL (XEXP (bitfield, 1)), MODE_INT, 1))
2622           != BLKmode)
2623       && INTVAL (XEXP (bitfield, 2)) % INTVAL (XEXP (bitfield, 1)) == 0)
2624     {
2625       rtx memref = 0;
2626
2627       /* Now check that the containing word is memory, not a register,
2628          and that it is safe to change the machine mode.  */
2629
2630       if (GET_CODE (XEXP (bitfield, 0)) == MEM)
2631         memref = XEXP (bitfield, 0);
2632       else if (GET_CODE (XEXP (bitfield, 0)) == REG
2633                && equiv_mem != 0)
2634         memref = equiv_mem[REGNO (XEXP (bitfield, 0))];
2635       else if (GET_CODE (XEXP (bitfield, 0)) == SUBREG
2636                && GET_CODE (SUBREG_REG (XEXP (bitfield, 0))) == MEM)
2637         memref = SUBREG_REG (XEXP (bitfield, 0));
2638       else if (GET_CODE (XEXP (bitfield, 0)) == SUBREG
2639                && equiv_mem != 0
2640                && GET_CODE (SUBREG_REG (XEXP (bitfield, 0))) == REG)
2641         memref = equiv_mem[REGNO (SUBREG_REG (XEXP (bitfield, 0)))];
2642
2643       if (memref
2644           && ! mode_dependent_address_p (XEXP (memref, 0))
2645           && ! MEM_VOLATILE_P (memref))
2646         {
2647           /* Now adjust the address, first for any subreg'ing
2648              that we are now getting rid of,
2649              and then for which byte of the word is wanted.  */
2650
2651           HOST_WIDE_INT offset = INTVAL (XEXP (bitfield, 2));
2652           rtx insns;
2653
2654           /* Adjust OFFSET to count bits from low-address byte.  */
2655           if (BITS_BIG_ENDIAN != BYTES_BIG_ENDIAN)
2656             offset = (GET_MODE_BITSIZE (GET_MODE (XEXP (bitfield, 0)))
2657                       - offset - INTVAL (XEXP (bitfield, 1)));
2658
2659           /* Adjust OFFSET to count bytes from low-address byte.  */
2660           offset /= BITS_PER_UNIT;
2661           if (GET_CODE (XEXP (bitfield, 0)) == SUBREG)
2662             {
2663               offset += (SUBREG_BYTE (XEXP (bitfield, 0))
2664                          / UNITS_PER_WORD) * UNITS_PER_WORD;
2665               if (BYTES_BIG_ENDIAN)
2666                 offset -= (MIN (UNITS_PER_WORD,
2667                                 GET_MODE_SIZE (GET_MODE (XEXP (bitfield, 0))))
2668                            - MIN (UNITS_PER_WORD,
2669                                   GET_MODE_SIZE (GET_MODE (memref))));
2670             }
2671
2672           start_sequence ();
2673           memref = adjust_address (memref, mode, offset);
2674           insns = get_insns ();
2675           end_sequence ();
2676           emit_insn_before (insns, insn);
2677
2678           /* Store this memory reference where
2679              we found the bit field reference.  */
2680
2681           if (destflag)
2682             {
2683               validate_change (insn, &SET_DEST (body), memref, 1);
2684               if (! CONSTANT_ADDRESS_P (SET_SRC (body)))
2685                 {
2686                   rtx src = SET_SRC (body);
2687                   while (GET_CODE (src) == SUBREG
2688                          && SUBREG_BYTE (src) == 0)
2689                     src = SUBREG_REG (src);
2690                   if (GET_MODE (src) != GET_MODE (memref))
2691                     src = gen_lowpart (GET_MODE (memref), SET_SRC (body));
2692                   validate_change (insn, &SET_SRC (body), src, 1);
2693                 }
2694               else if (GET_MODE (SET_SRC (body)) != VOIDmode
2695                        && GET_MODE (SET_SRC (body)) != GET_MODE (memref))
2696                 /* This shouldn't happen because anything that didn't have
2697                    one of these modes should have got converted explicitly
2698                    and then referenced through a subreg.
2699                    This is so because the original bit-field was
2700                    handled by agg_mode and so its tree structure had
2701                    the same mode that memref now has.  */
2702                 abort ();
2703             }
2704           else
2705             {
2706               rtx dest = SET_DEST (body);
2707
2708               while (GET_CODE (dest) == SUBREG
2709                      && SUBREG_BYTE (dest) == 0
2710                      && (GET_MODE_CLASS (GET_MODE (dest))
2711                          == GET_MODE_CLASS (GET_MODE (SUBREG_REG (dest))))
2712                      && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
2713                          <= UNITS_PER_WORD))
2714                 dest = SUBREG_REG (dest);
2715
2716               validate_change (insn, &SET_DEST (body), dest, 1);
2717
2718               if (GET_MODE (dest) == GET_MODE (memref))
2719                 validate_change (insn, &SET_SRC (body), memref, 1);
2720               else
2721                 {
2722                   /* Convert the mem ref to the destination mode.  */
2723                   rtx newreg = gen_reg_rtx (GET_MODE (dest));
2724
2725                   start_sequence ();
2726                   convert_move (newreg, memref,
2727                                 GET_CODE (SET_SRC (body)) == ZERO_EXTRACT);
2728                   seq = get_insns ();
2729                   end_sequence ();
2730
2731                   validate_change (insn, &SET_SRC (body), newreg, 1);
2732                 }
2733             }
2734
2735           /* See if we can convert this extraction or insertion into
2736              a simple move insn.  We might not be able to do so if this
2737              was, for example, part of a PARALLEL.
2738
2739              If we succeed, write out any needed conversions.  If we fail,
2740              it is hard to guess why we failed, so don't do anything
2741              special; just let the optimization be suppressed.  */
2742
2743           if (apply_change_group () && seq)
2744             emit_insn_before (seq, insn);
2745         }
2746     }
2747 }
2748 \f
2749 /* These routines are responsible for converting virtual register references
2750    to the actual hard register references once RTL generation is complete.
2751
2752    The following four variables are used for communication between the
2753    routines.  They contain the offsets of the virtual registers from their
2754    respective hard registers.  */
2755
2756 static int in_arg_offset;
2757 static int var_offset;
2758 static int dynamic_offset;
2759 static int out_arg_offset;
2760 static int cfa_offset;
2761
2762 /* In most machines, the stack pointer register is equivalent to the bottom
2763    of the stack.  */
2764
2765 #ifndef STACK_POINTER_OFFSET
2766 #define STACK_POINTER_OFFSET    0
2767 #endif
2768
2769 /* If not defined, pick an appropriate default for the offset of dynamically
2770    allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS,
2771    REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE.  */
2772
2773 #ifndef STACK_DYNAMIC_OFFSET
2774
2775 /* The bottom of the stack points to the actual arguments.  If
2776    REG_PARM_STACK_SPACE is defined, this includes the space for the register
2777    parameters.  However, if OUTGOING_REG_PARM_STACK space is not defined,
2778    stack space for register parameters is not pushed by the caller, but
2779    rather part of the fixed stack areas and hence not included in
2780    `current_function_outgoing_args_size'.  Nevertheless, we must allow
2781    for it when allocating stack dynamic objects.  */
2782
2783 #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
2784 #define STACK_DYNAMIC_OFFSET(FNDECL)    \
2785 ((ACCUMULATE_OUTGOING_ARGS                                                    \
2786   ? (current_function_outgoing_args_size + REG_PARM_STACK_SPACE (FNDECL)) : 0)\
2787  + (STACK_POINTER_OFFSET))                                                    \
2788
2789 #else
2790 #define STACK_DYNAMIC_OFFSET(FNDECL)    \
2791 ((ACCUMULATE_OUTGOING_ARGS ? current_function_outgoing_args_size : 0)         \
2792  + (STACK_POINTER_OFFSET))
2793 #endif
2794 #endif
2795
2796 /* On most machines, the CFA coincides with the first incoming parm.  */
2797
2798 #ifndef ARG_POINTER_CFA_OFFSET
2799 #define ARG_POINTER_CFA_OFFSET(FNDECL) FIRST_PARM_OFFSET (FNDECL)
2800 #endif
2801
2802 /* Build up a (MEM (ADDRESSOF (REG))) rtx for a register REG that just
2803    had its address taken.  DECL is the decl or SAVE_EXPR for the
2804    object stored in the register, for later use if we do need to force
2805    REG into the stack.  REG is overwritten by the MEM like in
2806    put_reg_into_stack.  RESCAN is true if previously emitted
2807    instructions must be rescanned and modified now that the REG has
2808    been transformed.  */
2809
2810 rtx
2811 gen_mem_addressof (rtx reg, tree decl, int rescan)
2812 {
2813   rtx r = gen_rtx_ADDRESSOF (Pmode, gen_reg_rtx (GET_MODE (reg)),
2814                              REGNO (reg), decl);
2815
2816   /* Calculate this before we start messing with decl's RTL.  */
2817   HOST_WIDE_INT set = decl ? get_alias_set (decl) : 0;
2818
2819   /* If the original REG was a user-variable, then so is the REG whose
2820      address is being taken.  Likewise for unchanging.  */
2821   REG_USERVAR_P (XEXP (r, 0)) = REG_USERVAR_P (reg);
2822   RTX_UNCHANGING_P (XEXP (r, 0)) = RTX_UNCHANGING_P (reg);
2823
2824   PUT_CODE (reg, MEM);
2825   MEM_ATTRS (reg) = 0;
2826   XEXP (reg, 0) = r;
2827
2828   if (decl)
2829     {
2830       tree type = TREE_TYPE (decl);
2831       enum machine_mode decl_mode
2832         = (DECL_P (decl) ? DECL_MODE (decl) : TYPE_MODE (TREE_TYPE (decl)));
2833       rtx decl_rtl = (TREE_CODE (decl) == SAVE_EXPR ? SAVE_EXPR_RTL (decl)
2834                       : DECL_RTL_IF_SET (decl));
2835
2836       PUT_MODE (reg, decl_mode);
2837
2838       /* Clear DECL_RTL momentarily so functions below will work
2839          properly, then set it again.  */
2840       if (DECL_P (decl) && decl_rtl == reg)
2841         SET_DECL_RTL (decl, 0);
2842
2843       set_mem_attributes (reg, decl, 1);
2844       set_mem_alias_set (reg, set);
2845
2846       if (DECL_P (decl) && decl_rtl == reg)
2847         SET_DECL_RTL (decl, reg);
2848
2849       if (rescan
2850           && (TREE_USED (decl) || (DECL_P (decl) && DECL_INITIAL (decl) != 0)))
2851         fixup_var_refs (reg, GET_MODE (reg), TREE_UNSIGNED (type), reg, 0);
2852     }
2853   else if (rescan)
2854     fixup_var_refs (reg, GET_MODE (reg), 0, reg, 0);
2855
2856   return reg;
2857 }
2858
2859 /* If DECL has an RTL that is an ADDRESSOF rtx, put it into the stack.  */
2860
2861 void
2862 flush_addressof (tree decl)
2863 {
2864   if ((TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == VAR_DECL)
2865       && DECL_RTL (decl) != 0
2866       && GET_CODE (DECL_RTL (decl)) == MEM
2867       && GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF
2868       && GET_CODE (XEXP (XEXP (DECL_RTL (decl), 0), 0)) == REG)
2869     put_addressof_into_stack (XEXP (DECL_RTL (decl), 0), 0);
2870 }
2871
2872 /* Force the register pointed to by R, an ADDRESSOF rtx, into the stack.  */
2873
2874 static void
2875 put_addressof_into_stack (rtx r, htab_t ht)
2876 {
2877   tree decl, type;
2878   int volatile_p, used_p;
2879
2880   rtx reg = XEXP (r, 0);
2881
2882   if (GET_CODE (reg) != REG)
2883     abort ();
2884
2885   decl = ADDRESSOF_DECL (r);
2886   if (decl)
2887     {
2888       type = TREE_TYPE (decl);
2889       volatile_p = (TREE_CODE (decl) != SAVE_EXPR
2890                     && TREE_THIS_VOLATILE (decl));
2891       used_p = (TREE_USED (decl)
2892                 || (DECL_P (decl) && DECL_INITIAL (decl) != 0));
2893     }
2894   else
2895     {
2896       type = NULL_TREE;
2897       volatile_p = 0;
2898       used_p = 1;
2899     }
2900
2901   put_reg_into_stack (0, reg, type, GET_MODE (reg), GET_MODE (reg),
2902                       volatile_p, ADDRESSOF_REGNO (r), used_p, ht);
2903 }
2904
2905 /* List of replacements made below in purge_addressof_1 when creating
2906    bitfield insertions.  */
2907 static rtx purge_bitfield_addressof_replacements;
2908
2909 /* List of replacements made below in purge_addressof_1 for patterns
2910    (MEM (ADDRESSOF (REG ...))).  The key of the list entry is the
2911    corresponding (ADDRESSOF (REG ...)) and value is a substitution for
2912    the all pattern.  List PURGE_BITFIELD_ADDRESSOF_REPLACEMENTS is not
2913    enough in complex cases, e.g. when some field values can be
2914    extracted by usage MEM with narrower mode.  */
2915 static rtx purge_addressof_replacements;
2916
2917 /* Helper function for purge_addressof.  See if the rtx expression at *LOC
2918    in INSN needs to be changed.  If FORCE, always put any ADDRESSOFs into
2919    the stack.  If the function returns FALSE then the replacement could not
2920    be made.  If MAY_POSTPONE is true and we would not put the addressof
2921    to stack, postpone processing of the insn.  */
2922
2923 static bool
2924 purge_addressof_1 (rtx *loc, rtx insn, int force, int store, int may_postpone,
2925                    htab_t ht)
2926 {
2927   rtx x;
2928   RTX_CODE code;
2929   int i, j;
2930   const char *fmt;
2931   bool result = true;
2932   bool libcall = false;
2933
2934   /* Re-start here to avoid recursion in common cases.  */
2935  restart:
2936
2937   x = *loc;
2938   if (x == 0)
2939     return true;
2940
2941   /* Is this a libcall?  */
2942   if (!insn)
2943     libcall = REG_NOTE_KIND (*loc) == REG_RETVAL;
2944
2945   code = GET_CODE (x);
2946
2947   /* If we don't return in any of the cases below, we will recurse inside
2948      the RTX, which will normally result in any ADDRESSOF being forced into
2949      memory.  */
2950   if (code == SET)
2951     {
2952       result = purge_addressof_1 (&SET_DEST (x), insn, force, 1,
2953                                   may_postpone, ht);
2954       result &= purge_addressof_1 (&SET_SRC (x), insn, force, 0,
2955                                    may_postpone, ht);
2956       return result;
2957     }
2958   else if (code == ADDRESSOF)
2959     {
2960       rtx sub, insns;
2961
2962       if (GET_CODE (XEXP (x, 0)) != MEM)
2963         put_addressof_into_stack (x, ht);
2964
2965       /* We must create a copy of the rtx because it was created by
2966          overwriting a REG rtx which is always shared.  */
2967       sub = copy_rtx (XEXP (XEXP (x, 0), 0));
2968       if (validate_change (insn, loc, sub, 0)
2969           || validate_replace_rtx (x, sub, insn))
2970         return true;
2971
2972       start_sequence ();
2973
2974       /* If SUB is a hard or virtual register, try it as a pseudo-register.
2975          Otherwise, perhaps SUB is an expression, so generate code to compute
2976          it.  */
2977       if (GET_CODE (sub) == REG && REGNO (sub) <= LAST_VIRTUAL_REGISTER)
2978         sub = copy_to_reg (sub);
2979       else
2980         sub = force_operand (sub, NULL_RTX);
2981
2982       if (! validate_change (insn, loc, sub, 0)
2983           && ! validate_replace_rtx (x, sub, insn))
2984         abort ();
2985
2986       insns = get_insns ();
2987       end_sequence ();
2988       emit_insn_before (insns, insn);
2989       return true;
2990     }
2991
2992   else if (code == MEM && GET_CODE (XEXP (x, 0)) == ADDRESSOF && ! force)
2993     {
2994       rtx sub = XEXP (XEXP (x, 0), 0);
2995
2996       if (GET_CODE (sub) == MEM)
2997         sub = adjust_address_nv (sub, GET_MODE (x), 0);
2998       else if (GET_CODE (sub) == REG
2999                && (MEM_VOLATILE_P (x) || GET_MODE (x) == BLKmode))
3000         ;
3001       else if (GET_CODE (sub) == REG && GET_MODE (x) != GET_MODE (sub))
3002         {
3003           int size_x, size_sub;
3004
3005           if (may_postpone)
3006             {
3007               /* Postpone for now, so that we do not emit bitfield arithmetics
3008                  unless there is some benefit from it.  */
3009               if (!postponed_insns || XEXP (postponed_insns, 0) != insn)
3010                 postponed_insns = alloc_INSN_LIST (insn, postponed_insns);
3011               return true;
3012             }
3013
3014           if (!insn)
3015             {
3016               /* When processing REG_NOTES look at the list of
3017                  replacements done on the insn to find the register that X
3018                  was replaced by.  */
3019               rtx tem;
3020
3021               for (tem = purge_bitfield_addressof_replacements;
3022                    tem != NULL_RTX;
3023                    tem = XEXP (XEXP (tem, 1), 1))
3024                 if (rtx_equal_p (x, XEXP (tem, 0)))
3025                   {
3026                     *loc = XEXP (XEXP (tem, 1), 0);
3027                     return true;
3028                   }
3029
3030               /* See comment for purge_addressof_replacements.  */
3031               for (tem = purge_addressof_replacements;
3032                    tem != NULL_RTX;
3033                    tem = XEXP (XEXP (tem, 1), 1))
3034                 if (rtx_equal_p (XEXP (x, 0), XEXP (tem, 0)))
3035                   {
3036                     rtx z = XEXP (XEXP (tem, 1), 0);
3037
3038                     if (GET_MODE (x) == GET_MODE (z)
3039                         || (GET_CODE (XEXP (XEXP (tem, 1), 0)) != REG
3040                             && GET_CODE (XEXP (XEXP (tem, 1), 0)) != SUBREG))
3041                       abort ();
3042
3043                     /* It can happen that the note may speak of things
3044                        in a wider (or just different) mode than the
3045                        code did.  This is especially true of
3046                        REG_RETVAL.  */
3047
3048                     if (GET_CODE (z) == SUBREG && SUBREG_BYTE (z) == 0)
3049                       z = SUBREG_REG (z);
3050
3051                     if (GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD
3052                         && (GET_MODE_SIZE (GET_MODE (x))
3053                             > GET_MODE_SIZE (GET_MODE (z))))
3054                       {
3055                         /* This can occur as a result in invalid
3056                            pointer casts, e.g. float f; ...
3057                            *(long long int *)&f.
3058                            ??? We could emit a warning here, but
3059                            without a line number that wouldn't be
3060                            very helpful.  */
3061                         z = gen_rtx_SUBREG (GET_MODE (x), z, 0);
3062                       }
3063                     else
3064                       z = gen_lowpart (GET_MODE (x), z);
3065
3066                     *loc = z;
3067                     return true;
3068                   }
3069
3070               /* When we are processing the REG_NOTES of the last instruction
3071                  of a libcall, there will be typically no replacements
3072                  for that insn; the replacements happened before, piecemeal
3073                  fashion.  OTOH we are not interested in the details of
3074                  this for the REG_EQUAL note, we want to know the big picture,
3075                  which can be succinctly described with a simple SUBREG.
3076                  Note that removing the REG_EQUAL note is not an option
3077                  on the last insn of a libcall, so we must do a replacement.  */
3078
3079               /* In compile/990107-1.c:7 compiled at -O1 -m1 for sh-elf,
3080                  we got
3081                  (mem:DI (addressof:SI (reg/v:DF 160) 159 0x401c8510)
3082                  [0 S8 A32]), which can be expressed with a simple
3083                  same-size subreg  */
3084               if ((GET_MODE_SIZE (GET_MODE (x))
3085                    <= GET_MODE_SIZE (GET_MODE (sub)))
3086                   /* Again, invalid pointer casts (as in
3087                      compile/990203-1.c) can require paradoxical
3088                      subregs.  */
3089                   || (GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD
3090                       && (GET_MODE_SIZE (GET_MODE (x))
3091                           > GET_MODE_SIZE (GET_MODE (sub)))
3092                       && libcall))
3093                 {
3094                   *loc = gen_rtx_SUBREG (GET_MODE (x), sub, 0);
3095                   return true;
3096                 }
3097               /* ??? Are there other cases we should handle?  */
3098
3099               /* Sometimes we may not be able to find the replacement.  For
3100                  example when the original insn was a MEM in a wider mode,
3101                  and the note is part of a sign extension of a narrowed
3102                  version of that MEM.  Gcc testcase compile/990829-1.c can
3103                  generate an example of this situation.  Rather than complain
3104                  we return false, which will prompt our caller to remove the
3105                  offending note.  */
3106               return false;
3107             }
3108
3109           size_x = GET_MODE_BITSIZE (GET_MODE (x));
3110           size_sub = GET_MODE_BITSIZE (GET_MODE (sub));
3111
3112           /* Do not frob unchanging MEMs.  If a later reference forces the
3113              pseudo to the stack, we can wind up with multiple writes to
3114              an unchanging memory, which is invalid.  */
3115           if (RTX_UNCHANGING_P (x) && size_x != size_sub)
3116             ;
3117
3118           /* Don't even consider working with paradoxical subregs,
3119              or the moral equivalent seen here.  */
3120           else if (size_x <= size_sub
3121                    && int_mode_for_mode (GET_MODE (sub)) != BLKmode)
3122             {
3123               /* Do a bitfield insertion to mirror what would happen
3124                  in memory.  */
3125
3126               rtx val, seq;
3127
3128               if (store)
3129                 {
3130                   rtx p = PREV_INSN (insn);
3131
3132                   start_sequence ();
3133                   val = gen_reg_rtx (GET_MODE (x));
3134                   if (! validate_change (insn, loc, val, 0))
3135                     {
3136                       /* Discard the current sequence and put the
3137                          ADDRESSOF on stack.  */
3138                       end_sequence ();
3139                       goto give_up;
3140                     }
3141                   seq = get_insns ();
3142                   end_sequence ();
3143                   emit_insn_before (seq, insn);
3144                   compute_insns_for_mem (p ? NEXT_INSN (p) : get_insns (),
3145                                          insn, ht);
3146
3147                   start_sequence ();
3148                   store_bit_field (sub, size_x, 0, GET_MODE (x),
3149                                    val, GET_MODE_SIZE (GET_MODE (sub)));
3150
3151                   /* Make sure to unshare any shared rtl that store_bit_field
3152                      might have created.  */
3153                   unshare_all_rtl_again (get_insns ());
3154
3155                   seq = get_insns ();
3156                   end_sequence ();
3157                   p = emit_insn_after (seq, insn);
3158                   if (NEXT_INSN (insn))
3159                     compute_insns_for_mem (NEXT_INSN (insn),
3160                                            p ? NEXT_INSN (p) : NULL_RTX,
3161                                            ht);
3162                 }
3163               else
3164                 {
3165                   rtx p = PREV_INSN (insn);
3166
3167                   start_sequence ();
3168                   val = extract_bit_field (sub, size_x, 0, 1, NULL_RTX,
3169                                            GET_MODE (x), GET_MODE (x),
3170                                            GET_MODE_SIZE (GET_MODE (sub)));
3171
3172                   if (! validate_change (insn, loc, val, 0))
3173                     {
3174                       /* Discard the current sequence and put the
3175                          ADDRESSOF on stack.  */
3176                       end_sequence ();
3177                       goto give_up;
3178                     }
3179
3180                   seq = get_insns ();
3181                   end_sequence ();
3182                   emit_insn_before (seq, insn);
3183                   compute_insns_for_mem (p ? NEXT_INSN (p) : get_insns (),
3184                                          insn, ht);
3185                 }
3186
3187               /* Remember the replacement so that the same one can be done
3188                  on the REG_NOTES.  */
3189               purge_bitfield_addressof_replacements
3190                 = gen_rtx_EXPR_LIST (VOIDmode, x,
3191                                      gen_rtx_EXPR_LIST
3192                                      (VOIDmode, val,
3193                                       purge_bitfield_addressof_replacements));
3194
3195               /* We replaced with a reg -- all done.  */
3196               return true;
3197             }
3198         }
3199
3200       else if (validate_change (insn, loc, sub, 0))
3201         {
3202           /* Remember the replacement so that the same one can be done
3203              on the REG_NOTES.  */
3204           if (GET_CODE (sub) == REG || GET_CODE (sub) == SUBREG)
3205             {
3206               rtx tem;
3207
3208               for (tem = purge_addressof_replacements;
3209                    tem != NULL_RTX;
3210                    tem = XEXP (XEXP (tem, 1), 1))
3211                 if (rtx_equal_p (XEXP (x, 0), XEXP (tem, 0)))
3212                   {
3213                     XEXP (XEXP (tem, 1), 0) = sub;
3214                     return true;
3215                   }
3216               purge_addressof_replacements
3217                 = gen_rtx (EXPR_LIST, VOIDmode, XEXP (x, 0),
3218                            gen_rtx_EXPR_LIST (VOIDmode, sub,
3219                                               purge_addressof_replacements));
3220               return true;
3221             }
3222           goto restart;
3223         }
3224     }
3225
3226  give_up:
3227   /* Scan all subexpressions.  */
3228   fmt = GET_RTX_FORMAT (code);
3229   for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
3230     {
3231       if (*fmt == 'e')
3232         result &= purge_addressof_1 (&XEXP (x, i), insn, force, 0,
3233                                      may_postpone, ht);
3234       else if (*fmt == 'E')
3235         for (j = 0; j < XVECLEN (x, i); j++)
3236           result &= purge_addressof_1 (&XVECEXP (x, i, j), insn, force, 0,
3237                                        may_postpone, ht);
3238     }
3239
3240   return result;
3241 }
3242
3243 /* Return a hash value for K, a REG.  */
3244
3245 static hashval_t
3246 insns_for_mem_hash (const void *k)
3247 {
3248   /* Use the address of the key for the hash value.  */
3249   struct insns_for_mem_entry *m = (struct insns_for_mem_entry *) k;
3250   return htab_hash_pointer (m->key);
3251 }
3252
3253 /* Return nonzero if K1 and K2 (two REGs) are the same.  */
3254
3255 static int
3256 insns_for_mem_comp (const void *k1, const void *k2)
3257 {
3258   struct insns_for_mem_entry *m1 = (struct insns_for_mem_entry *) k1;
3259   struct insns_for_mem_entry *m2 = (struct insns_for_mem_entry *) k2;
3260   return m1->key == m2->key;
3261 }
3262
3263 struct insns_for_mem_walk_info
3264 {
3265   /* The hash table that we are using to record which INSNs use which
3266      MEMs.  */
3267   htab_t ht;
3268
3269   /* The INSN we are currently processing.  */
3270   rtx insn;
3271
3272   /* Zero if we are walking to find ADDRESSOFs, one if we are walking
3273      to find the insns that use the REGs in the ADDRESSOFs.  */
3274   int pass;
3275 };
3276
3277 /* Called from compute_insns_for_mem via for_each_rtx.  If R is a REG
3278    that might be used in an ADDRESSOF expression, record this INSN in
3279    the hash table given by DATA (which is really a pointer to an
3280    insns_for_mem_walk_info structure).  */
3281
3282 static int
3283 insns_for_mem_walk (rtx *r, void *data)
3284 {
3285   struct insns_for_mem_walk_info *ifmwi
3286     = (struct insns_for_mem_walk_info *) data;
3287   struct insns_for_mem_entry tmp;
3288   tmp.insns = NULL_RTX;
3289
3290   if (ifmwi->pass == 0 && *r && GET_CODE (*r) == ADDRESSOF
3291       && GET_CODE (XEXP (*r, 0)) == REG)
3292     {
3293       void **e;
3294       tmp.key = XEXP (*r, 0);
3295       e = htab_find_slot (ifmwi->ht, &tmp, INSERT);
3296       if (*e == NULL)
3297         {
3298           *e = ggc_alloc (sizeof (tmp));
3299           memcpy (*e, &tmp, sizeof (tmp));
3300         }
3301     }
3302   else if (ifmwi->pass == 1 && *r && GET_CODE (*r) == REG)
3303     {
3304       struct insns_for_mem_entry *ifme;
3305       tmp.key = *r;
3306       ifme = htab_find (ifmwi->ht, &tmp);
3307
3308       /* If we have not already recorded this INSN, do so now.  Since
3309          we process the INSNs in order, we know that if we have
3310          recorded it it must be at the front of the list.  */
3311       if (ifme && (!ifme->insns || XEXP (ifme->insns, 0) != ifmwi->insn))
3312         ifme->insns = gen_rtx_EXPR_LIST (VOIDmode, ifmwi->insn,
3313                                          ifme->insns);
3314     }
3315
3316   return 0;
3317 }
3318
3319 /* Walk the INSNS, until we reach LAST_INSN, recording which INSNs use
3320    which REGs in HT.  */
3321
3322 static void
3323 compute_insns_for_mem (rtx insns, rtx last_insn, htab_t ht)
3324 {
3325   rtx insn;
3326   struct insns_for_mem_walk_info ifmwi;
3327   ifmwi.ht = ht;
3328
3329   for (ifmwi.pass = 0; ifmwi.pass < 2; ++ifmwi.pass)
3330     for (insn = insns; insn != last_insn; insn = NEXT_INSN (insn))
3331       if (INSN_P (insn))
3332         {
3333           ifmwi.insn = insn;
3334           for_each_rtx (&insn, insns_for_mem_walk, &ifmwi);
3335         }
3336 }
3337
3338 /* Helper function for purge_addressof called through for_each_rtx.
3339    Returns true iff the rtl is an ADDRESSOF.  */
3340
3341 static int
3342 is_addressof (rtx *rtl, void *data ATTRIBUTE_UNUSED)
3343 {
3344   return GET_CODE (*rtl) == ADDRESSOF;
3345 }
3346
3347 /* Eliminate all occurrences of ADDRESSOF from INSNS.  Elide any remaining
3348    (MEM (ADDRESSOF)) patterns, and force any needed registers into the
3349    stack.  */
3350
3351 void
3352 purge_addressof (rtx insns)
3353 {
3354   rtx insn, tmp;
3355   htab_t ht;
3356
3357   /* When we actually purge ADDRESSOFs, we turn REGs into MEMs.  That
3358      requires a fixup pass over the instruction stream to correct
3359      INSNs that depended on the REG being a REG, and not a MEM.  But,
3360      these fixup passes are slow.  Furthermore, most MEMs are not
3361      mentioned in very many instructions.  So, we speed up the process
3362      by pre-calculating which REGs occur in which INSNs; that allows
3363      us to perform the fixup passes much more quickly.  */
3364   ht = htab_create_ggc (1000, insns_for_mem_hash, insns_for_mem_comp, NULL);
3365   compute_insns_for_mem (insns, NULL_RTX, ht);
3366
3367   postponed_insns = NULL;
3368
3369   for (insn = insns; insn; insn = NEXT_INSN (insn))
3370     if (INSN_P (insn))
3371       {
3372         if (! purge_addressof_1 (&PATTERN (insn), insn,
3373                                  asm_noperands (PATTERN (insn)) > 0, 0, 1, ht))
3374           /* If we could not replace the ADDRESSOFs in the insn,
3375              something is wrong.  */
3376           abort ();
3377
3378         if (! purge_addressof_1 (&REG_NOTES (insn), NULL_RTX, 0, 0, 0, ht))
3379           {
3380             /* If we could not replace the ADDRESSOFs in the insn's notes,
3381                we can just remove the offending notes instead.  */
3382             rtx note;
3383
3384             for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
3385               {
3386                 /* If we find a REG_RETVAL note then the insn is a libcall.
3387                    Such insns must have REG_EQUAL notes as well, in order
3388                    for later passes of the compiler to work.  So it is not
3389                    safe to delete the notes here, and instead we abort.  */
3390                 if (REG_NOTE_KIND (note) == REG_RETVAL)
3391                   abort ();
3392                 if (for_each_rtx (&note, is_addressof, NULL))
3393                   remove_note (insn, note);
3394               }
3395           }
3396       }
3397
3398   /* Process the postponed insns.  */
3399   while (postponed_insns)
3400     {
3401       insn = XEXP (postponed_insns, 0);
3402       tmp = postponed_insns;
3403       postponed_insns = XEXP (postponed_insns, 1);
3404       free_INSN_LIST_node (tmp);
3405
3406       if (! purge_addressof_1 (&PATTERN (insn), insn,
3407                                asm_noperands (PATTERN (insn)) > 0, 0, 0, ht))
3408         abort ();
3409     }
3410
3411   /* Clean up.  */
3412   purge_bitfield_addressof_replacements = 0;
3413   purge_addressof_replacements = 0;
3414
3415   /* REGs are shared.  purge_addressof will destructively replace a REG
3416      with a MEM, which creates shared MEMs.
3417
3418      Unfortunately, the children of put_reg_into_stack assume that MEMs
3419      referring to the same stack slot are shared (fixup_var_refs and
3420      the associated hash table code).
3421
3422      So, we have to do another unsharing pass after we have flushed any
3423      REGs that had their address taken into the stack.
3424
3425      It may be worth tracking whether or not we converted any REGs into
3426      MEMs to avoid this overhead when it is not needed.  */
3427   unshare_all_rtl_again (get_insns ());
3428 }
3429 \f
3430 /* Convert a SET of a hard subreg to a set of the appropriate hard
3431    register.  A subroutine of purge_hard_subreg_sets.  */
3432
3433 static void
3434 purge_single_hard_subreg_set (rtx pattern)
3435 {
3436   rtx reg = SET_DEST (pattern);
3437   enum machine_mode mode = GET_MODE (SET_DEST (pattern));
3438   int offset = 0;
3439
3440   if (GET_CODE (reg) == SUBREG && GET_CODE (SUBREG_REG (reg)) == REG
3441       && REGNO (SUBREG_REG (reg)) < FIRST_PSEUDO_REGISTER)
3442     {
3443       offset = subreg_regno_offset (REGNO (SUBREG_REG (reg)),
3444                                     GET_MODE (SUBREG_REG (reg)),
3445                                     SUBREG_BYTE (reg),
3446                                     GET_MODE (reg));
3447       reg = SUBREG_REG (reg);
3448     }
3449
3450
3451   if (GET_CODE (reg) == REG && REGNO (reg) < FIRST_PSEUDO_REGISTER)
3452     {
3453       reg = gen_rtx_REG (mode, REGNO (reg) + offset);
3454       SET_DEST (pattern) = reg;
3455     }
3456 }
3457
3458 /* Eliminate all occurrences of SETs of hard subregs from INSNS.  The
3459    only such SETs that we expect to see are those left in because
3460    integrate can't handle sets of parts of a return value register.
3461
3462    We don't use alter_subreg because we only want to eliminate subregs
3463    of hard registers.  */
3464
3465 void
3466 purge_hard_subreg_sets (rtx insn)
3467 {
3468   for (; insn; insn = NEXT_INSN (insn))
3469     {
3470       if (INSN_P (insn))
3471         {
3472           rtx pattern = PATTERN (insn);
3473           switch (GET_CODE (pattern))
3474             {
3475             case SET:
3476               if (GET_CODE (SET_DEST (pattern)) == SUBREG)
3477                 purge_single_hard_subreg_set (pattern);
3478               break;
3479             case PARALLEL:
3480               {
3481                 int j;
3482                 for (j = XVECLEN (pattern, 0) - 1; j >= 0; j--)
3483                   {
3484                     rtx inner_pattern = XVECEXP (pattern, 0, j);
3485                     if (GET_CODE (inner_pattern) == SET
3486                         && GET_CODE (SET_DEST (inner_pattern)) == SUBREG)
3487                       purge_single_hard_subreg_set (inner_pattern);
3488                   }
3489               }
3490               break;
3491             default:
3492               break;
3493             }
3494         }
3495     }
3496 }
3497 \f
3498 /* Pass through the INSNS of function FNDECL and convert virtual register
3499    references to hard register references.  */
3500
3501 void
3502 instantiate_virtual_regs (tree fndecl, rtx insns)
3503 {
3504   rtx insn;
3505   unsigned int i;
3506
3507   /* Compute the offsets to use for this function.  */
3508   in_arg_offset = FIRST_PARM_OFFSET (fndecl);
3509   var_offset = STARTING_FRAME_OFFSET;
3510   dynamic_offset = STACK_DYNAMIC_OFFSET (fndecl);
3511   out_arg_offset = STACK_POINTER_OFFSET;
3512   cfa_offset = ARG_POINTER_CFA_OFFSET (fndecl);
3513
3514   /* Scan all variables and parameters of this function.  For each that is
3515      in memory, instantiate all virtual registers if the result is a valid
3516      address.  If not, we do it later.  That will handle most uses of virtual
3517      regs on many machines.  */
3518   instantiate_decls (fndecl, 1);
3519
3520   /* Initialize recognition, indicating that volatile is OK.  */
3521   init_recog ();
3522
3523   /* Scan through all the insns, instantiating every virtual register still
3524      present.  */
3525   for (insn = insns; insn; insn = NEXT_INSN (insn))
3526     if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN
3527         || GET_CODE (insn) == CALL_INSN)
3528       {
3529         instantiate_virtual_regs_1 (&PATTERN (insn), insn, 1);
3530         if (INSN_DELETED_P (insn))
3531           continue;
3532         instantiate_virtual_regs_1 (&REG_NOTES (insn), NULL_RTX, 0);
3533         /* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE.  */
3534         if (GET_CODE (insn) == CALL_INSN)
3535           instantiate_virtual_regs_1 (&CALL_INSN_FUNCTION_USAGE (insn),
3536                                       NULL_RTX, 0);
3537
3538         /* Past this point all ASM statements should match.  Verify that
3539            to avoid failures later in the compilation process.  */
3540         if (asm_noperands (PATTERN (insn)) >= 0
3541             && ! check_asm_operands (PATTERN (insn)))
3542           instantiate_virtual_regs_lossage (insn);
3543       }
3544
3545   /* Instantiate the stack slots for the parm registers, for later use in
3546      addressof elimination.  */
3547   for (i = 0; i < max_parm_reg; ++i)
3548     if (parm_reg_stack_loc[i])
3549       instantiate_virtual_regs_1 (&parm_reg_stack_loc[i], NULL_RTX, 0);
3550
3551   /* Now instantiate the remaining register equivalences for debugging info.
3552      These will not be valid addresses.  */
3553   instantiate_decls (fndecl, 0);
3554
3555   /* Indicate that, from now on, assign_stack_local should use
3556      frame_pointer_rtx.  */
3557   virtuals_instantiated = 1;
3558 }
3559
3560 /* Scan all decls in FNDECL (both variables and parameters) and instantiate
3561    all virtual registers in their DECL_RTL's.
3562
3563    If VALID_ONLY, do this only if the resulting address is still valid.
3564    Otherwise, always do it.  */
3565
3566 static void
3567 instantiate_decls (tree fndecl, int valid_only)
3568 {
3569   tree decl;
3570
3571   /* Process all parameters of the function.  */
3572   for (decl = DECL_ARGUMENTS (fndecl); decl; decl = TREE_CHAIN (decl))
3573     {
3574       HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (decl));
3575       HOST_WIDE_INT size_rtl;
3576
3577       instantiate_decl (DECL_RTL (decl), size, valid_only);
3578
3579       /* If the parameter was promoted, then the incoming RTL mode may be
3580          larger than the declared type size.  We must use the larger of
3581          the two sizes.  */
3582       size_rtl = GET_MODE_SIZE (GET_MODE (DECL_INCOMING_RTL (decl)));
3583       size = MAX (size_rtl, size);
3584       instantiate_decl (DECL_INCOMING_RTL (decl), size, valid_only);
3585     }
3586
3587   /* Now process all variables defined in the function or its subblocks.  */
3588   instantiate_decls_1 (DECL_INITIAL (fndecl), valid_only);
3589 }
3590
3591 /* Subroutine of instantiate_decls: Process all decls in the given
3592    BLOCK node and all its subblocks.  */
3593
3594 static void
3595 instantiate_decls_1 (tree let, int valid_only)
3596 {
3597   tree t;
3598
3599   for (t = BLOCK_VARS (let); t; t = TREE_CHAIN (t))
3600     if (DECL_RTL_SET_P (t))
3601       instantiate_decl (DECL_RTL (t),
3602                         int_size_in_bytes (TREE_TYPE (t)),
3603                         valid_only);
3604
3605   /* Process all subblocks.  */
3606   for (t = BLOCK_SUBBLOCKS (let); t; t = TREE_CHAIN (t))
3607     instantiate_decls_1 (t, valid_only);
3608 }
3609
3610 /* Subroutine of the preceding procedures: Given RTL representing a
3611    decl and the size of the object, do any instantiation required.
3612
3613    If VALID_ONLY is nonzero, it means that the RTL should only be
3614    changed if the new address is valid.  */
3615
3616 static void
3617 instantiate_decl (rtx x, HOST_WIDE_INT size, int valid_only)
3618 {
3619   enum machine_mode mode;
3620   rtx addr;
3621
3622   /* If this is not a MEM, no need to do anything.  Similarly if the
3623      address is a constant or a register that is not a virtual register.  */
3624
3625   if (x == 0 || GET_CODE (x) != MEM)
3626     return;
3627
3628   addr = XEXP (x, 0);
3629   if (CONSTANT_P (addr)
3630       || (GET_CODE (addr) == ADDRESSOF && GET_CODE (XEXP (addr, 0)) == REG)
3631       || (GET_CODE (addr) == REG
3632           && (REGNO (addr) < FIRST_VIRTUAL_REGISTER
3633               || REGNO (addr) > LAST_VIRTUAL_REGISTER)))
3634     return;
3635
3636   /* If we should only do this if the address is valid, copy the address.
3637      We need to do this so we can undo any changes that might make the
3638      address invalid.  This copy is unfortunate, but probably can't be
3639      avoided.  */
3640
3641   if (valid_only)
3642     addr = copy_rtx (addr);
3643
3644   instantiate_virtual_regs_1 (&addr, NULL_RTX, 0);
3645
3646   if (valid_only && size >= 0)
3647     {
3648       unsigned HOST_WIDE_INT decl_size = size;
3649
3650       /* Now verify that the resulting address is valid for every integer or
3651          floating-point mode up to and including SIZE bytes long.  We do this
3652          since the object might be accessed in any mode and frame addresses
3653          are shared.  */
3654
3655       for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
3656            mode != VOIDmode && GET_MODE_SIZE (mode) <= decl_size;
3657            mode = GET_MODE_WIDER_MODE (mode))
3658         if (! memory_address_p (mode, addr))
3659           return;
3660
3661       for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
3662            mode != VOIDmode && GET_MODE_SIZE (mode) <= decl_size;
3663            mode = GET_MODE_WIDER_MODE (mode))
3664         if (! memory_address_p (mode, addr))
3665           return;
3666     }
3667
3668   /* Put back the address now that we have updated it and we either know
3669      it is valid or we don't care whether it is valid.  */
3670
3671   XEXP (x, 0) = addr;
3672 }
3673 \f
3674 /* Given a piece of RTX and a pointer to a HOST_WIDE_INT, if the RTX
3675    is a virtual register, return the equivalent hard register and set the
3676    offset indirectly through the pointer.  Otherwise, return 0.  */
3677
3678 static rtx
3679 instantiate_new_reg (rtx x, HOST_WIDE_INT *poffset)
3680 {
3681   rtx new;
3682   HOST_WIDE_INT offset;
3683
3684   if (x == virtual_incoming_args_rtx)
3685     new = arg_pointer_rtx, offset = in_arg_offset;
3686   else if (x == virtual_stack_vars_rtx)
3687     new = frame_pointer_rtx, offset = var_offset;
3688   else if (x == virtual_stack_dynamic_rtx)
3689     new = stack_pointer_rtx, offset = dynamic_offset;
3690   else if (x == virtual_outgoing_args_rtx)
3691     new = stack_pointer_rtx, offset = out_arg_offset;
3692   else if (x == virtual_cfa_rtx)
3693     new = arg_pointer_rtx, offset = cfa_offset;
3694   else
3695     return 0;
3696
3697   *poffset = offset;
3698   return new;
3699 }
3700 \f
3701
3702 /* Called when instantiate_virtual_regs has failed to update the instruction.
3703    Usually this means that non-matching instruction has been emit, however for
3704    asm statements it may be the problem in the constraints.  */
3705 static void
3706 instantiate_virtual_regs_lossage (rtx insn)
3707 {
3708   if (asm_noperands (PATTERN (insn)) >= 0)
3709     {
3710       error_for_asm (insn, "impossible constraint in `asm'");
3711       delete_insn (insn);
3712     }
3713   else
3714     abort ();
3715 }
3716 /* Given a pointer to a piece of rtx and an optional pointer to the
3717    containing object, instantiate any virtual registers present in it.
3718
3719    If EXTRA_INSNS, we always do the replacement and generate
3720    any extra insns before OBJECT.  If it zero, we do nothing if replacement
3721    is not valid.
3722
3723    Return 1 if we either had nothing to do or if we were able to do the
3724    needed replacement.  Return 0 otherwise; we only return zero if
3725    EXTRA_INSNS is zero.
3726
3727    We first try some simple transformations to avoid the creation of extra
3728    pseudos.  */
3729
3730 static int
3731 instantiate_virtual_regs_1 (rtx *loc, rtx object, int extra_insns)
3732 {
3733   rtx x;
3734   RTX_CODE code;
3735   rtx new = 0;
3736   HOST_WIDE_INT offset = 0;
3737   rtx temp;
3738   rtx seq;
3739   int i, j;
3740   const char *fmt;
3741
3742   /* Re-start here to avoid recursion in common cases.  */
3743  restart:
3744
3745   x = *loc;
3746   if (x == 0)
3747     return 1;
3748
3749   /* We may have detected and deleted invalid asm statements.  */
3750   if (object && INSN_P (object) && INSN_DELETED_P (object))
3751     return 1;
3752
3753   code = GET_CODE (x);
3754
3755   /* Check for some special cases.  */
3756   switch (code)
3757     {
3758     case CONST_INT:
3759     case CONST_DOUBLE:
3760     case CONST_VECTOR:
3761     case CONST:
3762     case SYMBOL_REF:
3763     case CODE_LABEL:
3764     case PC:
3765     case CC0:
3766     case ASM_INPUT:
3767     case ADDR_VEC:
3768     case ADDR_DIFF_VEC:
3769     case RETURN:
3770       return 1;
3771
3772     case SET:
3773       /* We are allowed to set the virtual registers.  This means that
3774          the actual register should receive the source minus the
3775          appropriate offset.  This is used, for example, in the handling
3776          of non-local gotos.  */
3777       if ((new = instantiate_new_reg (SET_DEST (x), &offset)) != 0)
3778         {
3779           rtx src = SET_SRC (x);
3780
3781           /* We are setting the register, not using it, so the relevant
3782              offset is the negative of the offset to use were we using
3783              the register.  */
3784           offset = - offset;
3785           instantiate_virtual_regs_1 (&src, NULL_RTX, 0);
3786
3787           /* The only valid sources here are PLUS or REG.  Just do
3788              the simplest possible thing to handle them.  */
3789           if (GET_CODE (src) != REG && GET_CODE (src) != PLUS)
3790             {
3791               instantiate_virtual_regs_lossage (object);
3792               return 1;
3793             }
3794
3795           start_sequence ();
3796           if (GET_CODE (src) != REG)
3797             temp = force_operand (src, NULL_RTX);
3798           else
3799             temp = src;
3800           temp = force_operand (plus_constant (temp, offset), NULL_RTX);
3801           seq = get_insns ();
3802           end_sequence ();
3803
3804           emit_insn_before (seq, object);
3805           SET_DEST (x) = new;
3806
3807           if (! validate_change (object, &SET_SRC (x), temp, 0)
3808               || ! extra_insns)
3809             instantiate_virtual_regs_lossage (object);
3810
3811           return 1;
3812         }
3813
3814       instantiate_virtual_regs_1 (&SET_DEST (x), object, extra_insns);
3815       loc = &SET_SRC (x);
3816       goto restart;
3817
3818     case PLUS:
3819       /* Handle special case of virtual register plus constant.  */
3820       if (CONSTANT_P (XEXP (x, 1)))
3821         {
3822           rtx old, new_offset;
3823
3824           /* Check for (plus (plus VIRT foo) (const_int)) first.  */
3825           if (GET_CODE (XEXP (x, 0)) == PLUS)
3826             {
3827               if ((new = instantiate_new_reg (XEXP (XEXP (x, 0), 0), &offset)))
3828                 {
3829                   instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 1), object,
3830                                               extra_insns);
3831                   new = gen_rtx_PLUS (Pmode, new, XEXP (XEXP (x, 0), 1));
3832                 }
3833               else
3834                 {
3835                   loc = &XEXP (x, 0);
3836                   goto restart;
3837                 }
3838             }
3839
3840 #ifdef POINTERS_EXTEND_UNSIGNED
3841           /* If we have (plus (subreg (virtual-reg)) (const_int)), we know
3842              we can commute the PLUS and SUBREG because pointers into the
3843              frame are well-behaved.  */
3844           else if (GET_CODE (XEXP (x, 0)) == SUBREG && GET_MODE (x) == ptr_mode
3845                    && GET_CODE (XEXP (x, 1)) == CONST_INT
3846                    && 0 != (new
3847                             = instantiate_new_reg (SUBREG_REG (XEXP (x, 0)),
3848                                                    &offset))
3849                    && validate_change (object, loc,
3850                                        plus_constant (gen_lowpart (ptr_mode,
3851                                                                    new),
3852                                                       offset
3853                                                       + INTVAL (XEXP (x, 1))),
3854                                        0))
3855                 return 1;
3856 #endif
3857           else if ((new = instantiate_new_reg (XEXP (x, 0), &offset)) == 0)
3858             {
3859               /* We know the second operand is a constant.  Unless the
3860                  first operand is a REG (which has been already checked),
3861                  it needs to be checked.  */
3862               if (GET_CODE (XEXP (x, 0)) != REG)
3863                 {
3864                   loc = &XEXP (x, 0);
3865                   goto restart;
3866                 }
3867               return 1;
3868             }
3869
3870           new_offset = plus_constant (XEXP (x, 1), offset);
3871
3872           /* If the new constant is zero, try to replace the sum with just
3873              the register.  */
3874           if (new_offset == const0_rtx
3875               && validate_change (object, loc, new, 0))
3876             return 1;
3877
3878           /* Next try to replace the register and new offset.
3879              There are two changes to validate here and we can't assume that
3880              in the case of old offset equals new just changing the register
3881              will yield a valid insn.  In the interests of a little efficiency,
3882              however, we only call validate change once (we don't queue up the
3883              changes and then call apply_change_group).  */
3884
3885           old = XEXP (x, 0);
3886           if (offset == 0
3887               ? ! validate_change (object, &XEXP (x, 0), new, 0)
3888               : (XEXP (x, 0) = new,
3889                  ! validate_change (object, &XEXP (x, 1), new_offset, 0)))
3890             {
3891               if (! extra_insns)
3892                 {
3893                   XEXP (x, 0) = old;
3894                   return 0;
3895                 }
3896
3897               /* Otherwise copy the new constant into a register and replace
3898                  constant with that register.  */
3899               temp = gen_reg_rtx (Pmode);
3900               XEXP (x, 0) = new;
3901               if (validate_change (object, &XEXP (x, 1), temp, 0))
3902                 emit_insn_before (gen_move_insn (temp, new_offset), object);
3903               else
3904                 {
3905                   /* If that didn't work, replace this expression with a
3906                      register containing the sum.  */
3907
3908                   XEXP (x, 0) = old;
3909                   new = gen_rtx_PLUS (Pmode, new, new_offset);
3910
3911                   start_sequence ();
3912                   temp = force_operand (new, NULL_RTX);
3913                   seq = get_insns ();
3914                   end_sequence ();
3915
3916                   emit_insn_before (seq, object);
3917                   if (! validate_change (object, loc, temp, 0)
3918                       && ! validate_replace_rtx (x, temp, object))
3919                     {
3920                       instantiate_virtual_regs_lossage (object);
3921                       return 1;
3922                     }
3923                 }
3924             }
3925
3926           return 1;
3927         }
3928
3929       /* Fall through to generic two-operand expression case.  */
3930     case EXPR_LIST:
3931     case CALL:
3932     case COMPARE:
3933     case MINUS:
3934     case MULT:
3935     case DIV:      case UDIV:
3936     case MOD:      case UMOD:
3937     case AND:      case IOR:      case XOR:
3938     case ROTATERT: case ROTATE:
3939     case ASHIFTRT: case LSHIFTRT: case ASHIFT:
3940     case NE:       case EQ:
3941     case GE:       case GT:       case GEU:    case GTU:
3942     case LE:       case LT:       case LEU:    case LTU:
3943       if (XEXP (x, 1) && ! CONSTANT_P (XEXP (x, 1)))
3944         instantiate_virtual_regs_1 (&XEXP (x, 1), object, extra_insns);
3945       loc = &XEXP (x, 0);
3946       goto restart;
3947
3948     case MEM:
3949       /* Most cases of MEM that convert to valid addresses have already been
3950          handled by our scan of decls.  The only special handling we
3951          need here is to make a copy of the rtx to ensure it isn't being
3952          shared if we have to change it to a pseudo.
3953
3954          If the rtx is a simple reference to an address via a virtual register,
3955          it can potentially be shared.  In such cases, first try to make it
3956          a valid address, which can also be shared.  Otherwise, copy it and
3957          proceed normally.
3958
3959          First check for common cases that need no processing.  These are
3960          usually due to instantiation already being done on a previous instance
3961          of a shared rtx.  */
3962
3963       temp = XEXP (x, 0);
3964       if (CONSTANT_ADDRESS_P (temp)
3965 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
3966           || temp == arg_pointer_rtx
3967 #endif
3968 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
3969           || temp == hard_frame_pointer_rtx
3970 #endif
3971           || temp == frame_pointer_rtx)
3972         return 1;
3973
3974       if (GET_CODE (temp) == PLUS
3975           && CONSTANT_ADDRESS_P (XEXP (temp, 1))
3976           && (XEXP (temp, 0) == frame_pointer_rtx
3977 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
3978               || XEXP (temp, 0) == hard_frame_pointer_rtx
3979 #endif
3980 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
3981               || XEXP (temp, 0) == arg_pointer_rtx
3982 #endif
3983               ))
3984         return 1;
3985
3986       if (temp == virtual_stack_vars_rtx
3987           || temp == virtual_incoming_args_rtx
3988           || (GET_CODE (temp) == PLUS
3989               && CONSTANT_ADDRESS_P (XEXP (temp, 1))
3990               && (XEXP (temp, 0) == virtual_stack_vars_rtx
3991                   || XEXP (temp, 0) == virtual_incoming_args_rtx)))
3992         {
3993           /* This MEM may be shared.  If the substitution can be done without
3994              the need to generate new pseudos, we want to do it in place
3995              so all copies of the shared rtx benefit.  The call below will
3996              only make substitutions if the resulting address is still
3997              valid.
3998
3999              Note that we cannot pass X as the object in the recursive call
4000              since the insn being processed may not allow all valid
4001              addresses.  However, if we were not passed on object, we can
4002              only modify X without copying it if X will have a valid
4003              address.
4004
4005              ??? Also note that this can still lose if OBJECT is an insn that
4006              has less restrictions on an address that some other insn.
4007              In that case, we will modify the shared address.  This case
4008              doesn't seem very likely, though.  One case where this could
4009              happen is in the case of a USE or CLOBBER reference, but we
4010              take care of that below.  */
4011
4012           if (instantiate_virtual_regs_1 (&XEXP (x, 0),
4013                                           object ? object : x, 0))
4014             return 1;
4015
4016           /* Otherwise make a copy and process that copy.  We copy the entire
4017              RTL expression since it might be a PLUS which could also be
4018              shared.  */
4019           *loc = x = copy_rtx (x);
4020         }
4021
4022       /* Fall through to generic unary operation case.  */
4023     case PREFETCH:
4024     case SUBREG:
4025     case STRICT_LOW_PART:
4026     case NEG:          case NOT:
4027     case PRE_DEC:      case PRE_INC:      case POST_DEC:    case POST_INC:
4028     case SIGN_EXTEND:  case ZERO_EXTEND:
4029     case TRUNCATE:     case FLOAT_EXTEND: case FLOAT_TRUNCATE:
4030     case FLOAT:        case FIX:
4031     case UNSIGNED_FIX: case UNSIGNED_FLOAT:
4032     case ABS:
4033     case SQRT:
4034     case FFS:
4035     case CLZ:          case CTZ:
4036     case POPCOUNT:     case PARITY:
4037       /* These case either have just one operand or we know that we need not
4038          check the rest of the operands.  */
4039       loc = &XEXP (x, 0);
4040       goto restart;
4041
4042     case USE:
4043     case CLOBBER:
4044       /* If the operand is a MEM, see if the change is a valid MEM.  If not,
4045          go ahead and make the invalid one, but do it to a copy.  For a REG,
4046          just make the recursive call, since there's no chance of a problem.  */
4047
4048       if ((GET_CODE (XEXP (x, 0)) == MEM
4049            && instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 0), XEXP (x, 0),
4050                                           0))
4051           || (GET_CODE (XEXP (x, 0)) == REG
4052               && instantiate_virtual_regs_1 (&XEXP (x, 0), object, 0)))
4053         return 1;
4054
4055       XEXP (x, 0) = copy_rtx (XEXP (x, 0));
4056       loc = &XEXP (x, 0);
4057       goto restart;
4058
4059     case REG:
4060       /* Try to replace with a PLUS.  If that doesn't work, compute the sum
4061          in front of this insn and substitute the temporary.  */
4062       if ((new = instantiate_new_reg (x, &offset)) != 0)
4063         {
4064           temp = plus_constant (new, offset);
4065           if (!validate_change (object, loc, temp, 0))
4066             {
4067               if (! extra_insns)
4068                 return 0;
4069
4070               start_sequence ();
4071               temp = force_operand (temp, NULL_RTX);
4072               seq = get_insns ();
4073               end_sequence ();
4074
4075               emit_insn_before (seq, object);
4076               if (! validate_change (object, loc, temp, 0)
4077                   && ! validate_replace_rtx (x, temp, object))
4078                 instantiate_virtual_regs_lossage (object);
4079             }
4080         }
4081
4082       return 1;
4083
4084     case ADDRESSOF:
4085       if (GET_CODE (XEXP (x, 0)) == REG)
4086         return 1;
4087
4088       else if (GET_CODE (XEXP (x, 0)) == MEM)
4089         {
4090           /* If we have a (addressof (mem ..)), do any instantiation inside
4091              since we know we'll be making the inside valid when we finally
4092              remove the ADDRESSOF.  */
4093           instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 0), NULL_RTX, 0);
4094           return 1;
4095         }
4096       break;
4097
4098     default:
4099       break;
4100     }
4101
4102   /* Scan all subexpressions.  */
4103   fmt = GET_RTX_FORMAT (code);
4104   for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
4105     if (*fmt == 'e')
4106       {
4107         if (!instantiate_virtual_regs_1 (&XEXP (x, i), object, extra_insns))
4108           return 0;
4109       }
4110     else if (*fmt == 'E')
4111       for (j = 0; j < XVECLEN (x, i); j++)
4112         if (! instantiate_virtual_regs_1 (&XVECEXP (x, i, j), object,
4113                                           extra_insns))
4114           return 0;
4115
4116   return 1;
4117 }
4118 \f
4119 /* Optimization: assuming this function does not receive nonlocal gotos,
4120    delete the handlers for such, as well as the insns to establish
4121    and disestablish them.  */
4122
4123 static void
4124 delete_handlers (void)
4125 {
4126   rtx insn;
4127   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4128     {
4129       /* Delete the handler by turning off the flag that would
4130          prevent jump_optimize from deleting it.
4131          Also permit deletion of the nonlocal labels themselves
4132          if nothing local refers to them.  */
4133       if (GET_CODE (insn) == CODE_LABEL)
4134         {
4135           tree t, last_t;
4136
4137           LABEL_PRESERVE_P (insn) = 0;
4138
4139           /* Remove it from the nonlocal_label list, to avoid confusing
4140              flow.  */
4141           for (t = nonlocal_labels, last_t = 0; t;
4142                last_t = t, t = TREE_CHAIN (t))
4143             if (DECL_RTL (TREE_VALUE (t)) == insn)
4144               break;
4145           if (t)
4146             {
4147               if (! last_t)
4148                 nonlocal_labels = TREE_CHAIN (nonlocal_labels);
4149               else
4150                 TREE_CHAIN (last_t) = TREE_CHAIN (t);
4151             }
4152         }
4153       if (GET_CODE (insn) == INSN)
4154         {
4155           int can_delete = 0;
4156           rtx t;
4157           for (t = nonlocal_goto_handler_slots; t != 0; t = XEXP (t, 1))
4158             if (reg_mentioned_p (t, PATTERN (insn)))
4159               {
4160                 can_delete = 1;
4161                 break;
4162               }
4163           if (can_delete
4164               || (nonlocal_goto_stack_level != 0
4165                   && reg_mentioned_p (nonlocal_goto_stack_level,
4166                                       PATTERN (insn))))
4167             delete_related_insns (insn);
4168         }
4169     }
4170 }
4171 \f
4172 /* Return the first insn following those generated by `assign_parms'.  */
4173
4174 rtx
4175 get_first_nonparm_insn (void)
4176 {
4177   if (last_parm_insn)
4178     return NEXT_INSN (last_parm_insn);
4179   return get_insns ();
4180 }
4181
4182 /* Return 1 if EXP is an aggregate type (or a value with aggregate type).
4183    This means a type for which function calls must pass an address to the
4184    function or get an address back from the function.
4185    EXP may be a type node or an expression (whose type is tested).  */
4186
4187 int
4188 aggregate_value_p (tree exp, tree fntype)
4189 {
4190   int i, regno, nregs;
4191   rtx reg;
4192
4193   tree type = (TYPE_P (exp)) ? exp : TREE_TYPE (exp);
4194
4195   if (fntype)
4196     switch (TREE_CODE (fntype))
4197       {
4198       case CALL_EXPR:
4199         fntype = get_callee_fndecl (fntype);
4200         fntype = fntype ? TREE_TYPE (fntype) : 0;
4201         break;
4202       case FUNCTION_DECL:
4203         fntype = TREE_TYPE (fntype);
4204         break;
4205       case FUNCTION_TYPE:
4206       case METHOD_TYPE:
4207         break;
4208       case IDENTIFIER_NODE:
4209         fntype = 0;
4210         break;
4211       default:
4212         /* We don't expect other rtl types here.  */
4213         abort();
4214       }
4215
4216   if (TREE_CODE (type) == VOID_TYPE)
4217     return 0;
4218   if (targetm.calls.return_in_memory (type, fntype))
4219     return 1;
4220   /* Types that are TREE_ADDRESSABLE must be constructed in memory,
4221      and thus can't be returned in registers.  */
4222   if (TREE_ADDRESSABLE (type))
4223     return 1;
4224   if (flag_pcc_struct_return && AGGREGATE_TYPE_P (type))
4225     return 1;
4226   /* Make sure we have suitable call-clobbered regs to return
4227      the value in; if not, we must return it in memory.  */
4228   reg = hard_function_value (type, 0, 0);
4229
4230   /* If we have something other than a REG (e.g. a PARALLEL), then assume
4231      it is OK.  */
4232   if (GET_CODE (reg) != REG)
4233     return 0;
4234
4235   regno = REGNO (reg);
4236   nregs = HARD_REGNO_NREGS (regno, TYPE_MODE (type));
4237   for (i = 0; i < nregs; i++)
4238     if (! call_used_regs[regno + i])
4239       return 1;
4240   return 0;
4241 }
4242 \f
4243 /* Assign RTL expressions to the function's parameters.
4244    This may involve copying them into registers and using
4245    those registers as the RTL for them.  */
4246
4247 void
4248 assign_parms (tree fndecl)
4249 {
4250   tree parm;
4251   CUMULATIVE_ARGS args_so_far;
4252   /* Total space needed so far for args on the stack,
4253      given as a constant and a tree-expression.  */
4254   struct args_size stack_args_size;
4255   tree fntype = TREE_TYPE (fndecl);
4256   tree fnargs = DECL_ARGUMENTS (fndecl), orig_fnargs;
4257   /* This is used for the arg pointer when referring to stack args.  */
4258   rtx internal_arg_pointer;
4259   /* This is a dummy PARM_DECL that we used for the function result if
4260      the function returns a structure.  */
4261   tree function_result_decl = 0;
4262   int varargs_setup = 0;
4263   int reg_parm_stack_space ATTRIBUTE_UNUSED = 0;
4264   rtx conversion_insns = 0;
4265
4266   /* Nonzero if function takes extra anonymous args.
4267      This means the last named arg must be on the stack
4268      right before the anonymous ones.  */
4269   int stdarg
4270     = (TYPE_ARG_TYPES (fntype) != 0
4271        && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
4272            != void_type_node));
4273
4274   current_function_stdarg = stdarg;
4275
4276   /* If the reg that the virtual arg pointer will be translated into is
4277      not a fixed reg or is the stack pointer, make a copy of the virtual
4278      arg pointer, and address parms via the copy.  The frame pointer is
4279      considered fixed even though it is not marked as such.
4280
4281      The second time through, simply use ap to avoid generating rtx.  */
4282
4283   if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
4284        || ! (fixed_regs[ARG_POINTER_REGNUM]
4285              || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
4286     internal_arg_pointer = copy_to_reg (virtual_incoming_args_rtx);
4287   else
4288     internal_arg_pointer = virtual_incoming_args_rtx;
4289   current_function_internal_arg_pointer = internal_arg_pointer;
4290
4291   stack_args_size.constant = 0;
4292   stack_args_size.var = 0;
4293
4294   /* If struct value address is treated as the first argument, make it so.  */
4295   if (aggregate_value_p (DECL_RESULT (fndecl), fndecl)
4296       && ! current_function_returns_pcc_struct
4297       && targetm.calls.struct_value_rtx (TREE_TYPE (fndecl), 1) == 0)
4298     {
4299       tree type = build_pointer_type (TREE_TYPE (fntype));
4300
4301       function_result_decl = build_decl (PARM_DECL, NULL_TREE, type);
4302
4303       DECL_ARG_TYPE (function_result_decl) = type;
4304       TREE_CHAIN (function_result_decl) = fnargs;
4305       fnargs = function_result_decl;
4306     }
4307
4308   orig_fnargs = fnargs;
4309
4310   max_parm_reg = LAST_VIRTUAL_REGISTER + 1;
4311   parm_reg_stack_loc = ggc_alloc_cleared (max_parm_reg * sizeof (rtx));
4312
4313   if (SPLIT_COMPLEX_ARGS)
4314     fnargs = split_complex_args (fnargs);
4315
4316 #ifdef REG_PARM_STACK_SPACE
4317 #ifdef MAYBE_REG_PARM_STACK_SPACE
4318   reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
4319 #else
4320   reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
4321 #endif
4322 #endif
4323
4324 #ifdef INIT_CUMULATIVE_INCOMING_ARGS
4325   INIT_CUMULATIVE_INCOMING_ARGS (args_so_far, fntype, NULL_RTX);
4326 #else
4327   INIT_CUMULATIVE_ARGS (args_so_far, fntype, NULL_RTX, fndecl);
4328 #endif
4329
4330   /* We haven't yet found an argument that we must push and pretend the
4331      caller did.  */
4332   current_function_pretend_args_size = 0;
4333
4334   for (parm = fnargs; parm; parm = TREE_CHAIN (parm))
4335     {
4336       rtx entry_parm;
4337       rtx stack_parm;
4338       enum machine_mode promoted_mode, passed_mode;
4339       enum machine_mode nominal_mode, promoted_nominal_mode;
4340       int unsignedp;
4341       struct locate_and_pad_arg_data locate;
4342       int passed_pointer = 0;
4343       int did_conversion = 0;
4344       tree passed_type = DECL_ARG_TYPE (parm);
4345       tree nominal_type = TREE_TYPE (parm);
4346       int last_named = 0, named_arg;
4347       int in_regs;
4348       int partial = 0;
4349       int pretend_bytes = 0;
4350
4351       /* Set LAST_NAMED if this is last named arg before last
4352          anonymous args.  */
4353       if (stdarg)
4354         {
4355           tree tem;
4356
4357           for (tem = TREE_CHAIN (parm); tem; tem = TREE_CHAIN (tem))
4358             if (DECL_NAME (tem))
4359               break;
4360
4361           if (tem == 0)
4362             last_named = 1;
4363         }
4364       /* Set NAMED_ARG if this arg should be treated as a named arg.  For
4365          most machines, if this is a varargs/stdarg function, then we treat
4366          the last named arg as if it were anonymous too.  */
4367       named_arg = targetm.calls.strict_argument_naming (&args_so_far) ? 1 : ! last_named;
4368
4369       if (TREE_TYPE (parm) == error_mark_node
4370           /* This can happen after weird syntax errors
4371              or if an enum type is defined among the parms.  */
4372           || TREE_CODE (parm) != PARM_DECL
4373           || passed_type == NULL)
4374         {
4375           SET_DECL_RTL (parm, gen_rtx_MEM (BLKmode, const0_rtx));
4376           DECL_INCOMING_RTL (parm) = DECL_RTL (parm);
4377           TREE_USED (parm) = 1;
4378           continue;
4379         }
4380
4381       /* Find mode of arg as it is passed, and mode of arg
4382          as it should be during execution of this function.  */
4383       passed_mode = TYPE_MODE (passed_type);
4384       nominal_mode = TYPE_MODE (nominal_type);
4385
4386       /* If the parm's mode is VOID, its value doesn't matter,
4387          and avoid the usual things like emit_move_insn that could crash.  */
4388       if (nominal_mode == VOIDmode)
4389         {
4390           SET_DECL_RTL (parm, const0_rtx);
4391           DECL_INCOMING_RTL (parm) = DECL_RTL (parm);
4392           continue;
4393         }
4394
4395       /* If the parm is to be passed as a transparent union, use the
4396          type of the first field for the tests below.  We have already
4397          verified that the modes are the same.  */
4398       if (DECL_TRANSPARENT_UNION (parm)
4399           || (TREE_CODE (passed_type) == UNION_TYPE
4400               && TYPE_TRANSPARENT_UNION (passed_type)))
4401         passed_type = TREE_TYPE (TYPE_FIELDS (passed_type));
4402
4403       /* See if this arg was passed by invisible reference.  It is if
4404          it is an object whose size depends on the contents of the
4405          object itself or if the machine requires these objects be passed
4406          that way.  */
4407
4408       if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (passed_type))
4409           || TREE_ADDRESSABLE (passed_type)
4410 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
4411           || FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, passed_mode,
4412                                              passed_type, named_arg)
4413 #endif
4414           )
4415         {
4416           passed_type = nominal_type = build_pointer_type (passed_type);
4417           passed_pointer = 1;
4418           passed_mode = nominal_mode = Pmode;
4419         }
4420       /* See if the frontend wants to pass this by invisible reference.  */
4421       else if (passed_type != nominal_type
4422                && POINTER_TYPE_P (passed_type)
4423                && TREE_TYPE (passed_type) == nominal_type)
4424         {
4425           nominal_type = passed_type;
4426           passed_pointer = 1;
4427           passed_mode = nominal_mode = Pmode;
4428         }
4429
4430       promoted_mode = passed_mode;
4431
4432       if (targetm.calls.promote_function_args (TREE_TYPE (fndecl)))
4433         {
4434           /* Compute the mode in which the arg is actually extended to.  */
4435           unsignedp = TREE_UNSIGNED (passed_type);
4436           promoted_mode = promote_mode (passed_type, promoted_mode, &unsignedp, 1);
4437         }
4438
4439       /* Let machine desc say which reg (if any) the parm arrives in.
4440          0 means it arrives on the stack.  */
4441 #ifdef FUNCTION_INCOMING_ARG
4442       entry_parm = FUNCTION_INCOMING_ARG (args_so_far, promoted_mode,
4443                                           passed_type, named_arg);
4444 #else
4445       entry_parm = FUNCTION_ARG (args_so_far, promoted_mode,
4446                                  passed_type, named_arg);
4447 #endif
4448
4449       if (entry_parm == 0)
4450         promoted_mode = passed_mode;
4451
4452       /* If this is the last named parameter, do any required setup for
4453          varargs or stdargs.  We need to know about the case of this being an
4454          addressable type, in which case we skip the registers it
4455          would have arrived in.
4456
4457          For stdargs, LAST_NAMED will be set for two parameters, the one that
4458          is actually the last named, and the dummy parameter.  We only
4459          want to do this action once.
4460
4461          Also, indicate when RTL generation is to be suppressed.  */
4462       if (last_named && !varargs_setup)
4463         {
4464           int varargs_pretend_bytes = 0;
4465           targetm.calls.setup_incoming_varargs (&args_so_far, promoted_mode,
4466                                                 passed_type,
4467                                                 &varargs_pretend_bytes, 0);
4468           varargs_setup = 1;
4469
4470           /* If the back-end has requested extra stack space, record how
4471              much is needed.  Do not change pretend_args_size otherwise
4472              since it may be nonzero from an earlier partial argument.  */
4473           if (varargs_pretend_bytes > 0)
4474             current_function_pretend_args_size = varargs_pretend_bytes;
4475         }
4476
4477       /* Determine parm's home in the stack,
4478          in case it arrives in the stack or we should pretend it did.
4479
4480          Compute the stack position and rtx where the argument arrives
4481          and its size.
4482
4483          There is one complexity here:  If this was a parameter that would
4484          have been passed in registers, but wasn't only because it is
4485          __builtin_va_alist, we want locate_and_pad_parm to treat it as if
4486          it came in a register so that REG_PARM_STACK_SPACE isn't skipped.
4487          In this case, we call FUNCTION_ARG with NAMED set to 1 instead of
4488          0 as it was the previous time.  */
4489       in_regs = entry_parm != 0;
4490 #ifdef STACK_PARMS_IN_REG_PARM_AREA
4491       in_regs = 1;
4492 #endif
4493       if (!in_regs && !named_arg)
4494         {
4495           int pretend_named =
4496             targetm.calls.pretend_outgoing_varargs_named (&args_so_far);
4497           if (pretend_named)
4498             {
4499 #ifdef FUNCTION_INCOMING_ARG
4500               in_regs = FUNCTION_INCOMING_ARG (args_so_far, promoted_mode,
4501                                                passed_type,
4502                                                pretend_named) != 0;
4503 #else
4504               in_regs = FUNCTION_ARG (args_so_far, promoted_mode,
4505                                       passed_type,
4506                                       pretend_named) != 0;
4507 #endif
4508             }
4509         }
4510
4511       /* If this parameter was passed both in registers and in the stack,
4512          use the copy on the stack.  */
4513       if (MUST_PASS_IN_STACK (promoted_mode, passed_type))
4514         entry_parm = 0;
4515
4516 #ifdef FUNCTION_ARG_PARTIAL_NREGS
4517       if (entry_parm)
4518         {
4519           partial = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, promoted_mode,
4520                                                 passed_type, named_arg);
4521           if (partial
4522 #ifndef MAYBE_REG_PARM_STACK_SPACE
4523               /* The caller might already have allocated stack space
4524                  for the register parameters.  */
4525               && reg_parm_stack_space == 0
4526 #endif
4527               )
4528             {
4529               /* Part of this argument is passed in registers and part
4530                  is passed on the stack.  Ask the prologue code to extend
4531                  the stack part so that we can recreate the full value.
4532
4533                  PRETEND_BYTES is the size of the registers we need to store.
4534                  CURRENT_FUNCTION_PRETEND_ARGS_SIZE is the amount of extra
4535                  stack space that the prologue should allocate.
4536
4537                  Internally, gcc assumes that the argument pointer is
4538                  aligned to STACK_BOUNDARY bits.  This is used both for
4539                  alignment optimizations (see init_emit) and to locate
4540                  arguments that are aligned to more than PARM_BOUNDARY
4541                  bits.  We must preserve this invariant by rounding
4542                  CURRENT_FUNCTION_PRETEND_ARGS_SIZE up to a stack
4543                  boundary.  */
4544               pretend_bytes = partial * UNITS_PER_WORD;
4545               current_function_pretend_args_size
4546                 = CEIL_ROUND (pretend_bytes, STACK_BYTES);
4547
4548               /* If PRETEND_BYTES != CURRENT_FUNCTION_PRETEND_ARGS_SIZE,
4549                  insert the padding before the start of the first pretend
4550                  argument.  */
4551               stack_args_size.constant
4552                 = (current_function_pretend_args_size - pretend_bytes);
4553             }
4554         }
4555 #endif
4556
4557       memset (&locate, 0, sizeof (locate));
4558       locate_and_pad_parm (promoted_mode, passed_type, in_regs,
4559                            entry_parm ? partial : 0, fndecl,
4560                            &stack_args_size, &locate);
4561
4562       {
4563         rtx offset_rtx;
4564
4565         /* If we're passing this arg using a reg, make its stack home
4566            the aligned stack slot.  */
4567         if (entry_parm)
4568           offset_rtx = ARGS_SIZE_RTX (locate.slot_offset);
4569         else
4570           offset_rtx = ARGS_SIZE_RTX (locate.offset);
4571
4572         if (offset_rtx == const0_rtx)
4573           stack_parm = gen_rtx_MEM (promoted_mode, internal_arg_pointer);
4574         else
4575           stack_parm = gen_rtx_MEM (promoted_mode,
4576                                     gen_rtx_PLUS (Pmode,
4577                                                   internal_arg_pointer,
4578                                                   offset_rtx));
4579
4580         set_mem_attributes (stack_parm, parm, 1);
4581         if (entry_parm && MEM_ATTRS (stack_parm)->align < PARM_BOUNDARY)
4582           set_mem_align (stack_parm, PARM_BOUNDARY);
4583
4584         /* Set also REG_ATTRS if parameter was passed in a register.  */
4585         if (entry_parm)
4586           set_reg_attrs_for_parm (entry_parm, stack_parm);
4587       }
4588
4589       /* If this parm was passed part in regs and part in memory,
4590          pretend it arrived entirely in memory
4591          by pushing the register-part onto the stack.
4592
4593          In the special case of a DImode or DFmode that is split,
4594          we could put it together in a pseudoreg directly,
4595          but for now that's not worth bothering with.  */
4596
4597       if (partial)
4598         {
4599           /* Handle calls that pass values in multiple non-contiguous
4600              locations.  The Irix 6 ABI has examples of this.  */
4601           if (GET_CODE (entry_parm) == PARALLEL)
4602             emit_group_store (validize_mem (stack_parm), entry_parm,
4603                               TREE_TYPE (parm),
4604                               int_size_in_bytes (TREE_TYPE (parm)));
4605
4606           else
4607             move_block_from_reg (REGNO (entry_parm), validize_mem (stack_parm),
4608                                  partial);
4609
4610           entry_parm = stack_parm;
4611         }
4612
4613       /* If we didn't decide this parm came in a register,
4614          by default it came on the stack.  */
4615       if (entry_parm == 0)
4616         entry_parm = stack_parm;
4617
4618       /* Record permanently how this parm was passed.  */
4619       DECL_INCOMING_RTL (parm) = entry_parm;
4620
4621       /* If there is actually space on the stack for this parm,
4622          count it in stack_args_size; otherwise set stack_parm to 0
4623          to indicate there is no preallocated stack slot for the parm.  */
4624
4625       if (entry_parm == stack_parm
4626           || (GET_CODE (entry_parm) == PARALLEL
4627               && XEXP (XVECEXP (entry_parm, 0, 0), 0) == NULL_RTX)
4628 #if defined (REG_PARM_STACK_SPACE) && ! defined (MAYBE_REG_PARM_STACK_SPACE)
4629           /* On some machines, even if a parm value arrives in a register
4630              there is still an (uninitialized) stack slot allocated for it.
4631
4632              ??? When MAYBE_REG_PARM_STACK_SPACE is defined, we can't tell
4633              whether this parameter already has a stack slot allocated,
4634              because an arg block exists only if current_function_args_size
4635              is larger than some threshold, and we haven't calculated that
4636              yet.  So, for now, we just assume that stack slots never exist
4637              in this case.  */
4638           || REG_PARM_STACK_SPACE (fndecl) > 0
4639 #endif
4640           )
4641         {
4642           stack_args_size.constant += pretend_bytes + locate.size.constant;
4643           if (locate.size.var)
4644             ADD_PARM_SIZE (stack_args_size, locate.size.var);
4645         }
4646       else
4647         /* No stack slot was pushed for this parm.  */
4648         stack_parm = 0;
4649
4650       /* Update info on where next arg arrives in registers.  */
4651
4652       FUNCTION_ARG_ADVANCE (args_so_far, promoted_mode,
4653                             passed_type, named_arg);
4654
4655       /* If we can't trust the parm stack slot to be aligned enough
4656          for its ultimate type, don't use that slot after entry.
4657          We'll make another stack slot, if we need one.  */
4658       {
4659         unsigned int thisparm_boundary
4660           = FUNCTION_ARG_BOUNDARY (promoted_mode, passed_type);
4661
4662         if (GET_MODE_ALIGNMENT (nominal_mode) > thisparm_boundary)
4663           stack_parm = 0;
4664       }
4665
4666       /* If parm was passed in memory, and we need to convert it on entry,
4667          don't store it back in that same slot.  */
4668       if (entry_parm == stack_parm
4669           && nominal_mode != BLKmode && nominal_mode != passed_mode)
4670         stack_parm = 0;
4671
4672       /* When an argument is passed in multiple locations, we can't
4673          make use of this information, but we can save some copying if
4674          the whole argument is passed in a single register.  */
4675       if (GET_CODE (entry_parm) == PARALLEL
4676           && nominal_mode != BLKmode && passed_mode != BLKmode)
4677         {
4678           int i, len = XVECLEN (entry_parm, 0);
4679
4680           for (i = 0; i < len; i++)
4681             if (XEXP (XVECEXP (entry_parm, 0, i), 0) != NULL_RTX
4682                 && GET_CODE (XEXP (XVECEXP (entry_parm, 0, i), 0)) == REG
4683                 && (GET_MODE (XEXP (XVECEXP (entry_parm, 0, i), 0))
4684                     == passed_mode)
4685                 && INTVAL (XEXP (XVECEXP (entry_parm, 0, i), 1)) == 0)
4686               {
4687                 entry_parm = XEXP (XVECEXP (entry_parm, 0, i), 0);
4688                 DECL_INCOMING_RTL (parm) = entry_parm;
4689                 break;
4690               }
4691         }
4692
4693       /* ENTRY_PARM is an RTX for the parameter as it arrives,
4694          in the mode in which it arrives.
4695          STACK_PARM is an RTX for a stack slot where the parameter can live
4696          during the function (in case we want to put it there).
4697          STACK_PARM is 0 if no stack slot was pushed for it.
4698
4699          Now output code if necessary to convert ENTRY_PARM to
4700          the type in which this function declares it,
4701          and store that result in an appropriate place,
4702          which may be a pseudo reg, may be STACK_PARM,
4703          or may be a local stack slot if STACK_PARM is 0.
4704
4705          Set DECL_RTL to that place.  */
4706
4707       if (GET_CODE (entry_parm) == PARALLEL && nominal_mode != BLKmode)
4708         {
4709           /* Objects the size of a register can be combined in registers */
4710           rtx parmreg = gen_reg_rtx (nominal_mode);
4711           emit_group_store (parmreg, entry_parm, TREE_TYPE (parm),
4712                             int_size_in_bytes (TREE_TYPE (parm)));
4713           SET_DECL_RTL (parm, parmreg);
4714         }
4715
4716       if (nominal_mode == BLKmode
4717 #ifdef BLOCK_REG_PADDING
4718           || (locate.where_pad == (BYTES_BIG_ENDIAN ? upward : downward)
4719               && GET_MODE_SIZE (promoted_mode) < UNITS_PER_WORD)
4720 #endif
4721           || GET_CODE (entry_parm) == PARALLEL)
4722         {
4723           /* If a BLKmode arrives in registers, copy it to a stack slot.
4724              Handle calls that pass values in multiple non-contiguous
4725              locations.  The Irix 6 ABI has examples of this.  */
4726           if (GET_CODE (entry_parm) == REG
4727               || GET_CODE (entry_parm) == PARALLEL)
4728             {
4729               int size = int_size_in_bytes (TREE_TYPE (parm));
4730               int size_stored = CEIL_ROUND (size, UNITS_PER_WORD);
4731               rtx mem;
4732
4733               /* Note that we will be storing an integral number of words.
4734                  So we have to be careful to ensure that we allocate an
4735                  integral number of words.  We do this below in the
4736                  assign_stack_local if space was not allocated in the argument
4737                  list.  If it was, this will not work if PARM_BOUNDARY is not
4738                  a multiple of BITS_PER_WORD.  It isn't clear how to fix this
4739                  if it becomes a problem.  Exception is when BLKmode arrives
4740                  with arguments not conforming to word_mode.  */
4741
4742               if (stack_parm == 0)
4743                 {
4744                   stack_parm = assign_stack_local (BLKmode, size_stored, 0);
4745                   PUT_MODE (stack_parm, GET_MODE (entry_parm));
4746                   set_mem_attributes (stack_parm, parm, 1);
4747                 }
4748               else if (GET_CODE (entry_parm) == PARALLEL 
4749                        && GET_MODE(entry_parm) == BLKmode)
4750                 ;
4751               else if (PARM_BOUNDARY % BITS_PER_WORD != 0)
4752                 abort ();
4753
4754               mem = validize_mem (stack_parm);
4755
4756               /* Handle calls that pass values in multiple non-contiguous
4757                  locations.  The Irix 6 ABI has examples of this.  */
4758               if (GET_CODE (entry_parm) == PARALLEL)
4759                 emit_group_store (mem, entry_parm, TREE_TYPE (parm), size);
4760
4761               else if (size == 0)
4762                 ;
4763
4764               /* If SIZE is that of a mode no bigger than a word, just use
4765                  that mode's store operation.  */
4766               else if (size <= UNITS_PER_WORD)
4767                 {
4768                   enum machine_mode mode
4769                     = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
4770
4771                   if (mode != BLKmode
4772 #ifdef BLOCK_REG_PADDING
4773                       && (size == UNITS_PER_WORD
4774                           || (BLOCK_REG_PADDING (mode, TREE_TYPE (parm), 1)
4775                               != (BYTES_BIG_ENDIAN ? upward : downward)))
4776 #endif
4777                       )
4778                     {
4779                       rtx reg = gen_rtx_REG (mode, REGNO (entry_parm));
4780                       emit_move_insn (change_address (mem, mode, 0), reg);
4781                     }
4782
4783                   /* Blocks smaller than a word on a BYTES_BIG_ENDIAN
4784                      machine must be aligned to the left before storing
4785                      to memory.  Note that the previous test doesn't
4786                      handle all cases (e.g. SIZE == 3).  */
4787                   else if (size != UNITS_PER_WORD
4788 #ifdef BLOCK_REG_PADDING
4789                            && (BLOCK_REG_PADDING (mode, TREE_TYPE (parm), 1)
4790                                == downward)
4791 #else
4792                            && BYTES_BIG_ENDIAN
4793 #endif
4794                            )
4795                     {
4796                       rtx tem, x;
4797                       int by = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
4798                       rtx reg = gen_rtx_REG (word_mode, REGNO (entry_parm));
4799
4800                       x = expand_binop (word_mode, ashl_optab, reg,
4801                                         GEN_INT (by), 0, 1, OPTAB_WIDEN);
4802                       tem = change_address (mem, word_mode, 0);
4803                       emit_move_insn (tem, x);
4804                     }
4805                   else
4806                     move_block_from_reg (REGNO (entry_parm), mem,
4807                                          size_stored / UNITS_PER_WORD);
4808                 }
4809               else
4810                 move_block_from_reg (REGNO (entry_parm), mem,
4811                                      size_stored / UNITS_PER_WORD);
4812             }
4813           /* If parm is already bound to register pair, don't change 
4814              this binding. */
4815           if (! DECL_RTL_SET_P (parm))
4816             SET_DECL_RTL (parm, stack_parm);
4817         }
4818       else if (! ((! optimize
4819                    && ! DECL_REGISTER (parm))
4820                   || TREE_SIDE_EFFECTS (parm)
4821                   /* If -ffloat-store specified, don't put explicit
4822                      float variables into registers.  */
4823                   || (flag_float_store
4824                       && TREE_CODE (TREE_TYPE (parm)) == REAL_TYPE))
4825                /* Always assign pseudo to structure return or item passed
4826                   by invisible reference.  */
4827                || passed_pointer || parm == function_result_decl)
4828         {
4829           /* Store the parm in a pseudoregister during the function, but we
4830              may need to do it in a wider mode.  */
4831
4832           rtx parmreg;
4833           unsigned int regno, regnoi = 0, regnor = 0;
4834
4835           unsignedp = TREE_UNSIGNED (TREE_TYPE (parm));
4836
4837           promoted_nominal_mode
4838             = promote_mode (TREE_TYPE (parm), nominal_mode, &unsignedp, 0);
4839
4840           parmreg = gen_reg_rtx (promoted_nominal_mode);
4841           mark_user_reg (parmreg);
4842
4843           /* If this was an item that we received a pointer to, set DECL_RTL
4844              appropriately.  */
4845           if (passed_pointer)
4846             {
4847               rtx x = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (passed_type)),
4848                                    parmreg);
4849               set_mem_attributes (x, parm, 1);
4850               SET_DECL_RTL (parm, x);
4851             }
4852           else
4853             {
4854               SET_DECL_RTL (parm, parmreg);
4855               maybe_set_unchanging (DECL_RTL (parm), parm);
4856             }
4857
4858           /* Copy the value into the register.  */
4859           if (nominal_mode != passed_mode
4860               || promoted_nominal_mode != promoted_mode)
4861             {
4862               int save_tree_used;
4863               /* ENTRY_PARM has been converted to PROMOTED_MODE, its
4864                  mode, by the caller.  We now have to convert it to
4865                  NOMINAL_MODE, if different.  However, PARMREG may be in
4866                  a different mode than NOMINAL_MODE if it is being stored
4867                  promoted.
4868
4869                  If ENTRY_PARM is a hard register, it might be in a register
4870                  not valid for operating in its mode (e.g., an odd-numbered
4871                  register for a DFmode).  In that case, moves are the only
4872                  thing valid, so we can't do a convert from there.  This
4873                  occurs when the calling sequence allow such misaligned
4874                  usages.
4875
4876                  In addition, the conversion may involve a call, which could
4877                  clobber parameters which haven't been copied to pseudo
4878                  registers yet.  Therefore, we must first copy the parm to
4879                  a pseudo reg here, and save the conversion until after all
4880                  parameters have been moved.  */
4881
4882               rtx tempreg = gen_reg_rtx (GET_MODE (entry_parm));
4883
4884               emit_move_insn (tempreg, validize_mem (entry_parm));
4885
4886               push_to_sequence (conversion_insns);
4887               tempreg = convert_to_mode (nominal_mode, tempreg, unsignedp);
4888
4889               if (GET_CODE (tempreg) == SUBREG
4890                   && GET_MODE (tempreg) == nominal_mode
4891                   && GET_CODE (SUBREG_REG (tempreg)) == REG
4892                   && nominal_mode == passed_mode
4893                   && GET_MODE (SUBREG_REG (tempreg)) == GET_MODE (entry_parm)
4894                   && GET_MODE_SIZE (GET_MODE (tempreg))
4895                      < GET_MODE_SIZE (GET_MODE (entry_parm)))
4896                 {
4897                   /* The argument is already sign/zero extended, so note it
4898                      into the subreg.  */
4899                   SUBREG_PROMOTED_VAR_P (tempreg) = 1;
4900                   SUBREG_PROMOTED_UNSIGNED_SET (tempreg, unsignedp);
4901                 }
4902
4903               /* TREE_USED gets set erroneously during expand_assignment.  */
4904               save_tree_used = TREE_USED (parm);
4905               expand_assignment (parm,
4906                                  make_tree (nominal_type, tempreg), 0);
4907               TREE_USED (parm) = save_tree_used;
4908               conversion_insns = get_insns ();
4909               did_conversion = 1;
4910               end_sequence ();
4911             }
4912           else
4913             emit_move_insn (parmreg, validize_mem (entry_parm));
4914
4915           /* If we were passed a pointer but the actual value
4916              can safely live in a register, put it in one.  */
4917           if (passed_pointer && TYPE_MODE (TREE_TYPE (parm)) != BLKmode
4918               /* If by-reference argument was promoted, demote it.  */
4919               && (TYPE_MODE (TREE_TYPE (parm)) != GET_MODE (DECL_RTL (parm))
4920                   || ! ((! optimize
4921                          && ! DECL_REGISTER (parm))
4922                         || TREE_SIDE_EFFECTS (parm)
4923                         /* If -ffloat-store specified, don't put explicit
4924                            float variables into registers.  */
4925                         || (flag_float_store
4926                             && TREE_CODE (TREE_TYPE (parm)) == REAL_TYPE))))
4927             {
4928               /* We can't use nominal_mode, because it will have been set to
4929                  Pmode above.  We must use the actual mode of the parm.  */
4930               parmreg = gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm)));
4931               mark_user_reg (parmreg);
4932               if (GET_MODE (parmreg) != GET_MODE (DECL_RTL (parm)))
4933                 {
4934                   rtx tempreg = gen_reg_rtx (GET_MODE (DECL_RTL (parm)));
4935                   int unsigned_p = TREE_UNSIGNED (TREE_TYPE (parm));
4936                   push_to_sequence (conversion_insns);
4937                   emit_move_insn (tempreg, DECL_RTL (parm));
4938                   SET_DECL_RTL (parm,
4939                                 convert_to_mode (GET_MODE (parmreg),
4940                                                  tempreg,
4941                                                  unsigned_p));
4942                   emit_move_insn (parmreg, DECL_RTL (parm));
4943                   conversion_insns = get_insns();
4944                   did_conversion = 1;
4945                   end_sequence ();
4946                 }
4947               else
4948                 emit_move_insn (parmreg, DECL_RTL (parm));
4949               SET_DECL_RTL (parm, parmreg);
4950               /* STACK_PARM is the pointer, not the parm, and PARMREG is
4951                  now the parm.  */
4952               stack_parm = 0;
4953             }
4954 #ifdef FUNCTION_ARG_CALLEE_COPIES
4955           /* If we are passed an arg by reference and it is our responsibility
4956              to make a copy, do it now.
4957              PASSED_TYPE and PASSED mode now refer to the pointer, not the
4958              original argument, so we must recreate them in the call to
4959              FUNCTION_ARG_CALLEE_COPIES.  */
4960           /* ??? Later add code to handle the case that if the argument isn't
4961              modified, don't do the copy.  */
4962
4963           else if (passed_pointer
4964                    && FUNCTION_ARG_CALLEE_COPIES (args_so_far,
4965                                                   TYPE_MODE (TREE_TYPE (passed_type)),
4966                                                   TREE_TYPE (passed_type),
4967                                                   named_arg)
4968                    && ! TREE_ADDRESSABLE (TREE_TYPE (passed_type)))
4969             {
4970               rtx copy;
4971               tree type = TREE_TYPE (passed_type);
4972
4973               /* This sequence may involve a library call perhaps clobbering
4974                  registers that haven't been copied to pseudos yet.  */
4975
4976               push_to_sequence (conversion_insns);
4977
4978               if (!COMPLETE_TYPE_P (type)
4979                   || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4980                 /* This is a variable sized object.  */
4981                 copy = gen_rtx_MEM (BLKmode,
4982                                     allocate_dynamic_stack_space
4983                                     (expr_size (parm), NULL_RTX,
4984                                      TYPE_ALIGN (type)));
4985               else
4986                 copy = assign_stack_temp (TYPE_MODE (type),
4987                                           int_size_in_bytes (type), 1);
4988               set_mem_attributes (copy, parm, 1);
4989
4990               store_expr (parm, copy, 0);
4991               emit_move_insn (parmreg, XEXP (copy, 0));
4992               conversion_insns = get_insns ();
4993               did_conversion = 1;
4994               end_sequence ();
4995             }
4996 #endif /* FUNCTION_ARG_CALLEE_COPIES */
4997
4998           /* In any case, record the parm's desired stack location
4999              in case we later discover it must live in the stack.
5000
5001              If it is a COMPLEX value, store the stack location for both
5002              halves.  */
5003
5004           if (GET_CODE (parmreg) == CONCAT)
5005             regno = MAX (REGNO (XEXP (parmreg, 0)), REGNO (XEXP (parmreg, 1)));
5006           else
5007             regno = REGNO (parmreg);
5008
5009           if (regno >= max_parm_reg)
5010             {
5011               rtx *new;
5012               int old_max_parm_reg = max_parm_reg;
5013
5014               /* It's slow to expand this one register at a time,
5015                  but it's also rare and we need max_parm_reg to be
5016                  precisely correct.  */
5017               max_parm_reg = regno + 1;
5018               new = ggc_realloc (parm_reg_stack_loc,
5019                                  max_parm_reg * sizeof (rtx));
5020               memset (new + old_max_parm_reg, 0,
5021                       (max_parm_reg - old_max_parm_reg) * sizeof (rtx));
5022               parm_reg_stack_loc = new;
5023             }
5024
5025           if (GET_CODE (parmreg) == CONCAT)
5026             {
5027               enum machine_mode submode = GET_MODE (XEXP (parmreg, 0));
5028
5029               regnor = REGNO (gen_realpart (submode, parmreg));
5030               regnoi = REGNO (gen_imagpart (submode, parmreg));
5031
5032               if (stack_parm != 0)
5033                 {
5034                   parm_reg_stack_loc[regnor]
5035                     = gen_realpart (submode, stack_parm);
5036                   parm_reg_stack_loc[regnoi]
5037                     = gen_imagpart (submode, stack_parm);
5038                 }
5039               else
5040                 {
5041                   parm_reg_stack_loc[regnor] = 0;
5042                   parm_reg_stack_loc[regnoi] = 0;
5043                 }
5044             }
5045           else
5046             parm_reg_stack_loc[REGNO (parmreg)] = stack_parm;
5047
5048           /* Mark the register as eliminable if we did no conversion
5049              and it was copied from memory at a fixed offset,
5050              and the arg pointer was not copied to a pseudo-reg.
5051              If the arg pointer is a pseudo reg or the offset formed
5052              an invalid address, such memory-equivalences
5053              as we make here would screw up life analysis for it.  */
5054           if (nominal_mode == passed_mode
5055               && ! did_conversion
5056               && stack_parm != 0
5057               && GET_CODE (stack_parm) == MEM
5058               && locate.offset.var == 0
5059               && reg_mentioned_p (virtual_incoming_args_rtx,
5060                                   XEXP (stack_parm, 0)))
5061             {
5062               rtx linsn = get_last_insn ();
5063               rtx sinsn, set;
5064
5065               /* Mark complex types separately.  */
5066               if (GET_CODE (parmreg) == CONCAT)
5067                 /* Scan backwards for the set of the real and
5068                    imaginary parts.  */
5069                 for (sinsn = linsn; sinsn != 0;
5070                      sinsn = prev_nonnote_insn (sinsn))
5071                   {
5072                     set = single_set (sinsn);
5073                     if (set != 0
5074                         && SET_DEST (set) == regno_reg_rtx [regnoi])
5075                       REG_NOTES (sinsn)
5076                         = gen_rtx_EXPR_LIST (REG_EQUIV,
5077                                              parm_reg_stack_loc[regnoi],
5078                                              REG_NOTES (sinsn));
5079                     else if (set != 0
5080                              && SET_DEST (set) == regno_reg_rtx [regnor])
5081                       REG_NOTES (sinsn)
5082                         = gen_rtx_EXPR_LIST (REG_EQUIV,
5083                                              parm_reg_stack_loc[regnor],
5084                                              REG_NOTES (sinsn));
5085                   }
5086               else if ((set = single_set (linsn)) != 0
5087                        && SET_DEST (set) == parmreg)
5088                 REG_NOTES (linsn)
5089                   = gen_rtx_EXPR_LIST (REG_EQUIV,
5090                                        stack_parm, REG_NOTES (linsn));
5091             }
5092
5093           /* For pointer data type, suggest pointer register.  */
5094           if (POINTER_TYPE_P (TREE_TYPE (parm)))
5095             mark_reg_pointer (parmreg,
5096                               TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm))));
5097
5098           /* If something wants our address, try to use ADDRESSOF.  */
5099           if (TREE_ADDRESSABLE (parm))
5100             {
5101               /* If we end up putting something into the stack,
5102                  fixup_var_refs_insns will need to make a pass over
5103                  all the instructions.  It looks through the pending
5104                  sequences -- but it can't see the ones in the
5105                  CONVERSION_INSNS, if they're not on the sequence
5106                  stack.  So, we go back to that sequence, just so that
5107                  the fixups will happen.  */
5108               push_to_sequence (conversion_insns);
5109               put_var_into_stack (parm, /*rescan=*/true);
5110               conversion_insns = get_insns ();
5111               end_sequence ();
5112             }
5113         }
5114       else
5115         {
5116           /* Value must be stored in the stack slot STACK_PARM
5117              during function execution.  */
5118
5119           if (promoted_mode != nominal_mode)
5120             {
5121               /* Conversion is required.  */
5122               rtx tempreg = gen_reg_rtx (GET_MODE (entry_parm));
5123
5124               emit_move_insn (tempreg, validize_mem (entry_parm));
5125
5126               push_to_sequence (conversion_insns);
5127               entry_parm = convert_to_mode (nominal_mode, tempreg,
5128                                             TREE_UNSIGNED (TREE_TYPE (parm)));
5129               if (stack_parm)
5130                 /* ??? This may need a big-endian conversion on sparc64.  */
5131                 stack_parm = adjust_address (stack_parm, nominal_mode, 0);
5132
5133               conversion_insns = get_insns ();
5134               did_conversion = 1;
5135               end_sequence ();
5136             }
5137
5138           if (entry_parm != stack_parm)
5139             {
5140               if (stack_parm == 0)
5141                 {
5142                   stack_parm
5143                     = assign_stack_local (GET_MODE (entry_parm),
5144                                           GET_MODE_SIZE (GET_MODE (entry_parm)),
5145                                           0);
5146                   set_mem_attributes (stack_parm, parm, 1);
5147                 }
5148
5149               if (promoted_mode != nominal_mode)
5150                 {
5151                   push_to_sequence (conversion_insns);
5152                   emit_move_insn (validize_mem (stack_parm),
5153                                   validize_mem (entry_parm));
5154                   conversion_insns = get_insns ();
5155                   end_sequence ();
5156                 }
5157               else
5158                 emit_move_insn (validize_mem (stack_parm),
5159                                 validize_mem (entry_parm));
5160             }
5161
5162           SET_DECL_RTL (parm, stack_parm);
5163         }
5164     }
5165
5166   if (SPLIT_COMPLEX_ARGS && fnargs != orig_fnargs)
5167     {
5168       for (parm = orig_fnargs; parm; parm = TREE_CHAIN (parm))
5169         {
5170           if (TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE)
5171             {
5172               SET_DECL_RTL (parm,
5173                             gen_rtx_CONCAT (DECL_MODE (parm),
5174                                             DECL_RTL (fnargs),
5175                                             DECL_RTL (TREE_CHAIN (fnargs))));
5176               DECL_INCOMING_RTL (parm)
5177                 = gen_rtx_CONCAT (DECL_MODE (parm),
5178                                   DECL_INCOMING_RTL (fnargs),
5179                                   DECL_INCOMING_RTL (TREE_CHAIN (fnargs)));
5180               fnargs = TREE_CHAIN (fnargs);
5181             }
5182           else
5183             {
5184               SET_DECL_RTL (parm, DECL_RTL (fnargs));
5185               DECL_INCOMING_RTL (parm) = DECL_INCOMING_RTL (fnargs);
5186             }
5187           fnargs = TREE_CHAIN (fnargs);
5188         }
5189     }
5190
5191   /* Output all parameter conversion instructions (possibly including calls)
5192      now that all parameters have been copied out of hard registers.  */
5193   emit_insn (conversion_insns);
5194
5195   /* If we are receiving a struct value address as the first argument, set up
5196      the RTL for the function result. As this might require code to convert
5197      the transmitted address to Pmode, we do this here to ensure that possible
5198      preliminary conversions of the address have been emitted already.  */
5199   if (function_result_decl)
5200     {
5201       tree result = DECL_RESULT (fndecl);
5202       rtx addr = DECL_RTL (function_result_decl);
5203       rtx x;
5204
5205       addr = convert_memory_address (Pmode, addr);
5206       x = gen_rtx_MEM (DECL_MODE (result), addr);
5207       set_mem_attributes (x, result, 1);
5208       SET_DECL_RTL (result, x);
5209     }
5210
5211   last_parm_insn = get_last_insn ();
5212
5213   current_function_args_size = stack_args_size.constant;
5214
5215   /* Adjust function incoming argument size for alignment and
5216      minimum length.  */
5217
5218 #ifdef REG_PARM_STACK_SPACE
5219 #ifndef MAYBE_REG_PARM_STACK_SPACE
5220   current_function_args_size = MAX (current_function_args_size,
5221                                     REG_PARM_STACK_SPACE (fndecl));
5222 #endif
5223 #endif
5224
5225   current_function_args_size
5226     = ((current_function_args_size + STACK_BYTES - 1)
5227        / STACK_BYTES) * STACK_BYTES;
5228
5229 #ifdef ARGS_GROW_DOWNWARD
5230   current_function_arg_offset_rtx
5231     = (stack_args_size.var == 0 ? GEN_INT (-stack_args_size.constant)
5232        : expand_expr (size_diffop (stack_args_size.var,
5233                                    size_int (-stack_args_size.constant)),
5234                       NULL_RTX, VOIDmode, 0));
5235 #else
5236   current_function_arg_offset_rtx = ARGS_SIZE_RTX (stack_args_size);
5237 #endif
5238
5239   /* See how many bytes, if any, of its args a function should try to pop
5240      on return.  */
5241
5242   current_function_pops_args = RETURN_POPS_ARGS (fndecl, TREE_TYPE (fndecl),
5243                                                  current_function_args_size);
5244
5245   /* For stdarg.h function, save info about
5246      regs and stack space used by the named args.  */
5247
5248   current_function_args_info = args_so_far;
5249
5250   /* Set the rtx used for the function return value.  Put this in its
5251      own variable so any optimizers that need this information don't have
5252      to include tree.h.  Do this here so it gets done when an inlined
5253      function gets output.  */
5254
5255   current_function_return_rtx
5256     = (DECL_RTL_SET_P (DECL_RESULT (fndecl))
5257        ? DECL_RTL (DECL_RESULT (fndecl)) : NULL_RTX);
5258
5259   /* If scalar return value was computed in a pseudo-reg, or was a named
5260      return value that got dumped to the stack, copy that to the hard
5261      return register.  */
5262   if (DECL_RTL_SET_P (DECL_RESULT (fndecl)))
5263     {
5264       tree decl_result = DECL_RESULT (fndecl);
5265       rtx decl_rtl = DECL_RTL (decl_result);
5266
5267       if (REG_P (decl_rtl)
5268           ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER
5269           : DECL_REGISTER (decl_result))
5270         {
5271           rtx real_decl_rtl;
5272
5273 #ifdef FUNCTION_OUTGOING_VALUE
5274           real_decl_rtl = FUNCTION_OUTGOING_VALUE (TREE_TYPE (decl_result),
5275                                                    fndecl);
5276 #else
5277           real_decl_rtl = FUNCTION_VALUE (TREE_TYPE (decl_result),
5278                                           fndecl);
5279 #endif
5280           REG_FUNCTION_VALUE_P (real_decl_rtl) = 1;
5281           /* The delay slot scheduler assumes that current_function_return_rtx
5282              holds the hard register containing the return value, not a
5283              temporary pseudo.  */
5284           current_function_return_rtx = real_decl_rtl;
5285         }
5286     }
5287 }
5288
5289 /* If ARGS contains entries with complex types, split the entry into two
5290    entries of the component type.  Return a new list of substitutions are
5291    needed, else the old list.  */
5292
5293 static tree
5294 split_complex_args (tree args)
5295 {
5296   tree p;
5297
5298   /* Before allocating memory, check for the common case of no complex.  */
5299   for (p = args; p; p = TREE_CHAIN (p))
5300     if (TREE_CODE (TREE_TYPE (p)) == COMPLEX_TYPE)
5301       goto found;
5302   return args;
5303
5304  found:
5305   args = copy_list (args);
5306
5307   for (p = args; p; p = TREE_CHAIN (p))
5308     {
5309       tree type = TREE_TYPE (p);
5310       if (TREE_CODE (type) == COMPLEX_TYPE)
5311         {
5312           tree decl;
5313           tree subtype = TREE_TYPE (type);
5314
5315           /* Rewrite the PARM_DECL's type with its component.  */
5316           TREE_TYPE (p) = subtype;
5317           DECL_ARG_TYPE (p) = TREE_TYPE (DECL_ARG_TYPE (p));
5318           DECL_MODE (p) = VOIDmode;
5319           DECL_SIZE (p) = NULL;
5320           DECL_SIZE_UNIT (p) = NULL;
5321           layout_decl (p, 0);
5322
5323           /* Build a second synthetic decl.  */
5324           decl = build_decl (PARM_DECL, NULL_TREE, subtype);
5325           DECL_ARG_TYPE (decl) = DECL_ARG_TYPE (p);
5326           layout_decl (decl, 0);
5327
5328           /* Splice it in; skip the new decl.  */
5329           TREE_CHAIN (decl) = TREE_CHAIN (p);
5330           TREE_CHAIN (p) = decl;
5331           p = decl;
5332         }
5333     }
5334
5335   return args;
5336 }
5337 \f
5338 /* Indicate whether REGNO is an incoming argument to the current function
5339    that was promoted to a wider mode.  If so, return the RTX for the
5340    register (to get its mode).  PMODE and PUNSIGNEDP are set to the mode
5341    that REGNO is promoted from and whether the promotion was signed or
5342    unsigned.  */
5343
5344 rtx
5345 promoted_input_arg (unsigned int regno, enum machine_mode *pmode, int *punsignedp)
5346 {
5347   tree arg;
5348
5349   for (arg = DECL_ARGUMENTS (current_function_decl); arg;
5350        arg = TREE_CHAIN (arg))
5351     if (GET_CODE (DECL_INCOMING_RTL (arg)) == REG
5352         && REGNO (DECL_INCOMING_RTL (arg)) == regno
5353         && TYPE_MODE (DECL_ARG_TYPE (arg)) == TYPE_MODE (TREE_TYPE (arg)))
5354       {
5355         enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg));
5356         int unsignedp = TREE_UNSIGNED (TREE_TYPE (arg));
5357
5358         mode = promote_mode (TREE_TYPE (arg), mode, &unsignedp, 1);
5359         if (mode == GET_MODE (DECL_INCOMING_RTL (arg))
5360             && mode != DECL_MODE (arg))
5361           {
5362             *pmode = DECL_MODE (arg);
5363             *punsignedp = unsignedp;
5364             return DECL_INCOMING_RTL (arg);
5365           }
5366       }
5367
5368   return 0;
5369 }
5370
5371 \f
5372 /* Compute the size and offset from the start of the stacked arguments for a
5373    parm passed in mode PASSED_MODE and with type TYPE.
5374
5375    INITIAL_OFFSET_PTR points to the current offset into the stacked
5376    arguments.
5377
5378    The starting offset and size for this parm are returned in
5379    LOCATE->OFFSET and LOCATE->SIZE, respectively.  When IN_REGS is
5380    nonzero, the offset is that of stack slot, which is returned in
5381    LOCATE->SLOT_OFFSET.  LOCATE->ALIGNMENT_PAD is the amount of
5382    padding required from the initial offset ptr to the stack slot.
5383
5384    IN_REGS is nonzero if the argument will be passed in registers.  It will
5385    never be set if REG_PARM_STACK_SPACE is not defined.
5386
5387    FNDECL is the function in which the argument was defined.
5388
5389    There are two types of rounding that are done.  The first, controlled by
5390    FUNCTION_ARG_BOUNDARY, forces the offset from the start of the argument
5391    list to be aligned to the specific boundary (in bits).  This rounding
5392    affects the initial and starting offsets, but not the argument size.
5393
5394    The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY,
5395    optionally rounds the size of the parm to PARM_BOUNDARY.  The
5396    initial offset is not affected by this rounding, while the size always
5397    is and the starting offset may be.  */
5398
5399 /*  LOCATE->OFFSET will be negative for ARGS_GROW_DOWNWARD case;
5400     INITIAL_OFFSET_PTR is positive because locate_and_pad_parm's
5401     callers pass in the total size of args so far as
5402     INITIAL_OFFSET_PTR.  LOCATE->SIZE is always positive.  */
5403
5404 void
5405 locate_and_pad_parm (enum machine_mode passed_mode, tree type, int in_regs,
5406                      int partial, tree fndecl ATTRIBUTE_UNUSED,
5407                      struct args_size *initial_offset_ptr,
5408                      struct locate_and_pad_arg_data *locate)
5409 {
5410   tree sizetree;
5411   enum direction where_pad;
5412   int boundary;
5413   int reg_parm_stack_space = 0;
5414   int part_size_in_regs;
5415
5416 #ifdef REG_PARM_STACK_SPACE
5417 #ifdef MAYBE_REG_PARM_STACK_SPACE
5418   reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
5419 #else
5420   reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
5421 #endif
5422
5423   /* If we have found a stack parm before we reach the end of the
5424      area reserved for registers, skip that area.  */
5425   if (! in_regs)
5426     {
5427       if (reg_parm_stack_space > 0)
5428         {
5429           if (initial_offset_ptr->var)
5430             {
5431               initial_offset_ptr->var
5432                 = size_binop (MAX_EXPR, ARGS_SIZE_TREE (*initial_offset_ptr),
5433                               ssize_int (reg_parm_stack_space));
5434               initial_offset_ptr->constant = 0;
5435             }
5436           else if (initial_offset_ptr->constant < reg_parm_stack_space)
5437             initial_offset_ptr->constant = reg_parm_stack_space;
5438         }
5439     }
5440 #endif /* REG_PARM_STACK_SPACE */
5441
5442   part_size_in_regs = 0;
5443   if (reg_parm_stack_space == 0)
5444     part_size_in_regs = ((partial * UNITS_PER_WORD)
5445                          / (PARM_BOUNDARY / BITS_PER_UNIT)
5446                          * (PARM_BOUNDARY / BITS_PER_UNIT));
5447
5448   sizetree
5449     = type ? size_in_bytes (type) : size_int (GET_MODE_SIZE (passed_mode));
5450   where_pad = FUNCTION_ARG_PADDING (passed_mode, type);
5451   boundary = FUNCTION_ARG_BOUNDARY (passed_mode, type);
5452   locate->where_pad = where_pad;
5453
5454 #ifdef ARGS_GROW_DOWNWARD
5455   locate->slot_offset.constant = -initial_offset_ptr->constant;
5456   if (initial_offset_ptr->var)
5457     locate->slot_offset.var = size_binop (MINUS_EXPR, ssize_int (0),
5458                                           initial_offset_ptr->var);
5459
5460   {
5461     tree s2 = sizetree;
5462     if (where_pad != none
5463         && (!host_integerp (sizetree, 1)
5464             || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % PARM_BOUNDARY))
5465       s2 = round_up (s2, PARM_BOUNDARY / BITS_PER_UNIT);
5466     SUB_PARM_SIZE (locate->slot_offset, s2);
5467   }
5468
5469   locate->slot_offset.constant += part_size_in_regs;
5470
5471   if (!in_regs
5472 #ifdef REG_PARM_STACK_SPACE
5473       || REG_PARM_STACK_SPACE (fndecl) > 0
5474 #endif
5475      )
5476     pad_to_arg_alignment (&locate->slot_offset, boundary,
5477                           &locate->alignment_pad);
5478
5479   locate->size.constant = (-initial_offset_ptr->constant
5480                            - locate->slot_offset.constant);
5481   if (initial_offset_ptr->var)
5482     locate->size.var = size_binop (MINUS_EXPR,
5483                                    size_binop (MINUS_EXPR,
5484                                                ssize_int (0),
5485                                                initial_offset_ptr->var),
5486                                    locate->slot_offset.var);
5487
5488   /* Pad_below needs the pre-rounded size to know how much to pad
5489      below.  */
5490   locate->offset = locate->slot_offset;
5491   if (where_pad == downward)
5492     pad_below (&locate->offset, passed_mode, sizetree);
5493
5494 #else /* !ARGS_GROW_DOWNWARD */
5495   if (!in_regs
5496 #ifdef REG_PARM_STACK_SPACE
5497       || REG_PARM_STACK_SPACE (fndecl) > 0
5498 #endif
5499       )
5500     pad_to_arg_alignment (initial_offset_ptr, boundary,
5501                           &locate->alignment_pad);
5502   locate->slot_offset = *initial_offset_ptr;
5503
5504 #ifdef PUSH_ROUNDING
5505   if (passed_mode != BLKmode)
5506     sizetree = size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree)));
5507 #endif
5508
5509   /* Pad_below needs the pre-rounded size to know how much to pad below
5510      so this must be done before rounding up.  */
5511   locate->offset = locate->slot_offset;
5512   if (where_pad == downward)
5513     pad_below (&locate->offset, passed_mode, sizetree);
5514
5515   if (where_pad != none
5516       && (!host_integerp (sizetree, 1)
5517           || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % PARM_BOUNDARY))
5518     sizetree = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT);
5519
5520   ADD_PARM_SIZE (locate->size, sizetree);
5521
5522   locate->size.constant -= part_size_in_regs;
5523 #endif /* ARGS_GROW_DOWNWARD */
5524 }
5525
5526 /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY.
5527    BOUNDARY is measured in bits, but must be a multiple of a storage unit.  */
5528
5529 static void
5530 pad_to_arg_alignment (struct args_size *offset_ptr, int boundary,
5531                       struct args_size *alignment_pad)
5532 {
5533   tree save_var = NULL_TREE;
5534   HOST_WIDE_INT save_constant = 0;
5535   int boundary_in_bytes = boundary / BITS_PER_UNIT;
5536   HOST_WIDE_INT sp_offset = STACK_POINTER_OFFSET;
5537
5538 #ifdef SPARC_STACK_BOUNDARY_HACK
5539   /* The sparc port has a bug.  It sometimes claims a STACK_BOUNDARY
5540      higher than the real alignment of %sp.  However, when it does this,
5541      the alignment of %sp+STACK_POINTER_OFFSET will be STACK_BOUNDARY.
5542      This is a temporary hack while the sparc port is fixed.  */
5543   if (SPARC_STACK_BOUNDARY_HACK)
5544     sp_offset = 0;
5545 #endif
5546
5547   if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
5548     {
5549       save_var = offset_ptr->var;
5550       save_constant = offset_ptr->constant;
5551     }
5552
5553   alignment_pad->var = NULL_TREE;
5554   alignment_pad->constant = 0;
5555
5556   if (boundary > BITS_PER_UNIT)
5557     {
5558       if (offset_ptr->var)
5559         {
5560           tree sp_offset_tree = ssize_int (sp_offset);
5561           tree offset = size_binop (PLUS_EXPR,
5562                                     ARGS_SIZE_TREE (*offset_ptr),
5563                                     sp_offset_tree);
5564 #ifdef ARGS_GROW_DOWNWARD
5565           tree rounded = round_down (offset, boundary / BITS_PER_UNIT);
5566 #else
5567           tree rounded = round_up   (offset, boundary / BITS_PER_UNIT);
5568 #endif
5569
5570           offset_ptr->var = size_binop (MINUS_EXPR, rounded, sp_offset_tree);
5571           /* ARGS_SIZE_TREE includes constant term.  */
5572           offset_ptr->constant = 0;
5573           if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
5574             alignment_pad->var = size_binop (MINUS_EXPR, offset_ptr->var,
5575                                              save_var);
5576         }
5577       else
5578         {
5579           offset_ptr->constant = -sp_offset +
5580 #ifdef ARGS_GROW_DOWNWARD
5581             FLOOR_ROUND (offset_ptr->constant + sp_offset, boundary_in_bytes);
5582 #else
5583             CEIL_ROUND (offset_ptr->constant + sp_offset, boundary_in_bytes);
5584 #endif
5585             if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
5586               alignment_pad->constant = offset_ptr->constant - save_constant;
5587         }
5588     }
5589 }
5590
5591 static void
5592 pad_below (struct args_size *offset_ptr, enum machine_mode passed_mode, tree sizetree)
5593 {
5594   if (passed_mode != BLKmode)
5595     {
5596       if (GET_MODE_BITSIZE (passed_mode) % PARM_BOUNDARY)
5597         offset_ptr->constant
5598           += (((GET_MODE_BITSIZE (passed_mode) + PARM_BOUNDARY - 1)
5599                / PARM_BOUNDARY * PARM_BOUNDARY / BITS_PER_UNIT)
5600               - GET_MODE_SIZE (passed_mode));
5601     }
5602   else
5603     {
5604       if (TREE_CODE (sizetree) != INTEGER_CST
5605           || (TREE_INT_CST_LOW (sizetree) * BITS_PER_UNIT) % PARM_BOUNDARY)
5606         {
5607           /* Round the size up to multiple of PARM_BOUNDARY bits.  */
5608           tree s2 = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT);
5609           /* Add it in.  */
5610           ADD_PARM_SIZE (*offset_ptr, s2);
5611           SUB_PARM_SIZE (*offset_ptr, sizetree);
5612         }
5613     }
5614 }
5615 \f
5616 /* Walk the tree of blocks describing the binding levels within a function
5617    and warn about uninitialized variables.
5618    This is done after calling flow_analysis and before global_alloc
5619    clobbers the pseudo-regs to hard regs.  */
5620
5621 void
5622 uninitialized_vars_warning (tree block)
5623 {
5624   tree decl, sub;
5625   for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
5626     {
5627       if (warn_uninitialized
5628           && TREE_CODE (decl) == VAR_DECL
5629           /* These warnings are unreliable for and aggregates
5630              because assigning the fields one by one can fail to convince
5631              flow.c that the entire aggregate was initialized.
5632              Unions are troublesome because members may be shorter.  */
5633           && ! AGGREGATE_TYPE_P (TREE_TYPE (decl))
5634           && DECL_RTL (decl) != 0
5635           && GET_CODE (DECL_RTL (decl)) == REG
5636           /* Global optimizations can make it difficult to determine if a
5637              particular variable has been initialized.  However, a VAR_DECL
5638              with a nonzero DECL_INITIAL had an initializer, so do not
5639              claim it is potentially uninitialized.
5640
5641              When the DECL_INITIAL is NULL call the language hook to tell us
5642              if we want to warn.  */
5643           && (DECL_INITIAL (decl) == NULL_TREE || lang_hooks.decl_uninit (decl))
5644           && regno_uninitialized (REGNO (DECL_RTL (decl))))
5645         warning ("%J'%D' might be used uninitialized in this function",
5646                  decl, decl);
5647       if (extra_warnings
5648           && TREE_CODE (decl) == VAR_DECL
5649           && DECL_RTL (decl) != 0
5650           && GET_CODE (DECL_RTL (decl)) == REG
5651           && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl))))
5652         warning ("%Jvariable '%D' might be clobbered by `longjmp' or `vfork'",
5653                  decl, decl);
5654     }
5655   for (sub = BLOCK_SUBBLOCKS (block); sub; sub = TREE_CHAIN (sub))
5656     uninitialized_vars_warning (sub);
5657 }
5658
5659 /* Do the appropriate part of uninitialized_vars_warning
5660    but for arguments instead of local variables.  */
5661
5662 void
5663 setjmp_args_warning (void)
5664 {
5665   tree decl;
5666   for (decl = DECL_ARGUMENTS (current_function_decl);
5667        decl; decl = TREE_CHAIN (decl))
5668     if (DECL_RTL (decl) != 0
5669         && GET_CODE (DECL_RTL (decl)) == REG
5670         && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl))))
5671       warning ("%Jargument '%D' might be clobbered by `longjmp' or `vfork'",
5672                decl, decl);
5673 }
5674
5675 /* If this function call setjmp, put all vars into the stack
5676    unless they were declared `register'.  */
5677
5678 void
5679 setjmp_protect (tree block)
5680 {
5681   tree decl, sub;
5682   for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
5683     if ((TREE_CODE (decl) == VAR_DECL
5684          || TREE_CODE (decl) == PARM_DECL)
5685         && DECL_RTL (decl) != 0
5686         && (GET_CODE (DECL_RTL (decl)) == REG
5687             || (GET_CODE (DECL_RTL (decl)) == MEM
5688                 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF))
5689         /* If this variable came from an inline function, it must be
5690            that its life doesn't overlap the setjmp.  If there was a
5691            setjmp in the function, it would already be in memory.  We
5692            must exclude such variable because their DECL_RTL might be
5693            set to strange things such as virtual_stack_vars_rtx.  */
5694         && ! DECL_FROM_INLINE (decl)
5695         && (
5696 #ifdef NON_SAVING_SETJMP
5697             /* If longjmp doesn't restore the registers,
5698                don't put anything in them.  */
5699             NON_SAVING_SETJMP
5700             ||
5701 #endif
5702             ! DECL_REGISTER (decl)))
5703       put_var_into_stack (decl, /*rescan=*/true);
5704   for (sub = BLOCK_SUBBLOCKS (block); sub; sub = TREE_CHAIN (sub))
5705     setjmp_protect (sub);
5706 }
5707 \f
5708 /* Like the previous function, but for args instead of local variables.  */
5709
5710 void
5711 setjmp_protect_args (void)
5712 {
5713   tree decl;
5714   for (decl = DECL_ARGUMENTS (current_function_decl);
5715        decl; decl = TREE_CHAIN (decl))
5716     if ((TREE_CODE (decl) == VAR_DECL
5717          || TREE_CODE (decl) == PARM_DECL)
5718         && DECL_RTL (decl) != 0
5719         && (GET_CODE (DECL_RTL (decl)) == REG
5720             || (GET_CODE (DECL_RTL (decl)) == MEM
5721                 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF))
5722         && (
5723             /* If longjmp doesn't restore the registers,
5724                don't put anything in them.  */
5725 #ifdef NON_SAVING_SETJMP
5726             NON_SAVING_SETJMP
5727             ||
5728 #endif
5729             ! DECL_REGISTER (decl)))
5730       put_var_into_stack (decl, /*rescan=*/true);
5731 }
5732 \f
5733 /* Return the context-pointer register corresponding to DECL,
5734    or 0 if it does not need one.  */
5735
5736 rtx
5737 lookup_static_chain (tree decl)
5738 {
5739   tree context = decl_function_context (decl);
5740   tree link;
5741
5742   if (context == 0
5743       || (TREE_CODE (decl) == FUNCTION_DECL && DECL_NO_STATIC_CHAIN (decl)))
5744     return 0;
5745
5746   /* We treat inline_function_decl as an alias for the current function
5747      because that is the inline function whose vars, types, etc.
5748      are being merged into the current function.
5749      See expand_inline_function.  */
5750   if (context == current_function_decl || context == inline_function_decl)
5751     return virtual_stack_vars_rtx;
5752
5753   for (link = context_display; link; link = TREE_CHAIN (link))
5754     if (TREE_PURPOSE (link) == context)
5755       return RTL_EXPR_RTL (TREE_VALUE (link));
5756
5757   abort ();
5758 }
5759 \f
5760 /* Convert a stack slot address ADDR for variable VAR
5761    (from a containing function)
5762    into an address valid in this function (using a static chain).  */
5763
5764 rtx
5765 fix_lexical_addr (rtx addr, tree var)
5766 {
5767   rtx basereg;
5768   HOST_WIDE_INT displacement;
5769   tree context = decl_function_context (var);
5770   struct function *fp;
5771   rtx base = 0;
5772
5773   /* If this is the present function, we need not do anything.  */
5774   if (context == current_function_decl || context == inline_function_decl)
5775     return addr;
5776
5777   fp = find_function_data (context);
5778
5779   if (GET_CODE (addr) == ADDRESSOF && GET_CODE (XEXP (addr, 0)) == MEM)
5780     addr = XEXP (XEXP (addr, 0), 0);
5781
5782   /* Decode given address as base reg plus displacement.  */
5783   if (GET_CODE (addr) == REG)
5784     basereg = addr, displacement = 0;
5785   else if (GET_CODE (addr) == PLUS && GET_CODE (XEXP (addr, 1)) == CONST_INT)
5786     basereg = XEXP (addr, 0), displacement = INTVAL (XEXP (addr, 1));
5787   else
5788     abort ();
5789
5790   /* We accept vars reached via the containing function's
5791      incoming arg pointer and via its stack variables pointer.  */
5792   if (basereg == fp->internal_arg_pointer)
5793     {
5794       /* If reached via arg pointer, get the arg pointer value
5795          out of that function's stack frame.
5796
5797          There are two cases:  If a separate ap is needed, allocate a
5798          slot in the outer function for it and dereference it that way.
5799          This is correct even if the real ap is actually a pseudo.
5800          Otherwise, just adjust the offset from the frame pointer to
5801          compensate.  */
5802
5803 #ifdef NEED_SEPARATE_AP
5804       rtx addr;
5805
5806       addr = get_arg_pointer_save_area (fp);
5807       addr = fix_lexical_addr (XEXP (addr, 0), var);
5808       addr = memory_address (Pmode, addr);
5809
5810       base = gen_rtx_MEM (Pmode, addr);
5811       set_mem_alias_set (base, get_frame_alias_set ());
5812       base = copy_to_reg (base);
5813 #else
5814       displacement += (FIRST_PARM_OFFSET (context) - STARTING_FRAME_OFFSET);
5815       base = lookup_static_chain (var);
5816 #endif
5817     }
5818
5819   else if (basereg == virtual_stack_vars_rtx)
5820     {
5821       /* This is the same code as lookup_static_chain, duplicated here to
5822          avoid an extra call to decl_function_context.  */
5823       tree link;
5824
5825       for (link = context_display; link; link = TREE_CHAIN (link))
5826         if (TREE_PURPOSE (link) == context)
5827           {
5828             base = RTL_EXPR_RTL (TREE_VALUE (link));
5829             break;
5830           }
5831     }
5832
5833   if (base == 0)
5834     abort ();
5835
5836   /* Use same offset, relative to appropriate static chain or argument
5837      pointer.  */
5838   return plus_constant (base, displacement);
5839 }
5840 \f
5841 /* Return the address of the trampoline for entering nested fn FUNCTION.
5842    If necessary, allocate a trampoline (in the stack frame)
5843    and emit rtl to initialize its contents (at entry to this function).  */
5844
5845 rtx
5846 trampoline_address (tree function)
5847 {
5848   tree link;
5849   tree rtlexp;
5850   rtx tramp;
5851   struct function *fp;
5852   tree fn_context;
5853
5854   /* Find an existing trampoline and return it.  */
5855   for (link = trampoline_list; link; link = TREE_CHAIN (link))
5856     if (TREE_PURPOSE (link) == function)
5857       return
5858         adjust_trampoline_addr (XEXP (RTL_EXPR_RTL (TREE_VALUE (link)), 0));
5859
5860   for (fp = outer_function_chain; fp; fp = fp->outer)
5861     for (link = fp->x_trampoline_list; link; link = TREE_CHAIN (link))
5862       if (TREE_PURPOSE (link) == function)
5863         {
5864           tramp = fix_lexical_addr (XEXP (RTL_EXPR_RTL (TREE_VALUE (link)), 0),
5865                                     function);
5866           return adjust_trampoline_addr (tramp);
5867         }
5868
5869   /* None exists; we must make one.  */
5870
5871   /* Find the `struct function' for the function containing FUNCTION.  */
5872   fp = 0;
5873   fn_context = decl_function_context (function);
5874   if (fn_context != current_function_decl
5875       && fn_context != inline_function_decl)
5876     fp = find_function_data (fn_context);
5877
5878   /* Allocate run-time space for this trampoline.  */
5879   /* If rounding needed, allocate extra space
5880      to ensure we have TRAMPOLINE_SIZE bytes left after rounding up.  */
5881 #define TRAMPOLINE_REAL_SIZE \
5882   (TRAMPOLINE_SIZE + (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT) - 1)
5883   tramp = assign_stack_local_1 (BLKmode, TRAMPOLINE_REAL_SIZE, 0,
5884                                 fp ? fp : cfun);
5885   /* Record the trampoline for reuse and note it for later initialization
5886      by expand_function_end.  */
5887   if (fp != 0)
5888     {
5889       rtlexp = make_node (RTL_EXPR);
5890       RTL_EXPR_RTL (rtlexp) = tramp;
5891       fp->x_trampoline_list = tree_cons (function, rtlexp,
5892                                          fp->x_trampoline_list);
5893     }
5894   else
5895     {
5896       /* Make the RTL_EXPR node temporary, not momentary, so that the
5897          trampoline_list doesn't become garbage.  */
5898       rtlexp = make_node (RTL_EXPR);
5899
5900       RTL_EXPR_RTL (rtlexp) = tramp;
5901       trampoline_list = tree_cons (function, rtlexp, trampoline_list);
5902     }
5903
5904   tramp = fix_lexical_addr (XEXP (tramp, 0), function);
5905   return adjust_trampoline_addr (tramp);
5906 }
5907
5908 /* Given a trampoline address,
5909    round it to multiple of TRAMPOLINE_ALIGNMENT.  */
5910
5911 static rtx
5912 round_trampoline_addr (rtx tramp)
5913 {
5914   /* Round address up to desired boundary.  */
5915   rtx temp = gen_reg_rtx (Pmode);
5916   rtx addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
5917   rtx mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
5918
5919   temp  = expand_simple_binop (Pmode, PLUS, tramp, addend,
5920                                temp, 0, OPTAB_LIB_WIDEN);
5921   tramp = expand_simple_binop (Pmode, AND, temp, mask,
5922                                temp, 0, OPTAB_LIB_WIDEN);
5923
5924   return tramp;
5925 }
5926
5927 /* Given a trampoline address, round it then apply any
5928    platform-specific adjustments so that the result can be used for a
5929    function call .  */
5930
5931 static rtx
5932 adjust_trampoline_addr (rtx tramp)
5933 {
5934   tramp = round_trampoline_addr (tramp);
5935 #ifdef TRAMPOLINE_ADJUST_ADDRESS
5936   TRAMPOLINE_ADJUST_ADDRESS (tramp);
5937 #endif
5938   return tramp;
5939 }
5940 \f
5941 /* Put all this function's BLOCK nodes including those that are chained
5942    onto the first block into a vector, and return it.
5943    Also store in each NOTE for the beginning or end of a block
5944    the index of that block in the vector.
5945    The arguments are BLOCK, the chain of top-level blocks of the function,
5946    and INSNS, the insn chain of the function.  */
5947
5948 void
5949 identify_blocks (void)
5950 {
5951   int n_blocks;
5952   tree *block_vector, *last_block_vector;
5953   tree *block_stack;
5954   tree block = DECL_INITIAL (current_function_decl);
5955
5956   if (block == 0)
5957     return;
5958
5959   /* Fill the BLOCK_VECTOR with all of the BLOCKs in this function, in
5960      depth-first order.  */
5961   block_vector = get_block_vector (block, &n_blocks);
5962   block_stack = xmalloc (n_blocks * sizeof (tree));
5963
5964   last_block_vector = identify_blocks_1 (get_insns (),
5965                                          block_vector + 1,
5966                                          block_vector + n_blocks,
5967                                          block_stack);
5968
5969   /* If we didn't use all of the subblocks, we've misplaced block notes.  */
5970   /* ??? This appears to happen all the time.  Latent bugs elsewhere?  */
5971   if (0 && last_block_vector != block_vector + n_blocks)
5972     abort ();
5973
5974   free (block_vector);
5975   free (block_stack);
5976 }
5977
5978 /* Subroutine of identify_blocks.  Do the block substitution on the
5979    insn chain beginning with INSNS.  Recurse for CALL_PLACEHOLDER chains.
5980
5981    BLOCK_STACK is pushed and popped for each BLOCK_BEGIN/BLOCK_END pair.
5982    BLOCK_VECTOR is incremented for each block seen.  */
5983
5984 static tree *
5985 identify_blocks_1 (rtx insns, tree *block_vector, tree *end_block_vector,
5986                    tree *orig_block_stack)
5987 {
5988   rtx insn;
5989   tree *block_stack = orig_block_stack;
5990
5991   for (insn = insns; insn; insn = NEXT_INSN (insn))
5992     {
5993       if (GET_CODE (insn) == NOTE)
5994         {
5995           if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG)
5996             {
5997               tree b;
5998
5999               /* If there are more block notes than BLOCKs, something
6000                  is badly wrong.  */
6001               if (block_vector == end_block_vector)
6002                 abort ();
6003
6004               b = *block_vector++;
6005               NOTE_BLOCK (insn) = b;
6006               *block_stack++ = b;
6007             }
6008           else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
6009             {
6010               /* If there are more NOTE_INSN_BLOCK_ENDs than
6011                  NOTE_INSN_BLOCK_BEGs, something is badly wrong.  */
6012               if (block_stack == orig_block_stack)
6013                 abort ();
6014
6015               NOTE_BLOCK (insn) = *--block_stack;
6016             }
6017         }
6018       else if (GET_CODE (insn) == CALL_INSN
6019                && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
6020         {
6021           rtx cp = PATTERN (insn);
6022
6023           block_vector = identify_blocks_1 (XEXP (cp, 0), block_vector,
6024                                             end_block_vector, block_stack);
6025           if (XEXP (cp, 1))
6026             block_vector = identify_blocks_1 (XEXP (cp, 1), block_vector,
6027                                               end_block_vector, block_stack);
6028           if (XEXP (cp, 2))
6029             block_vector = identify_blocks_1 (XEXP (cp, 2), block_vector,
6030                                               end_block_vector, block_stack);
6031         }
6032     }
6033
6034   /* If there are more NOTE_INSN_BLOCK_BEGINs than NOTE_INSN_BLOCK_ENDs,
6035      something is badly wrong.  */
6036   if (block_stack != orig_block_stack)
6037     abort ();
6038
6039   return block_vector;
6040 }
6041
6042 /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
6043    and create duplicate blocks.  */
6044 /* ??? Need an option to either create block fragments or to create
6045    abstract origin duplicates of a source block.  It really depends
6046    on what optimization has been performed.  */
6047
6048 void
6049 reorder_blocks (void)
6050 {
6051   tree block = DECL_INITIAL (current_function_decl);
6052   varray_type block_stack;
6053
6054   if (block == NULL_TREE)
6055     return;
6056
6057   VARRAY_TREE_INIT (block_stack, 10, "block_stack");
6058
6059   /* Reset the TREE_ASM_WRITTEN bit for all blocks.  */
6060   reorder_blocks_0 (block);
6061
6062   /* Prune the old trees away, so that they don't get in the way.  */
6063   BLOCK_SUBBLOCKS (block) = NULL_TREE;
6064   BLOCK_CHAIN (block) = NULL_TREE;
6065
6066   /* Recreate the block tree from the note nesting.  */
6067   reorder_blocks_1 (get_insns (), block, &block_stack);
6068   BLOCK_SUBBLOCKS (block) = blocks_nreverse (BLOCK_SUBBLOCKS (block));
6069
6070   /* Remove deleted blocks from the block fragment chains.  */
6071   reorder_fix_fragments (block);
6072 }
6073
6074 /* Helper function for reorder_blocks.  Reset TREE_ASM_WRITTEN.  */
6075
6076 static void
6077 reorder_blocks_0 (tree block)
6078 {
6079   while (block)
6080     {
6081       TREE_ASM_WRITTEN (block) = 0;
6082       reorder_blocks_0 (BLOCK_SUBBLOCKS (block));
6083       block = BLOCK_CHAIN (block);
6084     }
6085 }
6086
6087 static void
6088 reorder_blocks_1 (rtx insns, tree current_block, varray_type *p_block_stack)
6089 {
6090   rtx insn;
6091
6092   for (insn = insns; insn; insn = NEXT_INSN (insn))
6093     {
6094       if (GET_CODE (insn) == NOTE)
6095         {
6096           if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG)
6097             {
6098               tree block = NOTE_BLOCK (insn);
6099
6100               /* If we have seen this block before, that means it now
6101                  spans multiple address regions.  Create a new fragment.  */
6102               if (TREE_ASM_WRITTEN (block))
6103                 {
6104                   tree new_block = copy_node (block);
6105                   tree origin;
6106
6107                   origin = (BLOCK_FRAGMENT_ORIGIN (block)
6108                             ? BLOCK_FRAGMENT_ORIGIN (block)
6109                             : block);
6110                   BLOCK_FRAGMENT_ORIGIN (new_block) = origin;
6111                   BLOCK_FRAGMENT_CHAIN (new_block)
6112                     = BLOCK_FRAGMENT_CHAIN (origin);
6113                   BLOCK_FRAGMENT_CHAIN (origin) = new_block;
6114
6115                   NOTE_BLOCK (insn) = new_block;
6116                   block = new_block;
6117                 }
6118
6119               BLOCK_SUBBLOCKS (block) = 0;
6120               TREE_ASM_WRITTEN (block) = 1;
6121               /* When there's only one block for the entire function,
6122                  current_block == block and we mustn't do this, it
6123                  will cause infinite recursion.  */
6124               if (block != current_block)
6125                 {
6126                   BLOCK_SUPERCONTEXT (block) = current_block;
6127                   BLOCK_CHAIN (block) = BLOCK_SUBBLOCKS (current_block);
6128                   BLOCK_SUBBLOCKS (current_block) = block;
6129                   current_block = block;
6130                 }
6131               VARRAY_PUSH_TREE (*p_block_stack, block);
6132             }
6133           else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
6134             {
6135               NOTE_BLOCK (insn) = VARRAY_TOP_TREE (*p_block_stack);
6136               VARRAY_POP (*p_block_stack);
6137               BLOCK_SUBBLOCKS (current_block)
6138                 = blocks_nreverse (BLOCK_SUBBLOCKS (current_block));
6139               current_block = BLOCK_SUPERCONTEXT (current_block);
6140             }
6141         }
6142       else if (GET_CODE (insn) == CALL_INSN
6143                && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
6144         {
6145           rtx cp = PATTERN (insn);
6146           reorder_blocks_1 (XEXP (cp, 0), current_block, p_block_stack);
6147           if (XEXP (cp, 1))
6148             reorder_blocks_1 (XEXP (cp, 1), current_block, p_block_stack);
6149           if (XEXP (cp, 2))
6150             reorder_blocks_1 (XEXP (cp, 2), current_block, p_block_stack);
6151         }
6152     }
6153 }
6154
6155 /* Rationalize BLOCK_FRAGMENT_ORIGIN.  If an origin block no longer
6156    appears in the block tree, select one of the fragments to become
6157    the new origin block.  */
6158
6159 static void
6160 reorder_fix_fragments (tree block)
6161 {
6162   while (block)
6163     {
6164       tree dup_origin = BLOCK_FRAGMENT_ORIGIN (block);
6165       tree new_origin = NULL_TREE;
6166
6167       if (dup_origin)
6168         {
6169           if (! TREE_ASM_WRITTEN (dup_origin))
6170             {
6171               new_origin = BLOCK_FRAGMENT_CHAIN (dup_origin);
6172
6173               /* Find the first of the remaining fragments.  There must
6174                  be at least one -- the current block.  */
6175               while (! TREE_ASM_WRITTEN (new_origin))
6176                 new_origin = BLOCK_FRAGMENT_CHAIN (new_origin);
6177               BLOCK_FRAGMENT_ORIGIN (new_origin) = NULL_TREE;
6178             }
6179         }
6180       else if (! dup_origin)
6181         new_origin = block;
6182
6183       /* Re-root the rest of the fragments to the new origin.  In the
6184          case that DUP_ORIGIN was null, that means BLOCK was the origin
6185          of a chain of fragments and we want to remove those fragments
6186          that didn't make it to the output.  */
6187       if (new_origin)
6188         {
6189           tree *pp = &BLOCK_FRAGMENT_CHAIN (new_origin);
6190           tree chain = *pp;
6191
6192           while (chain)
6193             {
6194               if (TREE_ASM_WRITTEN (chain))
6195                 {
6196                   BLOCK_FRAGMENT_ORIGIN (chain) = new_origin;
6197                   *pp = chain;
6198                   pp = &BLOCK_FRAGMENT_CHAIN (chain);
6199                 }
6200               chain = BLOCK_FRAGMENT_CHAIN (chain);
6201             }
6202           *pp = NULL_TREE;
6203         }
6204
6205       reorder_fix_fragments (BLOCK_SUBBLOCKS (block));
6206       block = BLOCK_CHAIN (block);
6207     }
6208 }
6209
6210 /* Reverse the order of elements in the chain T of blocks,
6211    and return the new head of the chain (old last element).  */
6212
6213 static tree
6214 blocks_nreverse (tree t)
6215 {
6216   tree prev = 0, decl, next;
6217   for (decl = t; decl; decl = next)
6218     {
6219       next = BLOCK_CHAIN (decl);
6220       BLOCK_CHAIN (decl) = prev;
6221       prev = decl;
6222     }
6223   return prev;
6224 }
6225
6226 /* Count the subblocks of the list starting with BLOCK.  If VECTOR is
6227    non-NULL, list them all into VECTOR, in a depth-first preorder
6228    traversal of the block tree.  Also clear TREE_ASM_WRITTEN in all
6229    blocks.  */
6230
6231 static int
6232 all_blocks (tree block, tree *vector)
6233 {
6234   int n_blocks = 0;
6235
6236   while (block)
6237     {
6238       TREE_ASM_WRITTEN (block) = 0;
6239
6240       /* Record this block.  */
6241       if (vector)
6242         vector[n_blocks] = block;
6243
6244       ++n_blocks;
6245
6246       /* Record the subblocks, and their subblocks...  */
6247       n_blocks += all_blocks (BLOCK_SUBBLOCKS (block),
6248                               vector ? vector + n_blocks : 0);
6249       block = BLOCK_CHAIN (block);
6250     }
6251
6252   return n_blocks;
6253 }
6254
6255 /* Return a vector containing all the blocks rooted at BLOCK.  The
6256    number of elements in the vector is stored in N_BLOCKS_P.  The
6257    vector is dynamically allocated; it is the caller's responsibility
6258    to call `free' on the pointer returned.  */
6259
6260 static tree *
6261 get_block_vector (tree block, int *n_blocks_p)
6262 {
6263   tree *block_vector;
6264
6265   *n_blocks_p = all_blocks (block, NULL);
6266   block_vector = xmalloc (*n_blocks_p * sizeof (tree));
6267   all_blocks (block, block_vector);
6268
6269   return block_vector;
6270 }
6271
6272 static GTY(()) int next_block_index = 2;
6273
6274 /* Set BLOCK_NUMBER for all the blocks in FN.  */
6275
6276 void
6277 number_blocks (tree fn)
6278 {
6279   int i;
6280   int n_blocks;
6281   tree *block_vector;
6282
6283   /* For SDB and XCOFF debugging output, we start numbering the blocks
6284      from 1 within each function, rather than keeping a running
6285      count.  */
6286 #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
6287   if (write_symbols == SDB_DEBUG || write_symbols == XCOFF_DEBUG)
6288     next_block_index = 1;
6289 #endif
6290
6291   block_vector = get_block_vector (DECL_INITIAL (fn), &n_blocks);
6292
6293   /* The top-level BLOCK isn't numbered at all.  */
6294   for (i = 1; i < n_blocks; ++i)
6295     /* We number the blocks from two.  */
6296     BLOCK_NUMBER (block_vector[i]) = next_block_index++;
6297
6298   free (block_vector);
6299
6300   return;
6301 }
6302
6303 /* If VAR is present in a subblock of BLOCK, return the subblock.  */
6304
6305 tree
6306 debug_find_var_in_block_tree (tree var, tree block)
6307 {
6308   tree t;
6309
6310   for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))
6311     if (t == var)
6312       return block;
6313
6314   for (t = BLOCK_SUBBLOCKS (block); t; t = TREE_CHAIN (t))
6315     {
6316       tree ret = debug_find_var_in_block_tree (var, t);
6317       if (ret)
6318         return ret;
6319     }
6320
6321   return NULL_TREE;
6322 }
6323 \f
6324 /* Allocate a function structure for FNDECL and set its contents
6325    to the defaults.  */
6326
6327 void
6328 allocate_struct_function (tree fndecl)
6329 {
6330   tree result;
6331
6332   cfun = ggc_alloc_cleared (sizeof (struct function));
6333
6334   max_parm_reg = LAST_VIRTUAL_REGISTER + 1;
6335
6336   cfun->stack_alignment_needed = STACK_BOUNDARY;
6337   cfun->preferred_stack_boundary = STACK_BOUNDARY;
6338
6339   current_function_funcdef_no = funcdef_no++;
6340
6341   cfun->function_frequency = FUNCTION_FREQUENCY_NORMAL;
6342
6343   init_stmt_for_function ();
6344   init_eh_for_function ();
6345   init_emit ();
6346   init_expr ();
6347   init_varasm_status (cfun);
6348
6349   (*lang_hooks.function.init) (cfun);
6350   if (init_machine_status)
6351     cfun->machine = (*init_machine_status) ();
6352
6353   if (fndecl == NULL)
6354     return;
6355
6356   DECL_SAVED_INSNS (fndecl) = cfun;
6357   cfun->decl = fndecl;
6358
6359   current_function_name = (*lang_hooks.decl_printable_name) (fndecl, 2);
6360
6361   result = DECL_RESULT (fndecl);
6362   if (aggregate_value_p (result, fndecl))
6363     {
6364 #ifdef PCC_STATIC_STRUCT_RETURN
6365       current_function_returns_pcc_struct = 1;
6366 #endif
6367       current_function_returns_struct = 1;
6368     }
6369
6370   current_function_returns_pointer = POINTER_TYPE_P (TREE_TYPE (result));
6371
6372   current_function_needs_context
6373     = (decl_function_context (current_function_decl) != 0
6374        && ! DECL_NO_STATIC_CHAIN (current_function_decl));
6375 }
6376
6377 /* Reset cfun, and other non-struct-function variables to defaults as
6378    appropriate for emitting rtl at the start of a function.  */
6379
6380 static void
6381 prepare_function_start (tree fndecl)
6382 {
6383   if (fndecl && DECL_SAVED_INSNS (fndecl))
6384     cfun = DECL_SAVED_INSNS (fndecl);
6385   else
6386     allocate_struct_function (fndecl);
6387
6388   cse_not_expected = ! optimize;
6389
6390   /* Caller save not needed yet.  */
6391   caller_save_needed = 0;
6392
6393   /* We haven't done register allocation yet.  */
6394   reg_renumber = 0;
6395
6396   /* Indicate that we need to distinguish between the return value of the
6397      present function and the return value of a function being called.  */
6398   rtx_equal_function_value_matters = 1;
6399
6400   /* Indicate that we have not instantiated virtual registers yet.  */
6401   virtuals_instantiated = 0;
6402
6403   /* Indicate that we want CONCATs now.  */
6404   generating_concat_p = 1;
6405
6406   /* Indicate we have no need of a frame pointer yet.  */
6407   frame_pointer_needed = 0;
6408 }
6409
6410 /* Initialize the rtl expansion mechanism so that we can do simple things
6411    like generate sequences.  This is used to provide a context during global
6412    initialization of some passes.  */
6413 void
6414 init_dummy_function_start (void)
6415 {
6416   prepare_function_start (NULL);
6417 }
6418
6419 /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node)
6420    and initialize static variables for generating RTL for the statements
6421    of the function.  */
6422
6423 void
6424 init_function_start (tree subr)
6425 {
6426   prepare_function_start (subr);
6427
6428   /* Within function body, compute a type's size as soon it is laid out.  */
6429   immediate_size_expand++;
6430
6431   /* Prevent ever trying to delete the first instruction of a
6432      function.  Also tell final how to output a linenum before the
6433      function prologue.  Note linenums could be missing, e.g. when
6434      compiling a Java .class file.  */
6435   if (DECL_SOURCE_LINE (subr))
6436     emit_line_note (DECL_SOURCE_LOCATION (subr));
6437
6438   /* Make sure first insn is a note even if we don't want linenums.
6439      This makes sure the first insn will never be deleted.
6440      Also, final expects a note to appear there.  */
6441   emit_note (NOTE_INSN_DELETED);
6442
6443   /* Warn if this value is an aggregate type,
6444      regardless of which calling convention we are using for it.  */
6445   if (warn_aggregate_return
6446       && AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr))))
6447     warning ("function returns an aggregate");
6448 }
6449
6450 /* Make sure all values used by the optimization passes have sane
6451    defaults.  */
6452 void
6453 init_function_for_compilation (void)
6454 {
6455   reg_renumber = 0;
6456
6457   /* No prologue/epilogue insns yet.  */
6458   VARRAY_GROW (prologue, 0);
6459   VARRAY_GROW (epilogue, 0);
6460   VARRAY_GROW (sibcall_epilogue, 0);
6461 }
6462
6463 /* Expand a call to __main at the beginning of a possible main function.  */
6464
6465 #if defined(INIT_SECTION_ASM_OP) && !defined(INVOKE__main)
6466 #undef HAS_INIT_SECTION
6467 #define HAS_INIT_SECTION
6468 #endif
6469
6470 void
6471 expand_main_function (void)
6472 {
6473 #ifdef FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN
6474   if (FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN)
6475     {
6476       int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
6477       rtx tmp, seq;
6478
6479       start_sequence ();
6480       /* Forcibly align the stack.  */
6481 #ifdef STACK_GROWS_DOWNWARD
6482       tmp = expand_simple_binop (Pmode, AND, stack_pointer_rtx, GEN_INT(-align),
6483                                  stack_pointer_rtx, 1, OPTAB_WIDEN);
6484 #else
6485       tmp = expand_simple_binop (Pmode, PLUS, stack_pointer_rtx,
6486                                  GEN_INT (align - 1), NULL_RTX, 1, OPTAB_WIDEN);
6487       tmp = expand_simple_binop (Pmode, AND, tmp, GEN_INT (-align),
6488                                  stack_pointer_rtx, 1, OPTAB_WIDEN);
6489 #endif
6490       if (tmp != stack_pointer_rtx)
6491         emit_move_insn (stack_pointer_rtx, tmp);
6492
6493       /* Enlist allocate_dynamic_stack_space to pick up the pieces.  */
6494       tmp = force_reg (Pmode, const0_rtx);
6495       allocate_dynamic_stack_space (tmp, NULL_RTX, BIGGEST_ALIGNMENT);
6496       seq = get_insns ();
6497       end_sequence ();
6498
6499       for (tmp = get_last_insn (); tmp; tmp = PREV_INSN (tmp))
6500         if (NOTE_P (tmp) && NOTE_LINE_NUMBER (tmp) == NOTE_INSN_FUNCTION_BEG)
6501           break;
6502       if (tmp)
6503         emit_insn_before (seq, tmp);
6504       else
6505         emit_insn (seq);
6506     }
6507 #endif
6508
6509 #ifndef HAS_INIT_SECTION
6510   emit_library_call (init_one_libfunc (NAME__MAIN), LCT_NORMAL, VOIDmode, 0);
6511 #endif
6512 }
6513 \f
6514 /* The PENDING_SIZES represent the sizes of variable-sized types.
6515    Create RTL for the various sizes now (using temporary variables),
6516    so that we can refer to the sizes from the RTL we are generating
6517    for the current function.  The PENDING_SIZES are a TREE_LIST.  The
6518    TREE_VALUE of each node is a SAVE_EXPR.  */
6519
6520 void
6521 expand_pending_sizes (tree pending_sizes)
6522 {
6523   tree tem;
6524
6525   /* Evaluate now the sizes of any types declared among the arguments.  */
6526   for (tem = pending_sizes; tem; tem = TREE_CHAIN (tem))
6527     {
6528       expand_expr (TREE_VALUE (tem), const0_rtx, VOIDmode, 0);
6529       /* Flush the queue in case this parameter declaration has
6530          side-effects.  */
6531       emit_queue ();
6532     }
6533 }
6534
6535 /* Start the RTL for a new function, and set variables used for
6536    emitting RTL.
6537    SUBR is the FUNCTION_DECL node.
6538    PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with
6539    the function's parameters, which must be run at any return statement.  */
6540
6541 void
6542 expand_function_start (tree subr, int parms_have_cleanups)
6543 {
6544   tree tem;
6545   rtx last_ptr = NULL_RTX;
6546
6547   /* Make sure volatile mem refs aren't considered
6548      valid operands of arithmetic insns.  */
6549   init_recog_no_volatile ();
6550
6551   current_function_instrument_entry_exit
6552     = (flag_instrument_function_entry_exit
6553        && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr));
6554
6555   current_function_profile
6556     = (profile_flag
6557        && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr));
6558
6559   current_function_limit_stack
6560     = (stack_limit_rtx != NULL_RTX && ! DECL_NO_LIMIT_STACK (subr));
6561
6562   /* If function gets a static chain arg, store it in the stack frame.
6563      Do this first, so it gets the first stack slot offset.  */
6564   if (current_function_needs_context)
6565     {
6566       last_ptr = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0);
6567
6568       /* Delay copying static chain if it is not a register to avoid
6569          conflicts with regs used for parameters.  */
6570       if (! SMALL_REGISTER_CLASSES
6571           || GET_CODE (static_chain_incoming_rtx) == REG)
6572         emit_move_insn (last_ptr, static_chain_incoming_rtx);
6573     }
6574
6575   /* If the parameters of this function need cleaning up, get a label
6576      for the beginning of the code which executes those cleanups.  This must
6577      be done before doing anything with return_label.  */
6578   if (parms_have_cleanups)
6579     cleanup_label = gen_label_rtx ();
6580   else
6581     cleanup_label = 0;
6582
6583   /* Make the label for return statements to jump to.  Do not special
6584      case machines with special return instructions -- they will be
6585      handled later during jump, ifcvt, or epilogue creation.  */
6586   return_label = gen_label_rtx ();
6587
6588   /* Initialize rtx used to return the value.  */
6589   /* Do this before assign_parms so that we copy the struct value address
6590      before any library calls that assign parms might generate.  */
6591
6592   /* Decide whether to return the value in memory or in a register.  */
6593   if (aggregate_value_p (DECL_RESULT (subr), subr))
6594     {
6595       /* Returning something that won't go in a register.  */
6596       rtx value_address = 0;
6597
6598 #ifdef PCC_STATIC_STRUCT_RETURN
6599       if (current_function_returns_pcc_struct)
6600         {
6601           int size = int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr)));
6602           value_address = assemble_static_space (size);
6603         }
6604       else
6605 #endif
6606         {
6607           rtx sv = targetm.calls.struct_value_rtx (TREE_TYPE (subr), 1);
6608           /* Expect to be passed the address of a place to store the value.
6609              If it is passed as an argument, assign_parms will take care of
6610              it.  */
6611           if (sv)
6612             {
6613               value_address = gen_reg_rtx (Pmode);
6614               emit_move_insn (value_address, sv);
6615             }
6616         }
6617       if (value_address)
6618         {
6619           rtx x = gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr)), value_address);
6620           set_mem_attributes (x, DECL_RESULT (subr), 1);
6621           SET_DECL_RTL (DECL_RESULT (subr), x);
6622         }
6623     }
6624   else if (DECL_MODE (DECL_RESULT (subr)) == VOIDmode)
6625     /* If return mode is void, this decl rtl should not be used.  */
6626     SET_DECL_RTL (DECL_RESULT (subr), NULL_RTX);
6627   else
6628     {
6629       /* Compute the return values into a pseudo reg, which we will copy
6630          into the true return register after the cleanups are done.  */
6631
6632       /* In order to figure out what mode to use for the pseudo, we
6633          figure out what the mode of the eventual return register will
6634          actually be, and use that.  */
6635       rtx hard_reg
6636         = hard_function_value (TREE_TYPE (DECL_RESULT (subr)),
6637                                subr, 1);
6638
6639       /* Structures that are returned in registers are not aggregate_value_p,
6640          so we may see a PARALLEL or a REG.  */
6641       if (REG_P (hard_reg))
6642         SET_DECL_RTL (DECL_RESULT (subr), gen_reg_rtx (GET_MODE (hard_reg)));
6643       else if (GET_CODE (hard_reg) == PARALLEL)
6644         SET_DECL_RTL (DECL_RESULT (subr), gen_group_rtx (hard_reg));
6645       else
6646         abort ();
6647
6648       /* Set DECL_REGISTER flag so that expand_function_end will copy the
6649          result to the real return register(s).  */
6650       DECL_REGISTER (DECL_RESULT (subr)) = 1;
6651     }
6652
6653   /* Initialize rtx for parameters and local variables.
6654      In some cases this requires emitting insns.  */
6655
6656   assign_parms (subr);
6657
6658   /* Copy the static chain now if it wasn't a register.  The delay is to
6659      avoid conflicts with the parameter passing registers.  */
6660
6661   if (SMALL_REGISTER_CLASSES && current_function_needs_context)
6662     if (GET_CODE (static_chain_incoming_rtx) != REG)
6663       emit_move_insn (last_ptr, static_chain_incoming_rtx);
6664
6665   /* The following was moved from init_function_start.
6666      The move is supposed to make sdb output more accurate.  */
6667   /* Indicate the beginning of the function body,
6668      as opposed to parm setup.  */
6669   emit_note (NOTE_INSN_FUNCTION_BEG);
6670
6671   if (GET_CODE (get_last_insn ()) != NOTE)
6672     emit_note (NOTE_INSN_DELETED);
6673   parm_birth_insn = get_last_insn ();
6674
6675   context_display = 0;
6676   if (current_function_needs_context)
6677     {
6678       /* Fetch static chain values for containing functions.  */
6679       tem = decl_function_context (current_function_decl);
6680       /* Copy the static chain pointer into a pseudo.  If we have
6681          small register classes, copy the value from memory if
6682          static_chain_incoming_rtx is a REG.  */
6683       if (tem)
6684         {
6685           /* If the static chain originally came in a register, put it back
6686              there, then move it out in the next insn.  The reason for
6687              this peculiar code is to satisfy function integration.  */
6688           if (SMALL_REGISTER_CLASSES
6689               && GET_CODE (static_chain_incoming_rtx) == REG)
6690             emit_move_insn (static_chain_incoming_rtx, last_ptr);
6691           last_ptr = copy_to_reg (static_chain_incoming_rtx);
6692         }
6693
6694       while (tem)
6695         {
6696           tree rtlexp = make_node (RTL_EXPR);
6697
6698           RTL_EXPR_RTL (rtlexp) = last_ptr;
6699           context_display = tree_cons (tem, rtlexp, context_display);
6700           tem = decl_function_context (tem);
6701           if (tem == 0)
6702             break;
6703           /* Chain thru stack frames, assuming pointer to next lexical frame
6704              is found at the place we always store it.  */
6705 #ifdef FRAME_GROWS_DOWNWARD
6706           last_ptr = plus_constant (last_ptr,
6707                                     -(HOST_WIDE_INT) GET_MODE_SIZE (Pmode));
6708 #endif
6709           last_ptr = gen_rtx_MEM (Pmode, memory_address (Pmode, last_ptr));
6710           set_mem_alias_set (last_ptr, get_frame_alias_set ());
6711           last_ptr = copy_to_reg (last_ptr);
6712
6713           /* If we are not optimizing, ensure that we know that this
6714              piece of context is live over the entire function.  */
6715           if (! optimize)
6716             save_expr_regs = gen_rtx_EXPR_LIST (VOIDmode, last_ptr,
6717                                                 save_expr_regs);
6718         }
6719     }
6720
6721   if (current_function_instrument_entry_exit)
6722     {
6723       rtx fun = DECL_RTL (current_function_decl);
6724       if (GET_CODE (fun) == MEM)
6725         fun = XEXP (fun, 0);
6726       else
6727         abort ();
6728       emit_library_call (profile_function_entry_libfunc, LCT_NORMAL, VOIDmode,
6729                          2, fun, Pmode,
6730                          expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
6731                                                      0,
6732                                                      hard_frame_pointer_rtx),
6733                          Pmode);
6734     }
6735
6736   if (current_function_profile)
6737     {
6738 #ifdef PROFILE_HOOK
6739       PROFILE_HOOK (current_function_funcdef_no);
6740 #endif
6741     }
6742
6743   /* After the display initializations is where the tail-recursion label
6744      should go, if we end up needing one.   Ensure we have a NOTE here
6745      since some things (like trampolines) get placed before this.  */
6746   tail_recursion_reentry = emit_note (NOTE_INSN_DELETED);
6747
6748   /* Evaluate now the sizes of any types declared among the arguments.  */
6749   expand_pending_sizes (nreverse (get_pending_sizes ()));
6750
6751   /* Make sure there is a line number after the function entry setup code.  */
6752   force_next_line_note ();
6753 }
6754 \f
6755 /* Undo the effects of init_dummy_function_start.  */
6756 void
6757 expand_dummy_function_end (void)
6758 {
6759   /* End any sequences that failed to be closed due to syntax errors.  */
6760   while (in_sequence_p ())
6761     end_sequence ();
6762
6763   /* Outside function body, can't compute type's actual size
6764      until next function's body starts.  */
6765
6766   free_after_parsing (cfun);
6767   free_after_compilation (cfun);
6768   cfun = 0;
6769 }
6770
6771 /* Call DOIT for each hard register used as a return value from
6772    the current function.  */
6773
6774 void
6775 diddle_return_value (void (*doit) (rtx, void *), void *arg)
6776 {
6777   rtx outgoing = current_function_return_rtx;
6778
6779   if (! outgoing)
6780     return;
6781
6782   if (GET_CODE (outgoing) == REG)
6783     (*doit) (outgoing, arg);
6784   else if (GET_CODE (outgoing) == PARALLEL)
6785     {
6786       int i;
6787
6788       for (i = 0; i < XVECLEN (outgoing, 0); i++)
6789         {
6790           rtx x = XEXP (XVECEXP (outgoing, 0, i), 0);
6791
6792           if (GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
6793             (*doit) (x, arg);
6794         }
6795     }
6796 }
6797
6798 static void
6799 do_clobber_return_reg (rtx reg, void *arg ATTRIBUTE_UNUSED)
6800 {
6801   emit_insn (gen_rtx_CLOBBER (VOIDmode, reg));
6802 }
6803
6804 void
6805 clobber_return_register (void)
6806 {
6807   diddle_return_value (do_clobber_return_reg, NULL);
6808
6809   /* In case we do use pseudo to return value, clobber it too.  */
6810   if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl)))
6811     {
6812       tree decl_result = DECL_RESULT (current_function_decl);
6813       rtx decl_rtl = DECL_RTL (decl_result);
6814       if (REG_P (decl_rtl) && REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER)
6815         {
6816           do_clobber_return_reg (decl_rtl, NULL);
6817         }
6818     }
6819 }
6820
6821 static void
6822 do_use_return_reg (rtx reg, void *arg ATTRIBUTE_UNUSED)
6823 {
6824   emit_insn (gen_rtx_USE (VOIDmode, reg));
6825 }
6826
6827 void
6828 use_return_register (void)
6829 {
6830   diddle_return_value (do_use_return_reg, NULL);
6831 }
6832
6833 static GTY(()) rtx initial_trampoline;
6834
6835 /* Generate RTL for the end of the current function.  */
6836
6837 void
6838 expand_function_end (void)
6839 {
6840   tree link;
6841   rtx clobber_after;
6842
6843   finish_expr_for_function ();
6844
6845   /* If arg_pointer_save_area was referenced only from a nested
6846      function, we will not have initialized it yet.  Do that now.  */
6847   if (arg_pointer_save_area && ! cfun->arg_pointer_save_area_init)
6848     get_arg_pointer_save_area (cfun);
6849
6850 #ifdef NON_SAVING_SETJMP
6851   /* Don't put any variables in registers if we call setjmp
6852      on a machine that fails to restore the registers.  */
6853   if (NON_SAVING_SETJMP && current_function_calls_setjmp)
6854     {
6855       if (DECL_INITIAL (current_function_decl) != error_mark_node)
6856         setjmp_protect (DECL_INITIAL (current_function_decl));
6857
6858       setjmp_protect_args ();
6859     }
6860 #endif
6861
6862   /* Initialize any trampolines required by this function.  */
6863   for (link = trampoline_list; link; link = TREE_CHAIN (link))
6864     {
6865       tree function = TREE_PURPOSE (link);
6866       rtx context ATTRIBUTE_UNUSED = lookup_static_chain (function);
6867       rtx tramp = RTL_EXPR_RTL (TREE_VALUE (link));
6868 #ifdef TRAMPOLINE_TEMPLATE
6869       rtx blktramp;
6870 #endif
6871       rtx seq;
6872
6873 #ifdef TRAMPOLINE_TEMPLATE
6874       /* First make sure this compilation has a template for
6875          initializing trampolines.  */
6876       if (initial_trampoline == 0)
6877         {
6878           initial_trampoline
6879             = gen_rtx_MEM (BLKmode, assemble_trampoline_template ());
6880           set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT);
6881         }
6882 #endif
6883
6884       /* Generate insns to initialize the trampoline.  */
6885       start_sequence ();
6886       tramp = round_trampoline_addr (XEXP (tramp, 0));
6887 #ifdef TRAMPOLINE_TEMPLATE
6888       blktramp = replace_equiv_address (initial_trampoline, tramp);
6889       emit_block_move (blktramp, initial_trampoline,
6890                        GEN_INT (TRAMPOLINE_SIZE), BLOCK_OP_NORMAL);
6891 #endif
6892       trampolines_created = 1;
6893       INITIALIZE_TRAMPOLINE (tramp, XEXP (DECL_RTL (function), 0), context);
6894       seq = get_insns ();
6895       end_sequence ();
6896
6897       /* Put those insns at entry to the containing function (this one).  */
6898       emit_insn_before (seq, tail_recursion_reentry);
6899     }
6900
6901   /* If we are doing stack checking and this function makes calls,
6902      do a stack probe at the start of the function to ensure we have enough
6903      space for another stack frame.  */
6904   if (flag_stack_check && ! STACK_CHECK_BUILTIN)
6905     {
6906       rtx insn, seq;
6907
6908       for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
6909         if (GET_CODE (insn) == CALL_INSN)
6910           {
6911             start_sequence ();
6912             probe_stack_range (STACK_CHECK_PROTECT,
6913                                GEN_INT (STACK_CHECK_MAX_FRAME_SIZE));
6914             seq = get_insns ();
6915             end_sequence ();
6916             emit_insn_before (seq, tail_recursion_reentry);
6917             break;
6918           }
6919     }
6920
6921   /* Possibly warn about unused parameters.  */
6922   if (warn_unused_parameter)
6923     {
6924       tree decl;
6925
6926       for (decl = DECL_ARGUMENTS (current_function_decl);
6927            decl; decl = TREE_CHAIN (decl))
6928         if (! TREE_USED (decl) && TREE_CODE (decl) == PARM_DECL
6929             && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
6930           warning ("%Junused parameter '%D'", decl, decl);
6931     }
6932
6933   /* Delete handlers for nonlocal gotos if nothing uses them.  */
6934   if (nonlocal_goto_handler_slots != 0
6935       && ! current_function_has_nonlocal_label)
6936     delete_handlers ();
6937
6938   /* End any sequences that failed to be closed due to syntax errors.  */
6939   while (in_sequence_p ())
6940     end_sequence ();
6941
6942   /* Outside function body, can't compute type's actual size
6943      until next function's body starts.  */
6944   immediate_size_expand--;
6945
6946   clear_pending_stack_adjust ();
6947   do_pending_stack_adjust ();
6948
6949   /* Mark the end of the function body.
6950      If control reaches this insn, the function can drop through
6951      without returning a value.  */
6952   emit_note (NOTE_INSN_FUNCTION_END);
6953
6954   /* Must mark the last line number note in the function, so that the test
6955      coverage code can avoid counting the last line twice.  This just tells
6956      the code to ignore the immediately following line note, since there
6957      already exists a copy of this note somewhere above.  This line number
6958      note is still needed for debugging though, so we can't delete it.  */
6959   if (flag_test_coverage)
6960     emit_note (NOTE_INSN_REPEATED_LINE_NUMBER);
6961
6962   /* Output a linenumber for the end of the function.
6963      SDB depends on this.  */
6964   force_next_line_note ();
6965   emit_line_note (input_location);
6966
6967   /* Before the return label (if any), clobber the return
6968      registers so that they are not propagated live to the rest of
6969      the function.  This can only happen with functions that drop
6970      through; if there had been a return statement, there would
6971      have either been a return rtx, or a jump to the return label.
6972
6973      We delay actual code generation after the current_function_value_rtx
6974      is computed.  */
6975   clobber_after = get_last_insn ();
6976
6977   /* Output the label for the actual return from the function,
6978      if one is expected.  This happens either because a function epilogue
6979      is used instead of a return instruction, or because a return was done
6980      with a goto in order to run local cleanups, or because of pcc-style
6981      structure returning.  */
6982   if (return_label)
6983     emit_label (return_label);
6984
6985   if (current_function_instrument_entry_exit)
6986     {
6987       rtx fun = DECL_RTL (current_function_decl);
6988       if (GET_CODE (fun) == MEM)
6989         fun = XEXP (fun, 0);
6990       else
6991         abort ();
6992       emit_library_call (profile_function_exit_libfunc, LCT_NORMAL, VOIDmode,
6993                          2, fun, Pmode,
6994                          expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
6995                                                      0,
6996                                                      hard_frame_pointer_rtx),
6997                          Pmode);
6998     }
6999
7000   /* Let except.c know where it should emit the call to unregister
7001      the function context for sjlj exceptions.  */
7002   if (flag_exceptions && USING_SJLJ_EXCEPTIONS)
7003     sjlj_emit_function_exit_after (get_last_insn ());
7004
7005   /* If we had calls to alloca, and this machine needs
7006      an accurate stack pointer to exit the function,
7007      insert some code to save and restore the stack pointer.  */
7008 #ifdef EXIT_IGNORE_STACK
7009   if (! EXIT_IGNORE_STACK)
7010 #endif
7011     if (current_function_calls_alloca)
7012       {
7013         rtx tem = 0;
7014
7015         emit_stack_save (SAVE_FUNCTION, &tem, parm_birth_insn);
7016         emit_stack_restore (SAVE_FUNCTION, tem, NULL_RTX);
7017       }
7018
7019   /* If scalar return value was computed in a pseudo-reg, or was a named
7020      return value that got dumped to the stack, copy that to the hard
7021      return register.  */
7022   if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl)))
7023     {
7024       tree decl_result = DECL_RESULT (current_function_decl);
7025       rtx decl_rtl = DECL_RTL (decl_result);
7026
7027       if (REG_P (decl_rtl)
7028           ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER
7029           : DECL_REGISTER (decl_result))
7030         {
7031           rtx real_decl_rtl = current_function_return_rtx;
7032
7033           /* This should be set in assign_parms.  */
7034           if (! REG_FUNCTION_VALUE_P (real_decl_rtl))
7035             abort ();
7036
7037           /* If this is a BLKmode structure being returned in registers,
7038              then use the mode computed in expand_return.  Note that if
7039              decl_rtl is memory, then its mode may have been changed,
7040              but that current_function_return_rtx has not.  */
7041           if (GET_MODE (real_decl_rtl) == BLKmode)
7042             PUT_MODE (real_decl_rtl, GET_MODE (decl_rtl));
7043
7044           /* If a named return value dumped decl_return to memory, then
7045              we may need to re-do the PROMOTE_MODE signed/unsigned
7046              extension.  */
7047           if (GET_MODE (real_decl_rtl) != GET_MODE (decl_rtl))
7048             {
7049               int unsignedp = TREE_UNSIGNED (TREE_TYPE (decl_result));
7050
7051               if (targetm.calls.promote_function_return (TREE_TYPE (current_function_decl)))
7052                 promote_mode (TREE_TYPE (decl_result), GET_MODE (decl_rtl),
7053                               &unsignedp, 1);
7054
7055               convert_move (real_decl_rtl, decl_rtl, unsignedp);
7056             }
7057           else if (GET_CODE (real_decl_rtl) == PARALLEL)
7058             {
7059               /* If expand_function_start has created a PARALLEL for decl_rtl,
7060                  move the result to the real return registers.  Otherwise, do
7061                  a group load from decl_rtl for a named return.  */
7062               if (GET_CODE (decl_rtl) == PARALLEL)
7063                 emit_group_move (real_decl_rtl, decl_rtl);
7064               else
7065                 emit_group_load (real_decl_rtl, decl_rtl,
7066                                  TREE_TYPE (decl_result),
7067                                  int_size_in_bytes (TREE_TYPE (decl_result)));
7068             }
7069           else
7070             emit_move_insn (real_decl_rtl, decl_rtl);
7071         }
7072     }
7073
7074   /* If returning a structure, arrange to return the address of the value
7075      in a place where debuggers expect to find it.
7076
7077      If returning a structure PCC style,
7078      the caller also depends on this value.
7079      And current_function_returns_pcc_struct is not necessarily set.  */
7080   if (current_function_returns_struct
7081       || current_function_returns_pcc_struct)
7082     {
7083       rtx value_address
7084         = XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
7085       tree type = TREE_TYPE (DECL_RESULT (current_function_decl));
7086 #ifdef FUNCTION_OUTGOING_VALUE
7087       rtx outgoing
7088         = FUNCTION_OUTGOING_VALUE (build_pointer_type (type),
7089                                    current_function_decl);
7090 #else
7091       rtx outgoing
7092         = FUNCTION_VALUE (build_pointer_type (type), current_function_decl);
7093 #endif
7094
7095       /* Mark this as a function return value so integrate will delete the
7096          assignment and USE below when inlining this function.  */
7097       REG_FUNCTION_VALUE_P (outgoing) = 1;
7098
7099       /* The address may be ptr_mode and OUTGOING may be Pmode.  */
7100       value_address = convert_memory_address (GET_MODE (outgoing),
7101                                               value_address);
7102
7103       emit_move_insn (outgoing, value_address);
7104
7105       /* Show return register used to hold result (in this case the address
7106          of the result.  */
7107       current_function_return_rtx = outgoing;
7108     }
7109
7110   /* If this is an implementation of throw, do what's necessary to
7111      communicate between __builtin_eh_return and the epilogue.  */
7112   expand_eh_return ();
7113
7114   /* Emit the actual code to clobber return register.  */
7115   {
7116     rtx seq, after;
7117
7118     start_sequence ();
7119     clobber_return_register ();
7120     seq = get_insns ();
7121     end_sequence ();
7122
7123     after = emit_insn_after (seq, clobber_after);
7124
7125     if (clobber_after != after)
7126       cfun->x_clobber_return_insn = after;
7127   }
7128
7129   /* ??? This should no longer be necessary since stupid is no longer with
7130      us, but there are some parts of the compiler (eg reload_combine, and
7131      sh mach_dep_reorg) that still try and compute their own lifetime info
7132      instead of using the general framework.  */
7133   use_return_register ();
7134
7135   /* Fix up any gotos that jumped out to the outermost
7136      binding level of the function.
7137      Must follow emitting RETURN_LABEL.  */
7138
7139   /* If you have any cleanups to do at this point,
7140      and they need to create temporary variables,
7141      then you will lose.  */
7142   expand_fixups (get_insns ());
7143 }
7144
7145 rtx
7146 get_arg_pointer_save_area (struct function *f)
7147 {
7148   rtx ret = f->x_arg_pointer_save_area;
7149
7150   if (! ret)
7151     {
7152       ret = assign_stack_local_1 (Pmode, GET_MODE_SIZE (Pmode), 0, f);
7153       f->x_arg_pointer_save_area = ret;
7154     }
7155
7156   if (f == cfun && ! f->arg_pointer_save_area_init)
7157     {
7158       rtx seq;
7159
7160       /* Save the arg pointer at the beginning of the function.  The
7161          generated stack slot may not be a valid memory address, so we
7162          have to check it and fix it if necessary.  */
7163       start_sequence ();
7164       emit_move_insn (validize_mem (ret), virtual_incoming_args_rtx);
7165       seq = get_insns ();
7166       end_sequence ();
7167
7168       push_topmost_sequence ();
7169       emit_insn_after (seq, get_insns ());
7170       pop_topmost_sequence ();
7171     }
7172
7173   return ret;
7174 }
7175 \f
7176 /* Extend a vector that records the INSN_UIDs of INSNS
7177    (a list of one or more insns).  */
7178
7179 static void
7180 record_insns (rtx insns, varray_type *vecp)
7181 {
7182   int i, len;
7183   rtx tmp;
7184
7185   tmp = insns;
7186   len = 0;
7187   while (tmp != NULL_RTX)
7188     {
7189       len++;
7190       tmp = NEXT_INSN (tmp);
7191     }
7192
7193   i = VARRAY_SIZE (*vecp);
7194   VARRAY_GROW (*vecp, i + len);
7195   tmp = insns;
7196   while (tmp != NULL_RTX)
7197     {
7198       VARRAY_INT (*vecp, i) = INSN_UID (tmp);
7199       i++;
7200       tmp = NEXT_INSN (tmp);
7201     }
7202 }
7203
7204 /* Set the specified locator to the insn chain.  */
7205 static void
7206 set_insn_locators (rtx insn, int loc)
7207 {
7208   while (insn != NULL_RTX)
7209     {
7210       if (INSN_P (insn))
7211         INSN_LOCATOR (insn) = loc;
7212       insn = NEXT_INSN (insn);
7213     }
7214 }
7215
7216 /* Determine how many INSN_UIDs in VEC are part of INSN.  Because we can
7217    be running after reorg, SEQUENCE rtl is possible.  */
7218
7219 static int
7220 contains (rtx insn, varray_type vec)
7221 {
7222   int i, j;
7223
7224   if (GET_CODE (insn) == INSN
7225       && GET_CODE (PATTERN (insn)) == SEQUENCE)
7226     {
7227       int count = 0;
7228       for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
7229         for (j = VARRAY_SIZE (vec) - 1; j >= 0; --j)
7230           if (INSN_UID (XVECEXP (PATTERN (insn), 0, i)) == VARRAY_INT (vec, j))
7231             count++;
7232       return count;
7233     }
7234   else
7235     {
7236       for (j = VARRAY_SIZE (vec) - 1; j >= 0; --j)
7237         if (INSN_UID (insn) == VARRAY_INT (vec, j))
7238           return 1;
7239     }
7240   return 0;
7241 }
7242
7243 int
7244 prologue_epilogue_contains (rtx insn)
7245 {
7246   if (contains (insn, prologue))
7247     return 1;
7248   if (contains (insn, epilogue))
7249     return 1;
7250   return 0;
7251 }
7252
7253 int
7254 sibcall_epilogue_contains (rtx insn)
7255 {
7256   if (sibcall_epilogue)
7257     return contains (insn, sibcall_epilogue);
7258   return 0;
7259 }
7260
7261 #ifdef HAVE_return
7262 /* Insert gen_return at the end of block BB.  This also means updating
7263    block_for_insn appropriately.  */
7264
7265 static void
7266 emit_return_into_block (basic_block bb, rtx line_note)
7267 {
7268   emit_jump_insn_after (gen_return (), bb->end);
7269   if (line_note)
7270     emit_note_copy_after (line_note, PREV_INSN (bb->end));
7271 }
7272 #endif /* HAVE_return */
7273
7274 #if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX)
7275
7276 /* These functions convert the epilogue into a variant that does not modify the
7277    stack pointer.  This is used in cases where a function returns an object
7278    whose size is not known until it is computed.  The called function leaves the
7279    object on the stack, leaves the stack depressed, and returns a pointer to
7280    the object.
7281
7282    What we need to do is track all modifications and references to the stack
7283    pointer, deleting the modifications and changing the references to point to
7284    the location the stack pointer would have pointed to had the modifications
7285    taken place.
7286
7287    These functions need to be portable so we need to make as few assumptions
7288    about the epilogue as we can.  However, the epilogue basically contains
7289    three things: instructions to reset the stack pointer, instructions to
7290    reload registers, possibly including the frame pointer, and an
7291    instruction to return to the caller.
7292
7293    If we can't be sure of what a relevant epilogue insn is doing, we abort.
7294    We also make no attempt to validate the insns we make since if they are
7295    invalid, we probably can't do anything valid.  The intent is that these
7296    routines get "smarter" as more and more machines start to use them and
7297    they try operating on different epilogues.
7298
7299    We use the following structure to track what the part of the epilogue that
7300    we've already processed has done.  We keep two copies of the SP equivalence,
7301    one for use during the insn we are processing and one for use in the next
7302    insn.  The difference is because one part of a PARALLEL may adjust SP
7303    and the other may use it.  */
7304
7305 struct epi_info
7306 {
7307   rtx sp_equiv_reg;             /* REG that SP is set from, perhaps SP.  */
7308   HOST_WIDE_INT sp_offset;      /* Offset from SP_EQUIV_REG of present SP.  */
7309   rtx new_sp_equiv_reg;         /* REG to be used at end of insn.  */
7310   HOST_WIDE_INT new_sp_offset;  /* Offset to be used at end of insn.  */
7311   rtx equiv_reg_src;            /* If nonzero, the value that SP_EQUIV_REG
7312                                    should be set to once we no longer need
7313                                    its value.  */
7314   rtx const_equiv[FIRST_PSEUDO_REGISTER]; /* Any known constant equivalences
7315                                              for registers.  */
7316 };
7317
7318 static void handle_epilogue_set (rtx, struct epi_info *);
7319 static void update_epilogue_consts PARAMS ((rtx, rtx, void *));
7320 static void emit_equiv_load (struct epi_info *);
7321
7322 /* Modify INSN, a list of one or more insns that is part of the epilogue, to
7323    no modifications to the stack pointer.  Return the new list of insns.  */
7324
7325 static rtx
7326 keep_stack_depressed (rtx insns)
7327 {
7328   int j;
7329   struct epi_info info;
7330   rtx insn, next;
7331
7332   /* If the epilogue is just a single instruction, it must be OK as is.  */
7333   if (NEXT_INSN (insns) == NULL_RTX)
7334     return insns;
7335
7336   /* Otherwise, start a sequence, initialize the information we have, and
7337      process all the insns we were given.  */
7338   start_sequence ();
7339
7340   info.sp_equiv_reg = stack_pointer_rtx;
7341   info.sp_offset = 0;
7342   info.equiv_reg_src = 0;
7343
7344   for (j = 0; j < FIRST_PSEUDO_REGISTER; j++)
7345     info.const_equiv[j] = 0;
7346
7347   insn = insns;
7348   next = NULL_RTX;
7349   while (insn != NULL_RTX)
7350     {
7351       next = NEXT_INSN (insn);
7352
7353       if (!INSN_P (insn))
7354         {
7355           add_insn (insn);
7356           insn = next;
7357           continue;
7358         }
7359
7360       /* If this insn references the register that SP is equivalent to and
7361          we have a pending load to that register, we must force out the load
7362          first and then indicate we no longer know what SP's equivalent is.  */
7363       if (info.equiv_reg_src != 0
7364           && reg_referenced_p (info.sp_equiv_reg, PATTERN (insn)))
7365         {
7366           emit_equiv_load (&info);
7367           info.sp_equiv_reg = 0;
7368         }
7369
7370       info.new_sp_equiv_reg = info.sp_equiv_reg;
7371       info.new_sp_offset = info.sp_offset;
7372
7373       /* If this is a (RETURN) and the return address is on the stack,
7374          update the address and change to an indirect jump.  */
7375       if (GET_CODE (PATTERN (insn)) == RETURN
7376           || (GET_CODE (PATTERN (insn)) == PARALLEL
7377               && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == RETURN))
7378         {
7379           rtx retaddr = INCOMING_RETURN_ADDR_RTX;
7380           rtx base = 0;
7381           HOST_WIDE_INT offset = 0;
7382           rtx jump_insn, jump_set;
7383
7384           /* If the return address is in a register, we can emit the insn
7385              unchanged.  Otherwise, it must be a MEM and we see what the
7386              base register and offset are.  In any case, we have to emit any
7387              pending load to the equivalent reg of SP, if any.  */
7388           if (GET_CODE (retaddr) == REG)
7389             {
7390               emit_equiv_load (&info);
7391               add_insn (insn);
7392               insn = next;
7393               continue;
7394             }
7395           else if (GET_CODE (retaddr) == MEM
7396                    && GET_CODE (XEXP (retaddr, 0)) == REG)
7397             base = gen_rtx_REG (Pmode, REGNO (XEXP (retaddr, 0))), offset = 0;
7398           else if (GET_CODE (retaddr) == MEM
7399                    && GET_CODE (XEXP (retaddr, 0)) == PLUS
7400                    && GET_CODE (XEXP (XEXP (retaddr, 0), 0)) == REG
7401                    && GET_CODE (XEXP (XEXP (retaddr, 0), 1)) == CONST_INT)
7402             {
7403               base = gen_rtx_REG (Pmode, REGNO (XEXP (XEXP (retaddr, 0), 0)));
7404               offset = INTVAL (XEXP (XEXP (retaddr, 0), 1));
7405             }
7406           else
7407             abort ();
7408
7409           /* If the base of the location containing the return pointer
7410              is SP, we must update it with the replacement address.  Otherwise,
7411              just build the necessary MEM.  */
7412           retaddr = plus_constant (base, offset);
7413           if (base == stack_pointer_rtx)
7414             retaddr = simplify_replace_rtx (retaddr, stack_pointer_rtx,
7415                                             plus_constant (info.sp_equiv_reg,
7416                                                            info.sp_offset));
7417
7418           retaddr = gen_rtx_MEM (Pmode, retaddr);
7419
7420           /* If there is a pending load to the equivalent register for SP
7421              and we reference that register, we must load our address into
7422              a scratch register and then do that load.  */
7423           if (info.equiv_reg_src
7424               && reg_overlap_mentioned_p (info.equiv_reg_src, retaddr))
7425             {
7426               unsigned int regno;
7427               rtx reg;
7428
7429               for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
7430                 if (HARD_REGNO_MODE_OK (regno, Pmode)
7431                     && !fixed_regs[regno]
7432                     && TEST_HARD_REG_BIT (regs_invalidated_by_call, regno)
7433                     && !REGNO_REG_SET_P (EXIT_BLOCK_PTR->global_live_at_start,
7434                                          regno)
7435                     && !refers_to_regno_p (regno,
7436                                            regno + HARD_REGNO_NREGS (regno,
7437                                                                      Pmode),
7438                                            info.equiv_reg_src, NULL)
7439                     && info.const_equiv[regno] == 0)
7440                   break;
7441
7442               if (regno == FIRST_PSEUDO_REGISTER)
7443                 abort ();
7444
7445               reg = gen_rtx_REG (Pmode, regno);
7446               emit_move_insn (reg, retaddr);
7447               retaddr = reg;
7448             }
7449
7450           emit_equiv_load (&info);
7451           jump_insn = emit_jump_insn (gen_indirect_jump (retaddr));
7452
7453           /* Show the SET in the above insn is a RETURN.  */
7454           jump_set = single_set (jump_insn);
7455           if (jump_set == 0)
7456             abort ();
7457           else
7458             SET_IS_RETURN_P (jump_set) = 1;
7459         }
7460
7461       /* If SP is not mentioned in the pattern and its equivalent register, if
7462          any, is not modified, just emit it.  Otherwise, if neither is set,
7463          replace the reference to SP and emit the insn.  If none of those are
7464          true, handle each SET individually.  */
7465       else if (!reg_mentioned_p (stack_pointer_rtx, PATTERN (insn))
7466                && (info.sp_equiv_reg == stack_pointer_rtx
7467                    || !reg_set_p (info.sp_equiv_reg, insn)))
7468         add_insn (insn);
7469       else if (! reg_set_p (stack_pointer_rtx, insn)
7470                && (info.sp_equiv_reg == stack_pointer_rtx
7471                    || !reg_set_p (info.sp_equiv_reg, insn)))
7472         {
7473           if (! validate_replace_rtx (stack_pointer_rtx,
7474                                       plus_constant (info.sp_equiv_reg,
7475                                                      info.sp_offset),
7476                                       insn))
7477             abort ();
7478
7479           add_insn (insn);
7480         }
7481       else if (GET_CODE (PATTERN (insn)) == SET)
7482         handle_epilogue_set (PATTERN (insn), &info);
7483       else if (GET_CODE (PATTERN (insn)) == PARALLEL)
7484         {
7485           for (j = 0; j < XVECLEN (PATTERN (insn), 0); j++)
7486             if (GET_CODE (XVECEXP (PATTERN (insn), 0, j)) == SET)
7487               handle_epilogue_set (XVECEXP (PATTERN (insn), 0, j), &info);
7488         }
7489       else
7490         add_insn (insn);
7491
7492       info.sp_equiv_reg = info.new_sp_equiv_reg;
7493       info.sp_offset = info.new_sp_offset;
7494
7495       /* Now update any constants this insn sets.  */
7496       note_stores (PATTERN (insn), update_epilogue_consts, &info);
7497       insn = next;
7498     }
7499
7500   insns = get_insns ();
7501   end_sequence ();
7502   return insns;
7503 }
7504
7505 /* SET is a SET from an insn in the epilogue.  P is a pointer to the epi_info
7506    structure that contains information about what we've seen so far.  We
7507    process this SET by either updating that data or by emitting one or
7508    more insns.  */
7509
7510 static void
7511 handle_epilogue_set (rtx set, struct epi_info *p)
7512 {
7513   /* First handle the case where we are setting SP.  Record what it is being
7514      set from.  If unknown, abort.  */
7515   if (reg_set_p (stack_pointer_rtx, set))
7516     {
7517       if (SET_DEST (set) != stack_pointer_rtx)
7518         abort ();
7519
7520       if (GET_CODE (SET_SRC (set)) == PLUS)
7521         {
7522           p->new_sp_equiv_reg = XEXP (SET_SRC (set), 0);
7523           if (GET_CODE (XEXP (SET_SRC (set), 1)) == CONST_INT)
7524             p->new_sp_offset = INTVAL (XEXP (SET_SRC (set), 1));
7525           else if (GET_CODE (XEXP (SET_SRC (set), 1)) == REG
7526                    && REGNO (XEXP (SET_SRC (set), 1)) < FIRST_PSEUDO_REGISTER
7527                    && p->const_equiv[REGNO (XEXP (SET_SRC (set), 1))] != 0)
7528             p->new_sp_offset
7529               = INTVAL (p->const_equiv[REGNO (XEXP (SET_SRC (set), 1))]);
7530           else
7531             abort ();
7532         }
7533       else
7534         p->new_sp_equiv_reg = SET_SRC (set), p->new_sp_offset = 0;
7535
7536       /* If we are adjusting SP, we adjust from the old data.  */
7537       if (p->new_sp_equiv_reg == stack_pointer_rtx)
7538         {
7539           p->new_sp_equiv_reg = p->sp_equiv_reg;
7540           p->new_sp_offset += p->sp_offset;
7541         }
7542
7543       if (p->new_sp_equiv_reg == 0 || GET_CODE (p->new_sp_equiv_reg) != REG)
7544         abort ();
7545
7546       return;
7547     }
7548
7549   /* Next handle the case where we are setting SP's equivalent register.
7550      If we already have a value to set it to, abort.  We could update, but
7551      there seems little point in handling that case.  Note that we have
7552      to allow for the case where we are setting the register set in
7553      the previous part of a PARALLEL inside a single insn.  But use the
7554      old offset for any updates within this insn.  We must allow for the case
7555      where the register is being set in a different (usually wider) mode than
7556      Pmode).  */
7557   else if (p->new_sp_equiv_reg != 0 && reg_set_p (p->new_sp_equiv_reg, set))
7558     {
7559       if (p->equiv_reg_src != 0
7560           || GET_CODE (p->new_sp_equiv_reg) != REG
7561           || GET_CODE (SET_DEST (set)) != REG
7562           || GET_MODE_BITSIZE (GET_MODE (SET_DEST (set))) > BITS_PER_WORD
7563           || REGNO (p->new_sp_equiv_reg) != REGNO (SET_DEST (set)))
7564         abort ();
7565       else
7566         p->equiv_reg_src
7567           = simplify_replace_rtx (SET_SRC (set), stack_pointer_rtx,
7568                                   plus_constant (p->sp_equiv_reg,
7569                                                  p->sp_offset));
7570     }
7571
7572   /* Otherwise, replace any references to SP in the insn to its new value
7573      and emit the insn.  */
7574   else
7575     {
7576       SET_SRC (set) = simplify_replace_rtx (SET_SRC (set), stack_pointer_rtx,
7577                                             plus_constant (p->sp_equiv_reg,
7578                                                            p->sp_offset));
7579       SET_DEST (set) = simplify_replace_rtx (SET_DEST (set), stack_pointer_rtx,
7580                                              plus_constant (p->sp_equiv_reg,
7581                                                             p->sp_offset));
7582       emit_insn (set);
7583     }
7584 }
7585
7586 /* Update the tracking information for registers set to constants.  */
7587
7588 static void
7589 update_epilogue_consts (rtx dest, rtx x, void *data)
7590 {
7591   struct epi_info *p = (struct epi_info *) data;
7592
7593   if (GET_CODE (dest) != REG || REGNO (dest) >= FIRST_PSEUDO_REGISTER)
7594     return;
7595   else if (GET_CODE (x) == CLOBBER || ! rtx_equal_p (dest, SET_DEST (x))
7596            || GET_CODE (SET_SRC (x)) != CONST_INT)
7597     p->const_equiv[REGNO (dest)] = 0;
7598   else
7599     p->const_equiv[REGNO (dest)] = SET_SRC (x);
7600 }
7601
7602 /* Emit an insn to do the load shown in p->equiv_reg_src, if needed.  */
7603
7604 static void
7605 emit_equiv_load (struct epi_info *p)
7606 {
7607   if (p->equiv_reg_src != 0)
7608     {
7609       rtx dest = p->sp_equiv_reg;
7610
7611       if (GET_MODE (p->equiv_reg_src) != GET_MODE (dest))
7612         dest = gen_rtx_REG (GET_MODE (p->equiv_reg_src),
7613                             REGNO (p->sp_equiv_reg));
7614
7615       emit_move_insn (dest, p->equiv_reg_src);
7616       p->equiv_reg_src = 0;
7617     }
7618 }
7619 #endif
7620
7621 /* Generate the prologue and epilogue RTL if the machine supports it.  Thread
7622    this into place with notes indicating where the prologue ends and where
7623    the epilogue begins.  Update the basic block information when possible.  */
7624
7625 void
7626 thread_prologue_and_epilogue_insns (rtx f ATTRIBUTE_UNUSED)
7627 {
7628   int inserted = 0;
7629   edge e;
7630 #if defined (HAVE_sibcall_epilogue) || defined (HAVE_epilogue) || defined (HAVE_return) || defined (HAVE_prologue)
7631   rtx seq;
7632 #endif
7633 #ifdef HAVE_prologue
7634   rtx prologue_end = NULL_RTX;
7635 #endif
7636 #if defined (HAVE_epilogue) || defined(HAVE_return)
7637   rtx epilogue_end = NULL_RTX;
7638 #endif
7639
7640 #ifdef HAVE_prologue
7641   if (HAVE_prologue)
7642     {
7643       start_sequence ();
7644       seq = gen_prologue ();
7645       emit_insn (seq);
7646
7647       /* Retain a map of the prologue insns.  */
7648       record_insns (seq, &prologue);
7649       prologue_end = emit_note (NOTE_INSN_PROLOGUE_END);
7650
7651       seq = get_insns ();
7652       end_sequence ();
7653       set_insn_locators (seq, prologue_locator);
7654
7655       /* Can't deal with multiple successors of the entry block
7656          at the moment.  Function should always have at least one
7657          entry point.  */
7658       if (!ENTRY_BLOCK_PTR->succ || ENTRY_BLOCK_PTR->succ->succ_next)
7659         abort ();
7660
7661       insert_insn_on_edge (seq, ENTRY_BLOCK_PTR->succ);
7662       inserted = 1;
7663     }
7664 #endif
7665
7666   /* If the exit block has no non-fake predecessors, we don't need
7667      an epilogue.  */
7668   for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
7669     if ((e->flags & EDGE_FAKE) == 0)
7670       break;
7671   if (e == NULL)
7672     goto epilogue_done;
7673
7674 #ifdef HAVE_return
7675   if (optimize && HAVE_return)
7676     {
7677       /* If we're allowed to generate a simple return instruction,
7678          then by definition we don't need a full epilogue.  Examine
7679          the block that falls through to EXIT.   If it does not
7680          contain any code, examine its predecessors and try to
7681          emit (conditional) return instructions.  */
7682
7683       basic_block last;
7684       edge e_next;
7685       rtx label;
7686
7687       for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
7688         if (e->flags & EDGE_FALLTHRU)
7689           break;
7690       if (e == NULL)
7691         goto epilogue_done;
7692       last = e->src;
7693
7694       /* Verify that there are no active instructions in the last block.  */
7695       label = last->end;
7696       while (label && GET_CODE (label) != CODE_LABEL)
7697         {
7698           if (active_insn_p (label))
7699             break;
7700           label = PREV_INSN (label);
7701         }
7702
7703       if (last->head == label && GET_CODE (label) == CODE_LABEL)
7704         {
7705           rtx epilogue_line_note = NULL_RTX;
7706
7707           /* Locate the line number associated with the closing brace,
7708              if we can find one.  */
7709           for (seq = get_last_insn ();
7710                seq && ! active_insn_p (seq);
7711                seq = PREV_INSN (seq))
7712             if (GET_CODE (seq) == NOTE && NOTE_LINE_NUMBER (seq) > 0)
7713               {
7714                 epilogue_line_note = seq;
7715                 break;
7716               }
7717
7718           for (e = last->pred; e; e = e_next)
7719             {
7720               basic_block bb = e->src;
7721               rtx jump;
7722
7723               e_next = e->pred_next;
7724               if (bb == ENTRY_BLOCK_PTR)
7725                 continue;
7726
7727               jump = bb->end;
7728               if ((GET_CODE (jump) != JUMP_INSN) || JUMP_LABEL (jump) != label)
7729                 continue;
7730
7731               /* If we have an unconditional jump, we can replace that
7732                  with a simple return instruction.  */
7733               if (simplejump_p (jump))
7734                 {
7735                   emit_return_into_block (bb, epilogue_line_note);
7736                   delete_insn (jump);
7737                 }
7738
7739               /* If we have a conditional jump, we can try to replace
7740                  that with a conditional return instruction.  */
7741               else if (condjump_p (jump))
7742                 {
7743                   if (! redirect_jump (jump, 0, 0))
7744                     continue;
7745
7746                   /* If this block has only one successor, it both jumps
7747                      and falls through to the fallthru block, so we can't
7748                      delete the edge.  */
7749                   if (bb->succ->succ_next == NULL)
7750                     continue;
7751                 }
7752               else
7753                 continue;
7754
7755               /* Fix up the CFG for the successful change we just made.  */
7756               redirect_edge_succ (e, EXIT_BLOCK_PTR);
7757             }
7758
7759           /* Emit a return insn for the exit fallthru block.  Whether
7760              this is still reachable will be determined later.  */
7761
7762           emit_barrier_after (last->end);
7763           emit_return_into_block (last, epilogue_line_note);
7764           epilogue_end = last->end;
7765           last->succ->flags &= ~EDGE_FALLTHRU;
7766           goto epilogue_done;
7767         }
7768     }
7769 #endif
7770 #ifdef HAVE_epilogue
7771   if (HAVE_epilogue)
7772     {
7773       /* Find the edge that falls through to EXIT.  Other edges may exist
7774          due to RETURN instructions, but those don't need epilogues.
7775          There really shouldn't be a mixture -- either all should have
7776          been converted or none, however...  */
7777
7778       for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
7779         if (e->flags & EDGE_FALLTHRU)
7780           break;
7781       if (e == NULL)
7782         goto epilogue_done;
7783
7784       start_sequence ();
7785       epilogue_end = emit_note (NOTE_INSN_EPILOGUE_BEG);
7786
7787       seq = gen_epilogue ();
7788
7789 #ifdef INCOMING_RETURN_ADDR_RTX
7790       /* If this function returns with the stack depressed and we can support
7791          it, massage the epilogue to actually do that.  */
7792       if (TREE_CODE (TREE_TYPE (current_function_decl)) == FUNCTION_TYPE
7793           && TYPE_RETURNS_STACK_DEPRESSED (TREE_TYPE (current_function_decl)))
7794         seq = keep_stack_depressed (seq);
7795 #endif
7796
7797       emit_jump_insn (seq);
7798
7799       /* Retain a map of the epilogue insns.  */
7800       record_insns (seq, &epilogue);
7801       set_insn_locators (seq, epilogue_locator);
7802
7803       seq = get_insns ();
7804       end_sequence ();
7805
7806       insert_insn_on_edge (seq, e);
7807       inserted = 1;
7808     }
7809 #endif
7810 epilogue_done:
7811
7812   if (inserted)
7813     commit_edge_insertions ();
7814
7815 #ifdef HAVE_sibcall_epilogue
7816   /* Emit sibling epilogues before any sibling call sites.  */
7817   for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
7818     {
7819       basic_block bb = e->src;
7820       rtx insn = bb->end;
7821       rtx i;
7822       rtx newinsn;
7823
7824       if (GET_CODE (insn) != CALL_INSN
7825           || ! SIBLING_CALL_P (insn))
7826         continue;
7827
7828       start_sequence ();
7829       emit_insn (gen_sibcall_epilogue ());
7830       seq = get_insns ();
7831       end_sequence ();
7832
7833       /* Retain a map of the epilogue insns.  Used in life analysis to
7834          avoid getting rid of sibcall epilogue insns.  Do this before we
7835          actually emit the sequence.  */
7836       record_insns (seq, &sibcall_epilogue);
7837       set_insn_locators (seq, epilogue_locator);
7838
7839       i = PREV_INSN (insn);
7840       newinsn = emit_insn_before (seq, insn);
7841     }
7842 #endif
7843
7844 #ifdef HAVE_prologue
7845   if (prologue_end)
7846     {
7847       rtx insn, prev;
7848
7849       /* GDB handles `break f' by setting a breakpoint on the first
7850          line note after the prologue.  Which means (1) that if
7851          there are line number notes before where we inserted the
7852          prologue we should move them, and (2) we should generate a
7853          note before the end of the first basic block, if there isn't
7854          one already there.
7855
7856          ??? This behavior is completely broken when dealing with
7857          multiple entry functions.  We simply place the note always
7858          into first basic block and let alternate entry points
7859          to be missed.
7860        */
7861
7862       for (insn = prologue_end; insn; insn = prev)
7863         {
7864           prev = PREV_INSN (insn);
7865           if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
7866             {
7867               /* Note that we cannot reorder the first insn in the
7868                  chain, since rest_of_compilation relies on that
7869                  remaining constant.  */
7870               if (prev == NULL)
7871                 break;
7872               reorder_insns (insn, insn, prologue_end);
7873             }
7874         }
7875
7876       /* Find the last line number note in the first block.  */
7877       for (insn = ENTRY_BLOCK_PTR->next_bb->end;
7878            insn != prologue_end && insn;
7879            insn = PREV_INSN (insn))
7880         if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
7881           break;
7882
7883       /* If we didn't find one, make a copy of the first line number
7884          we run across.  */
7885       if (! insn)
7886         {
7887           for (insn = next_active_insn (prologue_end);
7888                insn;
7889                insn = PREV_INSN (insn))
7890             if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
7891               {
7892                 emit_note_copy_after (insn, prologue_end);
7893                 break;
7894               }
7895         }
7896     }
7897 #endif
7898 #ifdef HAVE_epilogue
7899   if (epilogue_end)
7900     {
7901       rtx insn, next;
7902
7903       /* Similarly, move any line notes that appear after the epilogue.
7904          There is no need, however, to be quite so anal about the existence
7905          of such a note.  */
7906       for (insn = epilogue_end; insn; insn = next)
7907         {
7908           next = NEXT_INSN (insn);
7909           if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
7910             reorder_insns (insn, insn, PREV_INSN (epilogue_end));
7911         }
7912     }
7913 #endif
7914 }
7915
7916 /* Reposition the prologue-end and epilogue-begin notes after instruction
7917    scheduling and delayed branch scheduling.  */
7918
7919 void
7920 reposition_prologue_and_epilogue_notes (rtx f ATTRIBUTE_UNUSED)
7921 {
7922 #if defined (HAVE_prologue) || defined (HAVE_epilogue)
7923   rtx insn, last, note;
7924   int len;
7925
7926   if ((len = VARRAY_SIZE (prologue)) > 0)
7927     {
7928       last = 0, note = 0;
7929
7930       /* Scan from the beginning until we reach the last prologue insn.
7931          We apparently can't depend on basic_block_{head,end} after
7932          reorg has run.  */
7933       for (insn = f; insn; insn = NEXT_INSN (insn))
7934         {
7935           if (GET_CODE (insn) == NOTE)
7936             {
7937               if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PROLOGUE_END)
7938                 note = insn;
7939             }
7940           else if (contains (insn, prologue))
7941             {
7942               last = insn;
7943               if (--len == 0)
7944                 break;
7945             }
7946         }
7947
7948       if (last)
7949         {
7950           /* Find the prologue-end note if we haven't already, and
7951              move it to just after the last prologue insn.  */
7952           if (note == 0)
7953             {
7954               for (note = last; (note = NEXT_INSN (note));)
7955                 if (GET_CODE (note) == NOTE
7956                     && NOTE_LINE_NUMBER (note) == NOTE_INSN_PROLOGUE_END)
7957                   break;
7958             }
7959
7960           /* Avoid placing note between CODE_LABEL and BASIC_BLOCK note.  */
7961           if (GET_CODE (last) == CODE_LABEL)
7962             last = NEXT_INSN (last);
7963           reorder_insns (note, note, last);
7964         }
7965     }
7966
7967   if ((len = VARRAY_SIZE (epilogue)) > 0)
7968     {
7969       last = 0, note = 0;
7970
7971       /* Scan from the end until we reach the first epilogue insn.
7972          We apparently can't depend on basic_block_{head,end} after
7973          reorg has run.  */
7974       for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
7975         {
7976           if (GET_CODE (insn) == NOTE)
7977             {
7978               if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EPILOGUE_BEG)
7979                 note = insn;
7980             }
7981           else if (contains (insn, epilogue))
7982             {
7983               last = insn;
7984               if (--len == 0)
7985                 break;
7986             }
7987         }
7988
7989       if (last)
7990         {
7991           /* Find the epilogue-begin note if we haven't already, and
7992              move it to just before the first epilogue insn.  */
7993           if (note == 0)
7994             {
7995               for (note = insn; (note = PREV_INSN (note));)
7996                 if (GET_CODE (note) == NOTE
7997                     && NOTE_LINE_NUMBER (note) == NOTE_INSN_EPILOGUE_BEG)
7998                   break;
7999             }
8000
8001           if (PREV_INSN (last) != note)
8002             reorder_insns (note, note, PREV_INSN (last));
8003         }
8004     }
8005 #endif /* HAVE_prologue or HAVE_epilogue */
8006 }
8007
8008 /* Called once, at initialization, to initialize function.c.  */
8009
8010 void
8011 init_function_once (void)
8012 {
8013   VARRAY_INT_INIT (prologue, 0, "prologue");
8014   VARRAY_INT_INIT (epilogue, 0, "epilogue");
8015   VARRAY_INT_INIT (sibcall_epilogue, 0, "sibcall_epilogue");
8016 }
8017
8018 #include "gt-function.h"