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
2933   /* Re-start here to avoid recursion in common cases.  */
2934  restart:
2935
2936   x = *loc;
2937   if (x == 0)
2938     return true;
2939
2940   code = GET_CODE (x);
2941
2942   /* If we don't return in any of the cases below, we will recurse inside
2943      the RTX, which will normally result in any ADDRESSOF being forced into
2944      memory.  */
2945   if (code == SET)
2946     {
2947       result = purge_addressof_1 (&SET_DEST (x), insn, force, 1,
2948                                   may_postpone, ht);
2949       result &= purge_addressof_1 (&SET_SRC (x), insn, force, 0,
2950                                    may_postpone, ht);
2951       return result;
2952     }
2953   else if (code == ADDRESSOF)
2954     {
2955       rtx sub, insns;
2956
2957       if (GET_CODE (XEXP (x, 0)) != MEM)
2958         put_addressof_into_stack (x, ht);
2959
2960       /* We must create a copy of the rtx because it was created by
2961          overwriting a REG rtx which is always shared.  */
2962       sub = copy_rtx (XEXP (XEXP (x, 0), 0));
2963       if (validate_change (insn, loc, sub, 0)
2964           || validate_replace_rtx (x, sub, insn))
2965         return true;
2966
2967       start_sequence ();
2968
2969       /* If SUB is a hard or virtual register, try it as a pseudo-register.
2970          Otherwise, perhaps SUB is an expression, so generate code to compute
2971          it.  */
2972       if (GET_CODE (sub) == REG && REGNO (sub) <= LAST_VIRTUAL_REGISTER)
2973         sub = copy_to_reg (sub);
2974       else
2975         sub = force_operand (sub, NULL_RTX);
2976
2977       if (! validate_change (insn, loc, sub, 0)
2978           && ! validate_replace_rtx (x, sub, insn))
2979         abort ();
2980
2981       insns = get_insns ();
2982       end_sequence ();
2983       emit_insn_before (insns, insn);
2984       return true;
2985     }
2986
2987   else if (code == MEM && GET_CODE (XEXP (x, 0)) == ADDRESSOF && ! force)
2988     {
2989       rtx sub = XEXP (XEXP (x, 0), 0);
2990
2991       if (GET_CODE (sub) == MEM)
2992         sub = adjust_address_nv (sub, GET_MODE (x), 0);
2993       else if (GET_CODE (sub) == REG
2994                && (MEM_VOLATILE_P (x) || GET_MODE (x) == BLKmode))
2995         ;
2996       else if (GET_CODE (sub) == REG && GET_MODE (x) != GET_MODE (sub))
2997         {
2998           int size_x, size_sub;
2999
3000           if (may_postpone)
3001             {
3002               /* Postpone for now, so that we do not emit bitfield arithmetics
3003                  unless there is some benefit from it.  */
3004               if (!postponed_insns || XEXP (postponed_insns, 0) != insn)
3005                 postponed_insns = alloc_INSN_LIST (insn, postponed_insns);
3006               return true;
3007             }
3008
3009           if (!insn)
3010             {
3011               /* When processing REG_NOTES look at the list of
3012                  replacements done on the insn to find the register that X
3013                  was replaced by.  */
3014               rtx tem;
3015
3016               for (tem = purge_bitfield_addressof_replacements;
3017                    tem != NULL_RTX;
3018                    tem = XEXP (XEXP (tem, 1), 1))
3019                 if (rtx_equal_p (x, XEXP (tem, 0)))
3020                   {
3021                     *loc = XEXP (XEXP (tem, 1), 0);
3022                     return true;
3023                   }
3024
3025               /* See comment for purge_addressof_replacements.  */
3026               for (tem = purge_addressof_replacements;
3027                    tem != NULL_RTX;
3028                    tem = XEXP (XEXP (tem, 1), 1))
3029                 if (rtx_equal_p (XEXP (x, 0), XEXP (tem, 0)))
3030                   {
3031                     rtx z = XEXP (XEXP (tem, 1), 0);
3032
3033                     if (GET_MODE (x) == GET_MODE (z)
3034                         || (GET_CODE (XEXP (XEXP (tem, 1), 0)) != REG
3035                             && GET_CODE (XEXP (XEXP (tem, 1), 0)) != SUBREG))
3036                       abort ();
3037
3038                     /* It can happen that the note may speak of things
3039                        in a wider (or just different) mode than the
3040                        code did.  This is especially true of
3041                        REG_RETVAL.  */
3042
3043                     if (GET_CODE (z) == SUBREG && SUBREG_BYTE (z) == 0)
3044                       z = SUBREG_REG (z);
3045
3046                     if (GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD
3047                         && (GET_MODE_SIZE (GET_MODE (x))
3048                             > GET_MODE_SIZE (GET_MODE (z))))
3049                       {
3050                         /* This can occur as a result in invalid
3051                            pointer casts, e.g. float f; ...
3052                            *(long long int *)&f.
3053                            ??? We could emit a warning here, but
3054                            without a line number that wouldn't be
3055                            very helpful.  */
3056                         z = gen_rtx_SUBREG (GET_MODE (x), z, 0);
3057                       }
3058                     else
3059                       z = gen_lowpart (GET_MODE (x), z);
3060
3061                     *loc = z;
3062                     return true;
3063                   }
3064
3065               /* When we are processing the REG_NOTES of the last instruction
3066                  of a libcall, there will be typically no replacements
3067                  for that insn; the replacements happened before, piecemeal
3068                  fashion.  OTOH we are not interested in the details of
3069                  this for the REG_EQUAL note, we want to know the big picture,
3070                  which can be succinctly described with a simple SUBREG.
3071                  Note that removing the REG_EQUAL note is not an option
3072                  on the last insn of a libcall, so we must do a replacement.  */
3073               if (! purge_addressof_replacements
3074                   && ! purge_bitfield_addressof_replacements)
3075                 {
3076                   /* In compile/990107-1.c:7 compiled at -O1 -m1 for sh-elf,
3077                      we got
3078                      (mem:DI (addressof:SI (reg/v:DF 160) 159 0x401c8510)
3079                       [0 S8 A32]), which can be expressed with a simple
3080                      same-size subreg  */
3081                   if ((GET_MODE_SIZE (GET_MODE (x))
3082                        == GET_MODE_SIZE (GET_MODE (sub)))
3083                       /* Again, invalid pointer casts (as in
3084                          compile/990203-1.c) can require paradoxical
3085                          subregs.  */
3086                       || (GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD
3087                           && (GET_MODE_SIZE (GET_MODE (x))
3088                               > GET_MODE_SIZE (GET_MODE (sub))))
3089                       || (GET_MODE_SIZE (GET_MODE (x))
3090                           < GET_MODE_SIZE (GET_MODE (sub))))
3091
3092                     {
3093                       *loc = gen_rtx_SUBREG (GET_MODE (x), sub, 0);
3094                       return true;
3095                     }
3096                   /* ??? Are there other cases we should handle?  */
3097                 }
3098               /* Sometimes we may not be able to find the replacement.  For
3099                  example when the original insn was a MEM in a wider mode,
3100                  and the note is part of a sign extension of a narrowed
3101                  version of that MEM.  Gcc testcase compile/990829-1.c can
3102                  generate an example of this situation.  Rather than complain
3103                  we return false, which will prompt our caller to remove the
3104                  offending note.  */
3105               return false;
3106             }
3107
3108           size_x = GET_MODE_BITSIZE (GET_MODE (x));
3109           size_sub = GET_MODE_BITSIZE (GET_MODE (sub));
3110
3111           /* Do not frob unchanging MEMs.  If a later reference forces the
3112              pseudo to the stack, we can wind up with multiple writes to
3113              an unchanging memory, which is invalid.  */
3114           if (RTX_UNCHANGING_P (x) && size_x != size_sub)
3115             ;
3116
3117           /* Don't even consider working with paradoxical subregs,
3118              or the moral equivalent seen here.  */
3119           else if (size_x <= size_sub
3120                    && int_mode_for_mode (GET_MODE (sub)) != BLKmode)
3121             {
3122               /* Do a bitfield insertion to mirror what would happen
3123                  in memory.  */
3124
3125               rtx val, seq;
3126
3127               if (store)
3128                 {
3129                   rtx p = PREV_INSN (insn);
3130
3131                   start_sequence ();
3132                   val = gen_reg_rtx (GET_MODE (x));
3133                   if (! validate_change (insn, loc, val, 0))
3134                     {
3135                       /* Discard the current sequence and put the
3136                          ADDRESSOF on stack.  */
3137                       end_sequence ();
3138                       goto give_up;
3139                     }
3140                   seq = get_insns ();
3141                   end_sequence ();
3142                   emit_insn_before (seq, insn);
3143                   compute_insns_for_mem (p ? NEXT_INSN (p) : get_insns (),
3144                                          insn, ht);
3145
3146                   start_sequence ();
3147                   store_bit_field (sub, size_x, 0, GET_MODE (x),
3148                                    val, GET_MODE_SIZE (GET_MODE (sub)));
3149
3150                   /* Make sure to unshare any shared rtl that store_bit_field
3151                      might have created.  */
3152                   unshare_all_rtl_again (get_insns ());
3153
3154                   seq = get_insns ();
3155                   end_sequence ();
3156                   p = emit_insn_after (seq, insn);
3157                   if (NEXT_INSN (insn))
3158                     compute_insns_for_mem (NEXT_INSN (insn),
3159                                            p ? NEXT_INSN (p) : NULL_RTX,
3160                                            ht);
3161                 }
3162               else
3163                 {
3164                   rtx p = PREV_INSN (insn);
3165
3166                   start_sequence ();
3167                   val = extract_bit_field (sub, size_x, 0, 1, NULL_RTX,
3168                                            GET_MODE (x), GET_MODE (x),
3169                                            GET_MODE_SIZE (GET_MODE (sub)));
3170
3171                   if (! validate_change (insn, loc, val, 0))
3172                     {
3173                       /* Discard the current sequence and put the
3174                          ADDRESSOF on stack.  */
3175                       end_sequence ();
3176                       goto give_up;
3177                     }
3178
3179                   seq = get_insns ();
3180                   end_sequence ();
3181                   emit_insn_before (seq, insn);
3182                   compute_insns_for_mem (p ? NEXT_INSN (p) : get_insns (),
3183                                          insn, ht);
3184                 }
3185
3186               /* Remember the replacement so that the same one can be done
3187                  on the REG_NOTES.  */
3188               purge_bitfield_addressof_replacements
3189                 = gen_rtx_EXPR_LIST (VOIDmode, x,
3190                                      gen_rtx_EXPR_LIST
3191                                      (VOIDmode, val,
3192                                       purge_bitfield_addressof_replacements));
3193
3194               /* We replaced with a reg -- all done.  */
3195               return true;
3196             }
3197         }
3198
3199       else if (validate_change (insn, loc, sub, 0))
3200         {
3201           /* Remember the replacement so that the same one can be done
3202              on the REG_NOTES.  */
3203           if (GET_CODE (sub) == REG || GET_CODE (sub) == SUBREG)
3204             {
3205               rtx tem;
3206
3207               for (tem = purge_addressof_replacements;
3208                    tem != NULL_RTX;
3209                    tem = XEXP (XEXP (tem, 1), 1))
3210                 if (rtx_equal_p (XEXP (x, 0), XEXP (tem, 0)))
3211                   {
3212                     XEXP (XEXP (tem, 1), 0) = sub;
3213                     return true;
3214                   }
3215               purge_addressof_replacements
3216                 = gen_rtx (EXPR_LIST, VOIDmode, XEXP (x, 0),
3217                            gen_rtx_EXPR_LIST (VOIDmode, sub,
3218                                               purge_addressof_replacements));
3219               return true;
3220             }
3221           goto restart;
3222         }
3223     }
3224
3225  give_up:
3226   /* Scan all subexpressions.  */
3227   fmt = GET_RTX_FORMAT (code);
3228   for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
3229     {
3230       if (*fmt == 'e')
3231         result &= purge_addressof_1 (&XEXP (x, i), insn, force, 0,
3232                                      may_postpone, ht);
3233       else if (*fmt == 'E')
3234         for (j = 0; j < XVECLEN (x, i); j++)
3235           result &= purge_addressof_1 (&XVECEXP (x, i, j), insn, force, 0,
3236                                        may_postpone, ht);
3237     }
3238
3239   return result;
3240 }
3241
3242 /* Return a hash value for K, a REG.  */
3243
3244 static hashval_t
3245 insns_for_mem_hash (const void *k)
3246 {
3247   /* Use the address of the key for the hash value.  */
3248   struct insns_for_mem_entry *m = (struct insns_for_mem_entry *) k;
3249   return htab_hash_pointer (m->key);
3250 }
3251
3252 /* Return nonzero if K1 and K2 (two REGs) are the same.  */
3253
3254 static int
3255 insns_for_mem_comp (const void *k1, const void *k2)
3256 {
3257   struct insns_for_mem_entry *m1 = (struct insns_for_mem_entry *) k1;
3258   struct insns_for_mem_entry *m2 = (struct insns_for_mem_entry *) k2;
3259   return m1->key == m2->key;
3260 }
3261
3262 struct insns_for_mem_walk_info
3263 {
3264   /* The hash table that we are using to record which INSNs use which
3265      MEMs.  */
3266   htab_t ht;
3267
3268   /* The INSN we are currently processing.  */
3269   rtx insn;
3270
3271   /* Zero if we are walking to find ADDRESSOFs, one if we are walking
3272      to find the insns that use the REGs in the ADDRESSOFs.  */
3273   int pass;
3274 };
3275
3276 /* Called from compute_insns_for_mem via for_each_rtx.  If R is a REG
3277    that might be used in an ADDRESSOF expression, record this INSN in
3278    the hash table given by DATA (which is really a pointer to an
3279    insns_for_mem_walk_info structure).  */
3280
3281 static int
3282 insns_for_mem_walk (rtx *r, void *data)
3283 {
3284   struct insns_for_mem_walk_info *ifmwi
3285     = (struct insns_for_mem_walk_info *) data;
3286   struct insns_for_mem_entry tmp;
3287   tmp.insns = NULL_RTX;
3288
3289   if (ifmwi->pass == 0 && *r && GET_CODE (*r) == ADDRESSOF
3290       && GET_CODE (XEXP (*r, 0)) == REG)
3291     {
3292       void **e;
3293       tmp.key = XEXP (*r, 0);
3294       e = htab_find_slot (ifmwi->ht, &tmp, INSERT);
3295       if (*e == NULL)
3296         {
3297           *e = ggc_alloc (sizeof (tmp));
3298           memcpy (*e, &tmp, sizeof (tmp));
3299         }
3300     }
3301   else if (ifmwi->pass == 1 && *r && GET_CODE (*r) == REG)
3302     {
3303       struct insns_for_mem_entry *ifme;
3304       tmp.key = *r;
3305       ifme = htab_find (ifmwi->ht, &tmp);
3306
3307       /* If we have not already recorded this INSN, do so now.  Since
3308          we process the INSNs in order, we know that if we have
3309          recorded it it must be at the front of the list.  */
3310       if (ifme && (!ifme->insns || XEXP (ifme->insns, 0) != ifmwi->insn))
3311         ifme->insns = gen_rtx_EXPR_LIST (VOIDmode, ifmwi->insn,
3312                                          ifme->insns);
3313     }
3314
3315   return 0;
3316 }
3317
3318 /* Walk the INSNS, until we reach LAST_INSN, recording which INSNs use
3319    which REGs in HT.  */
3320
3321 static void
3322 compute_insns_for_mem (rtx insns, rtx last_insn, htab_t ht)
3323 {
3324   rtx insn;
3325   struct insns_for_mem_walk_info ifmwi;
3326   ifmwi.ht = ht;
3327
3328   for (ifmwi.pass = 0; ifmwi.pass < 2; ++ifmwi.pass)
3329     for (insn = insns; insn != last_insn; insn = NEXT_INSN (insn))
3330       if (INSN_P (insn))
3331         {
3332           ifmwi.insn = insn;
3333           for_each_rtx (&insn, insns_for_mem_walk, &ifmwi);
3334         }
3335 }
3336
3337 /* Helper function for purge_addressof called through for_each_rtx.
3338    Returns true iff the rtl is an ADDRESSOF.  */
3339
3340 static int
3341 is_addressof (rtx *rtl, void *data ATTRIBUTE_UNUSED)
3342 {
3343   return GET_CODE (*rtl) == ADDRESSOF;
3344 }
3345
3346 /* Eliminate all occurrences of ADDRESSOF from INSNS.  Elide any remaining
3347    (MEM (ADDRESSOF)) patterns, and force any needed registers into the
3348    stack.  */
3349
3350 void
3351 purge_addressof (rtx insns)
3352 {
3353   rtx insn, tmp;
3354   htab_t ht;
3355
3356   /* When we actually purge ADDRESSOFs, we turn REGs into MEMs.  That
3357      requires a fixup pass over the instruction stream to correct
3358      INSNs that depended on the REG being a REG, and not a MEM.  But,
3359      these fixup passes are slow.  Furthermore, most MEMs are not
3360      mentioned in very many instructions.  So, we speed up the process
3361      by pre-calculating which REGs occur in which INSNs; that allows
3362      us to perform the fixup passes much more quickly.  */
3363   ht = htab_create_ggc (1000, insns_for_mem_hash, insns_for_mem_comp, NULL);
3364   compute_insns_for_mem (insns, NULL_RTX, ht);
3365
3366   postponed_insns = NULL;
3367
3368   for (insn = insns; insn; insn = NEXT_INSN (insn))
3369     if (INSN_P (insn))
3370       {
3371         if (! purge_addressof_1 (&PATTERN (insn), insn,
3372                                  asm_noperands (PATTERN (insn)) > 0, 0, 1, ht))
3373           /* If we could not replace the ADDRESSOFs in the insn,
3374              something is wrong.  */
3375           abort ();
3376
3377         if (! purge_addressof_1 (&REG_NOTES (insn), NULL_RTX, 0, 0, 0, ht))
3378           {
3379             /* If we could not replace the ADDRESSOFs in the insn's notes,
3380                we can just remove the offending notes instead.  */
3381             rtx note;
3382
3383             for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
3384               {
3385                 /* If we find a REG_RETVAL note then the insn is a libcall.
3386                    Such insns must have REG_EQUAL notes as well, in order
3387                    for later passes of the compiler to work.  So it is not
3388                    safe to delete the notes here, and instead we abort.  */
3389                 if (REG_NOTE_KIND (note) == REG_RETVAL)
3390                   abort ();
3391                 if (for_each_rtx (&note, is_addressof, NULL))
3392                   remove_note (insn, note);
3393               }
3394           }
3395       }
3396
3397   /* Process the postponed insns.  */
3398   while (postponed_insns)
3399     {
3400       insn = XEXP (postponed_insns, 0);
3401       tmp = postponed_insns;
3402       postponed_insns = XEXP (postponed_insns, 1);
3403       free_INSN_LIST_node (tmp);
3404
3405       if (! purge_addressof_1 (&PATTERN (insn), insn,
3406                                asm_noperands (PATTERN (insn)) > 0, 0, 0, ht))
3407         abort ();
3408     }
3409
3410   /* Clean up.  */
3411   purge_bitfield_addressof_replacements = 0;
3412   purge_addressof_replacements = 0;
3413
3414   /* REGs are shared.  purge_addressof will destructively replace a REG
3415      with a MEM, which creates shared MEMs.
3416
3417      Unfortunately, the children of put_reg_into_stack assume that MEMs
3418      referring to the same stack slot are shared (fixup_var_refs and
3419      the associated hash table code).
3420
3421      So, we have to do another unsharing pass after we have flushed any
3422      REGs that had their address taken into the stack.
3423
3424      It may be worth tracking whether or not we converted any REGs into
3425      MEMs to avoid this overhead when it is not needed.  */
3426   unshare_all_rtl_again (get_insns ());
3427 }
3428 \f
3429 /* Convert a SET of a hard subreg to a set of the appropriate hard
3430    register.  A subroutine of purge_hard_subreg_sets.  */
3431
3432 static void
3433 purge_single_hard_subreg_set (rtx pattern)
3434 {
3435   rtx reg = SET_DEST (pattern);
3436   enum machine_mode mode = GET_MODE (SET_DEST (pattern));
3437   int offset = 0;
3438
3439   if (GET_CODE (reg) == SUBREG && GET_CODE (SUBREG_REG (reg)) == REG
3440       && REGNO (SUBREG_REG (reg)) < FIRST_PSEUDO_REGISTER)
3441     {
3442       offset = subreg_regno_offset (REGNO (SUBREG_REG (reg)),
3443                                     GET_MODE (SUBREG_REG (reg)),
3444                                     SUBREG_BYTE (reg),
3445                                     GET_MODE (reg));
3446       reg = SUBREG_REG (reg);
3447     }
3448
3449
3450   if (GET_CODE (reg) == REG && REGNO (reg) < FIRST_PSEUDO_REGISTER)
3451     {
3452       reg = gen_rtx_REG (mode, REGNO (reg) + offset);
3453       SET_DEST (pattern) = reg;
3454     }
3455 }
3456
3457 /* Eliminate all occurrences of SETs of hard subregs from INSNS.  The
3458    only such SETs that we expect to see are those left in because
3459    integrate can't handle sets of parts of a return value register.
3460
3461    We don't use alter_subreg because we only want to eliminate subregs
3462    of hard registers.  */
3463
3464 void
3465 purge_hard_subreg_sets (rtx insn)
3466 {
3467   for (; insn; insn = NEXT_INSN (insn))
3468     {
3469       if (INSN_P (insn))
3470         {
3471           rtx pattern = PATTERN (insn);
3472           switch (GET_CODE (pattern))
3473             {
3474             case SET:
3475               if (GET_CODE (SET_DEST (pattern)) == SUBREG)
3476                 purge_single_hard_subreg_set (pattern);
3477               break;
3478             case PARALLEL:
3479               {
3480                 int j;
3481                 for (j = XVECLEN (pattern, 0) - 1; j >= 0; j--)
3482                   {
3483                     rtx inner_pattern = XVECEXP (pattern, 0, j);
3484                     if (GET_CODE (inner_pattern) == SET
3485                         && GET_CODE (SET_DEST (inner_pattern)) == SUBREG)
3486                       purge_single_hard_subreg_set (inner_pattern);
3487                   }
3488               }
3489               break;
3490             default:
3491               break;
3492             }
3493         }
3494     }
3495 }
3496 \f
3497 /* Pass through the INSNS of function FNDECL and convert virtual register
3498    references to hard register references.  */
3499
3500 void
3501 instantiate_virtual_regs (tree fndecl, rtx insns)
3502 {
3503   rtx insn;
3504   unsigned int i;
3505
3506   /* Compute the offsets to use for this function.  */
3507   in_arg_offset = FIRST_PARM_OFFSET (fndecl);
3508   var_offset = STARTING_FRAME_OFFSET;
3509   dynamic_offset = STACK_DYNAMIC_OFFSET (fndecl);
3510   out_arg_offset = STACK_POINTER_OFFSET;
3511   cfa_offset = ARG_POINTER_CFA_OFFSET (fndecl);
3512
3513   /* Scan all variables and parameters of this function.  For each that is
3514      in memory, instantiate all virtual registers if the result is a valid
3515      address.  If not, we do it later.  That will handle most uses of virtual
3516      regs on many machines.  */
3517   instantiate_decls (fndecl, 1);
3518
3519   /* Initialize recognition, indicating that volatile is OK.  */
3520   init_recog ();
3521
3522   /* Scan through all the insns, instantiating every virtual register still
3523      present.  */
3524   for (insn = insns; insn; insn = NEXT_INSN (insn))
3525     if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN
3526         || GET_CODE (insn) == CALL_INSN)
3527       {
3528         instantiate_virtual_regs_1 (&PATTERN (insn), insn, 1);
3529         if (INSN_DELETED_P (insn))
3530           continue;
3531         instantiate_virtual_regs_1 (&REG_NOTES (insn), NULL_RTX, 0);
3532         /* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE.  */
3533         if (GET_CODE (insn) == CALL_INSN)
3534           instantiate_virtual_regs_1 (&CALL_INSN_FUNCTION_USAGE (insn),
3535                                       NULL_RTX, 0);
3536
3537         /* Past this point all ASM statements should match.  Verify that
3538            to avoid failures later in the compilation process.  */
3539         if (asm_noperands (PATTERN (insn)) >= 0
3540             && ! check_asm_operands (PATTERN (insn)))
3541           instantiate_virtual_regs_lossage (insn);
3542       }
3543
3544   /* Instantiate the stack slots for the parm registers, for later use in
3545      addressof elimination.  */
3546   for (i = 0; i < max_parm_reg; ++i)
3547     if (parm_reg_stack_loc[i])
3548       instantiate_virtual_regs_1 (&parm_reg_stack_loc[i], NULL_RTX, 0);
3549
3550   /* Now instantiate the remaining register equivalences for debugging info.
3551      These will not be valid addresses.  */
3552   instantiate_decls (fndecl, 0);
3553
3554   /* Indicate that, from now on, assign_stack_local should use
3555      frame_pointer_rtx.  */
3556   virtuals_instantiated = 1;
3557 }
3558
3559 /* Scan all decls in FNDECL (both variables and parameters) and instantiate
3560    all virtual registers in their DECL_RTL's.
3561
3562    If VALID_ONLY, do this only if the resulting address is still valid.
3563    Otherwise, always do it.  */
3564
3565 static void
3566 instantiate_decls (tree fndecl, int valid_only)
3567 {
3568   tree decl;
3569
3570   /* Process all parameters of the function.  */
3571   for (decl = DECL_ARGUMENTS (fndecl); decl; decl = TREE_CHAIN (decl))
3572     {
3573       HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (decl));
3574       HOST_WIDE_INT size_rtl;
3575
3576       instantiate_decl (DECL_RTL (decl), size, valid_only);
3577
3578       /* If the parameter was promoted, then the incoming RTL mode may be
3579          larger than the declared type size.  We must use the larger of
3580          the two sizes.  */
3581       size_rtl = GET_MODE_SIZE (GET_MODE (DECL_INCOMING_RTL (decl)));
3582       size = MAX (size_rtl, size);
3583       instantiate_decl (DECL_INCOMING_RTL (decl), size, valid_only);
3584     }
3585
3586   /* Now process all variables defined in the function or its subblocks.  */
3587   instantiate_decls_1 (DECL_INITIAL (fndecl), valid_only);
3588 }
3589
3590 /* Subroutine of instantiate_decls: Process all decls in the given
3591    BLOCK node and all its subblocks.  */
3592
3593 static void
3594 instantiate_decls_1 (tree let, int valid_only)
3595 {
3596   tree t;
3597
3598   for (t = BLOCK_VARS (let); t; t = TREE_CHAIN (t))
3599     if (DECL_RTL_SET_P (t))
3600       instantiate_decl (DECL_RTL (t),
3601                         int_size_in_bytes (TREE_TYPE (t)),
3602                         valid_only);
3603
3604   /* Process all subblocks.  */
3605   for (t = BLOCK_SUBBLOCKS (let); t; t = TREE_CHAIN (t))
3606     instantiate_decls_1 (t, valid_only);
3607 }
3608
3609 /* Subroutine of the preceding procedures: Given RTL representing a
3610    decl and the size of the object, do any instantiation required.
3611
3612    If VALID_ONLY is nonzero, it means that the RTL should only be
3613    changed if the new address is valid.  */
3614
3615 static void
3616 instantiate_decl (rtx x, HOST_WIDE_INT size, int valid_only)
3617 {
3618   enum machine_mode mode;
3619   rtx addr;
3620
3621   /* If this is not a MEM, no need to do anything.  Similarly if the
3622      address is a constant or a register that is not a virtual register.  */
3623
3624   if (x == 0 || GET_CODE (x) != MEM)
3625     return;
3626
3627   addr = XEXP (x, 0);
3628   if (CONSTANT_P (addr)
3629       || (GET_CODE (addr) == ADDRESSOF && GET_CODE (XEXP (addr, 0)) == REG)
3630       || (GET_CODE (addr) == REG
3631           && (REGNO (addr) < FIRST_VIRTUAL_REGISTER
3632               || REGNO (addr) > LAST_VIRTUAL_REGISTER)))
3633     return;
3634
3635   /* If we should only do this if the address is valid, copy the address.
3636      We need to do this so we can undo any changes that might make the
3637      address invalid.  This copy is unfortunate, but probably can't be
3638      avoided.  */
3639
3640   if (valid_only)
3641     addr = copy_rtx (addr);
3642
3643   instantiate_virtual_regs_1 (&addr, NULL_RTX, 0);
3644
3645   if (valid_only && size >= 0)
3646     {
3647       unsigned HOST_WIDE_INT decl_size = size;
3648
3649       /* Now verify that the resulting address is valid for every integer or
3650          floating-point mode up to and including SIZE bytes long.  We do this
3651          since the object might be accessed in any mode and frame addresses
3652          are shared.  */
3653
3654       for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
3655            mode != VOIDmode && GET_MODE_SIZE (mode) <= decl_size;
3656            mode = GET_MODE_WIDER_MODE (mode))
3657         if (! memory_address_p (mode, addr))
3658           return;
3659
3660       for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
3661            mode != VOIDmode && GET_MODE_SIZE (mode) <= decl_size;
3662            mode = GET_MODE_WIDER_MODE (mode))
3663         if (! memory_address_p (mode, addr))
3664           return;
3665     }
3666
3667   /* Put back the address now that we have updated it and we either know
3668      it is valid or we don't care whether it is valid.  */
3669
3670   XEXP (x, 0) = addr;
3671 }
3672 \f
3673 /* Given a piece of RTX and a pointer to a HOST_WIDE_INT, if the RTX
3674    is a virtual register, return the equivalent hard register and set the
3675    offset indirectly through the pointer.  Otherwise, return 0.  */
3676
3677 static rtx
3678 instantiate_new_reg (rtx x, HOST_WIDE_INT *poffset)
3679 {
3680   rtx new;
3681   HOST_WIDE_INT offset;
3682
3683   if (x == virtual_incoming_args_rtx)
3684     new = arg_pointer_rtx, offset = in_arg_offset;
3685   else if (x == virtual_stack_vars_rtx)
3686     new = frame_pointer_rtx, offset = var_offset;
3687   else if (x == virtual_stack_dynamic_rtx)
3688     new = stack_pointer_rtx, offset = dynamic_offset;
3689   else if (x == virtual_outgoing_args_rtx)
3690     new = stack_pointer_rtx, offset = out_arg_offset;
3691   else if (x == virtual_cfa_rtx)
3692     new = arg_pointer_rtx, offset = cfa_offset;
3693   else
3694     return 0;
3695
3696   *poffset = offset;
3697   return new;
3698 }
3699 \f
3700
3701 /* Called when instantiate_virtual_regs has failed to update the instruction.
3702    Usually this means that non-matching instruction has been emit, however for
3703    asm statements it may be the problem in the constraints.  */
3704 static void
3705 instantiate_virtual_regs_lossage (rtx insn)
3706 {
3707   if (asm_noperands (PATTERN (insn)) >= 0)
3708     {
3709       error_for_asm (insn, "impossible constraint in `asm'");
3710       delete_insn (insn);
3711     }
3712   else
3713     abort ();
3714 }
3715 /* Given a pointer to a piece of rtx and an optional pointer to the
3716    containing object, instantiate any virtual registers present in it.
3717
3718    If EXTRA_INSNS, we always do the replacement and generate
3719    any extra insns before OBJECT.  If it zero, we do nothing if replacement
3720    is not valid.
3721
3722    Return 1 if we either had nothing to do or if we were able to do the
3723    needed replacement.  Return 0 otherwise; we only return zero if
3724    EXTRA_INSNS is zero.
3725
3726    We first try some simple transformations to avoid the creation of extra
3727    pseudos.  */
3728
3729 static int
3730 instantiate_virtual_regs_1 (rtx *loc, rtx object, int extra_insns)
3731 {
3732   rtx x;
3733   RTX_CODE code;
3734   rtx new = 0;
3735   HOST_WIDE_INT offset = 0;
3736   rtx temp;
3737   rtx seq;
3738   int i, j;
3739   const char *fmt;
3740
3741   /* Re-start here to avoid recursion in common cases.  */
3742  restart:
3743
3744   x = *loc;
3745   if (x == 0)
3746     return 1;
3747
3748   /* We may have detected and deleted invalid asm statements.  */
3749   if (object && INSN_P (object) && INSN_DELETED_P (object))
3750     return 1;
3751
3752   code = GET_CODE (x);
3753
3754   /* Check for some special cases.  */
3755   switch (code)
3756     {
3757     case CONST_INT:
3758     case CONST_DOUBLE:
3759     case CONST_VECTOR:
3760     case CONST:
3761     case SYMBOL_REF:
3762     case CODE_LABEL:
3763     case PC:
3764     case CC0:
3765     case ASM_INPUT:
3766     case ADDR_VEC:
3767     case ADDR_DIFF_VEC:
3768     case RETURN:
3769       return 1;
3770
3771     case SET:
3772       /* We are allowed to set the virtual registers.  This means that
3773          the actual register should receive the source minus the
3774          appropriate offset.  This is used, for example, in the handling
3775          of non-local gotos.  */
3776       if ((new = instantiate_new_reg (SET_DEST (x), &offset)) != 0)
3777         {
3778           rtx src = SET_SRC (x);
3779
3780           /* We are setting the register, not using it, so the relevant
3781              offset is the negative of the offset to use were we using
3782              the register.  */
3783           offset = - offset;
3784           instantiate_virtual_regs_1 (&src, NULL_RTX, 0);
3785
3786           /* The only valid sources here are PLUS or REG.  Just do
3787              the simplest possible thing to handle them.  */
3788           if (GET_CODE (src) != REG && GET_CODE (src) != PLUS)
3789             {
3790               instantiate_virtual_regs_lossage (object);
3791               return 1;
3792             }
3793
3794           start_sequence ();
3795           if (GET_CODE (src) != REG)
3796             temp = force_operand (src, NULL_RTX);
3797           else
3798             temp = src;
3799           temp = force_operand (plus_constant (temp, offset), NULL_RTX);
3800           seq = get_insns ();
3801           end_sequence ();
3802
3803           emit_insn_before (seq, object);
3804           SET_DEST (x) = new;
3805
3806           if (! validate_change (object, &SET_SRC (x), temp, 0)
3807               || ! extra_insns)
3808             instantiate_virtual_regs_lossage (object);
3809
3810           return 1;
3811         }
3812
3813       instantiate_virtual_regs_1 (&SET_DEST (x), object, extra_insns);
3814       loc = &SET_SRC (x);
3815       goto restart;
3816
3817     case PLUS:
3818       /* Handle special case of virtual register plus constant.  */
3819       if (CONSTANT_P (XEXP (x, 1)))
3820         {
3821           rtx old, new_offset;
3822
3823           /* Check for (plus (plus VIRT foo) (const_int)) first.  */
3824           if (GET_CODE (XEXP (x, 0)) == PLUS)
3825             {
3826               if ((new = instantiate_new_reg (XEXP (XEXP (x, 0), 0), &offset)))
3827                 {
3828                   instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 1), object,
3829                                               extra_insns);
3830                   new = gen_rtx_PLUS (Pmode, new, XEXP (XEXP (x, 0), 1));
3831                 }
3832               else
3833                 {
3834                   loc = &XEXP (x, 0);
3835                   goto restart;
3836                 }
3837             }
3838
3839 #ifdef POINTERS_EXTEND_UNSIGNED
3840           /* If we have (plus (subreg (virtual-reg)) (const_int)), we know
3841              we can commute the PLUS and SUBREG because pointers into the
3842              frame are well-behaved.  */
3843           else if (GET_CODE (XEXP (x, 0)) == SUBREG && GET_MODE (x) == ptr_mode
3844                    && GET_CODE (XEXP (x, 1)) == CONST_INT
3845                    && 0 != (new
3846                             = instantiate_new_reg (SUBREG_REG (XEXP (x, 0)),
3847                                                    &offset))
3848                    && validate_change (object, loc,
3849                                        plus_constant (gen_lowpart (ptr_mode,
3850                                                                    new),
3851                                                       offset
3852                                                       + INTVAL (XEXP (x, 1))),
3853                                        0))
3854                 return 1;
3855 #endif
3856           else if ((new = instantiate_new_reg (XEXP (x, 0), &offset)) == 0)
3857             {
3858               /* We know the second operand is a constant.  Unless the
3859                  first operand is a REG (which has been already checked),
3860                  it needs to be checked.  */
3861               if (GET_CODE (XEXP (x, 0)) != REG)
3862                 {
3863                   loc = &XEXP (x, 0);
3864                   goto restart;
3865                 }
3866               return 1;
3867             }
3868
3869           new_offset = plus_constant (XEXP (x, 1), offset);
3870
3871           /* If the new constant is zero, try to replace the sum with just
3872              the register.  */
3873           if (new_offset == const0_rtx
3874               && validate_change (object, loc, new, 0))
3875             return 1;
3876
3877           /* Next try to replace the register and new offset.
3878              There are two changes to validate here and we can't assume that
3879              in the case of old offset equals new just changing the register
3880              will yield a valid insn.  In the interests of a little efficiency,
3881              however, we only call validate change once (we don't queue up the
3882              changes and then call apply_change_group).  */
3883
3884           old = XEXP (x, 0);
3885           if (offset == 0
3886               ? ! validate_change (object, &XEXP (x, 0), new, 0)
3887               : (XEXP (x, 0) = new,
3888                  ! validate_change (object, &XEXP (x, 1), new_offset, 0)))
3889             {
3890               if (! extra_insns)
3891                 {
3892                   XEXP (x, 0) = old;
3893                   return 0;
3894                 }
3895
3896               /* Otherwise copy the new constant into a register and replace
3897                  constant with that register.  */
3898               temp = gen_reg_rtx (Pmode);
3899               XEXP (x, 0) = new;
3900               if (validate_change (object, &XEXP (x, 1), temp, 0))
3901                 emit_insn_before (gen_move_insn (temp, new_offset), object);
3902               else
3903                 {
3904                   /* If that didn't work, replace this expression with a
3905                      register containing the sum.  */
3906
3907                   XEXP (x, 0) = old;
3908                   new = gen_rtx_PLUS (Pmode, new, new_offset);
3909
3910                   start_sequence ();
3911                   temp = force_operand (new, NULL_RTX);
3912                   seq = get_insns ();
3913                   end_sequence ();
3914
3915                   emit_insn_before (seq, object);
3916                   if (! validate_change (object, loc, temp, 0)
3917                       && ! validate_replace_rtx (x, temp, object))
3918                     {
3919                       instantiate_virtual_regs_lossage (object);
3920                       return 1;
3921                     }
3922                 }
3923             }
3924
3925           return 1;
3926         }
3927
3928       /* Fall through to generic two-operand expression case.  */
3929     case EXPR_LIST:
3930     case CALL:
3931     case COMPARE:
3932     case MINUS:
3933     case MULT:
3934     case DIV:      case UDIV:
3935     case MOD:      case UMOD:
3936     case AND:      case IOR:      case XOR:
3937     case ROTATERT: case ROTATE:
3938     case ASHIFTRT: case LSHIFTRT: case ASHIFT:
3939     case NE:       case EQ:
3940     case GE:       case GT:       case GEU:    case GTU:
3941     case LE:       case LT:       case LEU:    case LTU:
3942       if (XEXP (x, 1) && ! CONSTANT_P (XEXP (x, 1)))
3943         instantiate_virtual_regs_1 (&XEXP (x, 1), object, extra_insns);
3944       loc = &XEXP (x, 0);
3945       goto restart;
3946
3947     case MEM:
3948       /* Most cases of MEM that convert to valid addresses have already been
3949          handled by our scan of decls.  The only special handling we
3950          need here is to make a copy of the rtx to ensure it isn't being
3951          shared if we have to change it to a pseudo.
3952
3953          If the rtx is a simple reference to an address via a virtual register,
3954          it can potentially be shared.  In such cases, first try to make it
3955          a valid address, which can also be shared.  Otherwise, copy it and
3956          proceed normally.
3957
3958          First check for common cases that need no processing.  These are
3959          usually due to instantiation already being done on a previous instance
3960          of a shared rtx.  */
3961
3962       temp = XEXP (x, 0);
3963       if (CONSTANT_ADDRESS_P (temp)
3964 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
3965           || temp == arg_pointer_rtx
3966 #endif
3967 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
3968           || temp == hard_frame_pointer_rtx
3969 #endif
3970           || temp == frame_pointer_rtx)
3971         return 1;
3972
3973       if (GET_CODE (temp) == PLUS
3974           && CONSTANT_ADDRESS_P (XEXP (temp, 1))
3975           && (XEXP (temp, 0) == frame_pointer_rtx
3976 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
3977               || XEXP (temp, 0) == hard_frame_pointer_rtx
3978 #endif
3979 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
3980               || XEXP (temp, 0) == arg_pointer_rtx
3981 #endif
3982               ))
3983         return 1;
3984
3985       if (temp == virtual_stack_vars_rtx
3986           || temp == virtual_incoming_args_rtx
3987           || (GET_CODE (temp) == PLUS
3988               && CONSTANT_ADDRESS_P (XEXP (temp, 1))
3989               && (XEXP (temp, 0) == virtual_stack_vars_rtx
3990                   || XEXP (temp, 0) == virtual_incoming_args_rtx)))
3991         {
3992           /* This MEM may be shared.  If the substitution can be done without
3993              the need to generate new pseudos, we want to do it in place
3994              so all copies of the shared rtx benefit.  The call below will
3995              only make substitutions if the resulting address is still
3996              valid.
3997
3998              Note that we cannot pass X as the object in the recursive call
3999              since the insn being processed may not allow all valid
4000              addresses.  However, if we were not passed on object, we can
4001              only modify X without copying it if X will have a valid
4002              address.
4003
4004              ??? Also note that this can still lose if OBJECT is an insn that
4005              has less restrictions on an address that some other insn.
4006              In that case, we will modify the shared address.  This case
4007              doesn't seem very likely, though.  One case where this could
4008              happen is in the case of a USE or CLOBBER reference, but we
4009              take care of that below.  */
4010
4011           if (instantiate_virtual_regs_1 (&XEXP (x, 0),
4012                                           object ? object : x, 0))
4013             return 1;
4014
4015           /* Otherwise make a copy and process that copy.  We copy the entire
4016              RTL expression since it might be a PLUS which could also be
4017              shared.  */
4018           *loc = x = copy_rtx (x);
4019         }
4020
4021       /* Fall through to generic unary operation case.  */
4022     case PREFETCH:
4023     case SUBREG:
4024     case STRICT_LOW_PART:
4025     case NEG:          case NOT:
4026     case PRE_DEC:      case PRE_INC:      case POST_DEC:    case POST_INC:
4027     case SIGN_EXTEND:  case ZERO_EXTEND:
4028     case TRUNCATE:     case FLOAT_EXTEND: case FLOAT_TRUNCATE:
4029     case FLOAT:        case FIX:
4030     case UNSIGNED_FIX: case UNSIGNED_FLOAT:
4031     case ABS:
4032     case SQRT:
4033     case FFS:
4034     case CLZ:          case CTZ:
4035     case POPCOUNT:     case PARITY:
4036       /* These case either have just one operand or we know that we need not
4037          check the rest of the operands.  */
4038       loc = &XEXP (x, 0);
4039       goto restart;
4040
4041     case USE:
4042     case CLOBBER:
4043       /* If the operand is a MEM, see if the change is a valid MEM.  If not,
4044          go ahead and make the invalid one, but do it to a copy.  For a REG,
4045          just make the recursive call, since there's no chance of a problem.  */
4046
4047       if ((GET_CODE (XEXP (x, 0)) == MEM
4048            && instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 0), XEXP (x, 0),
4049                                           0))
4050           || (GET_CODE (XEXP (x, 0)) == REG
4051               && instantiate_virtual_regs_1 (&XEXP (x, 0), object, 0)))
4052         return 1;
4053
4054       XEXP (x, 0) = copy_rtx (XEXP (x, 0));
4055       loc = &XEXP (x, 0);
4056       goto restart;
4057
4058     case REG:
4059       /* Try to replace with a PLUS.  If that doesn't work, compute the sum
4060          in front of this insn and substitute the temporary.  */
4061       if ((new = instantiate_new_reg (x, &offset)) != 0)
4062         {
4063           temp = plus_constant (new, offset);
4064           if (!validate_change (object, loc, temp, 0))
4065             {
4066               if (! extra_insns)
4067                 return 0;
4068
4069               start_sequence ();
4070               temp = force_operand (temp, NULL_RTX);
4071               seq = get_insns ();
4072               end_sequence ();
4073
4074               emit_insn_before (seq, object);
4075               if (! validate_change (object, loc, temp, 0)
4076                   && ! validate_replace_rtx (x, temp, object))
4077                 instantiate_virtual_regs_lossage (object);
4078             }
4079         }
4080
4081       return 1;
4082
4083     case ADDRESSOF:
4084       if (GET_CODE (XEXP (x, 0)) == REG)
4085         return 1;
4086
4087       else if (GET_CODE (XEXP (x, 0)) == MEM)
4088         {
4089           /* If we have a (addressof (mem ..)), do any instantiation inside
4090              since we know we'll be making the inside valid when we finally
4091              remove the ADDRESSOF.  */
4092           instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 0), NULL_RTX, 0);
4093           return 1;
4094         }
4095       break;
4096
4097     default:
4098       break;
4099     }
4100
4101   /* Scan all subexpressions.  */
4102   fmt = GET_RTX_FORMAT (code);
4103   for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
4104     if (*fmt == 'e')
4105       {
4106         if (!instantiate_virtual_regs_1 (&XEXP (x, i), object, extra_insns))
4107           return 0;
4108       }
4109     else if (*fmt == 'E')
4110       for (j = 0; j < XVECLEN (x, i); j++)
4111         if (! instantiate_virtual_regs_1 (&XVECEXP (x, i, j), object,
4112                                           extra_insns))
4113           return 0;
4114
4115   return 1;
4116 }
4117 \f
4118 /* Optimization: assuming this function does not receive nonlocal gotos,
4119    delete the handlers for such, as well as the insns to establish
4120    and disestablish them.  */
4121
4122 static void
4123 delete_handlers (void)
4124 {
4125   rtx insn;
4126   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4127     {
4128       /* Delete the handler by turning off the flag that would
4129          prevent jump_optimize from deleting it.
4130          Also permit deletion of the nonlocal labels themselves
4131          if nothing local refers to them.  */
4132       if (GET_CODE (insn) == CODE_LABEL)
4133         {
4134           tree t, last_t;
4135
4136           LABEL_PRESERVE_P (insn) = 0;
4137
4138           /* Remove it from the nonlocal_label list, to avoid confusing
4139              flow.  */
4140           for (t = nonlocal_labels, last_t = 0; t;
4141                last_t = t, t = TREE_CHAIN (t))
4142             if (DECL_RTL (TREE_VALUE (t)) == insn)
4143               break;
4144           if (t)
4145             {
4146               if (! last_t)
4147                 nonlocal_labels = TREE_CHAIN (nonlocal_labels);
4148               else
4149                 TREE_CHAIN (last_t) = TREE_CHAIN (t);
4150             }
4151         }
4152       if (GET_CODE (insn) == INSN)
4153         {
4154           int can_delete = 0;
4155           rtx t;
4156           for (t = nonlocal_goto_handler_slots; t != 0; t = XEXP (t, 1))
4157             if (reg_mentioned_p (t, PATTERN (insn)))
4158               {
4159                 can_delete = 1;
4160                 break;
4161               }
4162           if (can_delete
4163               || (nonlocal_goto_stack_level != 0
4164                   && reg_mentioned_p (nonlocal_goto_stack_level,
4165                                       PATTERN (insn))))
4166             delete_related_insns (insn);
4167         }
4168     }
4169 }
4170 \f
4171 /* Return the first insn following those generated by `assign_parms'.  */
4172
4173 rtx
4174 get_first_nonparm_insn (void)
4175 {
4176   if (last_parm_insn)
4177     return NEXT_INSN (last_parm_insn);
4178   return get_insns ();
4179 }
4180
4181 /* Return 1 if EXP is an aggregate type (or a value with aggregate type).
4182    This means a type for which function calls must pass an address to the
4183    function or get an address back from the function.
4184    EXP may be a type node or an expression (whose type is tested).  */
4185
4186 int
4187 aggregate_value_p (tree exp, tree fntype)
4188 {
4189   int i, regno, nregs;
4190   rtx reg;
4191
4192   tree type = (TYPE_P (exp)) ? exp : TREE_TYPE (exp);
4193
4194   if (fntype)
4195     switch (TREE_CODE (fntype))
4196       {
4197       case CALL_EXPR:
4198         fntype = get_callee_fndecl (fntype);
4199         fntype = fntype ? TREE_TYPE (fntype) : 0;
4200         break;
4201       case FUNCTION_DECL:
4202         fntype = TREE_TYPE (fntype);
4203         break;
4204       case FUNCTION_TYPE:
4205       case METHOD_TYPE:
4206         break;
4207       case IDENTIFIER_NODE:
4208         fntype = 0;
4209         break;
4210       default:
4211         /* We don't expect other rtl types here.  */
4212         abort();
4213       }
4214
4215   if (TREE_CODE (type) == VOID_TYPE)
4216     return 0;
4217   if (targetm.calls.return_in_memory (type, fntype))
4218     return 1;
4219   /* Types that are TREE_ADDRESSABLE must be constructed in memory,
4220      and thus can't be returned in registers.  */
4221   if (TREE_ADDRESSABLE (type))
4222     return 1;
4223   if (flag_pcc_struct_return && AGGREGATE_TYPE_P (type))
4224     return 1;
4225   /* Make sure we have suitable call-clobbered regs to return
4226      the value in; if not, we must return it in memory.  */
4227   reg = hard_function_value (type, 0, 0);
4228
4229   /* If we have something other than a REG (e.g. a PARALLEL), then assume
4230      it is OK.  */
4231   if (GET_CODE (reg) != REG)
4232     return 0;
4233
4234   regno = REGNO (reg);
4235   nregs = HARD_REGNO_NREGS (regno, TYPE_MODE (type));
4236   for (i = 0; i < nregs; i++)
4237     if (! call_used_regs[regno + i])
4238       return 1;
4239   return 0;
4240 }
4241 \f
4242 /* Assign RTL expressions to the function's parameters.
4243    This may involve copying them into registers and using
4244    those registers as the RTL for them.  */
4245
4246 void
4247 assign_parms (tree fndecl)
4248 {
4249   tree parm;
4250   CUMULATIVE_ARGS args_so_far;
4251   /* Total space needed so far for args on the stack,
4252      given as a constant and a tree-expression.  */
4253   struct args_size stack_args_size;
4254   tree fntype = TREE_TYPE (fndecl);
4255   tree fnargs = DECL_ARGUMENTS (fndecl), orig_fnargs;
4256   /* This is used for the arg pointer when referring to stack args.  */
4257   rtx internal_arg_pointer;
4258   /* This is a dummy PARM_DECL that we used for the function result if
4259      the function returns a structure.  */
4260   tree function_result_decl = 0;
4261   int varargs_setup = 0;
4262   int reg_parm_stack_space = 0;
4263   rtx conversion_insns = 0;
4264
4265   /* Nonzero if function takes extra anonymous args.
4266      This means the last named arg must be on the stack
4267      right before the anonymous ones.  */
4268   int stdarg
4269     = (TYPE_ARG_TYPES (fntype) != 0
4270        && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
4271            != void_type_node));
4272
4273   current_function_stdarg = stdarg;
4274
4275   /* If the reg that the virtual arg pointer will be translated into is
4276      not a fixed reg or is the stack pointer, make a copy of the virtual
4277      arg pointer, and address parms via the copy.  The frame pointer is
4278      considered fixed even though it is not marked as such.
4279
4280      The second time through, simply use ap to avoid generating rtx.  */
4281
4282   if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
4283        || ! (fixed_regs[ARG_POINTER_REGNUM]
4284              || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
4285     internal_arg_pointer = copy_to_reg (virtual_incoming_args_rtx);
4286   else
4287     internal_arg_pointer = virtual_incoming_args_rtx;
4288   current_function_internal_arg_pointer = internal_arg_pointer;
4289
4290   stack_args_size.constant = 0;
4291   stack_args_size.var = 0;
4292
4293   /* If struct value address is treated as the first argument, make it so.  */
4294   if (aggregate_value_p (DECL_RESULT (fndecl), fndecl)
4295       && ! current_function_returns_pcc_struct
4296       && targetm.calls.struct_value_rtx (TREE_TYPE (fndecl), 1) == 0)
4297     {
4298       tree type = build_pointer_type (TREE_TYPE (fntype));
4299
4300       function_result_decl = build_decl (PARM_DECL, NULL_TREE, type);
4301
4302       DECL_ARG_TYPE (function_result_decl) = type;
4303       TREE_CHAIN (function_result_decl) = fnargs;
4304       fnargs = function_result_decl;
4305     }
4306
4307   orig_fnargs = fnargs;
4308
4309   max_parm_reg = LAST_VIRTUAL_REGISTER + 1;
4310   parm_reg_stack_loc = ggc_alloc_cleared (max_parm_reg * sizeof (rtx));
4311
4312   if (SPLIT_COMPLEX_ARGS)
4313     fnargs = split_complex_args (fnargs);
4314
4315 #ifdef REG_PARM_STACK_SPACE
4316 #ifdef MAYBE_REG_PARM_STACK_SPACE
4317   reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
4318 #else
4319   reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
4320 #endif
4321 #endif
4322
4323 #ifdef INIT_CUMULATIVE_INCOMING_ARGS
4324   INIT_CUMULATIVE_INCOMING_ARGS (args_so_far, fntype, NULL_RTX);
4325 #else
4326   INIT_CUMULATIVE_ARGS (args_so_far, fntype, NULL_RTX, fndecl);
4327 #endif
4328
4329   /* We haven't yet found an argument that we must push and pretend the
4330      caller did.  */
4331   current_function_pretend_args_size = 0;
4332
4333   for (parm = fnargs; parm; parm = TREE_CHAIN (parm))
4334     {
4335       rtx entry_parm;
4336       rtx stack_parm;
4337       enum machine_mode promoted_mode, passed_mode;
4338       enum machine_mode nominal_mode, promoted_nominal_mode;
4339       int unsignedp;
4340       struct locate_and_pad_arg_data locate;
4341       int passed_pointer = 0;
4342       int did_conversion = 0;
4343       tree passed_type = DECL_ARG_TYPE (parm);
4344       tree nominal_type = TREE_TYPE (parm);
4345       int last_named = 0, named_arg;
4346       int in_regs;
4347       int partial = 0;
4348       int pretend_bytes = 0;
4349
4350       /* Set LAST_NAMED if this is last named arg before last
4351          anonymous args.  */
4352       if (stdarg)
4353         {
4354           tree tem;
4355
4356           for (tem = TREE_CHAIN (parm); tem; tem = TREE_CHAIN (tem))
4357             if (DECL_NAME (tem))
4358               break;
4359
4360           if (tem == 0)
4361             last_named = 1;
4362         }
4363       /* Set NAMED_ARG if this arg should be treated as a named arg.  For
4364          most machines, if this is a varargs/stdarg function, then we treat
4365          the last named arg as if it were anonymous too.  */
4366       named_arg = targetm.calls.strict_argument_naming (&args_so_far) ? 1 : ! last_named;
4367
4368       if (TREE_TYPE (parm) == error_mark_node
4369           /* This can happen after weird syntax errors
4370              or if an enum type is defined among the parms.  */
4371           || TREE_CODE (parm) != PARM_DECL
4372           || passed_type == NULL)
4373         {
4374           SET_DECL_RTL (parm, gen_rtx_MEM (BLKmode, const0_rtx));
4375           DECL_INCOMING_RTL (parm) = DECL_RTL (parm);
4376           TREE_USED (parm) = 1;
4377           continue;
4378         }
4379
4380       /* Find mode of arg as it is passed, and mode of arg
4381          as it should be during execution of this function.  */
4382       passed_mode = TYPE_MODE (passed_type);
4383       nominal_mode = TYPE_MODE (nominal_type);
4384
4385       /* If the parm's mode is VOID, its value doesn't matter,
4386          and avoid the usual things like emit_move_insn that could crash.  */
4387       if (nominal_mode == VOIDmode)
4388         {
4389           SET_DECL_RTL (parm, const0_rtx);
4390           DECL_INCOMING_RTL (parm) = DECL_RTL (parm);
4391           continue;
4392         }
4393
4394       /* If the parm is to be passed as a transparent union, use the
4395          type of the first field for the tests below.  We have already
4396          verified that the modes are the same.  */
4397       if (DECL_TRANSPARENT_UNION (parm)
4398           || (TREE_CODE (passed_type) == UNION_TYPE
4399               && TYPE_TRANSPARENT_UNION (passed_type)))
4400         passed_type = TREE_TYPE (TYPE_FIELDS (passed_type));
4401
4402       /* See if this arg was passed by invisible reference.  It is if
4403          it is an object whose size depends on the contents of the
4404          object itself or if the machine requires these objects be passed
4405          that way.  */
4406
4407       if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (passed_type))
4408           || TREE_ADDRESSABLE (passed_type)
4409 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
4410           || FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, passed_mode,
4411                                              passed_type, named_arg)
4412 #endif
4413           )
4414         {
4415           passed_type = nominal_type = build_pointer_type (passed_type);
4416           passed_pointer = 1;
4417           passed_mode = nominal_mode = Pmode;
4418         }
4419       /* See if the frontend wants to pass this by invisible reference.  */
4420       else if (passed_type != nominal_type
4421                && POINTER_TYPE_P (passed_type)
4422                && TREE_TYPE (passed_type) == nominal_type)
4423         {
4424           nominal_type = passed_type;
4425           passed_pointer = 1;
4426           passed_mode = nominal_mode = Pmode;
4427         }
4428
4429       promoted_mode = passed_mode;
4430
4431       if (targetm.calls.promote_function_args (TREE_TYPE (fndecl)))
4432         {
4433           /* Compute the mode in which the arg is actually extended to.  */
4434           unsignedp = TREE_UNSIGNED (passed_type);
4435           promoted_mode = promote_mode (passed_type, promoted_mode, &unsignedp, 1);
4436         }
4437
4438       /* Let machine desc say which reg (if any) the parm arrives in.
4439          0 means it arrives on the stack.  */
4440 #ifdef FUNCTION_INCOMING_ARG
4441       entry_parm = FUNCTION_INCOMING_ARG (args_so_far, promoted_mode,
4442                                           passed_type, named_arg);
4443 #else
4444       entry_parm = FUNCTION_ARG (args_so_far, promoted_mode,
4445                                  passed_type, named_arg);
4446 #endif
4447
4448       if (entry_parm == 0)
4449         promoted_mode = passed_mode;
4450
4451       /* If this is the last named parameter, do any required setup for
4452          varargs or stdargs.  We need to know about the case of this being an
4453          addressable type, in which case we skip the registers it
4454          would have arrived in.
4455
4456          For stdargs, LAST_NAMED will be set for two parameters, the one that
4457          is actually the last named, and the dummy parameter.  We only
4458          want to do this action once.
4459
4460          Also, indicate when RTL generation is to be suppressed.  */
4461       if (last_named && !varargs_setup)
4462         {
4463           int varargs_pretend_bytes = 0;
4464           targetm.calls.setup_incoming_varargs (&args_so_far, promoted_mode,
4465                                                 passed_type,
4466                                                 &varargs_pretend_bytes, 0);
4467           varargs_setup = 1;
4468
4469           /* If the back-end has requested extra stack space, record how
4470              much is needed.  Do not change pretend_args_size otherwise
4471              since it may be nonzero from an earlier partial argument.  */
4472           if (varargs_pretend_bytes > 0)
4473             current_function_pretend_args_size = varargs_pretend_bytes;
4474         }
4475
4476       /* Determine parm's home in the stack,
4477          in case it arrives in the stack or we should pretend it did.
4478
4479          Compute the stack position and rtx where the argument arrives
4480          and its size.
4481
4482          There is one complexity here:  If this was a parameter that would
4483          have been passed in registers, but wasn't only because it is
4484          __builtin_va_alist, we want locate_and_pad_parm to treat it as if
4485          it came in a register so that REG_PARM_STACK_SPACE isn't skipped.
4486          In this case, we call FUNCTION_ARG with NAMED set to 1 instead of
4487          0 as it was the previous time.  */
4488       in_regs = entry_parm != 0;
4489 #ifdef STACK_PARMS_IN_REG_PARM_AREA
4490       in_regs = 1;
4491 #endif
4492       if (!in_regs && !named_arg)
4493         {
4494           int pretend_named =
4495             targetm.calls.pretend_outgoing_varargs_named (&args_so_far);
4496           if (pretend_named)
4497             {
4498 #ifdef FUNCTION_INCOMING_ARG
4499               in_regs = FUNCTION_INCOMING_ARG (args_so_far, promoted_mode,
4500                                                passed_type,
4501                                                pretend_named) != 0;
4502 #else
4503               in_regs = FUNCTION_ARG (args_so_far, promoted_mode,
4504                                       passed_type,
4505                                       pretend_named) != 0;
4506 #endif
4507             }
4508         }
4509
4510       /* If this parameter was passed both in registers and in the stack,
4511          use the copy on the stack.  */
4512       if (MUST_PASS_IN_STACK (promoted_mode, passed_type))
4513         entry_parm = 0;
4514
4515 #ifdef FUNCTION_ARG_PARTIAL_NREGS
4516       if (entry_parm)
4517         {
4518           partial = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, promoted_mode,
4519                                                 passed_type, named_arg);
4520           if (partial
4521 #ifndef MAYBE_REG_PARM_STACK_SPACE
4522               /* The caller might already have allocated stack space
4523                  for the register parameters.  */
4524               && reg_parm_stack_space == 0
4525 #endif
4526               )
4527             {
4528               /* Part of this argument is passed in registers and part
4529                  is passed on the stack.  Ask the prologue code to extend
4530                  the stack part so that we can recreate the full value.
4531
4532                  PRETEND_BYTES is the size of the registers we need to store.
4533                  CURRENT_FUNCTION_PRETEND_ARGS_SIZE is the amount of extra
4534                  stack space that the prologue should allocate.
4535
4536                  Internally, gcc assumes that the argument pointer is
4537                  aligned to STACK_BOUNDARY bits.  This is used both for
4538                  alignment optimizations (see init_emit) and to locate
4539                  arguments that are aligned to more than PARM_BOUNDARY
4540                  bits.  We must preserve this invariant by rounding
4541                  CURRENT_FUNCTION_PRETEND_ARGS_SIZE up to a stack
4542                  boundary.  */
4543               pretend_bytes = partial * UNITS_PER_WORD;
4544               current_function_pretend_args_size
4545                 = CEIL_ROUND (pretend_bytes, STACK_BYTES);
4546
4547               /* If PRETEND_BYTES != CURRENT_FUNCTION_PRETEND_ARGS_SIZE,
4548                  insert the padding before the start of the first pretend
4549                  argument.  */
4550               stack_args_size.constant
4551                 = (current_function_pretend_args_size - pretend_bytes);
4552             }
4553         }
4554 #endif
4555
4556       memset (&locate, 0, sizeof (locate));
4557       locate_and_pad_parm (promoted_mode, passed_type, in_regs,
4558                            entry_parm ? partial : 0, fndecl,
4559                            &stack_args_size, &locate);
4560
4561       {
4562         rtx offset_rtx;
4563
4564         /* If we're passing this arg using a reg, make its stack home
4565            the aligned stack slot.  */
4566         if (entry_parm)
4567           offset_rtx = ARGS_SIZE_RTX (locate.slot_offset);
4568         else
4569           offset_rtx = ARGS_SIZE_RTX (locate.offset);
4570
4571         if (offset_rtx == const0_rtx)
4572           stack_parm = gen_rtx_MEM (promoted_mode, internal_arg_pointer);
4573         else
4574           stack_parm = gen_rtx_MEM (promoted_mode,
4575                                     gen_rtx_PLUS (Pmode,
4576                                                   internal_arg_pointer,
4577                                                   offset_rtx));
4578
4579         set_mem_attributes (stack_parm, parm, 1);
4580         if (entry_parm && MEM_ATTRS (stack_parm)->align < PARM_BOUNDARY)
4581           set_mem_align (stack_parm, PARM_BOUNDARY);
4582
4583         /* Set also REG_ATTRS if parameter was passed in a register.  */
4584         if (entry_parm)
4585           set_reg_attrs_for_parm (entry_parm, stack_parm);
4586       }
4587
4588       /* If this parm was passed part in regs and part in memory,
4589          pretend it arrived entirely in memory
4590          by pushing the register-part onto the stack.
4591
4592          In the special case of a DImode or DFmode that is split,
4593          we could put it together in a pseudoreg directly,
4594          but for now that's not worth bothering with.  */
4595
4596       if (partial)
4597         {
4598           /* Handle calls that pass values in multiple non-contiguous
4599              locations.  The Irix 6 ABI has examples of this.  */
4600           if (GET_CODE (entry_parm) == PARALLEL)
4601             emit_group_store (validize_mem (stack_parm), entry_parm,
4602                               TREE_TYPE (parm),
4603                               int_size_in_bytes (TREE_TYPE (parm)));
4604
4605           else
4606             move_block_from_reg (REGNO (entry_parm), validize_mem (stack_parm),
4607                                  partial);
4608
4609           entry_parm = stack_parm;
4610         }
4611
4612       /* If we didn't decide this parm came in a register,
4613          by default it came on the stack.  */
4614       if (entry_parm == 0)
4615         entry_parm = stack_parm;
4616
4617       /* Record permanently how this parm was passed.  */
4618       DECL_INCOMING_RTL (parm) = entry_parm;
4619
4620       /* If there is actually space on the stack for this parm,
4621          count it in stack_args_size; otherwise set stack_parm to 0
4622          to indicate there is no preallocated stack slot for the parm.  */
4623
4624       if (entry_parm == stack_parm
4625           || (GET_CODE (entry_parm) == PARALLEL
4626               && XEXP (XVECEXP (entry_parm, 0, 0), 0) == NULL_RTX)
4627 #if defined (REG_PARM_STACK_SPACE) && ! defined (MAYBE_REG_PARM_STACK_SPACE)
4628           /* On some machines, even if a parm value arrives in a register
4629              there is still an (uninitialized) stack slot allocated for it.
4630
4631              ??? When MAYBE_REG_PARM_STACK_SPACE is defined, we can't tell
4632              whether this parameter already has a stack slot allocated,
4633              because an arg block exists only if current_function_args_size
4634              is larger than some threshold, and we haven't calculated that
4635              yet.  So, for now, we just assume that stack slots never exist
4636              in this case.  */
4637           || REG_PARM_STACK_SPACE (fndecl) > 0
4638 #endif
4639           )
4640         {
4641           stack_args_size.constant += pretend_bytes + locate.size.constant;
4642           if (locate.size.var)
4643             ADD_PARM_SIZE (stack_args_size, locate.size.var);
4644         }
4645       else
4646         /* No stack slot was pushed for this parm.  */
4647         stack_parm = 0;
4648
4649       /* Update info on where next arg arrives in registers.  */
4650
4651       FUNCTION_ARG_ADVANCE (args_so_far, promoted_mode,
4652                             passed_type, named_arg);
4653
4654       /* If we can't trust the parm stack slot to be aligned enough
4655          for its ultimate type, don't use that slot after entry.
4656          We'll make another stack slot, if we need one.  */
4657       {
4658         unsigned int thisparm_boundary
4659           = FUNCTION_ARG_BOUNDARY (promoted_mode, passed_type);
4660
4661         if (GET_MODE_ALIGNMENT (nominal_mode) > thisparm_boundary)
4662           stack_parm = 0;
4663       }
4664
4665       /* If parm was passed in memory, and we need to convert it on entry,
4666          don't store it back in that same slot.  */
4667       if (entry_parm == stack_parm
4668           && nominal_mode != BLKmode && nominal_mode != passed_mode)
4669         stack_parm = 0;
4670
4671       /* When an argument is passed in multiple locations, we can't
4672          make use of this information, but we can save some copying if
4673          the whole argument is passed in a single register.  */
4674       if (GET_CODE (entry_parm) == PARALLEL
4675           && nominal_mode != BLKmode && passed_mode != BLKmode)
4676         {
4677           int i, len = XVECLEN (entry_parm, 0);
4678
4679           for (i = 0; i < len; i++)
4680             if (XEXP (XVECEXP (entry_parm, 0, i), 0) != NULL_RTX
4681                 && GET_CODE (XEXP (XVECEXP (entry_parm, 0, i), 0)) == REG
4682                 && (GET_MODE (XEXP (XVECEXP (entry_parm, 0, i), 0))
4683                     == passed_mode)
4684                 && INTVAL (XEXP (XVECEXP (entry_parm, 0, i), 1)) == 0)
4685               {
4686                 entry_parm = XEXP (XVECEXP (entry_parm, 0, i), 0);
4687                 DECL_INCOMING_RTL (parm) = entry_parm;
4688                 break;
4689               }
4690         }
4691
4692       /* ENTRY_PARM is an RTX for the parameter as it arrives,
4693          in the mode in which it arrives.
4694          STACK_PARM is an RTX for a stack slot where the parameter can live
4695          during the function (in case we want to put it there).
4696          STACK_PARM is 0 if no stack slot was pushed for it.
4697
4698          Now output code if necessary to convert ENTRY_PARM to
4699          the type in which this function declares it,
4700          and store that result in an appropriate place,
4701          which may be a pseudo reg, may be STACK_PARM,
4702          or may be a local stack slot if STACK_PARM is 0.
4703
4704          Set DECL_RTL to that place.  */
4705
4706       if (nominal_mode == BLKmode
4707 #ifdef BLOCK_REG_PADDING
4708           || (locate.where_pad == (BYTES_BIG_ENDIAN ? upward : downward)
4709               && GET_MODE_SIZE (promoted_mode) < UNITS_PER_WORD)
4710 #endif
4711           || GET_CODE (entry_parm) == PARALLEL)
4712         {
4713           /* If a BLKmode arrives in registers, copy it to a stack slot.
4714              Handle calls that pass values in multiple non-contiguous
4715              locations.  The Irix 6 ABI has examples of this.  */
4716           if (GET_CODE (entry_parm) == REG
4717               || GET_CODE (entry_parm) == PARALLEL)
4718             {
4719               int size = int_size_in_bytes (TREE_TYPE (parm));
4720               int size_stored = CEIL_ROUND (size, UNITS_PER_WORD);
4721               rtx mem;
4722
4723               /* Note that we will be storing an integral number of words.
4724                  So we have to be careful to ensure that we allocate an
4725                  integral number of words.  We do this below in the
4726                  assign_stack_local if space was not allocated in the argument
4727                  list.  If it was, this will not work if PARM_BOUNDARY is not
4728                  a multiple of BITS_PER_WORD.  It isn't clear how to fix this
4729                  if it becomes a problem.  */
4730
4731               if (stack_parm == 0)
4732                 {
4733                   stack_parm = assign_stack_local (BLKmode, size_stored, 0);
4734                   PUT_MODE (stack_parm, GET_MODE (entry_parm));
4735                   set_mem_attributes (stack_parm, parm, 1);
4736                 }
4737
4738               else if (PARM_BOUNDARY % BITS_PER_WORD != 0)
4739                 abort ();
4740
4741               mem = validize_mem (stack_parm);
4742
4743               /* Handle calls that pass values in multiple non-contiguous
4744                  locations.  The Irix 6 ABI has examples of this.  */
4745               if (GET_CODE (entry_parm) == PARALLEL)
4746                 emit_group_store (mem, entry_parm, TREE_TYPE (parm), size);
4747
4748               else if (size == 0)
4749                 ;
4750
4751               /* If SIZE is that of a mode no bigger than a word, just use
4752                  that mode's store operation.  */
4753               else if (size <= UNITS_PER_WORD)
4754                 {
4755                   enum machine_mode mode
4756                     = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
4757
4758                   if (mode != BLKmode
4759 #ifdef BLOCK_REG_PADDING
4760                       && (size == UNITS_PER_WORD
4761                           || (BLOCK_REG_PADDING (mode, TREE_TYPE (parm), 1)
4762                               != (BYTES_BIG_ENDIAN ? upward : downward)))
4763 #endif
4764                       )
4765                     {
4766                       rtx reg = gen_rtx_REG (mode, REGNO (entry_parm));
4767                       emit_move_insn (change_address (mem, mode, 0), reg);
4768                     }
4769
4770                   /* Blocks smaller than a word on a BYTES_BIG_ENDIAN
4771                      machine must be aligned to the left before storing
4772                      to memory.  Note that the previous test doesn't
4773                      handle all cases (e.g. SIZE == 3).  */
4774                   else if (size != UNITS_PER_WORD
4775 #ifdef BLOCK_REG_PADDING
4776                            && (BLOCK_REG_PADDING (mode, TREE_TYPE (parm), 1)
4777                                == downward)
4778 #else
4779                            && BYTES_BIG_ENDIAN
4780 #endif
4781                            )
4782                     {
4783                       rtx tem, x;
4784                       int by = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
4785                       rtx reg = gen_rtx_REG (word_mode, REGNO (entry_parm));
4786
4787                       x = expand_binop (word_mode, ashl_optab, reg,
4788                                         GEN_INT (by), 0, 1, OPTAB_WIDEN);
4789                       tem = change_address (mem, word_mode, 0);
4790                       emit_move_insn (tem, x);
4791                     }
4792                   else
4793                     move_block_from_reg (REGNO (entry_parm), mem,
4794                                          size_stored / UNITS_PER_WORD);
4795                 }
4796               else
4797                 move_block_from_reg (REGNO (entry_parm), mem,
4798                                      size_stored / UNITS_PER_WORD);
4799             }
4800           SET_DECL_RTL (parm, stack_parm);
4801         }
4802       else if (! ((! optimize
4803                    && ! DECL_REGISTER (parm))
4804                   || TREE_SIDE_EFFECTS (parm)
4805                   /* If -ffloat-store specified, don't put explicit
4806                      float variables into registers.  */
4807                   || (flag_float_store
4808                       && TREE_CODE (TREE_TYPE (parm)) == REAL_TYPE))
4809                /* Always assign pseudo to structure return or item passed
4810                   by invisible reference.  */
4811                || passed_pointer || parm == function_result_decl)
4812         {
4813           /* Store the parm in a pseudoregister during the function, but we
4814              may need to do it in a wider mode.  */
4815
4816           rtx parmreg;
4817           unsigned int regno, regnoi = 0, regnor = 0;
4818
4819           unsignedp = TREE_UNSIGNED (TREE_TYPE (parm));
4820
4821           promoted_nominal_mode
4822             = promote_mode (TREE_TYPE (parm), nominal_mode, &unsignedp, 0);
4823
4824           parmreg = gen_reg_rtx (promoted_nominal_mode);
4825           mark_user_reg (parmreg);
4826
4827           /* If this was an item that we received a pointer to, set DECL_RTL
4828              appropriately.  */
4829           if (passed_pointer)
4830             {
4831               rtx x = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (passed_type)),
4832                                    parmreg);
4833               set_mem_attributes (x, parm, 1);
4834               SET_DECL_RTL (parm, x);
4835             }
4836           else
4837             {
4838               SET_DECL_RTL (parm, parmreg);
4839               maybe_set_unchanging (DECL_RTL (parm), parm);
4840             }
4841
4842           /* Copy the value into the register.  */
4843           if (nominal_mode != passed_mode
4844               || promoted_nominal_mode != promoted_mode)
4845             {
4846               int save_tree_used;
4847               /* ENTRY_PARM has been converted to PROMOTED_MODE, its
4848                  mode, by the caller.  We now have to convert it to
4849                  NOMINAL_MODE, if different.  However, PARMREG may be in
4850                  a different mode than NOMINAL_MODE if it is being stored
4851                  promoted.
4852
4853                  If ENTRY_PARM is a hard register, it might be in a register
4854                  not valid for operating in its mode (e.g., an odd-numbered
4855                  register for a DFmode).  In that case, moves are the only
4856                  thing valid, so we can't do a convert from there.  This
4857                  occurs when the calling sequence allow such misaligned
4858                  usages.
4859
4860                  In addition, the conversion may involve a call, which could
4861                  clobber parameters which haven't been copied to pseudo
4862                  registers yet.  Therefore, we must first copy the parm to
4863                  a pseudo reg here, and save the conversion until after all
4864                  parameters have been moved.  */
4865
4866               rtx tempreg = gen_reg_rtx (GET_MODE (entry_parm));
4867
4868               emit_move_insn (tempreg, validize_mem (entry_parm));
4869
4870               push_to_sequence (conversion_insns);
4871               tempreg = convert_to_mode (nominal_mode, tempreg, unsignedp);
4872
4873               if (GET_CODE (tempreg) == SUBREG
4874                   && GET_MODE (tempreg) == nominal_mode
4875                   && GET_CODE (SUBREG_REG (tempreg)) == REG
4876                   && nominal_mode == passed_mode
4877                   && GET_MODE (SUBREG_REG (tempreg)) == GET_MODE (entry_parm)
4878                   && GET_MODE_SIZE (GET_MODE (tempreg))
4879                      < GET_MODE_SIZE (GET_MODE (entry_parm)))
4880                 {
4881                   /* The argument is already sign/zero extended, so note it
4882                      into the subreg.  */
4883                   SUBREG_PROMOTED_VAR_P (tempreg) = 1;
4884                   SUBREG_PROMOTED_UNSIGNED_SET (tempreg, unsignedp);
4885                 }
4886
4887               /* TREE_USED gets set erroneously during expand_assignment.  */
4888               save_tree_used = TREE_USED (parm);
4889               expand_assignment (parm,
4890                                  make_tree (nominal_type, tempreg), 0);
4891               TREE_USED (parm) = save_tree_used;
4892               conversion_insns = get_insns ();
4893               did_conversion = 1;
4894               end_sequence ();
4895             }
4896           else
4897             emit_move_insn (parmreg, validize_mem (entry_parm));
4898
4899           /* If we were passed a pointer but the actual value
4900              can safely live in a register, put it in one.  */
4901           if (passed_pointer && TYPE_MODE (TREE_TYPE (parm)) != BLKmode
4902               /* If by-reference argument was promoted, demote it.  */
4903               && (TYPE_MODE (TREE_TYPE (parm)) != GET_MODE (DECL_RTL (parm))
4904                   || ! ((! optimize
4905                          && ! DECL_REGISTER (parm))
4906                         || TREE_SIDE_EFFECTS (parm)
4907                         /* If -ffloat-store specified, don't put explicit
4908                            float variables into registers.  */
4909                         || (flag_float_store
4910                             && TREE_CODE (TREE_TYPE (parm)) == REAL_TYPE))))
4911             {
4912               /* We can't use nominal_mode, because it will have been set to
4913                  Pmode above.  We must use the actual mode of the parm.  */
4914               parmreg = gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm)));
4915               mark_user_reg (parmreg);
4916               if (GET_MODE (parmreg) != GET_MODE (DECL_RTL (parm)))
4917                 {
4918                   rtx tempreg = gen_reg_rtx (GET_MODE (DECL_RTL (parm)));
4919                   int unsigned_p = TREE_UNSIGNED (TREE_TYPE (parm));
4920                   push_to_sequence (conversion_insns);
4921                   emit_move_insn (tempreg, DECL_RTL (parm));
4922                   SET_DECL_RTL (parm,
4923                                 convert_to_mode (GET_MODE (parmreg),
4924                                                  tempreg,
4925                                                  unsigned_p));
4926                   emit_move_insn (parmreg, DECL_RTL (parm));
4927                   conversion_insns = get_insns();
4928                   did_conversion = 1;
4929                   end_sequence ();
4930                 }
4931               else
4932                 emit_move_insn (parmreg, DECL_RTL (parm));
4933               SET_DECL_RTL (parm, parmreg);
4934               /* STACK_PARM is the pointer, not the parm, and PARMREG is
4935                  now the parm.  */
4936               stack_parm = 0;
4937             }
4938 #ifdef FUNCTION_ARG_CALLEE_COPIES
4939           /* If we are passed an arg by reference and it is our responsibility
4940              to make a copy, do it now.
4941              PASSED_TYPE and PASSED mode now refer to the pointer, not the
4942              original argument, so we must recreate them in the call to
4943              FUNCTION_ARG_CALLEE_COPIES.  */
4944           /* ??? Later add code to handle the case that if the argument isn't
4945              modified, don't do the copy.  */
4946
4947           else if (passed_pointer
4948                    && FUNCTION_ARG_CALLEE_COPIES (args_so_far,
4949                                                   TYPE_MODE (DECL_ARG_TYPE (parm)),
4950                                                   DECL_ARG_TYPE (parm),
4951                                                   named_arg)
4952                    && ! TREE_ADDRESSABLE (DECL_ARG_TYPE (parm)))
4953             {
4954               rtx copy;
4955               tree type = DECL_ARG_TYPE (parm);
4956
4957               /* This sequence may involve a library call perhaps clobbering
4958                  registers that haven't been copied to pseudos yet.  */
4959
4960               push_to_sequence (conversion_insns);
4961
4962               if (!COMPLETE_TYPE_P (type)
4963                   || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4964                 /* This is a variable sized object.  */
4965                 copy = gen_rtx_MEM (BLKmode,
4966                                     allocate_dynamic_stack_space
4967                                     (expr_size (parm), NULL_RTX,
4968                                      TYPE_ALIGN (type)));
4969               else
4970                 copy = assign_stack_temp (TYPE_MODE (type),
4971                                           int_size_in_bytes (type), 1);
4972               set_mem_attributes (copy, parm, 1);
4973
4974               store_expr (parm, copy, 0);
4975               emit_move_insn (parmreg, XEXP (copy, 0));
4976               conversion_insns = get_insns ();
4977               did_conversion = 1;
4978               end_sequence ();
4979             }
4980 #endif /* FUNCTION_ARG_CALLEE_COPIES */
4981
4982           /* In any case, record the parm's desired stack location
4983              in case we later discover it must live in the stack.
4984
4985              If it is a COMPLEX value, store the stack location for both
4986              halves.  */
4987
4988           if (GET_CODE (parmreg) == CONCAT)
4989             regno = MAX (REGNO (XEXP (parmreg, 0)), REGNO (XEXP (parmreg, 1)));
4990           else
4991             regno = REGNO (parmreg);
4992
4993           if (regno >= max_parm_reg)
4994             {
4995               rtx *new;
4996               int old_max_parm_reg = max_parm_reg;
4997
4998               /* It's slow to expand this one register at a time,
4999                  but it's also rare and we need max_parm_reg to be
5000                  precisely correct.  */
5001               max_parm_reg = regno + 1;
5002               new = ggc_realloc (parm_reg_stack_loc,
5003                                  max_parm_reg * sizeof (rtx));
5004               memset (new + old_max_parm_reg, 0,
5005                       (max_parm_reg - old_max_parm_reg) * sizeof (rtx));
5006               parm_reg_stack_loc = new;
5007             }
5008
5009           if (GET_CODE (parmreg) == CONCAT)
5010             {
5011               enum machine_mode submode = GET_MODE (XEXP (parmreg, 0));
5012
5013               regnor = REGNO (gen_realpart (submode, parmreg));
5014               regnoi = REGNO (gen_imagpart (submode, parmreg));
5015
5016               if (stack_parm != 0)
5017                 {
5018                   parm_reg_stack_loc[regnor]
5019                     = gen_realpart (submode, stack_parm);
5020                   parm_reg_stack_loc[regnoi]
5021                     = gen_imagpart (submode, stack_parm);
5022                 }
5023               else
5024                 {
5025                   parm_reg_stack_loc[regnor] = 0;
5026                   parm_reg_stack_loc[regnoi] = 0;
5027                 }
5028             }
5029           else
5030             parm_reg_stack_loc[REGNO (parmreg)] = stack_parm;
5031
5032           /* Mark the register as eliminable if we did no conversion
5033              and it was copied from memory at a fixed offset,
5034              and the arg pointer was not copied to a pseudo-reg.
5035              If the arg pointer is a pseudo reg or the offset formed
5036              an invalid address, such memory-equivalences
5037              as we make here would screw up life analysis for it.  */
5038           if (nominal_mode == passed_mode
5039               && ! did_conversion
5040               && stack_parm != 0
5041               && GET_CODE (stack_parm) == MEM
5042               && locate.offset.var == 0
5043               && reg_mentioned_p (virtual_incoming_args_rtx,
5044                                   XEXP (stack_parm, 0)))
5045             {
5046               rtx linsn = get_last_insn ();
5047               rtx sinsn, set;
5048
5049               /* Mark complex types separately.  */
5050               if (GET_CODE (parmreg) == CONCAT)
5051                 /* Scan backwards for the set of the real and
5052                    imaginary parts.  */
5053                 for (sinsn = linsn; sinsn != 0;
5054                      sinsn = prev_nonnote_insn (sinsn))
5055                   {
5056                     set = single_set (sinsn);
5057                     if (set != 0
5058                         && SET_DEST (set) == regno_reg_rtx [regnoi])
5059                       REG_NOTES (sinsn)
5060                         = gen_rtx_EXPR_LIST (REG_EQUIV,
5061                                              parm_reg_stack_loc[regnoi],
5062                                              REG_NOTES (sinsn));
5063                     else if (set != 0
5064                              && SET_DEST (set) == regno_reg_rtx [regnor])
5065                       REG_NOTES (sinsn)
5066                         = gen_rtx_EXPR_LIST (REG_EQUIV,
5067                                              parm_reg_stack_loc[regnor],
5068                                              REG_NOTES (sinsn));
5069                   }
5070               else if ((set = single_set (linsn)) != 0
5071                        && SET_DEST (set) == parmreg)
5072                 REG_NOTES (linsn)
5073                   = gen_rtx_EXPR_LIST (REG_EQUIV,
5074                                        stack_parm, REG_NOTES (linsn));
5075             }
5076
5077           /* For pointer data type, suggest pointer register.  */
5078           if (POINTER_TYPE_P (TREE_TYPE (parm)))
5079             mark_reg_pointer (parmreg,
5080                               TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm))));
5081
5082           /* If something wants our address, try to use ADDRESSOF.  */
5083           if (TREE_ADDRESSABLE (parm))
5084             {
5085               /* If we end up putting something into the stack,
5086                  fixup_var_refs_insns will need to make a pass over
5087                  all the instructions.  It looks through the pending
5088                  sequences -- but it can't see the ones in the
5089                  CONVERSION_INSNS, if they're not on the sequence
5090                  stack.  So, we go back to that sequence, just so that
5091                  the fixups will happen.  */
5092               push_to_sequence (conversion_insns);
5093               put_var_into_stack (parm, /*rescan=*/true);
5094               conversion_insns = get_insns ();
5095               end_sequence ();
5096             }
5097         }
5098       else
5099         {
5100           /* Value must be stored in the stack slot STACK_PARM
5101              during function execution.  */
5102
5103           if (promoted_mode != nominal_mode)
5104             {
5105               /* Conversion is required.  */
5106               rtx tempreg = gen_reg_rtx (GET_MODE (entry_parm));
5107
5108               emit_move_insn (tempreg, validize_mem (entry_parm));
5109
5110               push_to_sequence (conversion_insns);
5111               entry_parm = convert_to_mode (nominal_mode, tempreg,
5112                                             TREE_UNSIGNED (TREE_TYPE (parm)));
5113               if (stack_parm)
5114                 /* ??? This may need a big-endian conversion on sparc64.  */
5115                 stack_parm = adjust_address (stack_parm, nominal_mode, 0);
5116
5117               conversion_insns = get_insns ();
5118               did_conversion = 1;
5119               end_sequence ();
5120             }
5121
5122           if (entry_parm != stack_parm)
5123             {
5124               if (stack_parm == 0)
5125                 {
5126                   stack_parm
5127                     = assign_stack_local (GET_MODE (entry_parm),
5128                                           GET_MODE_SIZE (GET_MODE (entry_parm)),
5129                                           0);
5130                   set_mem_attributes (stack_parm, parm, 1);
5131                 }
5132
5133               if (promoted_mode != nominal_mode)
5134                 {
5135                   push_to_sequence (conversion_insns);
5136                   emit_move_insn (validize_mem (stack_parm),
5137                                   validize_mem (entry_parm));
5138                   conversion_insns = get_insns ();
5139                   end_sequence ();
5140                 }
5141               else
5142                 emit_move_insn (validize_mem (stack_parm),
5143                                 validize_mem (entry_parm));
5144             }
5145
5146           SET_DECL_RTL (parm, stack_parm);
5147         }
5148     }
5149
5150   if (SPLIT_COMPLEX_ARGS && fnargs != orig_fnargs)
5151     {
5152       for (parm = orig_fnargs; parm; parm = TREE_CHAIN (parm))
5153         {
5154           if (TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE)
5155             {
5156               SET_DECL_RTL (parm,
5157                             gen_rtx_CONCAT (DECL_MODE (parm),
5158                                             DECL_RTL (fnargs),
5159                                             DECL_RTL (TREE_CHAIN (fnargs))));
5160               DECL_INCOMING_RTL (parm)
5161                 = gen_rtx_CONCAT (DECL_MODE (parm),
5162                                   DECL_INCOMING_RTL (fnargs),
5163                                   DECL_INCOMING_RTL (TREE_CHAIN (fnargs)));
5164               fnargs = TREE_CHAIN (fnargs);
5165             }
5166           else
5167             {
5168               SET_DECL_RTL (parm, DECL_RTL (fnargs));
5169               DECL_INCOMING_RTL (parm) = DECL_INCOMING_RTL (fnargs);
5170             }
5171           fnargs = TREE_CHAIN (fnargs);
5172         }
5173     }
5174
5175   /* Output all parameter conversion instructions (possibly including calls)
5176      now that all parameters have been copied out of hard registers.  */
5177   emit_insn (conversion_insns);
5178
5179   /* If we are receiving a struct value address as the first argument, set up
5180      the RTL for the function result. As this might require code to convert
5181      the transmitted address to Pmode, we do this here to ensure that possible
5182      preliminary conversions of the address have been emitted already.  */
5183   if (function_result_decl)
5184     {
5185       tree result = DECL_RESULT (fndecl);
5186       rtx addr = DECL_RTL (function_result_decl);
5187       rtx x;
5188
5189       addr = convert_memory_address (Pmode, addr);
5190       x = gen_rtx_MEM (DECL_MODE (result), addr);
5191       set_mem_attributes (x, result, 1);
5192       SET_DECL_RTL (result, x);
5193     }
5194
5195   last_parm_insn = get_last_insn ();
5196
5197   current_function_args_size = stack_args_size.constant;
5198
5199   /* Adjust function incoming argument size for alignment and
5200      minimum length.  */
5201
5202 #ifdef REG_PARM_STACK_SPACE
5203 #ifndef MAYBE_REG_PARM_STACK_SPACE
5204   current_function_args_size = MAX (current_function_args_size,
5205                                     REG_PARM_STACK_SPACE (fndecl));
5206 #endif
5207 #endif
5208
5209   current_function_args_size
5210     = ((current_function_args_size + STACK_BYTES - 1)
5211        / STACK_BYTES) * STACK_BYTES;
5212
5213 #ifdef ARGS_GROW_DOWNWARD
5214   current_function_arg_offset_rtx
5215     = (stack_args_size.var == 0 ? GEN_INT (-stack_args_size.constant)
5216        : expand_expr (size_diffop (stack_args_size.var,
5217                                    size_int (-stack_args_size.constant)),
5218                       NULL_RTX, VOIDmode, 0));
5219 #else
5220   current_function_arg_offset_rtx = ARGS_SIZE_RTX (stack_args_size);
5221 #endif
5222
5223   /* See how many bytes, if any, of its args a function should try to pop
5224      on return.  */
5225
5226   current_function_pops_args = RETURN_POPS_ARGS (fndecl, TREE_TYPE (fndecl),
5227                                                  current_function_args_size);
5228
5229   /* For stdarg.h function, save info about
5230      regs and stack space used by the named args.  */
5231
5232   current_function_args_info = args_so_far;
5233
5234   /* Set the rtx used for the function return value.  Put this in its
5235      own variable so any optimizers that need this information don't have
5236      to include tree.h.  Do this here so it gets done when an inlined
5237      function gets output.  */
5238
5239   current_function_return_rtx
5240     = (DECL_RTL_SET_P (DECL_RESULT (fndecl))
5241        ? DECL_RTL (DECL_RESULT (fndecl)) : NULL_RTX);
5242
5243   /* If scalar return value was computed in a pseudo-reg, or was a named
5244      return value that got dumped to the stack, copy that to the hard
5245      return register.  */
5246   if (DECL_RTL_SET_P (DECL_RESULT (fndecl)))
5247     {
5248       tree decl_result = DECL_RESULT (fndecl);
5249       rtx decl_rtl = DECL_RTL (decl_result);
5250
5251       if (REG_P (decl_rtl)
5252           ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER
5253           : DECL_REGISTER (decl_result))
5254         {
5255           rtx real_decl_rtl;
5256
5257 #ifdef FUNCTION_OUTGOING_VALUE
5258           real_decl_rtl = FUNCTION_OUTGOING_VALUE (TREE_TYPE (decl_result),
5259                                                    fndecl);
5260 #else
5261           real_decl_rtl = FUNCTION_VALUE (TREE_TYPE (decl_result),
5262                                           fndecl);
5263 #endif
5264           REG_FUNCTION_VALUE_P (real_decl_rtl) = 1;
5265           /* The delay slot scheduler assumes that current_function_return_rtx
5266              holds the hard register containing the return value, not a
5267              temporary pseudo.  */
5268           current_function_return_rtx = real_decl_rtl;
5269         }
5270     }
5271 }
5272
5273 /* If ARGS contains entries with complex types, split the entry into two
5274    entries of the component type.  Return a new list of substitutions are
5275    needed, else the old list.  */
5276
5277 static tree
5278 split_complex_args (tree args)
5279 {
5280   tree p;
5281
5282   /* Before allocating memory, check for the common case of no complex.  */
5283   for (p = args; p; p = TREE_CHAIN (p))
5284     if (TREE_CODE (TREE_TYPE (p)) == COMPLEX_TYPE)
5285       goto found;
5286   return args;
5287
5288  found:
5289   args = copy_list (args);
5290
5291   for (p = args; p; p = TREE_CHAIN (p))
5292     {
5293       tree type = TREE_TYPE (p);
5294       if (TREE_CODE (type) == COMPLEX_TYPE)
5295         {
5296           tree decl;
5297           tree subtype = TREE_TYPE (type);
5298
5299           /* Rewrite the PARM_DECL's type with its component.  */
5300           TREE_TYPE (p) = subtype;
5301           DECL_ARG_TYPE (p) = TREE_TYPE (DECL_ARG_TYPE (p));
5302           DECL_MODE (p) = VOIDmode;
5303           DECL_SIZE (p) = NULL;
5304           DECL_SIZE_UNIT (p) = NULL;
5305           layout_decl (p, 0);
5306
5307           /* Build a second synthetic decl.  */
5308           decl = build_decl (PARM_DECL, NULL_TREE, subtype);
5309           DECL_ARG_TYPE (decl) = DECL_ARG_TYPE (p);
5310           layout_decl (decl, 0);
5311
5312           /* Splice it in; skip the new decl.  */
5313           TREE_CHAIN (decl) = TREE_CHAIN (p);
5314           TREE_CHAIN (p) = decl;
5315           p = decl;
5316         }
5317     }
5318
5319   return args;
5320 }
5321 \f
5322 /* Indicate whether REGNO is an incoming argument to the current function
5323    that was promoted to a wider mode.  If so, return the RTX for the
5324    register (to get its mode).  PMODE and PUNSIGNEDP are set to the mode
5325    that REGNO is promoted from and whether the promotion was signed or
5326    unsigned.  */
5327
5328 rtx
5329 promoted_input_arg (unsigned int regno, enum machine_mode *pmode, int *punsignedp)
5330 {
5331   tree arg;
5332
5333   for (arg = DECL_ARGUMENTS (current_function_decl); arg;
5334        arg = TREE_CHAIN (arg))
5335     if (GET_CODE (DECL_INCOMING_RTL (arg)) == REG
5336         && REGNO (DECL_INCOMING_RTL (arg)) == regno
5337         && TYPE_MODE (DECL_ARG_TYPE (arg)) == TYPE_MODE (TREE_TYPE (arg)))
5338       {
5339         enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg));
5340         int unsignedp = TREE_UNSIGNED (TREE_TYPE (arg));
5341
5342         mode = promote_mode (TREE_TYPE (arg), mode, &unsignedp, 1);
5343         if (mode == GET_MODE (DECL_INCOMING_RTL (arg))
5344             && mode != DECL_MODE (arg))
5345           {
5346             *pmode = DECL_MODE (arg);
5347             *punsignedp = unsignedp;
5348             return DECL_INCOMING_RTL (arg);
5349           }
5350       }
5351
5352   return 0;
5353 }
5354
5355 \f
5356 /* Compute the size and offset from the start of the stacked arguments for a
5357    parm passed in mode PASSED_MODE and with type TYPE.
5358
5359    INITIAL_OFFSET_PTR points to the current offset into the stacked
5360    arguments.
5361
5362    The starting offset and size for this parm are returned in
5363    LOCATE->OFFSET and LOCATE->SIZE, respectively.  When IN_REGS is
5364    nonzero, the offset is that of stack slot, which is returned in
5365    LOCATE->SLOT_OFFSET.  LOCATE->ALIGNMENT_PAD is the amount of
5366    padding required from the initial offset ptr to the stack slot.
5367
5368    IN_REGS is nonzero if the argument will be passed in registers.  It will
5369    never be set if REG_PARM_STACK_SPACE is not defined.
5370
5371    FNDECL is the function in which the argument was defined.
5372
5373    There are two types of rounding that are done.  The first, controlled by
5374    FUNCTION_ARG_BOUNDARY, forces the offset from the start of the argument
5375    list to be aligned to the specific boundary (in bits).  This rounding
5376    affects the initial and starting offsets, but not the argument size.
5377
5378    The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY,
5379    optionally rounds the size of the parm to PARM_BOUNDARY.  The
5380    initial offset is not affected by this rounding, while the size always
5381    is and the starting offset may be.  */
5382
5383 /*  LOCATE->OFFSET will be negative for ARGS_GROW_DOWNWARD case;
5384     INITIAL_OFFSET_PTR is positive because locate_and_pad_parm's
5385     callers pass in the total size of args so far as
5386     INITIAL_OFFSET_PTR.  LOCATE->SIZE is always positive.  */
5387
5388 void
5389 locate_and_pad_parm (enum machine_mode passed_mode, tree type, int in_regs,
5390                      int partial, tree fndecl ATTRIBUTE_UNUSED,
5391                      struct args_size *initial_offset_ptr,
5392                      struct locate_and_pad_arg_data *locate)
5393 {
5394   tree sizetree;
5395   enum direction where_pad;
5396   int boundary;
5397   int reg_parm_stack_space = 0;
5398   int part_size_in_regs;
5399
5400 #ifdef REG_PARM_STACK_SPACE
5401 #ifdef MAYBE_REG_PARM_STACK_SPACE
5402   reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
5403 #else
5404   reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
5405 #endif
5406
5407   /* If we have found a stack parm before we reach the end of the
5408      area reserved for registers, skip that area.  */
5409   if (! in_regs)
5410     {
5411       if (reg_parm_stack_space > 0)
5412         {
5413           if (initial_offset_ptr->var)
5414             {
5415               initial_offset_ptr->var
5416                 = size_binop (MAX_EXPR, ARGS_SIZE_TREE (*initial_offset_ptr),
5417                               ssize_int (reg_parm_stack_space));
5418               initial_offset_ptr->constant = 0;
5419             }
5420           else if (initial_offset_ptr->constant < reg_parm_stack_space)
5421             initial_offset_ptr->constant = reg_parm_stack_space;
5422         }
5423     }
5424 #endif /* REG_PARM_STACK_SPACE */
5425
5426   part_size_in_regs = 0;
5427   if (reg_parm_stack_space == 0)
5428     part_size_in_regs = ((partial * UNITS_PER_WORD)
5429                          / (PARM_BOUNDARY / BITS_PER_UNIT)
5430                          * (PARM_BOUNDARY / BITS_PER_UNIT));
5431
5432   sizetree
5433     = type ? size_in_bytes (type) : size_int (GET_MODE_SIZE (passed_mode));
5434   where_pad = FUNCTION_ARG_PADDING (passed_mode, type);
5435   boundary = FUNCTION_ARG_BOUNDARY (passed_mode, type);
5436   locate->where_pad = where_pad;
5437
5438 #ifdef ARGS_GROW_DOWNWARD
5439   locate->slot_offset.constant = -initial_offset_ptr->constant;
5440   if (initial_offset_ptr->var)
5441     locate->slot_offset.var = size_binop (MINUS_EXPR, ssize_int (0),
5442                                           initial_offset_ptr->var);
5443
5444   {
5445     tree s2 = sizetree;
5446     if (where_pad != none
5447         && (!host_integerp (sizetree, 1)
5448             || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % PARM_BOUNDARY))
5449       s2 = round_up (s2, PARM_BOUNDARY / BITS_PER_UNIT);
5450     SUB_PARM_SIZE (locate->slot_offset, s2);
5451   }
5452
5453   locate->slot_offset.constant += part_size_in_regs;
5454
5455   if (!in_regs
5456 #ifdef REG_PARM_STACK_SPACE
5457       || REG_PARM_STACK_SPACE (fndecl) > 0
5458 #endif
5459      )
5460     pad_to_arg_alignment (&locate->slot_offset, boundary,
5461                           &locate->alignment_pad);
5462
5463   locate->size.constant = (-initial_offset_ptr->constant
5464                            - locate->slot_offset.constant);
5465   if (initial_offset_ptr->var)
5466     locate->size.var = size_binop (MINUS_EXPR,
5467                                    size_binop (MINUS_EXPR,
5468                                                ssize_int (0),
5469                                                initial_offset_ptr->var),
5470                                    locate->slot_offset.var);
5471
5472   /* Pad_below needs the pre-rounded size to know how much to pad
5473      below.  */
5474   locate->offset = locate->slot_offset;
5475   if (where_pad == downward)
5476     pad_below (&locate->offset, passed_mode, sizetree);
5477
5478 #else /* !ARGS_GROW_DOWNWARD */
5479   if (!in_regs
5480 #ifdef REG_PARM_STACK_SPACE
5481       || REG_PARM_STACK_SPACE (fndecl) > 0
5482 #endif
5483       )
5484     pad_to_arg_alignment (initial_offset_ptr, boundary,
5485                           &locate->alignment_pad);
5486   locate->slot_offset = *initial_offset_ptr;
5487
5488 #ifdef PUSH_ROUNDING
5489   if (passed_mode != BLKmode)
5490     sizetree = size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree)));
5491 #endif
5492
5493   /* Pad_below needs the pre-rounded size to know how much to pad below
5494      so this must be done before rounding up.  */
5495   locate->offset = locate->slot_offset;
5496   if (where_pad == downward)
5497     pad_below (&locate->offset, passed_mode, sizetree);
5498
5499   if (where_pad != none
5500       && (!host_integerp (sizetree, 1)
5501           || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % PARM_BOUNDARY))
5502     sizetree = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT);
5503
5504   ADD_PARM_SIZE (locate->size, sizetree);
5505
5506   locate->size.constant -= part_size_in_regs;
5507 #endif /* ARGS_GROW_DOWNWARD */
5508 }
5509
5510 /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY.
5511    BOUNDARY is measured in bits, but must be a multiple of a storage unit.  */
5512
5513 static void
5514 pad_to_arg_alignment (struct args_size *offset_ptr, int boundary,
5515                       struct args_size *alignment_pad)
5516 {
5517   tree save_var = NULL_TREE;
5518   HOST_WIDE_INT save_constant = 0;
5519   int boundary_in_bytes = boundary / BITS_PER_UNIT;
5520   HOST_WIDE_INT sp_offset = STACK_POINTER_OFFSET;
5521
5522 #ifdef SPARC_STACK_BOUNDARY_HACK
5523   /* The sparc port has a bug.  It sometimes claims a STACK_BOUNDARY
5524      higher than the real alignment of %sp.  However, when it does this,
5525      the alignment of %sp+STACK_POINTER_OFFSET will be STACK_BOUNDARY.
5526      This is a temporary hack while the sparc port is fixed.  */
5527   if (SPARC_STACK_BOUNDARY_HACK)
5528     sp_offset = 0;
5529 #endif
5530
5531   if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
5532     {
5533       save_var = offset_ptr->var;
5534       save_constant = offset_ptr->constant;
5535     }
5536
5537   alignment_pad->var = NULL_TREE;
5538   alignment_pad->constant = 0;
5539
5540   if (boundary > BITS_PER_UNIT)
5541     {
5542       if (offset_ptr->var)
5543         {
5544           tree sp_offset_tree = ssize_int (sp_offset);
5545           tree offset = size_binop (PLUS_EXPR,
5546                                     ARGS_SIZE_TREE (*offset_ptr),
5547                                     sp_offset_tree);
5548 #ifdef ARGS_GROW_DOWNWARD
5549           tree rounded = round_down (offset, boundary / BITS_PER_UNIT);
5550 #else
5551           tree rounded = round_up   (offset, boundary / BITS_PER_UNIT);
5552 #endif
5553
5554           offset_ptr->var = size_binop (MINUS_EXPR, rounded, sp_offset_tree);
5555           /* ARGS_SIZE_TREE includes constant term.  */
5556           offset_ptr->constant = 0;
5557           if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
5558             alignment_pad->var = size_binop (MINUS_EXPR, offset_ptr->var,
5559                                              save_var);
5560         }
5561       else
5562         {
5563           offset_ptr->constant = -sp_offset +
5564 #ifdef ARGS_GROW_DOWNWARD
5565             FLOOR_ROUND (offset_ptr->constant + sp_offset, boundary_in_bytes);
5566 #else
5567             CEIL_ROUND (offset_ptr->constant + sp_offset, boundary_in_bytes);
5568 #endif
5569             if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
5570               alignment_pad->constant = offset_ptr->constant - save_constant;
5571         }
5572     }
5573 }
5574
5575 static void
5576 pad_below (struct args_size *offset_ptr, enum machine_mode passed_mode, tree sizetree)
5577 {
5578   if (passed_mode != BLKmode)
5579     {
5580       if (GET_MODE_BITSIZE (passed_mode) % PARM_BOUNDARY)
5581         offset_ptr->constant
5582           += (((GET_MODE_BITSIZE (passed_mode) + PARM_BOUNDARY - 1)
5583                / PARM_BOUNDARY * PARM_BOUNDARY / BITS_PER_UNIT)
5584               - GET_MODE_SIZE (passed_mode));
5585     }
5586   else
5587     {
5588       if (TREE_CODE (sizetree) != INTEGER_CST
5589           || (TREE_INT_CST_LOW (sizetree) * BITS_PER_UNIT) % PARM_BOUNDARY)
5590         {
5591           /* Round the size up to multiple of PARM_BOUNDARY bits.  */
5592           tree s2 = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT);
5593           /* Add it in.  */
5594           ADD_PARM_SIZE (*offset_ptr, s2);
5595           SUB_PARM_SIZE (*offset_ptr, sizetree);
5596         }
5597     }
5598 }
5599 \f
5600 /* Walk the tree of blocks describing the binding levels within a function
5601    and warn about uninitialized variables.
5602    This is done after calling flow_analysis and before global_alloc
5603    clobbers the pseudo-regs to hard regs.  */
5604
5605 void
5606 uninitialized_vars_warning (tree block)
5607 {
5608   tree decl, sub;
5609   for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
5610     {
5611       if (warn_uninitialized
5612           && TREE_CODE (decl) == VAR_DECL
5613           /* These warnings are unreliable for and aggregates
5614              because assigning the fields one by one can fail to convince
5615              flow.c that the entire aggregate was initialized.
5616              Unions are troublesome because members may be shorter.  */
5617           && ! AGGREGATE_TYPE_P (TREE_TYPE (decl))
5618           && DECL_RTL (decl) != 0
5619           && GET_CODE (DECL_RTL (decl)) == REG
5620           /* Global optimizations can make it difficult to determine if a
5621              particular variable has been initialized.  However, a VAR_DECL
5622              with a nonzero DECL_INITIAL had an initializer, so do not
5623              claim it is potentially uninitialized.
5624
5625              When the DECL_INITIAL is NULL call the language hook to tell us
5626              if we want to warn.  */
5627           && (DECL_INITIAL (decl) == NULL_TREE || lang_hooks.decl_uninit (decl))
5628           && regno_uninitialized (REGNO (DECL_RTL (decl))))
5629         warning ("%J'%D' might be used uninitialized in this function",
5630                  decl, decl);
5631       if (extra_warnings
5632           && TREE_CODE (decl) == VAR_DECL
5633           && DECL_RTL (decl) != 0
5634           && GET_CODE (DECL_RTL (decl)) == REG
5635           && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl))))
5636         warning ("%Jvariable '%D' might be clobbered by `longjmp' or `vfork'",
5637                  decl, decl);
5638     }
5639   for (sub = BLOCK_SUBBLOCKS (block); sub; sub = TREE_CHAIN (sub))
5640     uninitialized_vars_warning (sub);
5641 }
5642
5643 /* Do the appropriate part of uninitialized_vars_warning
5644    but for arguments instead of local variables.  */
5645
5646 void
5647 setjmp_args_warning (void)
5648 {
5649   tree decl;
5650   for (decl = DECL_ARGUMENTS (current_function_decl);
5651        decl; decl = TREE_CHAIN (decl))
5652     if (DECL_RTL (decl) != 0
5653         && GET_CODE (DECL_RTL (decl)) == REG
5654         && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl))))
5655       warning ("%Jargument '%D' might be clobbered by `longjmp' or `vfork'",
5656                decl, decl);
5657 }
5658
5659 /* If this function call setjmp, put all vars into the stack
5660    unless they were declared `register'.  */
5661
5662 void
5663 setjmp_protect (tree block)
5664 {
5665   tree decl, sub;
5666   for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
5667     if ((TREE_CODE (decl) == VAR_DECL
5668          || TREE_CODE (decl) == PARM_DECL)
5669         && DECL_RTL (decl) != 0
5670         && (GET_CODE (DECL_RTL (decl)) == REG
5671             || (GET_CODE (DECL_RTL (decl)) == MEM
5672                 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF))
5673         /* If this variable came from an inline function, it must be
5674            that its life doesn't overlap the setjmp.  If there was a
5675            setjmp in the function, it would already be in memory.  We
5676            must exclude such variable because their DECL_RTL might be
5677            set to strange things such as virtual_stack_vars_rtx.  */
5678         && ! DECL_FROM_INLINE (decl)
5679         && (
5680 #ifdef NON_SAVING_SETJMP
5681             /* If longjmp doesn't restore the registers,
5682                don't put anything in them.  */
5683             NON_SAVING_SETJMP
5684             ||
5685 #endif
5686             ! DECL_REGISTER (decl)))
5687       put_var_into_stack (decl, /*rescan=*/true);
5688   for (sub = BLOCK_SUBBLOCKS (block); sub; sub = TREE_CHAIN (sub))
5689     setjmp_protect (sub);
5690 }
5691 \f
5692 /* Like the previous function, but for args instead of local variables.  */
5693
5694 void
5695 setjmp_protect_args (void)
5696 {
5697   tree decl;
5698   for (decl = DECL_ARGUMENTS (current_function_decl);
5699        decl; decl = TREE_CHAIN (decl))
5700     if ((TREE_CODE (decl) == VAR_DECL
5701          || TREE_CODE (decl) == PARM_DECL)
5702         && DECL_RTL (decl) != 0
5703         && (GET_CODE (DECL_RTL (decl)) == REG
5704             || (GET_CODE (DECL_RTL (decl)) == MEM
5705                 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF))
5706         && (
5707             /* If longjmp doesn't restore the registers,
5708                don't put anything in them.  */
5709 #ifdef NON_SAVING_SETJMP
5710             NON_SAVING_SETJMP
5711             ||
5712 #endif
5713             ! DECL_REGISTER (decl)))
5714       put_var_into_stack (decl, /*rescan=*/true);
5715 }
5716 \f
5717 /* Return the context-pointer register corresponding to DECL,
5718    or 0 if it does not need one.  */
5719
5720 rtx
5721 lookup_static_chain (tree decl)
5722 {
5723   tree context = decl_function_context (decl);
5724   tree link;
5725
5726   if (context == 0
5727       || (TREE_CODE (decl) == FUNCTION_DECL && DECL_NO_STATIC_CHAIN (decl)))
5728     return 0;
5729
5730   /* We treat inline_function_decl as an alias for the current function
5731      because that is the inline function whose vars, types, etc.
5732      are being merged into the current function.
5733      See expand_inline_function.  */
5734   if (context == current_function_decl || context == inline_function_decl)
5735     return virtual_stack_vars_rtx;
5736
5737   for (link = context_display; link; link = TREE_CHAIN (link))
5738     if (TREE_PURPOSE (link) == context)
5739       return RTL_EXPR_RTL (TREE_VALUE (link));
5740
5741   abort ();
5742 }
5743 \f
5744 /* Convert a stack slot address ADDR for variable VAR
5745    (from a containing function)
5746    into an address valid in this function (using a static chain).  */
5747
5748 rtx
5749 fix_lexical_addr (rtx addr, tree var)
5750 {
5751   rtx basereg;
5752   HOST_WIDE_INT displacement;
5753   tree context = decl_function_context (var);
5754   struct function *fp;
5755   rtx base = 0;
5756
5757   /* If this is the present function, we need not do anything.  */
5758   if (context == current_function_decl || context == inline_function_decl)
5759     return addr;
5760
5761   fp = find_function_data (context);
5762
5763   if (GET_CODE (addr) == ADDRESSOF && GET_CODE (XEXP (addr, 0)) == MEM)
5764     addr = XEXP (XEXP (addr, 0), 0);
5765
5766   /* Decode given address as base reg plus displacement.  */
5767   if (GET_CODE (addr) == REG)
5768     basereg = addr, displacement = 0;
5769   else if (GET_CODE (addr) == PLUS && GET_CODE (XEXP (addr, 1)) == CONST_INT)
5770     basereg = XEXP (addr, 0), displacement = INTVAL (XEXP (addr, 1));
5771   else
5772     abort ();
5773
5774   /* We accept vars reached via the containing function's
5775      incoming arg pointer and via its stack variables pointer.  */
5776   if (basereg == fp->internal_arg_pointer)
5777     {
5778       /* If reached via arg pointer, get the arg pointer value
5779          out of that function's stack frame.
5780
5781          There are two cases:  If a separate ap is needed, allocate a
5782          slot in the outer function for it and dereference it that way.
5783          This is correct even if the real ap is actually a pseudo.
5784          Otherwise, just adjust the offset from the frame pointer to
5785          compensate.  */
5786
5787 #ifdef NEED_SEPARATE_AP
5788       rtx addr;
5789
5790       addr = get_arg_pointer_save_area (fp);
5791       addr = fix_lexical_addr (XEXP (addr, 0), var);
5792       addr = memory_address (Pmode, addr);
5793
5794       base = gen_rtx_MEM (Pmode, addr);
5795       set_mem_alias_set (base, get_frame_alias_set ());
5796       base = copy_to_reg (base);
5797 #else
5798       displacement += (FIRST_PARM_OFFSET (context) - STARTING_FRAME_OFFSET);
5799       base = lookup_static_chain (var);
5800 #endif
5801     }
5802
5803   else if (basereg == virtual_stack_vars_rtx)
5804     {
5805       /* This is the same code as lookup_static_chain, duplicated here to
5806          avoid an extra call to decl_function_context.  */
5807       tree link;
5808
5809       for (link = context_display; link; link = TREE_CHAIN (link))
5810         if (TREE_PURPOSE (link) == context)
5811           {
5812             base = RTL_EXPR_RTL (TREE_VALUE (link));
5813             break;
5814           }
5815     }
5816
5817   if (base == 0)
5818     abort ();
5819
5820   /* Use same offset, relative to appropriate static chain or argument
5821      pointer.  */
5822   return plus_constant (base, displacement);
5823 }
5824 \f
5825 /* Return the address of the trampoline for entering nested fn FUNCTION.
5826    If necessary, allocate a trampoline (in the stack frame)
5827    and emit rtl to initialize its contents (at entry to this function).  */
5828
5829 rtx
5830 trampoline_address (tree function)
5831 {
5832   tree link;
5833   tree rtlexp;
5834   rtx tramp;
5835   struct function *fp;
5836   tree fn_context;
5837
5838   /* Find an existing trampoline and return it.  */
5839   for (link = trampoline_list; link; link = TREE_CHAIN (link))
5840     if (TREE_PURPOSE (link) == function)
5841       return
5842         adjust_trampoline_addr (XEXP (RTL_EXPR_RTL (TREE_VALUE (link)), 0));
5843
5844   for (fp = outer_function_chain; fp; fp = fp->outer)
5845     for (link = fp->x_trampoline_list; link; link = TREE_CHAIN (link))
5846       if (TREE_PURPOSE (link) == function)
5847         {
5848           tramp = fix_lexical_addr (XEXP (RTL_EXPR_RTL (TREE_VALUE (link)), 0),
5849                                     function);
5850           return adjust_trampoline_addr (tramp);
5851         }
5852
5853   /* None exists; we must make one.  */
5854
5855   /* Find the `struct function' for the function containing FUNCTION.  */
5856   fp = 0;
5857   fn_context = decl_function_context (function);
5858   if (fn_context != current_function_decl
5859       && fn_context != inline_function_decl)
5860     fp = find_function_data (fn_context);
5861
5862   /* Allocate run-time space for this trampoline.  */
5863   /* If rounding needed, allocate extra space
5864      to ensure we have TRAMPOLINE_SIZE bytes left after rounding up.  */
5865 #define TRAMPOLINE_REAL_SIZE \
5866   (TRAMPOLINE_SIZE + (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT) - 1)
5867   tramp = assign_stack_local_1 (BLKmode, TRAMPOLINE_REAL_SIZE, 0,
5868                                 fp ? fp : cfun);
5869   /* Record the trampoline for reuse and note it for later initialization
5870      by expand_function_end.  */
5871   if (fp != 0)
5872     {
5873       rtlexp = make_node (RTL_EXPR);
5874       RTL_EXPR_RTL (rtlexp) = tramp;
5875       fp->x_trampoline_list = tree_cons (function, rtlexp,
5876                                          fp->x_trampoline_list);
5877     }
5878   else
5879     {
5880       /* Make the RTL_EXPR node temporary, not momentary, so that the
5881          trampoline_list doesn't become garbage.  */
5882       rtlexp = make_node (RTL_EXPR);
5883
5884       RTL_EXPR_RTL (rtlexp) = tramp;
5885       trampoline_list = tree_cons (function, rtlexp, trampoline_list);
5886     }
5887
5888   tramp = fix_lexical_addr (XEXP (tramp, 0), function);
5889   return adjust_trampoline_addr (tramp);
5890 }
5891
5892 /* Given a trampoline address,
5893    round it to multiple of TRAMPOLINE_ALIGNMENT.  */
5894
5895 static rtx
5896 round_trampoline_addr (rtx tramp)
5897 {
5898   /* Round address up to desired boundary.  */
5899   rtx temp = gen_reg_rtx (Pmode);
5900   rtx addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
5901   rtx mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
5902
5903   temp  = expand_simple_binop (Pmode, PLUS, tramp, addend,
5904                                temp, 0, OPTAB_LIB_WIDEN);
5905   tramp = expand_simple_binop (Pmode, AND, temp, mask,
5906                                temp, 0, OPTAB_LIB_WIDEN);
5907
5908   return tramp;
5909 }
5910
5911 /* Given a trampoline address, round it then apply any
5912    platform-specific adjustments so that the result can be used for a
5913    function call .  */
5914
5915 static rtx
5916 adjust_trampoline_addr (rtx tramp)
5917 {
5918   tramp = round_trampoline_addr (tramp);
5919 #ifdef TRAMPOLINE_ADJUST_ADDRESS
5920   TRAMPOLINE_ADJUST_ADDRESS (tramp);
5921 #endif
5922   return tramp;
5923 }
5924 \f
5925 /* Put all this function's BLOCK nodes including those that are chained
5926    onto the first block into a vector, and return it.
5927    Also store in each NOTE for the beginning or end of a block
5928    the index of that block in the vector.
5929    The arguments are BLOCK, the chain of top-level blocks of the function,
5930    and INSNS, the insn chain of the function.  */
5931
5932 void
5933 identify_blocks (void)
5934 {
5935   int n_blocks;
5936   tree *block_vector, *last_block_vector;
5937   tree *block_stack;
5938   tree block = DECL_INITIAL (current_function_decl);
5939
5940   if (block == 0)
5941     return;
5942
5943   /* Fill the BLOCK_VECTOR with all of the BLOCKs in this function, in
5944      depth-first order.  */
5945   block_vector = get_block_vector (block, &n_blocks);
5946   block_stack = xmalloc (n_blocks * sizeof (tree));
5947
5948   last_block_vector = identify_blocks_1 (get_insns (),
5949                                          block_vector + 1,
5950                                          block_vector + n_blocks,
5951                                          block_stack);
5952
5953   /* If we didn't use all of the subblocks, we've misplaced block notes.  */
5954   /* ??? This appears to happen all the time.  Latent bugs elsewhere?  */
5955   if (0 && last_block_vector != block_vector + n_blocks)
5956     abort ();
5957
5958   free (block_vector);
5959   free (block_stack);
5960 }
5961
5962 /* Subroutine of identify_blocks.  Do the block substitution on the
5963    insn chain beginning with INSNS.  Recurse for CALL_PLACEHOLDER chains.
5964
5965    BLOCK_STACK is pushed and popped for each BLOCK_BEGIN/BLOCK_END pair.
5966    BLOCK_VECTOR is incremented for each block seen.  */
5967
5968 static tree *
5969 identify_blocks_1 (rtx insns, tree *block_vector, tree *end_block_vector,
5970                    tree *orig_block_stack)
5971 {
5972   rtx insn;
5973   tree *block_stack = orig_block_stack;
5974
5975   for (insn = insns; insn; insn = NEXT_INSN (insn))
5976     {
5977       if (GET_CODE (insn) == NOTE)
5978         {
5979           if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG)
5980             {
5981               tree b;
5982
5983               /* If there are more block notes than BLOCKs, something
5984                  is badly wrong.  */
5985               if (block_vector == end_block_vector)
5986                 abort ();
5987
5988               b = *block_vector++;
5989               NOTE_BLOCK (insn) = b;
5990               *block_stack++ = b;
5991             }
5992           else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
5993             {
5994               /* If there are more NOTE_INSN_BLOCK_ENDs than
5995                  NOTE_INSN_BLOCK_BEGs, something is badly wrong.  */
5996               if (block_stack == orig_block_stack)
5997                 abort ();
5998
5999               NOTE_BLOCK (insn) = *--block_stack;
6000             }
6001         }
6002       else if (GET_CODE (insn) == CALL_INSN
6003                && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
6004         {
6005           rtx cp = PATTERN (insn);
6006
6007           block_vector = identify_blocks_1 (XEXP (cp, 0), block_vector,
6008                                             end_block_vector, block_stack);
6009           if (XEXP (cp, 1))
6010             block_vector = identify_blocks_1 (XEXP (cp, 1), block_vector,
6011                                               end_block_vector, block_stack);
6012           if (XEXP (cp, 2))
6013             block_vector = identify_blocks_1 (XEXP (cp, 2), block_vector,
6014                                               end_block_vector, block_stack);
6015         }
6016     }
6017
6018   /* If there are more NOTE_INSN_BLOCK_BEGINs than NOTE_INSN_BLOCK_ENDs,
6019      something is badly wrong.  */
6020   if (block_stack != orig_block_stack)
6021     abort ();
6022
6023   return block_vector;
6024 }
6025
6026 /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
6027    and create duplicate blocks.  */
6028 /* ??? Need an option to either create block fragments or to create
6029    abstract origin duplicates of a source block.  It really depends
6030    on what optimization has been performed.  */
6031
6032 void
6033 reorder_blocks (void)
6034 {
6035   tree block = DECL_INITIAL (current_function_decl);
6036   varray_type block_stack;
6037
6038   if (block == NULL_TREE)
6039     return;
6040
6041   VARRAY_TREE_INIT (block_stack, 10, "block_stack");
6042
6043   /* Reset the TREE_ASM_WRITTEN bit for all blocks.  */
6044   reorder_blocks_0 (block);
6045
6046   /* Prune the old trees away, so that they don't get in the way.  */
6047   BLOCK_SUBBLOCKS (block) = NULL_TREE;
6048   BLOCK_CHAIN (block) = NULL_TREE;
6049
6050   /* Recreate the block tree from the note nesting.  */
6051   reorder_blocks_1 (get_insns (), block, &block_stack);
6052   BLOCK_SUBBLOCKS (block) = blocks_nreverse (BLOCK_SUBBLOCKS (block));
6053
6054   /* Remove deleted blocks from the block fragment chains.  */
6055   reorder_fix_fragments (block);
6056 }
6057
6058 /* Helper function for reorder_blocks.  Reset TREE_ASM_WRITTEN.  */
6059
6060 static void
6061 reorder_blocks_0 (tree block)
6062 {
6063   while (block)
6064     {
6065       TREE_ASM_WRITTEN (block) = 0;
6066       reorder_blocks_0 (BLOCK_SUBBLOCKS (block));
6067       block = BLOCK_CHAIN (block);
6068     }
6069 }
6070
6071 static void
6072 reorder_blocks_1 (rtx insns, tree current_block, varray_type *p_block_stack)
6073 {
6074   rtx insn;
6075
6076   for (insn = insns; insn; insn = NEXT_INSN (insn))
6077     {
6078       if (GET_CODE (insn) == NOTE)
6079         {
6080           if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG)
6081             {
6082               tree block = NOTE_BLOCK (insn);
6083
6084               /* If we have seen this block before, that means it now
6085                  spans multiple address regions.  Create a new fragment.  */
6086               if (TREE_ASM_WRITTEN (block))
6087                 {
6088                   tree new_block = copy_node (block);
6089                   tree origin;
6090
6091                   origin = (BLOCK_FRAGMENT_ORIGIN (block)
6092                             ? BLOCK_FRAGMENT_ORIGIN (block)
6093                             : block);
6094                   BLOCK_FRAGMENT_ORIGIN (new_block) = origin;
6095                   BLOCK_FRAGMENT_CHAIN (new_block)
6096                     = BLOCK_FRAGMENT_CHAIN (origin);
6097                   BLOCK_FRAGMENT_CHAIN (origin) = new_block;
6098
6099                   NOTE_BLOCK (insn) = new_block;
6100                   block = new_block;
6101                 }
6102
6103               BLOCK_SUBBLOCKS (block) = 0;
6104               TREE_ASM_WRITTEN (block) = 1;
6105               /* When there's only one block for the entire function,
6106                  current_block == block and we mustn't do this, it
6107                  will cause infinite recursion.  */
6108               if (block != current_block)
6109                 {
6110                   BLOCK_SUPERCONTEXT (block) = current_block;
6111                   BLOCK_CHAIN (block) = BLOCK_SUBBLOCKS (current_block);
6112                   BLOCK_SUBBLOCKS (current_block) = block;
6113                   current_block = block;
6114                 }
6115               VARRAY_PUSH_TREE (*p_block_stack, block);
6116             }
6117           else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
6118             {
6119               NOTE_BLOCK (insn) = VARRAY_TOP_TREE (*p_block_stack);
6120               VARRAY_POP (*p_block_stack);
6121               BLOCK_SUBBLOCKS (current_block)
6122                 = blocks_nreverse (BLOCK_SUBBLOCKS (current_block));
6123               current_block = BLOCK_SUPERCONTEXT (current_block);
6124             }
6125         }
6126       else if (GET_CODE (insn) == CALL_INSN
6127                && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
6128         {
6129           rtx cp = PATTERN (insn);
6130           reorder_blocks_1 (XEXP (cp, 0), current_block, p_block_stack);
6131           if (XEXP (cp, 1))
6132             reorder_blocks_1 (XEXP (cp, 1), current_block, p_block_stack);
6133           if (XEXP (cp, 2))
6134             reorder_blocks_1 (XEXP (cp, 2), current_block, p_block_stack);
6135         }
6136     }
6137 }
6138
6139 /* Rationalize BLOCK_FRAGMENT_ORIGIN.  If an origin block no longer
6140    appears in the block tree, select one of the fragments to become
6141    the new origin block.  */
6142
6143 static void
6144 reorder_fix_fragments (tree block)
6145 {
6146   while (block)
6147     {
6148       tree dup_origin = BLOCK_FRAGMENT_ORIGIN (block);
6149       tree new_origin = NULL_TREE;
6150
6151       if (dup_origin)
6152         {
6153           if (! TREE_ASM_WRITTEN (dup_origin))
6154             {
6155               new_origin = BLOCK_FRAGMENT_CHAIN (dup_origin);
6156
6157               /* Find the first of the remaining fragments.  There must
6158                  be at least one -- the current block.  */
6159               while (! TREE_ASM_WRITTEN (new_origin))
6160                 new_origin = BLOCK_FRAGMENT_CHAIN (new_origin);
6161               BLOCK_FRAGMENT_ORIGIN (new_origin) = NULL_TREE;
6162             }
6163         }
6164       else if (! dup_origin)
6165         new_origin = block;
6166
6167       /* Re-root the rest of the fragments to the new origin.  In the
6168          case that DUP_ORIGIN was null, that means BLOCK was the origin
6169          of a chain of fragments and we want to remove those fragments
6170          that didn't make it to the output.  */
6171       if (new_origin)
6172         {
6173           tree *pp = &BLOCK_FRAGMENT_CHAIN (new_origin);
6174           tree chain = *pp;
6175
6176           while (chain)
6177             {
6178               if (TREE_ASM_WRITTEN (chain))
6179                 {
6180                   BLOCK_FRAGMENT_ORIGIN (chain) = new_origin;
6181                   *pp = chain;
6182                   pp = &BLOCK_FRAGMENT_CHAIN (chain);
6183                 }
6184               chain = BLOCK_FRAGMENT_CHAIN (chain);
6185             }
6186           *pp = NULL_TREE;
6187         }
6188
6189       reorder_fix_fragments (BLOCK_SUBBLOCKS (block));
6190       block = BLOCK_CHAIN (block);
6191     }
6192 }
6193
6194 /* Reverse the order of elements in the chain T of blocks,
6195    and return the new head of the chain (old last element).  */
6196
6197 static tree
6198 blocks_nreverse (tree t)
6199 {
6200   tree prev = 0, decl, next;
6201   for (decl = t; decl; decl = next)
6202     {
6203       next = BLOCK_CHAIN (decl);
6204       BLOCK_CHAIN (decl) = prev;
6205       prev = decl;
6206     }
6207   return prev;
6208 }
6209
6210 /* Count the subblocks of the list starting with BLOCK.  If VECTOR is
6211    non-NULL, list them all into VECTOR, in a depth-first preorder
6212    traversal of the block tree.  Also clear TREE_ASM_WRITTEN in all
6213    blocks.  */
6214
6215 static int
6216 all_blocks (tree block, tree *vector)
6217 {
6218   int n_blocks = 0;
6219
6220   while (block)
6221     {
6222       TREE_ASM_WRITTEN (block) = 0;
6223
6224       /* Record this block.  */
6225       if (vector)
6226         vector[n_blocks] = block;
6227
6228       ++n_blocks;
6229
6230       /* Record the subblocks, and their subblocks...  */
6231       n_blocks += all_blocks (BLOCK_SUBBLOCKS (block),
6232                               vector ? vector + n_blocks : 0);
6233       block = BLOCK_CHAIN (block);
6234     }
6235
6236   return n_blocks;
6237 }
6238
6239 /* Return a vector containing all the blocks rooted at BLOCK.  The
6240    number of elements in the vector is stored in N_BLOCKS_P.  The
6241    vector is dynamically allocated; it is the caller's responsibility
6242    to call `free' on the pointer returned.  */
6243
6244 static tree *
6245 get_block_vector (tree block, int *n_blocks_p)
6246 {
6247   tree *block_vector;
6248
6249   *n_blocks_p = all_blocks (block, NULL);
6250   block_vector = xmalloc (*n_blocks_p * sizeof (tree));
6251   all_blocks (block, block_vector);
6252
6253   return block_vector;
6254 }
6255
6256 static GTY(()) int next_block_index = 2;
6257
6258 /* Set BLOCK_NUMBER for all the blocks in FN.  */
6259
6260 void
6261 number_blocks (tree fn)
6262 {
6263   int i;
6264   int n_blocks;
6265   tree *block_vector;
6266
6267   /* For SDB and XCOFF debugging output, we start numbering the blocks
6268      from 1 within each function, rather than keeping a running
6269      count.  */
6270 #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
6271   if (write_symbols == SDB_DEBUG || write_symbols == XCOFF_DEBUG)
6272     next_block_index = 1;
6273 #endif
6274
6275   block_vector = get_block_vector (DECL_INITIAL (fn), &n_blocks);
6276
6277   /* The top-level BLOCK isn't numbered at all.  */
6278   for (i = 1; i < n_blocks; ++i)
6279     /* We number the blocks from two.  */
6280     BLOCK_NUMBER (block_vector[i]) = next_block_index++;
6281
6282   free (block_vector);
6283
6284   return;
6285 }
6286
6287 /* If VAR is present in a subblock of BLOCK, return the subblock.  */
6288
6289 tree
6290 debug_find_var_in_block_tree (tree var, tree block)
6291 {
6292   tree t;
6293
6294   for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))
6295     if (t == var)
6296       return block;
6297
6298   for (t = BLOCK_SUBBLOCKS (block); t; t = TREE_CHAIN (t))
6299     {
6300       tree ret = debug_find_var_in_block_tree (var, t);
6301       if (ret)
6302         return ret;
6303     }
6304
6305   return NULL_TREE;
6306 }
6307 \f
6308 /* Allocate a function structure for FNDECL and set its contents
6309    to the defaults.  */
6310
6311 void
6312 allocate_struct_function (tree fndecl)
6313 {
6314   tree result;
6315
6316   cfun = ggc_alloc_cleared (sizeof (struct function));
6317
6318   max_parm_reg = LAST_VIRTUAL_REGISTER + 1;
6319
6320   cfun->stack_alignment_needed = STACK_BOUNDARY;
6321   cfun->preferred_stack_boundary = STACK_BOUNDARY;
6322
6323   current_function_funcdef_no = funcdef_no++;
6324
6325   cfun->function_frequency = FUNCTION_FREQUENCY_NORMAL;
6326
6327   init_stmt_for_function ();
6328   init_eh_for_function ();
6329   init_emit ();
6330   init_expr ();
6331   init_varasm_status (cfun);
6332
6333   (*lang_hooks.function.init) (cfun);
6334   if (init_machine_status)
6335     cfun->machine = (*init_machine_status) ();
6336
6337   if (fndecl == NULL)
6338     return;
6339
6340   DECL_SAVED_INSNS (fndecl) = cfun;
6341   cfun->decl = fndecl;
6342
6343   current_function_name = (*lang_hooks.decl_printable_name) (fndecl, 2);
6344
6345   result = DECL_RESULT (fndecl);
6346   if (aggregate_value_p (result, fndecl))
6347     {
6348 #ifdef PCC_STATIC_STRUCT_RETURN
6349       current_function_returns_pcc_struct = 1;
6350 #endif
6351       current_function_returns_struct = 1;
6352     }
6353
6354   current_function_returns_pointer = POINTER_TYPE_P (TREE_TYPE (result));
6355
6356   current_function_needs_context
6357     = (decl_function_context (current_function_decl) != 0
6358        && ! DECL_NO_STATIC_CHAIN (current_function_decl));
6359 }
6360
6361 /* Reset cfun, and other non-struct-function variables to defaults as
6362    appropriate for emitting rtl at the start of a function.  */
6363
6364 static void
6365 prepare_function_start (tree fndecl)
6366 {
6367   if (fndecl && DECL_SAVED_INSNS (fndecl))
6368     cfun = DECL_SAVED_INSNS (fndecl);
6369   else
6370     allocate_struct_function (fndecl);
6371
6372   cse_not_expected = ! optimize;
6373
6374   /* Caller save not needed yet.  */
6375   caller_save_needed = 0;
6376
6377   /* We haven't done register allocation yet.  */
6378   reg_renumber = 0;
6379
6380   /* Indicate that we need to distinguish between the return value of the
6381      present function and the return value of a function being called.  */
6382   rtx_equal_function_value_matters = 1;
6383
6384   /* Indicate that we have not instantiated virtual registers yet.  */
6385   virtuals_instantiated = 0;
6386
6387   /* Indicate that we want CONCATs now.  */
6388   generating_concat_p = 1;
6389
6390   /* Indicate we have no need of a frame pointer yet.  */
6391   frame_pointer_needed = 0;
6392 }
6393
6394 /* Initialize the rtl expansion mechanism so that we can do simple things
6395    like generate sequences.  This is used to provide a context during global
6396    initialization of some passes.  */
6397 void
6398 init_dummy_function_start (void)
6399 {
6400   prepare_function_start (NULL);
6401 }
6402
6403 /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node)
6404    and initialize static variables for generating RTL for the statements
6405    of the function.  */
6406
6407 void
6408 init_function_start (tree subr)
6409 {
6410   prepare_function_start (subr);
6411
6412   /* Within function body, compute a type's size as soon it is laid out.  */
6413   immediate_size_expand++;
6414
6415   /* Prevent ever trying to delete the first instruction of a
6416      function.  Also tell final how to output a linenum before the
6417      function prologue.  Note linenums could be missing, e.g. when
6418      compiling a Java .class file.  */
6419   if (DECL_SOURCE_LINE (subr))
6420     emit_line_note (DECL_SOURCE_LOCATION (subr));
6421
6422   /* Make sure first insn is a note even if we don't want linenums.
6423      This makes sure the first insn will never be deleted.
6424      Also, final expects a note to appear there.  */
6425   emit_note (NOTE_INSN_DELETED);
6426
6427   /* Warn if this value is an aggregate type,
6428      regardless of which calling convention we are using for it.  */
6429   if (warn_aggregate_return
6430       && AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr))))
6431     warning ("function returns an aggregate");
6432 }
6433
6434 /* Make sure all values used by the optimization passes have sane
6435    defaults.  */
6436 void
6437 init_function_for_compilation (void)
6438 {
6439   reg_renumber = 0;
6440
6441   /* No prologue/epilogue insns yet.  */
6442   VARRAY_GROW (prologue, 0);
6443   VARRAY_GROW (epilogue, 0);
6444   VARRAY_GROW (sibcall_epilogue, 0);
6445 }
6446
6447 /* Expand a call to __main at the beginning of a possible main function.  */
6448
6449 #if defined(INIT_SECTION_ASM_OP) && !defined(INVOKE__main)
6450 #undef HAS_INIT_SECTION
6451 #define HAS_INIT_SECTION
6452 #endif
6453
6454 void
6455 expand_main_function (void)
6456 {
6457 #ifdef FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN
6458   if (FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN)
6459     {
6460       int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
6461       rtx tmp, seq;
6462
6463       start_sequence ();
6464       /* Forcibly align the stack.  */
6465 #ifdef STACK_GROWS_DOWNWARD
6466       tmp = expand_simple_binop (Pmode, AND, stack_pointer_rtx, GEN_INT(-align),
6467                                  stack_pointer_rtx, 1, OPTAB_WIDEN);
6468 #else
6469       tmp = expand_simple_binop (Pmode, PLUS, stack_pointer_rtx,
6470                                  GEN_INT (align - 1), NULL_RTX, 1, OPTAB_WIDEN);
6471       tmp = expand_simple_binop (Pmode, AND, tmp, GEN_INT (-align),
6472                                  stack_pointer_rtx, 1, OPTAB_WIDEN);
6473 #endif
6474       if (tmp != stack_pointer_rtx)
6475         emit_move_insn (stack_pointer_rtx, tmp);
6476
6477       /* Enlist allocate_dynamic_stack_space to pick up the pieces.  */
6478       tmp = force_reg (Pmode, const0_rtx);
6479       allocate_dynamic_stack_space (tmp, NULL_RTX, BIGGEST_ALIGNMENT);
6480       seq = get_insns ();
6481       end_sequence ();
6482
6483       for (tmp = get_last_insn (); tmp; tmp = PREV_INSN (tmp))
6484         if (NOTE_P (tmp) && NOTE_LINE_NUMBER (tmp) == NOTE_INSN_FUNCTION_BEG)
6485           break;
6486       if (tmp)
6487         emit_insn_before (seq, tmp);
6488       else
6489         emit_insn (seq);
6490     }
6491 #endif
6492
6493 #ifndef HAS_INIT_SECTION
6494   emit_library_call (init_one_libfunc (NAME__MAIN), LCT_NORMAL, VOIDmode, 0);
6495 #endif
6496 }
6497 \f
6498 /* The PENDING_SIZES represent the sizes of variable-sized types.
6499    Create RTL for the various sizes now (using temporary variables),
6500    so that we can refer to the sizes from the RTL we are generating
6501    for the current function.  The PENDING_SIZES are a TREE_LIST.  The
6502    TREE_VALUE of each node is a SAVE_EXPR.  */
6503
6504 void
6505 expand_pending_sizes (tree pending_sizes)
6506 {
6507   tree tem;
6508
6509   /* Evaluate now the sizes of any types declared among the arguments.  */
6510   for (tem = pending_sizes; tem; tem = TREE_CHAIN (tem))
6511     {
6512       expand_expr (TREE_VALUE (tem), const0_rtx, VOIDmode, 0);
6513       /* Flush the queue in case this parameter declaration has
6514          side-effects.  */
6515       emit_queue ();
6516     }
6517 }
6518
6519 /* Start the RTL for a new function, and set variables used for
6520    emitting RTL.
6521    SUBR is the FUNCTION_DECL node.
6522    PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with
6523    the function's parameters, which must be run at any return statement.  */
6524
6525 void
6526 expand_function_start (tree subr, int parms_have_cleanups)
6527 {
6528   tree tem;
6529   rtx last_ptr = NULL_RTX;
6530
6531   /* Make sure volatile mem refs aren't considered
6532      valid operands of arithmetic insns.  */
6533   init_recog_no_volatile ();
6534
6535   current_function_instrument_entry_exit
6536     = (flag_instrument_function_entry_exit
6537        && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr));
6538
6539   current_function_profile
6540     = (profile_flag
6541        && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr));
6542
6543   current_function_limit_stack
6544     = (stack_limit_rtx != NULL_RTX && ! DECL_NO_LIMIT_STACK (subr));
6545
6546   /* If function gets a static chain arg, store it in the stack frame.
6547      Do this first, so it gets the first stack slot offset.  */
6548   if (current_function_needs_context)
6549     {
6550       last_ptr = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0);
6551
6552       /* Delay copying static chain if it is not a register to avoid
6553          conflicts with regs used for parameters.  */
6554       if (! SMALL_REGISTER_CLASSES
6555           || GET_CODE (static_chain_incoming_rtx) == REG)
6556         emit_move_insn (last_ptr, static_chain_incoming_rtx);
6557     }
6558
6559   /* If the parameters of this function need cleaning up, get a label
6560      for the beginning of the code which executes those cleanups.  This must
6561      be done before doing anything with return_label.  */
6562   if (parms_have_cleanups)
6563     cleanup_label = gen_label_rtx ();
6564   else
6565     cleanup_label = 0;
6566
6567   /* Make the label for return statements to jump to.  Do not special
6568      case machines with special return instructions -- they will be
6569      handled later during jump, ifcvt, or epilogue creation.  */
6570   return_label = gen_label_rtx ();
6571
6572   /* Initialize rtx used to return the value.  */
6573   /* Do this before assign_parms so that we copy the struct value address
6574      before any library calls that assign parms might generate.  */
6575
6576   /* Decide whether to return the value in memory or in a register.  */
6577   if (aggregate_value_p (DECL_RESULT (subr), subr))
6578     {
6579       /* Returning something that won't go in a register.  */
6580       rtx value_address = 0;
6581
6582 #ifdef PCC_STATIC_STRUCT_RETURN
6583       if (current_function_returns_pcc_struct)
6584         {
6585           int size = int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr)));
6586           value_address = assemble_static_space (size);
6587         }
6588       else
6589 #endif
6590         {
6591           rtx sv = targetm.calls.struct_value_rtx (TREE_TYPE (subr), 1);
6592           /* Expect to be passed the address of a place to store the value.
6593              If it is passed as an argument, assign_parms will take care of
6594              it.  */
6595           if (sv)
6596             {
6597               value_address = gen_reg_rtx (Pmode);
6598               emit_move_insn (value_address, sv);
6599             }
6600         }
6601       if (value_address)
6602         {
6603           rtx x = gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr)), value_address);
6604           set_mem_attributes (x, DECL_RESULT (subr), 1);
6605           SET_DECL_RTL (DECL_RESULT (subr), x);
6606         }
6607     }
6608   else if (DECL_MODE (DECL_RESULT (subr)) == VOIDmode)
6609     /* If return mode is void, this decl rtl should not be used.  */
6610     SET_DECL_RTL (DECL_RESULT (subr), NULL_RTX);
6611   else
6612     {
6613       /* Compute the return values into a pseudo reg, which we will copy
6614          into the true return register after the cleanups are done.  */
6615
6616       /* In order to figure out what mode to use for the pseudo, we
6617          figure out what the mode of the eventual return register will
6618          actually be, and use that.  */
6619       rtx hard_reg
6620         = hard_function_value (TREE_TYPE (DECL_RESULT (subr)),
6621                                subr, 1);
6622
6623       /* Structures that are returned in registers are not aggregate_value_p,
6624          so we may see a PARALLEL or a REG.  */
6625       if (REG_P (hard_reg))
6626         SET_DECL_RTL (DECL_RESULT (subr), gen_reg_rtx (GET_MODE (hard_reg)));
6627       else if (GET_CODE (hard_reg) == PARALLEL)
6628         SET_DECL_RTL (DECL_RESULT (subr), gen_group_rtx (hard_reg));
6629       else
6630         abort ();
6631
6632       /* Set DECL_REGISTER flag so that expand_function_end will copy the
6633          result to the real return register(s).  */
6634       DECL_REGISTER (DECL_RESULT (subr)) = 1;
6635     }
6636
6637   /* Initialize rtx for parameters and local variables.
6638      In some cases this requires emitting insns.  */
6639
6640   assign_parms (subr);
6641
6642   /* Copy the static chain now if it wasn't a register.  The delay is to
6643      avoid conflicts with the parameter passing registers.  */
6644
6645   if (SMALL_REGISTER_CLASSES && current_function_needs_context)
6646     if (GET_CODE (static_chain_incoming_rtx) != REG)
6647       emit_move_insn (last_ptr, static_chain_incoming_rtx);
6648
6649   /* The following was moved from init_function_start.
6650      The move is supposed to make sdb output more accurate.  */
6651   /* Indicate the beginning of the function body,
6652      as opposed to parm setup.  */
6653   emit_note (NOTE_INSN_FUNCTION_BEG);
6654
6655   if (GET_CODE (get_last_insn ()) != NOTE)
6656     emit_note (NOTE_INSN_DELETED);
6657   parm_birth_insn = get_last_insn ();
6658
6659   context_display = 0;
6660   if (current_function_needs_context)
6661     {
6662       /* Fetch static chain values for containing functions.  */
6663       tem = decl_function_context (current_function_decl);
6664       /* Copy the static chain pointer into a pseudo.  If we have
6665          small register classes, copy the value from memory if
6666          static_chain_incoming_rtx is a REG.  */
6667       if (tem)
6668         {
6669           /* If the static chain originally came in a register, put it back
6670              there, then move it out in the next insn.  The reason for
6671              this peculiar code is to satisfy function integration.  */
6672           if (SMALL_REGISTER_CLASSES
6673               && GET_CODE (static_chain_incoming_rtx) == REG)
6674             emit_move_insn (static_chain_incoming_rtx, last_ptr);
6675           last_ptr = copy_to_reg (static_chain_incoming_rtx);
6676         }
6677
6678       while (tem)
6679         {
6680           tree rtlexp = make_node (RTL_EXPR);
6681
6682           RTL_EXPR_RTL (rtlexp) = last_ptr;
6683           context_display = tree_cons (tem, rtlexp, context_display);
6684           tem = decl_function_context (tem);
6685           if (tem == 0)
6686             break;
6687           /* Chain thru stack frames, assuming pointer to next lexical frame
6688              is found at the place we always store it.  */
6689 #ifdef FRAME_GROWS_DOWNWARD
6690           last_ptr = plus_constant (last_ptr,
6691                                     -(HOST_WIDE_INT) GET_MODE_SIZE (Pmode));
6692 #endif
6693           last_ptr = gen_rtx_MEM (Pmode, memory_address (Pmode, last_ptr));
6694           set_mem_alias_set (last_ptr, get_frame_alias_set ());
6695           last_ptr = copy_to_reg (last_ptr);
6696
6697           /* If we are not optimizing, ensure that we know that this
6698              piece of context is live over the entire function.  */
6699           if (! optimize)
6700             save_expr_regs = gen_rtx_EXPR_LIST (VOIDmode, last_ptr,
6701                                                 save_expr_regs);
6702         }
6703     }
6704
6705   if (current_function_instrument_entry_exit)
6706     {
6707       rtx fun = DECL_RTL (current_function_decl);
6708       if (GET_CODE (fun) == MEM)
6709         fun = XEXP (fun, 0);
6710       else
6711         abort ();
6712       emit_library_call (profile_function_entry_libfunc, LCT_NORMAL, VOIDmode,
6713                          2, fun, Pmode,
6714                          expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
6715                                                      0,
6716                                                      hard_frame_pointer_rtx),
6717                          Pmode);
6718     }
6719
6720   if (current_function_profile)
6721     {
6722 #ifdef PROFILE_HOOK
6723       PROFILE_HOOK (current_function_funcdef_no);
6724 #endif
6725     }
6726
6727   /* After the display initializations is where the tail-recursion label
6728      should go, if we end up needing one.   Ensure we have a NOTE here
6729      since some things (like trampolines) get placed before this.  */
6730   tail_recursion_reentry = emit_note (NOTE_INSN_DELETED);
6731
6732   /* Evaluate now the sizes of any types declared among the arguments.  */
6733   expand_pending_sizes (nreverse (get_pending_sizes ()));
6734
6735   /* Make sure there is a line number after the function entry setup code.  */
6736   force_next_line_note ();
6737 }
6738 \f
6739 /* Undo the effects of init_dummy_function_start.  */
6740 void
6741 expand_dummy_function_end (void)
6742 {
6743   /* End any sequences that failed to be closed due to syntax errors.  */
6744   while (in_sequence_p ())
6745     end_sequence ();
6746
6747   /* Outside function body, can't compute type's actual size
6748      until next function's body starts.  */
6749
6750   free_after_parsing (cfun);
6751   free_after_compilation (cfun);
6752   cfun = 0;
6753 }
6754
6755 /* Call DOIT for each hard register used as a return value from
6756    the current function.  */
6757
6758 void
6759 diddle_return_value (void (*doit) (rtx, void *), void *arg)
6760 {
6761   rtx outgoing = current_function_return_rtx;
6762
6763   if (! outgoing)
6764     return;
6765
6766   if (GET_CODE (outgoing) == REG)
6767     (*doit) (outgoing, arg);
6768   else if (GET_CODE (outgoing) == PARALLEL)
6769     {
6770       int i;
6771
6772       for (i = 0; i < XVECLEN (outgoing, 0); i++)
6773         {
6774           rtx x = XEXP (XVECEXP (outgoing, 0, i), 0);
6775
6776           if (GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
6777             (*doit) (x, arg);
6778         }
6779     }
6780 }
6781
6782 static void
6783 do_clobber_return_reg (rtx reg, void *arg ATTRIBUTE_UNUSED)
6784 {
6785   emit_insn (gen_rtx_CLOBBER (VOIDmode, reg));
6786 }
6787
6788 void
6789 clobber_return_register (void)
6790 {
6791   diddle_return_value (do_clobber_return_reg, NULL);
6792
6793   /* In case we do use pseudo to return value, clobber it too.  */
6794   if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl)))
6795     {
6796       tree decl_result = DECL_RESULT (current_function_decl);
6797       rtx decl_rtl = DECL_RTL (decl_result);
6798       if (REG_P (decl_rtl) && REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER)
6799         {
6800           do_clobber_return_reg (decl_rtl, NULL);
6801         }
6802     }
6803 }
6804
6805 static void
6806 do_use_return_reg (rtx reg, void *arg ATTRIBUTE_UNUSED)
6807 {
6808   emit_insn (gen_rtx_USE (VOIDmode, reg));
6809 }
6810
6811 void
6812 use_return_register (void)
6813 {
6814   diddle_return_value (do_use_return_reg, NULL);
6815 }
6816
6817 static GTY(()) rtx initial_trampoline;
6818
6819 /* Generate RTL for the end of the current function.  */
6820
6821 void
6822 expand_function_end (void)
6823 {
6824   tree link;
6825   rtx clobber_after;
6826
6827   finish_expr_for_function ();
6828
6829   /* If arg_pointer_save_area was referenced only from a nested
6830      function, we will not have initialized it yet.  Do that now.  */
6831   if (arg_pointer_save_area && ! cfun->arg_pointer_save_area_init)
6832     get_arg_pointer_save_area (cfun);
6833
6834 #ifdef NON_SAVING_SETJMP
6835   /* Don't put any variables in registers if we call setjmp
6836      on a machine that fails to restore the registers.  */
6837   if (NON_SAVING_SETJMP && current_function_calls_setjmp)
6838     {
6839       if (DECL_INITIAL (current_function_decl) != error_mark_node)
6840         setjmp_protect (DECL_INITIAL (current_function_decl));
6841
6842       setjmp_protect_args ();
6843     }
6844 #endif
6845
6846   /* Initialize any trampolines required by this function.  */
6847   for (link = trampoline_list; link; link = TREE_CHAIN (link))
6848     {
6849       tree function = TREE_PURPOSE (link);
6850       rtx context ATTRIBUTE_UNUSED = lookup_static_chain (function);
6851       rtx tramp = RTL_EXPR_RTL (TREE_VALUE (link));
6852 #ifdef TRAMPOLINE_TEMPLATE
6853       rtx blktramp;
6854 #endif
6855       rtx seq;
6856
6857 #ifdef TRAMPOLINE_TEMPLATE
6858       /* First make sure this compilation has a template for
6859          initializing trampolines.  */
6860       if (initial_trampoline == 0)
6861         {
6862           initial_trampoline
6863             = gen_rtx_MEM (BLKmode, assemble_trampoline_template ());
6864           set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT);
6865         }
6866 #endif
6867
6868       /* Generate insns to initialize the trampoline.  */
6869       start_sequence ();
6870       tramp = round_trampoline_addr (XEXP (tramp, 0));
6871 #ifdef TRAMPOLINE_TEMPLATE
6872       blktramp = replace_equiv_address (initial_trampoline, tramp);
6873       emit_block_move (blktramp, initial_trampoline,
6874                        GEN_INT (TRAMPOLINE_SIZE), BLOCK_OP_NORMAL);
6875 #endif
6876       trampolines_created = 1;
6877       INITIALIZE_TRAMPOLINE (tramp, XEXP (DECL_RTL (function), 0), context);
6878       seq = get_insns ();
6879       end_sequence ();
6880
6881       /* Put those insns at entry to the containing function (this one).  */
6882       emit_insn_before (seq, tail_recursion_reentry);
6883     }
6884
6885   /* If we are doing stack checking and this function makes calls,
6886      do a stack probe at the start of the function to ensure we have enough
6887      space for another stack frame.  */
6888   if (flag_stack_check && ! STACK_CHECK_BUILTIN)
6889     {
6890       rtx insn, seq;
6891
6892       for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
6893         if (GET_CODE (insn) == CALL_INSN)
6894           {
6895             start_sequence ();
6896             probe_stack_range (STACK_CHECK_PROTECT,
6897                                GEN_INT (STACK_CHECK_MAX_FRAME_SIZE));
6898             seq = get_insns ();
6899             end_sequence ();
6900             emit_insn_before (seq, tail_recursion_reentry);
6901             break;
6902           }
6903     }
6904
6905   /* Possibly warn about unused parameters.  */
6906   if (warn_unused_parameter)
6907     {
6908       tree decl;
6909
6910       for (decl = DECL_ARGUMENTS (current_function_decl);
6911            decl; decl = TREE_CHAIN (decl))
6912         if (! TREE_USED (decl) && TREE_CODE (decl) == PARM_DECL
6913             && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
6914           warning ("%Junused parameter '%D'", decl, decl);
6915     }
6916
6917   /* Delete handlers for nonlocal gotos if nothing uses them.  */
6918   if (nonlocal_goto_handler_slots != 0
6919       && ! current_function_has_nonlocal_label)
6920     delete_handlers ();
6921
6922   /* End any sequences that failed to be closed due to syntax errors.  */
6923   while (in_sequence_p ())
6924     end_sequence ();
6925
6926   /* Outside function body, can't compute type's actual size
6927      until next function's body starts.  */
6928   immediate_size_expand--;
6929
6930   clear_pending_stack_adjust ();
6931   do_pending_stack_adjust ();
6932
6933   /* Mark the end of the function body.
6934      If control reaches this insn, the function can drop through
6935      without returning a value.  */
6936   emit_note (NOTE_INSN_FUNCTION_END);
6937
6938   /* Must mark the last line number note in the function, so that the test
6939      coverage code can avoid counting the last line twice.  This just tells
6940      the code to ignore the immediately following line note, since there
6941      already exists a copy of this note somewhere above.  This line number
6942      note is still needed for debugging though, so we can't delete it.  */
6943   if (flag_test_coverage)
6944     emit_note (NOTE_INSN_REPEATED_LINE_NUMBER);
6945
6946   /* Output a linenumber for the end of the function.
6947      SDB depends on this.  */
6948   force_next_line_note ();
6949   emit_line_note (input_location);
6950
6951   /* Before the return label (if any), clobber the return
6952      registers so that they are not propagated live to the rest of
6953      the function.  This can only happen with functions that drop
6954      through; if there had been a return statement, there would
6955      have either been a return rtx, or a jump to the return label.
6956
6957      We delay actual code generation after the current_function_value_rtx
6958      is computed.  */
6959   clobber_after = get_last_insn ();
6960
6961   /* Output the label for the actual return from the function,
6962      if one is expected.  This happens either because a function epilogue
6963      is used instead of a return instruction, or because a return was done
6964      with a goto in order to run local cleanups, or because of pcc-style
6965      structure returning.  */
6966   if (return_label)
6967     emit_label (return_label);
6968
6969   if (current_function_instrument_entry_exit)
6970     {
6971       rtx fun = DECL_RTL (current_function_decl);
6972       if (GET_CODE (fun) == MEM)
6973         fun = XEXP (fun, 0);
6974       else
6975         abort ();
6976       emit_library_call (profile_function_exit_libfunc, LCT_NORMAL, VOIDmode,
6977                          2, fun, Pmode,
6978                          expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
6979                                                      0,
6980                                                      hard_frame_pointer_rtx),
6981                          Pmode);
6982     }
6983
6984   /* Let except.c know where it should emit the call to unregister
6985      the function context for sjlj exceptions.  */
6986   if (flag_exceptions && USING_SJLJ_EXCEPTIONS)
6987     sjlj_emit_function_exit_after (get_last_insn ());
6988
6989   /* If we had calls to alloca, and this machine needs
6990      an accurate stack pointer to exit the function,
6991      insert some code to save and restore the stack pointer.  */
6992 #ifdef EXIT_IGNORE_STACK
6993   if (! EXIT_IGNORE_STACK)
6994 #endif
6995     if (current_function_calls_alloca)
6996       {
6997         rtx tem = 0;
6998
6999         emit_stack_save (SAVE_FUNCTION, &tem, parm_birth_insn);
7000         emit_stack_restore (SAVE_FUNCTION, tem, NULL_RTX);
7001       }
7002
7003   /* If scalar return value was computed in a pseudo-reg, or was a named
7004      return value that got dumped to the stack, copy that to the hard
7005      return register.  */
7006   if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl)))
7007     {
7008       tree decl_result = DECL_RESULT (current_function_decl);
7009       rtx decl_rtl = DECL_RTL (decl_result);
7010
7011       if (REG_P (decl_rtl)
7012           ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER
7013           : DECL_REGISTER (decl_result))
7014         {
7015           rtx real_decl_rtl = current_function_return_rtx;
7016
7017           /* This should be set in assign_parms.  */
7018           if (! REG_FUNCTION_VALUE_P (real_decl_rtl))
7019             abort ();
7020
7021           /* If this is a BLKmode structure being returned in registers,
7022              then use the mode computed in expand_return.  Note that if
7023              decl_rtl is memory, then its mode may have been changed,
7024              but that current_function_return_rtx has not.  */
7025           if (GET_MODE (real_decl_rtl) == BLKmode)
7026             PUT_MODE (real_decl_rtl, GET_MODE (decl_rtl));
7027
7028           /* If a named return value dumped decl_return to memory, then
7029              we may need to re-do the PROMOTE_MODE signed/unsigned
7030              extension.  */
7031           if (GET_MODE (real_decl_rtl) != GET_MODE (decl_rtl))
7032             {
7033               int unsignedp = TREE_UNSIGNED (TREE_TYPE (decl_result));
7034
7035               if (targetm.calls.promote_function_return (TREE_TYPE (current_function_decl)))
7036                 promote_mode (TREE_TYPE (decl_result), GET_MODE (decl_rtl),
7037                               &unsignedp, 1);
7038
7039               convert_move (real_decl_rtl, decl_rtl, unsignedp);
7040             }
7041           else if (GET_CODE (real_decl_rtl) == PARALLEL)
7042             {
7043               /* If expand_function_start has created a PARALLEL for decl_rtl,
7044                  move the result to the real return registers.  Otherwise, do
7045                  a group load from decl_rtl for a named return.  */
7046               if (GET_CODE (decl_rtl) == PARALLEL)
7047                 emit_group_move (real_decl_rtl, decl_rtl);
7048               else
7049                 emit_group_load (real_decl_rtl, decl_rtl,
7050                                  TREE_TYPE (decl_result),
7051                                  int_size_in_bytes (TREE_TYPE (decl_result)));
7052             }
7053           else
7054             emit_move_insn (real_decl_rtl, decl_rtl);
7055         }
7056     }
7057
7058   /* If returning a structure, arrange to return the address of the value
7059      in a place where debuggers expect to find it.
7060
7061      If returning a structure PCC style,
7062      the caller also depends on this value.
7063      And current_function_returns_pcc_struct is not necessarily set.  */
7064   if (current_function_returns_struct
7065       || current_function_returns_pcc_struct)
7066     {
7067       rtx value_address
7068         = XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
7069       tree type = TREE_TYPE (DECL_RESULT (current_function_decl));
7070 #ifdef FUNCTION_OUTGOING_VALUE
7071       rtx outgoing
7072         = FUNCTION_OUTGOING_VALUE (build_pointer_type (type),
7073                                    current_function_decl);
7074 #else
7075       rtx outgoing
7076         = FUNCTION_VALUE (build_pointer_type (type), current_function_decl);
7077 #endif
7078
7079       /* Mark this as a function return value so integrate will delete the
7080          assignment and USE below when inlining this function.  */
7081       REG_FUNCTION_VALUE_P (outgoing) = 1;
7082
7083       /* The address may be ptr_mode and OUTGOING may be Pmode.  */
7084       value_address = convert_memory_address (GET_MODE (outgoing),
7085                                               value_address);
7086
7087       emit_move_insn (outgoing, value_address);
7088
7089       /* Show return register used to hold result (in this case the address
7090          of the result.  */
7091       current_function_return_rtx = outgoing;
7092     }
7093
7094   /* If this is an implementation of throw, do what's necessary to
7095      communicate between __builtin_eh_return and the epilogue.  */
7096   expand_eh_return ();
7097
7098   /* Emit the actual code to clobber return register.  */
7099   {
7100     rtx seq, after;
7101
7102     start_sequence ();
7103     clobber_return_register ();
7104     seq = get_insns ();
7105     end_sequence ();
7106
7107     after = emit_insn_after (seq, clobber_after);
7108
7109     if (clobber_after != after)
7110       cfun->x_clobber_return_insn = after;
7111   }
7112
7113   /* ??? This should no longer be necessary since stupid is no longer with
7114      us, but there are some parts of the compiler (eg reload_combine, and
7115      sh mach_dep_reorg) that still try and compute their own lifetime info
7116      instead of using the general framework.  */
7117   use_return_register ();
7118
7119   /* Fix up any gotos that jumped out to the outermost
7120      binding level of the function.
7121      Must follow emitting RETURN_LABEL.  */
7122
7123   /* If you have any cleanups to do at this point,
7124      and they need to create temporary variables,
7125      then you will lose.  */
7126   expand_fixups (get_insns ());
7127 }
7128
7129 rtx
7130 get_arg_pointer_save_area (struct function *f)
7131 {
7132   rtx ret = f->x_arg_pointer_save_area;
7133
7134   if (! ret)
7135     {
7136       ret = assign_stack_local_1 (Pmode, GET_MODE_SIZE (Pmode), 0, f);
7137       f->x_arg_pointer_save_area = ret;
7138     }
7139
7140   if (f == cfun && ! f->arg_pointer_save_area_init)
7141     {
7142       rtx seq;
7143
7144       /* Save the arg pointer at the beginning of the function.  The
7145          generated stack slot may not be a valid memory address, so we
7146          have to check it and fix it if necessary.  */
7147       start_sequence ();
7148       emit_move_insn (validize_mem (ret), virtual_incoming_args_rtx);
7149       seq = get_insns ();
7150       end_sequence ();
7151
7152       push_topmost_sequence ();
7153       emit_insn_after (seq, get_insns ());
7154       pop_topmost_sequence ();
7155     }
7156
7157   return ret;
7158 }
7159 \f
7160 /* Extend a vector that records the INSN_UIDs of INSNS
7161    (a list of one or more insns).  */
7162
7163 static void
7164 record_insns (rtx insns, varray_type *vecp)
7165 {
7166   int i, len;
7167   rtx tmp;
7168
7169   tmp = insns;
7170   len = 0;
7171   while (tmp != NULL_RTX)
7172     {
7173       len++;
7174       tmp = NEXT_INSN (tmp);
7175     }
7176
7177   i = VARRAY_SIZE (*vecp);
7178   VARRAY_GROW (*vecp, i + len);
7179   tmp = insns;
7180   while (tmp != NULL_RTX)
7181     {
7182       VARRAY_INT (*vecp, i) = INSN_UID (tmp);
7183       i++;
7184       tmp = NEXT_INSN (tmp);
7185     }
7186 }
7187
7188 /* Set the specified locator to the insn chain.  */
7189 static void
7190 set_insn_locators (rtx insn, int loc)
7191 {
7192   while (insn != NULL_RTX)
7193     {
7194       if (INSN_P (insn))
7195         INSN_LOCATOR (insn) = loc;
7196       insn = NEXT_INSN (insn);
7197     }
7198 }
7199
7200 /* Determine how many INSN_UIDs in VEC are part of INSN.  Because we can
7201    be running after reorg, SEQUENCE rtl is possible.  */
7202
7203 static int
7204 contains (rtx insn, varray_type vec)
7205 {
7206   int i, j;
7207
7208   if (GET_CODE (insn) == INSN
7209       && GET_CODE (PATTERN (insn)) == SEQUENCE)
7210     {
7211       int count = 0;
7212       for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
7213         for (j = VARRAY_SIZE (vec) - 1; j >= 0; --j)
7214           if (INSN_UID (XVECEXP (PATTERN (insn), 0, i)) == VARRAY_INT (vec, j))
7215             count++;
7216       return count;
7217     }
7218   else
7219     {
7220       for (j = VARRAY_SIZE (vec) - 1; j >= 0; --j)
7221         if (INSN_UID (insn) == VARRAY_INT (vec, j))
7222           return 1;
7223     }
7224   return 0;
7225 }
7226
7227 int
7228 prologue_epilogue_contains (rtx insn)
7229 {
7230   if (contains (insn, prologue))
7231     return 1;
7232   if (contains (insn, epilogue))
7233     return 1;
7234   return 0;
7235 }
7236
7237 int
7238 sibcall_epilogue_contains (rtx insn)
7239 {
7240   if (sibcall_epilogue)
7241     return contains (insn, sibcall_epilogue);
7242   return 0;
7243 }
7244
7245 #ifdef HAVE_return
7246 /* Insert gen_return at the end of block BB.  This also means updating
7247    block_for_insn appropriately.  */
7248
7249 static void
7250 emit_return_into_block (basic_block bb, rtx line_note)
7251 {
7252   emit_jump_insn_after (gen_return (), bb->end);
7253   if (line_note)
7254     emit_note_copy_after (line_note, PREV_INSN (bb->end));
7255 }
7256 #endif /* HAVE_return */
7257
7258 #if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX)
7259
7260 /* These functions convert the epilogue into a variant that does not modify the
7261    stack pointer.  This is used in cases where a function returns an object
7262    whose size is not known until it is computed.  The called function leaves the
7263    object on the stack, leaves the stack depressed, and returns a pointer to
7264    the object.
7265
7266    What we need to do is track all modifications and references to the stack
7267    pointer, deleting the modifications and changing the references to point to
7268    the location the stack pointer would have pointed to had the modifications
7269    taken place.
7270
7271    These functions need to be portable so we need to make as few assumptions
7272    about the epilogue as we can.  However, the epilogue basically contains
7273    three things: instructions to reset the stack pointer, instructions to
7274    reload registers, possibly including the frame pointer, and an
7275    instruction to return to the caller.
7276
7277    If we can't be sure of what a relevant epilogue insn is doing, we abort.
7278    We also make no attempt to validate the insns we make since if they are
7279    invalid, we probably can't do anything valid.  The intent is that these
7280    routines get "smarter" as more and more machines start to use them and
7281    they try operating on different epilogues.
7282
7283    We use the following structure to track what the part of the epilogue that
7284    we've already processed has done.  We keep two copies of the SP equivalence,
7285    one for use during the insn we are processing and one for use in the next
7286    insn.  The difference is because one part of a PARALLEL may adjust SP
7287    and the other may use it.  */
7288
7289 struct epi_info
7290 {
7291   rtx sp_equiv_reg;             /* REG that SP is set from, perhaps SP.  */
7292   HOST_WIDE_INT sp_offset;      /* Offset from SP_EQUIV_REG of present SP.  */
7293   rtx new_sp_equiv_reg;         /* REG to be used at end of insn.  */
7294   HOST_WIDE_INT new_sp_offset;  /* Offset to be used at end of insn.  */
7295   rtx equiv_reg_src;            /* If nonzero, the value that SP_EQUIV_REG
7296                                    should be set to once we no longer need
7297                                    its value.  */
7298 };
7299
7300 static void handle_epilogue_set (rtx, struct epi_info *);
7301 static void emit_equiv_load (struct epi_info *);
7302
7303 /* Modify INSN, a list of one or more insns that is part of the epilogue, to
7304    no modifications to the stack pointer.  Return the new list of insns.  */
7305
7306 static rtx
7307 keep_stack_depressed (rtx insns)
7308 {
7309   int j;
7310   struct epi_info info;
7311   rtx insn, next;
7312
7313   /* If the epilogue is just a single instruction, it ust be OK as is.  */
7314
7315   if (NEXT_INSN (insns) == NULL_RTX)
7316     return insns;
7317
7318   /* Otherwise, start a sequence, initialize the information we have, and
7319      process all the insns we were given.  */
7320   start_sequence ();
7321
7322   info.sp_equiv_reg = stack_pointer_rtx;
7323   info.sp_offset = 0;
7324   info.equiv_reg_src = 0;
7325
7326   insn = insns;
7327   next = NULL_RTX;
7328   while (insn != NULL_RTX)
7329     {
7330       next = NEXT_INSN (insn);
7331
7332       if (!INSN_P (insn))
7333         {
7334           add_insn (insn);
7335           insn = next;
7336           continue;
7337         }
7338
7339       /* If this insn references the register that SP is equivalent to and
7340          we have a pending load to that register, we must force out the load
7341          first and then indicate we no longer know what SP's equivalent is.  */
7342       if (info.equiv_reg_src != 0
7343           && reg_referenced_p (info.sp_equiv_reg, PATTERN (insn)))
7344         {
7345           emit_equiv_load (&info);
7346           info.sp_equiv_reg = 0;
7347         }
7348
7349       info.new_sp_equiv_reg = info.sp_equiv_reg;
7350       info.new_sp_offset = info.sp_offset;
7351
7352       /* If this is a (RETURN) and the return address is on the stack,
7353          update the address and change to an indirect jump.  */
7354       if (GET_CODE (PATTERN (insn)) == RETURN
7355           || (GET_CODE (PATTERN (insn)) == PARALLEL
7356               && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == RETURN))
7357         {
7358           rtx retaddr = INCOMING_RETURN_ADDR_RTX;
7359           rtx base = 0;
7360           HOST_WIDE_INT offset = 0;
7361           rtx jump_insn, jump_set;
7362
7363           /* If the return address is in a register, we can emit the insn
7364              unchanged.  Otherwise, it must be a MEM and we see what the
7365              base register and offset are.  In any case, we have to emit any
7366              pending load to the equivalent reg of SP, if any.  */
7367           if (GET_CODE (retaddr) == REG)
7368             {
7369               emit_equiv_load (&info);
7370               add_insn (insn);
7371               insn = next;
7372               continue;
7373             }
7374           else if (GET_CODE (retaddr) == MEM
7375                    && GET_CODE (XEXP (retaddr, 0)) == REG)
7376             base = gen_rtx_REG (Pmode, REGNO (XEXP (retaddr, 0))), offset = 0;
7377           else if (GET_CODE (retaddr) == MEM
7378                    && GET_CODE (XEXP (retaddr, 0)) == PLUS
7379                    && GET_CODE (XEXP (XEXP (retaddr, 0), 0)) == REG
7380                    && GET_CODE (XEXP (XEXP (retaddr, 0), 1)) == CONST_INT)
7381             {
7382               base = gen_rtx_REG (Pmode, REGNO (XEXP (XEXP (retaddr, 0), 0)));
7383               offset = INTVAL (XEXP (XEXP (retaddr, 0), 1));
7384             }
7385           else
7386             abort ();
7387
7388           /* If the base of the location containing the return pointer
7389              is SP, we must update it with the replacement address.  Otherwise,
7390              just build the necessary MEM.  */
7391           retaddr = plus_constant (base, offset);
7392           if (base == stack_pointer_rtx)
7393             retaddr = simplify_replace_rtx (retaddr, stack_pointer_rtx,
7394                                             plus_constant (info.sp_equiv_reg,
7395                                                            info.sp_offset));
7396
7397           retaddr = gen_rtx_MEM (Pmode, retaddr);
7398
7399           /* If there is a pending load to the equivalent register for SP
7400              and we reference that register, we must load our address into
7401              a scratch register and then do that load.  */
7402           if (info.equiv_reg_src
7403               && reg_overlap_mentioned_p (info.equiv_reg_src, retaddr))
7404             {
7405               unsigned int regno;
7406               rtx reg;
7407
7408               for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
7409                 if (HARD_REGNO_MODE_OK (regno, Pmode)
7410                     && !fixed_regs[regno]
7411                     && TEST_HARD_REG_BIT (regs_invalidated_by_call, regno)
7412                     && !REGNO_REG_SET_P (EXIT_BLOCK_PTR->global_live_at_start,
7413                                          regno)
7414                     && !refers_to_regno_p (regno,
7415                                            regno + HARD_REGNO_NREGS (regno,
7416                                                                      Pmode),
7417                                            info.equiv_reg_src, NULL))
7418                   break;
7419
7420               if (regno == FIRST_PSEUDO_REGISTER)
7421                 abort ();
7422
7423               reg = gen_rtx_REG (Pmode, regno);
7424               emit_move_insn (reg, retaddr);
7425               retaddr = reg;
7426             }
7427
7428           emit_equiv_load (&info);
7429           jump_insn = emit_jump_insn (gen_indirect_jump (retaddr));
7430
7431           /* Show the SET in the above insn is a RETURN.  */
7432           jump_set = single_set (jump_insn);
7433           if (jump_set == 0)
7434             abort ();
7435           else
7436             SET_IS_RETURN_P (jump_set) = 1;
7437         }
7438
7439       /* If SP is not mentioned in the pattern and its equivalent register, if
7440          any, is not modified, just emit it.  Otherwise, if neither is set,
7441          replace the reference to SP and emit the insn.  If none of those are
7442          true, handle each SET individually.  */
7443       else if (!reg_mentioned_p (stack_pointer_rtx, PATTERN (insn))
7444                && (info.sp_equiv_reg == stack_pointer_rtx
7445                    || !reg_set_p (info.sp_equiv_reg, insn)))
7446         add_insn (insn);
7447       else if (! reg_set_p (stack_pointer_rtx, insn)
7448                && (info.sp_equiv_reg == stack_pointer_rtx
7449                    || !reg_set_p (info.sp_equiv_reg, insn)))
7450         {
7451           if (! validate_replace_rtx (stack_pointer_rtx,
7452                                       plus_constant (info.sp_equiv_reg,
7453                                                      info.sp_offset),
7454                                       insn))
7455             abort ();
7456
7457           add_insn (insn);
7458         }
7459       else if (GET_CODE (PATTERN (insn)) == SET)
7460         handle_epilogue_set (PATTERN (insn), &info);
7461       else if (GET_CODE (PATTERN (insn)) == PARALLEL)
7462         {
7463           for (j = 0; j < XVECLEN (PATTERN (insn), 0); j++)
7464             if (GET_CODE (XVECEXP (PATTERN (insn), 0, j)) == SET)
7465               handle_epilogue_set (XVECEXP (PATTERN (insn), 0, j), &info);
7466         }
7467       else
7468         add_insn (insn);
7469
7470       info.sp_equiv_reg = info.new_sp_equiv_reg;
7471       info.sp_offset = info.new_sp_offset;
7472
7473       insn = next;
7474     }
7475
7476   insns = get_insns ();
7477   end_sequence ();
7478   return insns;
7479 }
7480
7481 /* SET is a SET from an insn in the epilogue.  P is a pointer to the epi_info
7482    structure that contains information about what we've seen so far.  We
7483    process this SET by either updating that data or by emitting one or
7484    more insns.  */
7485
7486 static void
7487 handle_epilogue_set (rtx set, struct epi_info *p)
7488 {
7489   /* First handle the case where we are setting SP.  Record what it is being
7490      set from.  If unknown, abort.  */
7491   if (reg_set_p (stack_pointer_rtx, set))
7492     {
7493       if (SET_DEST (set) != stack_pointer_rtx)
7494         abort ();
7495
7496       if (GET_CODE (SET_SRC (set)) == PLUS
7497           && GET_CODE (XEXP (SET_SRC (set), 1)) == CONST_INT)
7498         {
7499           p->new_sp_equiv_reg = XEXP (SET_SRC (set), 0);
7500           p->new_sp_offset = INTVAL (XEXP (SET_SRC (set), 1));
7501         }
7502       else
7503         p->new_sp_equiv_reg = SET_SRC (set), p->new_sp_offset = 0;
7504
7505       /* If we are adjusting SP, we adjust from the old data.  */
7506       if (p->new_sp_equiv_reg == stack_pointer_rtx)
7507         {
7508           p->new_sp_equiv_reg = p->sp_equiv_reg;
7509           p->new_sp_offset += p->sp_offset;
7510         }
7511
7512       if (p->new_sp_equiv_reg == 0 || GET_CODE (p->new_sp_equiv_reg) != REG)
7513         abort ();
7514
7515       return;
7516     }
7517
7518   /* Next handle the case where we are setting SP's equivalent register.
7519      If we already have a value to set it to, abort.  We could update, but
7520      there seems little point in handling that case.  Note that we have
7521      to allow for the case where we are setting the register set in
7522      the previous part of a PARALLEL inside a single insn.  But use the
7523      old offset for any updates within this insn.  */
7524   else if (p->new_sp_equiv_reg != 0 && reg_set_p (p->new_sp_equiv_reg, set))
7525     {
7526       if (!rtx_equal_p (p->new_sp_equiv_reg, SET_DEST (set))
7527           || p->equiv_reg_src != 0)
7528         abort ();
7529       else
7530         p->equiv_reg_src
7531           = simplify_replace_rtx (SET_SRC (set), stack_pointer_rtx,
7532                                   plus_constant (p->sp_equiv_reg,
7533                                                  p->sp_offset));
7534     }
7535
7536   /* Otherwise, replace any references to SP in the insn to its new value
7537      and emit the insn.  */
7538   else
7539     {
7540       SET_SRC (set) = simplify_replace_rtx (SET_SRC (set), stack_pointer_rtx,
7541                                             plus_constant (p->sp_equiv_reg,
7542                                                            p->sp_offset));
7543       SET_DEST (set) = simplify_replace_rtx (SET_DEST (set), stack_pointer_rtx,
7544                                              plus_constant (p->sp_equiv_reg,
7545                                                             p->sp_offset));
7546       emit_insn (set);
7547     }
7548 }
7549
7550 /* Emit an insn to do the load shown in p->equiv_reg_src, if needed.  */
7551
7552 static void
7553 emit_equiv_load (struct epi_info *p)
7554 {
7555   if (p->equiv_reg_src != 0)
7556     emit_move_insn (p->sp_equiv_reg, p->equiv_reg_src);
7557
7558   p->equiv_reg_src = 0;
7559 }
7560 #endif
7561
7562 /* Generate the prologue and epilogue RTL if the machine supports it.  Thread
7563    this into place with notes indicating where the prologue ends and where
7564    the epilogue begins.  Update the basic block information when possible.  */
7565
7566 void
7567 thread_prologue_and_epilogue_insns (rtx f ATTRIBUTE_UNUSED)
7568 {
7569   int inserted = 0;
7570   edge e;
7571 #if defined (HAVE_sibcall_epilogue) || defined (HAVE_epilogue) || defined (HAVE_return) || defined (HAVE_prologue)
7572   rtx seq;
7573 #endif
7574 #ifdef HAVE_prologue
7575   rtx prologue_end = NULL_RTX;
7576 #endif
7577 #if defined (HAVE_epilogue) || defined(HAVE_return)
7578   rtx epilogue_end = NULL_RTX;
7579 #endif
7580
7581 #ifdef HAVE_prologue
7582   if (HAVE_prologue)
7583     {
7584       start_sequence ();
7585       seq = gen_prologue ();
7586       emit_insn (seq);
7587
7588       /* Retain a map of the prologue insns.  */
7589       record_insns (seq, &prologue);
7590       prologue_end = emit_note (NOTE_INSN_PROLOGUE_END);
7591
7592       seq = get_insns ();
7593       end_sequence ();
7594       set_insn_locators (seq, prologue_locator);
7595
7596       /* Can't deal with multiple successors of the entry block
7597          at the moment.  Function should always have at least one
7598          entry point.  */
7599       if (!ENTRY_BLOCK_PTR->succ || ENTRY_BLOCK_PTR->succ->succ_next)
7600         abort ();
7601
7602       insert_insn_on_edge (seq, ENTRY_BLOCK_PTR->succ);
7603       inserted = 1;
7604     }
7605 #endif
7606
7607   /* If the exit block has no non-fake predecessors, we don't need
7608      an epilogue.  */
7609   for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
7610     if ((e->flags & EDGE_FAKE) == 0)
7611       break;
7612   if (e == NULL)
7613     goto epilogue_done;
7614
7615 #ifdef HAVE_return
7616   if (optimize && HAVE_return)
7617     {
7618       /* If we're allowed to generate a simple return instruction,
7619          then by definition we don't need a full epilogue.  Examine
7620          the block that falls through to EXIT.   If it does not
7621          contain any code, examine its predecessors and try to
7622          emit (conditional) return instructions.  */
7623
7624       basic_block last;
7625       edge e_next;
7626       rtx label;
7627
7628       for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
7629         if (e->flags & EDGE_FALLTHRU)
7630           break;
7631       if (e == NULL)
7632         goto epilogue_done;
7633       last = e->src;
7634
7635       /* Verify that there are no active instructions in the last block.  */
7636       label = last->end;
7637       while (label && GET_CODE (label) != CODE_LABEL)
7638         {
7639           if (active_insn_p (label))
7640             break;
7641           label = PREV_INSN (label);
7642         }
7643
7644       if (last->head == label && GET_CODE (label) == CODE_LABEL)
7645         {
7646           rtx epilogue_line_note = NULL_RTX;
7647
7648           /* Locate the line number associated with the closing brace,
7649              if we can find one.  */
7650           for (seq = get_last_insn ();
7651                seq && ! active_insn_p (seq);
7652                seq = PREV_INSN (seq))
7653             if (GET_CODE (seq) == NOTE && NOTE_LINE_NUMBER (seq) > 0)
7654               {
7655                 epilogue_line_note = seq;
7656                 break;
7657               }
7658
7659           for (e = last->pred; e; e = e_next)
7660             {
7661               basic_block bb = e->src;
7662               rtx jump;
7663
7664               e_next = e->pred_next;
7665               if (bb == ENTRY_BLOCK_PTR)
7666                 continue;
7667
7668               jump = bb->end;
7669               if ((GET_CODE (jump) != JUMP_INSN) || JUMP_LABEL (jump) != label)
7670                 continue;
7671
7672               /* If we have an unconditional jump, we can replace that
7673                  with a simple return instruction.  */
7674               if (simplejump_p (jump))
7675                 {
7676                   emit_return_into_block (bb, epilogue_line_note);
7677                   delete_insn (jump);
7678                 }
7679
7680               /* If we have a conditional jump, we can try to replace
7681                  that with a conditional return instruction.  */
7682               else if (condjump_p (jump))
7683                 {
7684                   if (! redirect_jump (jump, 0, 0))
7685                     continue;
7686
7687                   /* If this block has only one successor, it both jumps
7688                      and falls through to the fallthru block, so we can't
7689                      delete the edge.  */
7690                   if (bb->succ->succ_next == NULL)
7691                     continue;
7692                 }
7693               else
7694                 continue;
7695
7696               /* Fix up the CFG for the successful change we just made.  */
7697               redirect_edge_succ (e, EXIT_BLOCK_PTR);
7698             }
7699
7700           /* Emit a return insn for the exit fallthru block.  Whether
7701              this is still reachable will be determined later.  */
7702
7703           emit_barrier_after (last->end);
7704           emit_return_into_block (last, epilogue_line_note);
7705           epilogue_end = last->end;
7706           last->succ->flags &= ~EDGE_FALLTHRU;
7707           goto epilogue_done;
7708         }
7709     }
7710 #endif
7711 #ifdef HAVE_epilogue
7712   if (HAVE_epilogue)
7713     {
7714       /* Find the edge that falls through to EXIT.  Other edges may exist
7715          due to RETURN instructions, but those don't need epilogues.
7716          There really shouldn't be a mixture -- either all should have
7717          been converted or none, however...  */
7718
7719       for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
7720         if (e->flags & EDGE_FALLTHRU)
7721           break;
7722       if (e == NULL)
7723         goto epilogue_done;
7724
7725       start_sequence ();
7726       epilogue_end = emit_note (NOTE_INSN_EPILOGUE_BEG);
7727
7728       seq = gen_epilogue ();
7729
7730 #ifdef INCOMING_RETURN_ADDR_RTX
7731       /* If this function returns with the stack depressed and we can support
7732          it, massage the epilogue to actually do that.  */
7733       if (TREE_CODE (TREE_TYPE (current_function_decl)) == FUNCTION_TYPE
7734           && TYPE_RETURNS_STACK_DEPRESSED (TREE_TYPE (current_function_decl)))
7735         seq = keep_stack_depressed (seq);
7736 #endif
7737
7738       emit_jump_insn (seq);
7739
7740       /* Retain a map of the epilogue insns.  */
7741       record_insns (seq, &epilogue);
7742       set_insn_locators (seq, epilogue_locator);
7743
7744       seq = get_insns ();
7745       end_sequence ();
7746
7747       insert_insn_on_edge (seq, e);
7748       inserted = 1;
7749     }
7750 #endif
7751 epilogue_done:
7752
7753   if (inserted)
7754     commit_edge_insertions ();
7755
7756 #ifdef HAVE_sibcall_epilogue
7757   /* Emit sibling epilogues before any sibling call sites.  */
7758   for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
7759     {
7760       basic_block bb = e->src;
7761       rtx insn = bb->end;
7762       rtx i;
7763       rtx newinsn;
7764
7765       if (GET_CODE (insn) != CALL_INSN
7766           || ! SIBLING_CALL_P (insn))
7767         continue;
7768
7769       start_sequence ();
7770       emit_insn (gen_sibcall_epilogue ());
7771       seq = get_insns ();
7772       end_sequence ();
7773
7774       /* Retain a map of the epilogue insns.  Used in life analysis to
7775          avoid getting rid of sibcall epilogue insns.  Do this before we
7776          actually emit the sequence.  */
7777       record_insns (seq, &sibcall_epilogue);
7778       set_insn_locators (seq, epilogue_locator);
7779
7780       i = PREV_INSN (insn);
7781       newinsn = emit_insn_before (seq, insn);
7782     }
7783 #endif
7784
7785 #ifdef HAVE_prologue
7786   if (prologue_end)
7787     {
7788       rtx insn, prev;
7789
7790       /* GDB handles `break f' by setting a breakpoint on the first
7791          line note after the prologue.  Which means (1) that if
7792          there are line number notes before where we inserted the
7793          prologue we should move them, and (2) we should generate a
7794          note before the end of the first basic block, if there isn't
7795          one already there.
7796
7797          ??? This behavior is completely broken when dealing with
7798          multiple entry functions.  We simply place the note always
7799          into first basic block and let alternate entry points
7800          to be missed.
7801        */
7802
7803       for (insn = prologue_end; insn; insn = prev)
7804         {
7805           prev = PREV_INSN (insn);
7806           if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
7807             {
7808               /* Note that we cannot reorder the first insn in the
7809                  chain, since rest_of_compilation relies on that
7810                  remaining constant.  */
7811               if (prev == NULL)
7812                 break;
7813               reorder_insns (insn, insn, prologue_end);
7814             }
7815         }
7816
7817       /* Find the last line number note in the first block.  */
7818       for (insn = ENTRY_BLOCK_PTR->next_bb->end;
7819            insn != prologue_end && insn;
7820            insn = PREV_INSN (insn))
7821         if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
7822           break;
7823
7824       /* If we didn't find one, make a copy of the first line number
7825          we run across.  */
7826       if (! insn)
7827         {
7828           for (insn = next_active_insn (prologue_end);
7829                insn;
7830                insn = PREV_INSN (insn))
7831             if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
7832               {
7833                 emit_note_copy_after (insn, prologue_end);
7834                 break;
7835               }
7836         }
7837     }
7838 #endif
7839 #ifdef HAVE_epilogue
7840   if (epilogue_end)
7841     {
7842       rtx insn, next;
7843
7844       /* Similarly, move any line notes that appear after the epilogue.
7845          There is no need, however, to be quite so anal about the existence
7846          of such a note.  */
7847       for (insn = epilogue_end; insn; insn = next)
7848         {
7849           next = NEXT_INSN (insn);
7850           if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
7851             reorder_insns (insn, insn, PREV_INSN (epilogue_end));
7852         }
7853     }
7854 #endif
7855 }
7856
7857 /* Reposition the prologue-end and epilogue-begin notes after instruction
7858    scheduling and delayed branch scheduling.  */
7859
7860 void
7861 reposition_prologue_and_epilogue_notes (rtx f ATTRIBUTE_UNUSED)
7862 {
7863 #if defined (HAVE_prologue) || defined (HAVE_epilogue)
7864   rtx insn, last, note;
7865   int len;
7866
7867   if ((len = VARRAY_SIZE (prologue)) > 0)
7868     {
7869       last = 0, note = 0;
7870
7871       /* Scan from the beginning until we reach the last prologue insn.
7872          We apparently can't depend on basic_block_{head,end} after
7873          reorg has run.  */
7874       for (insn = f; insn; insn = NEXT_INSN (insn))
7875         {
7876           if (GET_CODE (insn) == NOTE)
7877             {
7878               if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PROLOGUE_END)
7879                 note = insn;
7880             }
7881           else if (contains (insn, prologue))
7882             {
7883               last = insn;
7884               if (--len == 0)
7885                 break;
7886             }
7887         }
7888
7889       if (last)
7890         {
7891           /* Find the prologue-end note if we haven't already, and
7892              move it to just after the last prologue insn.  */
7893           if (note == 0)
7894             {
7895               for (note = last; (note = NEXT_INSN (note));)
7896                 if (GET_CODE (note) == NOTE
7897                     && NOTE_LINE_NUMBER (note) == NOTE_INSN_PROLOGUE_END)
7898                   break;
7899             }
7900
7901           /* Avoid placing note between CODE_LABEL and BASIC_BLOCK note.  */
7902           if (GET_CODE (last) == CODE_LABEL)
7903             last = NEXT_INSN (last);
7904           reorder_insns (note, note, last);
7905         }
7906     }
7907
7908   if ((len = VARRAY_SIZE (epilogue)) > 0)
7909     {
7910       last = 0, note = 0;
7911
7912       /* Scan from the end until we reach the first epilogue insn.
7913          We apparently can't depend on basic_block_{head,end} after
7914          reorg has run.  */
7915       for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
7916         {
7917           if (GET_CODE (insn) == NOTE)
7918             {
7919               if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EPILOGUE_BEG)
7920                 note = insn;
7921             }
7922           else if (contains (insn, epilogue))
7923             {
7924               last = insn;
7925               if (--len == 0)
7926                 break;
7927             }
7928         }
7929
7930       if (last)
7931         {
7932           /* Find the epilogue-begin note if we haven't already, and
7933              move it to just before the first epilogue insn.  */
7934           if (note == 0)
7935             {
7936               for (note = insn; (note = PREV_INSN (note));)
7937                 if (GET_CODE (note) == NOTE
7938                     && NOTE_LINE_NUMBER (note) == NOTE_INSN_EPILOGUE_BEG)
7939                   break;
7940             }
7941
7942           if (PREV_INSN (last) != note)
7943             reorder_insns (note, note, PREV_INSN (last));
7944         }
7945     }
7946 #endif /* HAVE_prologue or HAVE_epilogue */
7947 }
7948
7949 /* Called once, at initialization, to initialize function.c.  */
7950
7951 void
7952 init_function_once (void)
7953 {
7954   VARRAY_INT_INIT (prologue, 0, "prologue");
7955   VARRAY_INT_INIT (epilogue, 0, "epilogue");
7956   VARRAY_INT_INIT (sibcall_epilogue, 0, "sibcall_epilogue");
7957 }
7958
7959 #include "gt-function.h"