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