gcc/function.c

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