gcc/function.c

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