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