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