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