contrib/gcc/function.c

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