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