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