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