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