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