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 x = gen_rtx_MEM (DECL_MODE (result), DECL_RTL (parm));
5022
5023           set_mem_attributes (x, result, 1);
5024           SET_DECL_RTL (result, x);
5025         }
5026
5027       if (GET_CODE (DECL_RTL (parm)) == REG)
5028         REGNO_DECL (REGNO (DECL_RTL (parm))) = parm;
5029       else if (GET_CODE (DECL_RTL (parm)) == CONCAT)
5030         {
5031           REGNO_DECL (REGNO (XEXP (DECL_RTL (parm), 0))) = parm;
5032           REGNO_DECL (REGNO (XEXP (DECL_RTL (parm), 1))) = parm;
5033         }
5034
5035     }
5036
5037   /* Output all parameter conversion instructions (possibly including calls)
5038      now that all parameters have been copied out of hard registers.  */
5039   emit_insns (conversion_insns);
5040
5041   last_parm_insn = get_last_insn ();
5042
5043   current_function_args_size = stack_args_size.constant;
5044
5045   /* Adjust function incoming argument size for alignment and
5046      minimum length.  */
5047
5048 #ifdef REG_PARM_STACK_SPACE
5049 #ifndef MAYBE_REG_PARM_STACK_SPACE
5050   current_function_args_size = MAX (current_function_args_size,
5051                                     REG_PARM_STACK_SPACE (fndecl));
5052 #endif
5053 #endif
5054
5055 #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
5056
5057   current_function_args_size
5058     = ((current_function_args_size + STACK_BYTES - 1)
5059        / STACK_BYTES) * STACK_BYTES;
5060
5061 #ifdef ARGS_GROW_DOWNWARD
5062   current_function_arg_offset_rtx
5063     = (stack_args_size.var == 0 ? GEN_INT (-stack_args_size.constant)
5064        : expand_expr (size_diffop (stack_args_size.var,
5065                                    size_int (-stack_args_size.constant)),
5066                       NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_BAD));
5067 #else
5068   current_function_arg_offset_rtx = ARGS_SIZE_RTX (stack_args_size);
5069 #endif
5070
5071   /* See how many bytes, if any, of its args a function should try to pop
5072      on return.  */
5073
5074   current_function_pops_args = RETURN_POPS_ARGS (fndecl, TREE_TYPE (fndecl),
5075                                                  current_function_args_size);
5076
5077   /* For stdarg.h function, save info about
5078      regs and stack space used by the named args.  */
5079
5080   if (!hide_last_arg)
5081     current_function_args_info = args_so_far;
5082
5083   /* Set the rtx used for the function return value.  Put this in its
5084      own variable so any optimizers that need this information don't have
5085      to include tree.h.  Do this here so it gets done when an inlined
5086      function gets output.  */
5087
5088   current_function_return_rtx
5089     = (DECL_RTL_SET_P (DECL_RESULT (fndecl))
5090        ? DECL_RTL (DECL_RESULT (fndecl)) : NULL_RTX);
5091 }
5092 \f
5093 /* Indicate whether REGNO is an incoming argument to the current function
5094    that was promoted to a wider mode.  If so, return the RTX for the
5095    register (to get its mode).  PMODE and PUNSIGNEDP are set to the mode
5096    that REGNO is promoted from and whether the promotion was signed or
5097    unsigned.  */
5098
5099 #ifdef PROMOTE_FUNCTION_ARGS
5100
5101 rtx
5102 promoted_input_arg (regno, pmode, punsignedp)
5103      unsigned int regno;
5104      enum machine_mode *pmode;
5105      int *punsignedp;
5106 {
5107   tree arg;
5108
5109   for (arg = DECL_ARGUMENTS (current_function_decl); arg;
5110        arg = TREE_CHAIN (arg))
5111     if (GET_CODE (DECL_INCOMING_RTL (arg)) == REG
5112         && REGNO (DECL_INCOMING_RTL (arg)) == regno
5113         && TYPE_MODE (DECL_ARG_TYPE (arg)) == TYPE_MODE (TREE_TYPE (arg)))
5114       {
5115         enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg));
5116         int unsignedp = TREE_UNSIGNED (TREE_TYPE (arg));
5117
5118         mode = promote_mode (TREE_TYPE (arg), mode, &unsignedp, 1);
5119         if (mode == GET_MODE (DECL_INCOMING_RTL (arg))
5120             && mode != DECL_MODE (arg))
5121           {
5122             *pmode = DECL_MODE (arg);
5123             *punsignedp = unsignedp;
5124             return DECL_INCOMING_RTL (arg);
5125           }
5126       }
5127
5128   return 0;
5129 }
5130
5131 #endif
5132 \f
5133 /* Compute the size and offset from the start of the stacked arguments for a
5134    parm passed in mode PASSED_MODE and with type TYPE.
5135
5136    INITIAL_OFFSET_PTR points to the current offset into the stacked
5137    arguments.
5138
5139    The starting offset and size for this parm are returned in *OFFSET_PTR
5140    and *ARG_SIZE_PTR, respectively.
5141
5142    IN_REGS is non-zero if the argument will be passed in registers.  It will
5143    never be set if REG_PARM_STACK_SPACE is not defined.
5144
5145    FNDECL is the function in which the argument was defined.
5146
5147    There are two types of rounding that are done.  The first, controlled by
5148    FUNCTION_ARG_BOUNDARY, forces the offset from the start of the argument
5149    list to be aligned to the specific boundary (in bits).  This rounding
5150    affects the initial and starting offsets, but not the argument size.
5151
5152    The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY,
5153    optionally rounds the size of the parm to PARM_BOUNDARY.  The
5154    initial offset is not affected by this rounding, while the size always
5155    is and the starting offset may be.  */
5156
5157 /*  offset_ptr will be negative for ARGS_GROW_DOWNWARD case;
5158     initial_offset_ptr is positive because locate_and_pad_parm's
5159     callers pass in the total size of args so far as
5160     initial_offset_ptr. arg_size_ptr is always positive.*/
5161
5162 void
5163 locate_and_pad_parm (passed_mode, type, in_regs, fndecl,
5164                      initial_offset_ptr, offset_ptr, arg_size_ptr,
5165                      alignment_pad)
5166      enum machine_mode passed_mode;
5167      tree type;
5168      int in_regs ATTRIBUTE_UNUSED;
5169      tree fndecl ATTRIBUTE_UNUSED;
5170      struct args_size *initial_offset_ptr;
5171      struct args_size *offset_ptr;
5172      struct args_size *arg_size_ptr;
5173      struct args_size *alignment_pad;
5174
5175 {
5176   tree sizetree
5177     = type ? size_in_bytes (type) : size_int (GET_MODE_SIZE (passed_mode));
5178   enum direction where_pad = FUNCTION_ARG_PADDING (passed_mode, type);
5179   int boundary = FUNCTION_ARG_BOUNDARY (passed_mode, type);
5180
5181 #ifdef REG_PARM_STACK_SPACE
5182   /* If we have found a stack parm before we reach the end of the
5183      area reserved for registers, skip that area.  */
5184   if (! in_regs)
5185     {
5186       int reg_parm_stack_space = 0;
5187
5188 #ifdef MAYBE_REG_PARM_STACK_SPACE
5189       reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
5190 #else
5191       reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
5192 #endif
5193       if (reg_parm_stack_space > 0)
5194         {
5195           if (initial_offset_ptr->var)
5196             {
5197               initial_offset_ptr->var
5198                 = size_binop (MAX_EXPR, ARGS_SIZE_TREE (*initial_offset_ptr),
5199                               ssize_int (reg_parm_stack_space));
5200               initial_offset_ptr->constant = 0;
5201             }
5202           else if (initial_offset_ptr->constant < reg_parm_stack_space)
5203             initial_offset_ptr->constant = reg_parm_stack_space;
5204         }
5205     }
5206 #endif /* REG_PARM_STACK_SPACE */
5207
5208   arg_size_ptr->var = 0;
5209   arg_size_ptr->constant = 0;
5210   alignment_pad->var = 0;
5211   alignment_pad->constant = 0;
5212
5213 #ifdef ARGS_GROW_DOWNWARD
5214   if (initial_offset_ptr->var)
5215     {
5216       offset_ptr->constant = 0;
5217       offset_ptr->var = size_binop (MINUS_EXPR, ssize_int (0),
5218                                     initial_offset_ptr->var);
5219     }
5220   else
5221     {
5222       offset_ptr->constant = -initial_offset_ptr->constant;
5223       offset_ptr->var = 0;
5224     }
5225   if (where_pad != none
5226       && (!host_integerp (sizetree, 1)
5227           || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % PARM_BOUNDARY))
5228     sizetree = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT);
5229   SUB_PARM_SIZE (*offset_ptr, sizetree);
5230   if (where_pad != downward)
5231     pad_to_arg_alignment (offset_ptr, boundary, alignment_pad);
5232   if (initial_offset_ptr->var)
5233     arg_size_ptr->var = size_binop (MINUS_EXPR,
5234                                     size_binop (MINUS_EXPR,
5235                                                 ssize_int (0),
5236                                                 initial_offset_ptr->var),
5237                                     offset_ptr->var);
5238
5239   else
5240     arg_size_ptr->constant = (-initial_offset_ptr->constant
5241                               - offset_ptr->constant);
5242
5243 #else /* !ARGS_GROW_DOWNWARD */
5244   if (!in_regs
5245 #ifdef REG_PARM_STACK_SPACE
5246       || REG_PARM_STACK_SPACE (fndecl) > 0
5247 #endif
5248       )
5249     pad_to_arg_alignment (initial_offset_ptr, boundary, alignment_pad);
5250   *offset_ptr = *initial_offset_ptr;
5251
5252 #ifdef PUSH_ROUNDING
5253   if (passed_mode != BLKmode)
5254     sizetree = size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree)));
5255 #endif
5256
5257   /* Pad_below needs the pre-rounded size to know how much to pad below
5258      so this must be done before rounding up.  */
5259   if (where_pad == downward
5260     /* However, BLKmode args passed in regs have their padding done elsewhere.
5261        The stack slot must be able to hold the entire register.  */
5262       && !(in_regs && passed_mode == BLKmode))
5263     pad_below (offset_ptr, passed_mode, sizetree);
5264
5265   if (where_pad != none
5266       && (!host_integerp (sizetree, 1)
5267           || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % PARM_BOUNDARY))
5268     sizetree = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT);
5269
5270   ADD_PARM_SIZE (*arg_size_ptr, sizetree);
5271 #endif /* ARGS_GROW_DOWNWARD */
5272 }
5273
5274 /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY.
5275    BOUNDARY is measured in bits, but must be a multiple of a storage unit.  */
5276
5277 static void
5278 pad_to_arg_alignment (offset_ptr, boundary, alignment_pad)
5279      struct args_size *offset_ptr;
5280      int boundary;
5281      struct args_size *alignment_pad;
5282 {
5283   tree save_var = NULL_TREE;
5284   HOST_WIDE_INT save_constant = 0;
5285
5286   int boundary_in_bytes = boundary / BITS_PER_UNIT;
5287
5288   if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
5289     {
5290       save_var = offset_ptr->var;
5291       save_constant = offset_ptr->constant;
5292     }
5293
5294   alignment_pad->var = NULL_TREE;
5295   alignment_pad->constant = 0;
5296
5297   if (boundary > BITS_PER_UNIT)
5298     {
5299       if (offset_ptr->var)
5300         {
5301           offset_ptr->var =
5302 #ifdef ARGS_GROW_DOWNWARD
5303             round_down
5304 #else
5305             round_up
5306 #endif
5307               (ARGS_SIZE_TREE (*offset_ptr),
5308                boundary / BITS_PER_UNIT);
5309           offset_ptr->constant = 0; /*?*/
5310           if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
5311             alignment_pad->var = size_binop (MINUS_EXPR, offset_ptr->var,
5312                                              save_var);
5313         }
5314       else
5315         {
5316           offset_ptr->constant =
5317 #ifdef ARGS_GROW_DOWNWARD
5318             FLOOR_ROUND (offset_ptr->constant, boundary_in_bytes);
5319 #else
5320             CEIL_ROUND (offset_ptr->constant, boundary_in_bytes);
5321 #endif
5322             if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
5323               alignment_pad->constant = offset_ptr->constant - save_constant;
5324         }
5325     }
5326 }
5327
5328 #ifndef ARGS_GROW_DOWNWARD
5329 static void
5330 pad_below (offset_ptr, passed_mode, sizetree)
5331      struct args_size *offset_ptr;
5332      enum machine_mode passed_mode;
5333      tree sizetree;
5334 {
5335   if (passed_mode != BLKmode)
5336     {
5337       if (GET_MODE_BITSIZE (passed_mode) % PARM_BOUNDARY)
5338         offset_ptr->constant
5339           += (((GET_MODE_BITSIZE (passed_mode) + PARM_BOUNDARY - 1)
5340                / PARM_BOUNDARY * PARM_BOUNDARY / BITS_PER_UNIT)
5341               - GET_MODE_SIZE (passed_mode));
5342     }
5343   else
5344     {
5345       if (TREE_CODE (sizetree) != INTEGER_CST
5346           || (TREE_INT_CST_LOW (sizetree) * BITS_PER_UNIT) % PARM_BOUNDARY)
5347         {
5348           /* Round the size up to multiple of PARM_BOUNDARY bits.  */
5349           tree s2 = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT);
5350           /* Add it in.  */
5351           ADD_PARM_SIZE (*offset_ptr, s2);
5352           SUB_PARM_SIZE (*offset_ptr, sizetree);
5353         }
5354     }
5355 }
5356 #endif
5357 \f
5358 /* Walk the tree of blocks describing the binding levels within a function
5359    and warn about uninitialized variables.
5360    This is done after calling flow_analysis and before global_alloc
5361    clobbers the pseudo-regs to hard regs.  */
5362
5363 void
5364 uninitialized_vars_warning (block)
5365      tree block;
5366 {
5367   tree decl, sub;
5368   for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
5369     {
5370       if (warn_uninitialized
5371           && TREE_CODE (decl) == VAR_DECL
5372           /* These warnings are unreliable for and aggregates
5373              because assigning the fields one by one can fail to convince
5374              flow.c that the entire aggregate was initialized.
5375              Unions are troublesome because members may be shorter.  */
5376           && ! AGGREGATE_TYPE_P (TREE_TYPE (decl))
5377           && DECL_RTL (decl) != 0
5378           && GET_CODE (DECL_RTL (decl)) == REG
5379           /* Global optimizations can make it difficult to determine if a
5380              particular variable has been initialized.  However, a VAR_DECL
5381              with a nonzero DECL_INITIAL had an initializer, so do not
5382              claim it is potentially uninitialized.
5383
5384              We do not care about the actual value in DECL_INITIAL, so we do
5385              not worry that it may be a dangling pointer.  */
5386           && DECL_INITIAL (decl) == NULL_TREE
5387           && regno_uninitialized (REGNO (DECL_RTL (decl))))
5388         warning_with_decl (decl,
5389                            "`%s' might be used uninitialized in this function");
5390       if (extra_warnings
5391           && TREE_CODE (decl) == VAR_DECL
5392           && DECL_RTL (decl) != 0
5393           && GET_CODE (DECL_RTL (decl)) == REG
5394           && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl))))
5395         warning_with_decl (decl,
5396                            "variable `%s' might be clobbered by `longjmp' or `vfork'");
5397     }
5398   for (sub = BLOCK_SUBBLOCKS (block); sub; sub = TREE_CHAIN (sub))
5399     uninitialized_vars_warning (sub);
5400 }
5401
5402 /* Do the appropriate part of uninitialized_vars_warning
5403    but for arguments instead of local variables.  */
5404
5405 void
5406 setjmp_args_warning ()
5407 {
5408   tree decl;
5409   for (decl = DECL_ARGUMENTS (current_function_decl);
5410        decl; decl = TREE_CHAIN (decl))
5411     if (DECL_RTL (decl) != 0
5412         && GET_CODE (DECL_RTL (decl)) == REG
5413         && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl))))
5414       warning_with_decl (decl,
5415                          "argument `%s' might be clobbered by `longjmp' or `vfork'");
5416 }
5417
5418 /* If this function call setjmp, put all vars into the stack
5419    unless they were declared `register'.  */
5420
5421 void
5422 setjmp_protect (block)
5423      tree block;
5424 {
5425   tree decl, sub;
5426   for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
5427     if ((TREE_CODE (decl) == VAR_DECL
5428          || TREE_CODE (decl) == PARM_DECL)
5429         && DECL_RTL (decl) != 0
5430         && (GET_CODE (DECL_RTL (decl)) == REG
5431             || (GET_CODE (DECL_RTL (decl)) == MEM
5432                 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF))
5433         /* If this variable came from an inline function, it must be
5434            that its life doesn't overlap the setjmp.  If there was a
5435            setjmp in the function, it would already be in memory.  We
5436            must exclude such variable because their DECL_RTL might be
5437            set to strange things such as virtual_stack_vars_rtx.  */
5438         && ! DECL_FROM_INLINE (decl)
5439         && (
5440 #ifdef NON_SAVING_SETJMP
5441             /* If longjmp doesn't restore the registers,
5442                don't put anything in them.  */
5443             NON_SAVING_SETJMP
5444             ||
5445 #endif
5446             ! DECL_REGISTER (decl)))
5447       put_var_into_stack (decl);
5448   for (sub = BLOCK_SUBBLOCKS (block); sub; sub = TREE_CHAIN (sub))
5449     setjmp_protect (sub);
5450 }
5451 \f
5452 /* Like the previous function, but for args instead of local variables.  */
5453
5454 void
5455 setjmp_protect_args ()
5456 {
5457   tree decl;
5458   for (decl = DECL_ARGUMENTS (current_function_decl);
5459        decl; decl = TREE_CHAIN (decl))
5460     if ((TREE_CODE (decl) == VAR_DECL
5461          || TREE_CODE (decl) == PARM_DECL)
5462         && DECL_RTL (decl) != 0
5463         && (GET_CODE (DECL_RTL (decl)) == REG
5464             || (GET_CODE (DECL_RTL (decl)) == MEM
5465                 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF))
5466         && (
5467             /* If longjmp doesn't restore the registers,
5468                don't put anything in them.  */
5469 #ifdef NON_SAVING_SETJMP
5470             NON_SAVING_SETJMP
5471             ||
5472 #endif
5473             ! DECL_REGISTER (decl)))
5474       put_var_into_stack (decl);
5475 }
5476 \f
5477 /* Return the context-pointer register corresponding to DECL,
5478    or 0 if it does not need one.  */
5479
5480 rtx
5481 lookup_static_chain (decl)
5482      tree decl;
5483 {
5484   tree context = decl_function_context (decl);
5485   tree link;
5486
5487   if (context == 0
5488       || (TREE_CODE (decl) == FUNCTION_DECL && DECL_NO_STATIC_CHAIN (decl)))
5489     return 0;
5490
5491   /* We treat inline_function_decl as an alias for the current function
5492      because that is the inline function whose vars, types, etc.
5493      are being merged into the current function.
5494      See expand_inline_function.  */
5495   if (context == current_function_decl || context == inline_function_decl)
5496     return virtual_stack_vars_rtx;
5497
5498   for (link = context_display; link; link = TREE_CHAIN (link))
5499     if (TREE_PURPOSE (link) == context)
5500       return RTL_EXPR_RTL (TREE_VALUE (link));
5501
5502   abort ();
5503 }
5504 \f
5505 /* Convert a stack slot address ADDR for variable VAR
5506    (from a containing function)
5507    into an address valid in this function (using a static chain).  */
5508
5509 rtx
5510 fix_lexical_addr (addr, var)
5511      rtx addr;
5512      tree var;
5513 {
5514   rtx basereg;
5515   HOST_WIDE_INT displacement;
5516   tree context = decl_function_context (var);
5517   struct function *fp;
5518   rtx base = 0;
5519
5520   /* If this is the present function, we need not do anything.  */
5521   if (context == current_function_decl || context == inline_function_decl)
5522     return addr;
5523
5524   fp = find_function_data (context);
5525
5526   if (GET_CODE (addr) == ADDRESSOF && GET_CODE (XEXP (addr, 0)) == MEM)
5527     addr = XEXP (XEXP (addr, 0), 0);
5528
5529   /* Decode given address as base reg plus displacement.  */
5530   if (GET_CODE (addr) == REG)
5531     basereg = addr, displacement = 0;
5532   else if (GET_CODE (addr) == PLUS && GET_CODE (XEXP (addr, 1)) == CONST_INT)
5533     basereg = XEXP (addr, 0), displacement = INTVAL (XEXP (addr, 1));
5534   else
5535     abort ();
5536
5537   /* We accept vars reached via the containing function's
5538      incoming arg pointer and via its stack variables pointer.  */
5539   if (basereg == fp->internal_arg_pointer)
5540     {
5541       /* If reached via arg pointer, get the arg pointer value
5542          out of that function's stack frame.
5543
5544          There are two cases:  If a separate ap is needed, allocate a
5545          slot in the outer function for it and dereference it that way.
5546          This is correct even if the real ap is actually a pseudo.
5547          Otherwise, just adjust the offset from the frame pointer to
5548          compensate.  */
5549
5550 #ifdef NEED_SEPARATE_AP
5551       rtx addr;
5552
5553       addr = get_arg_pointer_save_area (fp);
5554       addr = fix_lexical_addr (XEXP (addr, 0), var);
5555       addr = memory_address (Pmode, addr);
5556
5557       base = gen_rtx_MEM (Pmode, addr);
5558       set_mem_alias_set (base, get_frame_alias_set ());
5559       base = copy_to_reg (base);
5560 #else
5561       displacement += (FIRST_PARM_OFFSET (context) - STARTING_FRAME_OFFSET);
5562       base = lookup_static_chain (var);
5563 #endif
5564     }
5565
5566   else if (basereg == virtual_stack_vars_rtx)
5567     {
5568       /* This is the same code as lookup_static_chain, duplicated here to
5569          avoid an extra call to decl_function_context.  */
5570       tree link;
5571
5572       for (link = context_display; link; link = TREE_CHAIN (link))
5573         if (TREE_PURPOSE (link) == context)
5574           {
5575             base = RTL_EXPR_RTL (TREE_VALUE (link));
5576             break;
5577           }
5578     }
5579
5580   if (base == 0)
5581     abort ();
5582
5583   /* Use same offset, relative to appropriate static chain or argument
5584      pointer.  */
5585   return plus_constant (base, displacement);
5586 }
5587 \f
5588 /* Return the address of the trampoline for entering nested fn FUNCTION.
5589    If necessary, allocate a trampoline (in the stack frame)
5590    and emit rtl to initialize its contents (at entry to this function).  */
5591
5592 rtx
5593 trampoline_address (function)
5594      tree function;
5595 {
5596   tree link;
5597   tree rtlexp;
5598   rtx tramp;
5599   struct function *fp;
5600   tree fn_context;
5601
5602   /* Find an existing trampoline and return it.  */
5603   for (link = trampoline_list; link; link = TREE_CHAIN (link))
5604     if (TREE_PURPOSE (link) == function)
5605       return
5606         adjust_trampoline_addr (XEXP (RTL_EXPR_RTL (TREE_VALUE (link)), 0));
5607
5608   for (fp = outer_function_chain; fp; fp = fp->outer)
5609     for (link = fp->x_trampoline_list; link; link = TREE_CHAIN (link))
5610       if (TREE_PURPOSE (link) == function)
5611         {
5612           tramp = fix_lexical_addr (XEXP (RTL_EXPR_RTL (TREE_VALUE (link)), 0),
5613                                     function);
5614           return adjust_trampoline_addr (tramp);
5615         }
5616
5617   /* None exists; we must make one.  */
5618
5619   /* Find the `struct function' for the function containing FUNCTION.  */
5620   fp = 0;
5621   fn_context = decl_function_context (function);
5622   if (fn_context != current_function_decl
5623       && fn_context != inline_function_decl)
5624     fp = find_function_data (fn_context);
5625
5626   /* Allocate run-time space for this trampoline
5627      (usually in the defining function's stack frame).  */
5628 #ifdef ALLOCATE_TRAMPOLINE
5629   tramp = ALLOCATE_TRAMPOLINE (fp);
5630 #else
5631   /* If rounding needed, allocate extra space
5632      to ensure we have TRAMPOLINE_SIZE bytes left after rounding up.  */
5633 #ifdef TRAMPOLINE_ALIGNMENT
5634 #define TRAMPOLINE_REAL_SIZE \
5635   (TRAMPOLINE_SIZE + (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT) - 1)
5636 #else
5637 #define TRAMPOLINE_REAL_SIZE (TRAMPOLINE_SIZE)
5638 #endif
5639   tramp = assign_stack_local_1 (BLKmode, TRAMPOLINE_REAL_SIZE, 0,
5640                                 fp ? fp : cfun);
5641 #endif
5642
5643   /* Record the trampoline for reuse and note it for later initialization
5644      by expand_function_end.  */
5645   if (fp != 0)
5646     {
5647       rtlexp = make_node (RTL_EXPR);
5648       RTL_EXPR_RTL (rtlexp) = tramp;
5649       fp->x_trampoline_list = tree_cons (function, rtlexp,
5650                                          fp->x_trampoline_list);
5651     }
5652   else
5653     {
5654       /* Make the RTL_EXPR node temporary, not momentary, so that the
5655          trampoline_list doesn't become garbage.  */
5656       rtlexp = make_node (RTL_EXPR);
5657
5658       RTL_EXPR_RTL (rtlexp) = tramp;
5659       trampoline_list = tree_cons (function, rtlexp, trampoline_list);
5660     }
5661
5662   tramp = fix_lexical_addr (XEXP (tramp, 0), function);
5663   return adjust_trampoline_addr (tramp);
5664 }
5665
5666 /* Given a trampoline address,
5667    round it to multiple of TRAMPOLINE_ALIGNMENT.  */
5668
5669 static rtx
5670 round_trampoline_addr (tramp)
5671      rtx tramp;
5672 {
5673 #ifdef TRAMPOLINE_ALIGNMENT
5674   /* Round address up to desired boundary.  */
5675   rtx temp = gen_reg_rtx (Pmode);
5676   rtx addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
5677   rtx mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
5678
5679   temp  = expand_simple_binop (Pmode, PLUS, tramp, addend,
5680                                temp, 0, OPTAB_LIB_WIDEN);
5681   tramp = expand_simple_binop (Pmode, AND, temp, mask,
5682                                temp, 0, OPTAB_LIB_WIDEN);
5683 #endif
5684   return tramp;
5685 }
5686
5687 /* Given a trampoline address, round it then apply any
5688    platform-specific adjustments so that the result can be used for a
5689    function call .  */
5690
5691 static rtx
5692 adjust_trampoline_addr (tramp)
5693      rtx tramp;
5694 {
5695   tramp = round_trampoline_addr (tramp);
5696 #ifdef TRAMPOLINE_ADJUST_ADDRESS
5697   TRAMPOLINE_ADJUST_ADDRESS (tramp);
5698 #endif
5699   return tramp;
5700 }
5701 \f
5702 /* Put all this function's BLOCK nodes including those that are chained
5703    onto the first block into a vector, and return it.
5704    Also store in each NOTE for the beginning or end of a block
5705    the index of that block in the vector.
5706    The arguments are BLOCK, the chain of top-level blocks of the function,
5707    and INSNS, the insn chain of the function.  */
5708
5709 void
5710 identify_blocks ()
5711 {
5712   int n_blocks;
5713   tree *block_vector, *last_block_vector;
5714   tree *block_stack;
5715   tree block = DECL_INITIAL (current_function_decl);
5716
5717   if (block == 0)
5718     return;
5719
5720   /* Fill the BLOCK_VECTOR with all of the BLOCKs in this function, in
5721      depth-first order.  */
5722   block_vector = get_block_vector (block, &n_blocks);
5723   block_stack = (tree *) xmalloc (n_blocks * sizeof (tree));
5724
5725   last_block_vector = identify_blocks_1 (get_insns (),
5726                                          block_vector + 1,
5727                                          block_vector + n_blocks,
5728                                          block_stack);
5729
5730   /* If we didn't use all of the subblocks, we've misplaced block notes.  */
5731   /* ??? This appears to happen all the time.  Latent bugs elsewhere?  */
5732   if (0 && last_block_vector != block_vector + n_blocks)
5733     abort ();
5734
5735   free (block_vector);
5736   free (block_stack);
5737 }
5738
5739 /* Subroutine of identify_blocks.  Do the block substitution on the
5740    insn chain beginning with INSNS.  Recurse for CALL_PLACEHOLDER chains.
5741
5742    BLOCK_STACK is pushed and popped for each BLOCK_BEGIN/BLOCK_END pair.
5743    BLOCK_VECTOR is incremented for each block seen.  */
5744
5745 static tree *
5746 identify_blocks_1 (insns, block_vector, end_block_vector, orig_block_stack)
5747      rtx insns;
5748      tree *block_vector;
5749      tree *end_block_vector;
5750      tree *orig_block_stack;
5751 {
5752   rtx insn;
5753   tree *block_stack = orig_block_stack;
5754
5755   for (insn = insns; insn; insn = NEXT_INSN (insn))
5756     {
5757       if (GET_CODE (insn) == NOTE)
5758         {
5759           if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG)
5760             {
5761               tree b;
5762
5763               /* If there are more block notes than BLOCKs, something
5764                  is badly wrong.  */
5765               if (block_vector == end_block_vector)
5766                 abort ();
5767
5768               b = *block_vector++;
5769               NOTE_BLOCK (insn) = b;
5770               *block_stack++ = b;
5771             }
5772           else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
5773             {
5774               /* If there are more NOTE_INSN_BLOCK_ENDs than
5775                  NOTE_INSN_BLOCK_BEGs, something is badly wrong.  */
5776               if (block_stack == orig_block_stack)
5777                 abort ();
5778
5779               NOTE_BLOCK (insn) = *--block_stack;
5780             }
5781         }
5782       else if (GET_CODE (insn) == CALL_INSN
5783                && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
5784         {
5785           rtx cp = PATTERN (insn);
5786
5787           block_vector = identify_blocks_1 (XEXP (cp, 0), block_vector,
5788                                             end_block_vector, block_stack);
5789           if (XEXP (cp, 1))
5790             block_vector = identify_blocks_1 (XEXP (cp, 1), block_vector,
5791                                               end_block_vector, block_stack);
5792           if (XEXP (cp, 2))
5793             block_vector = identify_blocks_1 (XEXP (cp, 2), block_vector,
5794                                               end_block_vector, block_stack);
5795         }
5796     }
5797
5798   /* If there are more NOTE_INSN_BLOCK_BEGINs than NOTE_INSN_BLOCK_ENDs,
5799      something is badly wrong.  */
5800   if (block_stack != orig_block_stack)
5801     abort ();
5802
5803   return block_vector;
5804 }
5805
5806 /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
5807    and create duplicate blocks.  */
5808 /* ??? Need an option to either create block fragments or to create
5809    abstract origin duplicates of a source block.  It really depends
5810    on what optimization has been performed.  */
5811
5812 void
5813 reorder_blocks ()
5814 {
5815   tree block = DECL_INITIAL (current_function_decl);
5816   varray_type block_stack;
5817
5818   if (block == NULL_TREE)
5819     return;
5820
5821   VARRAY_TREE_INIT (block_stack, 10, "block_stack");
5822
5823   /* Reset the TREE_ASM_WRITTEN bit for all blocks.  */
5824   reorder_blocks_0 (block);
5825
5826   /* Prune the old trees away, so that they don't get in the way.  */
5827   BLOCK_SUBBLOCKS (block) = NULL_TREE;
5828   BLOCK_CHAIN (block) = NULL_TREE;
5829
5830   /* Recreate the block tree from the note nesting.  */
5831   reorder_blocks_1 (get_insns (), block, &block_stack);
5832   BLOCK_SUBBLOCKS (block) = blocks_nreverse (BLOCK_SUBBLOCKS (block));
5833
5834   /* Remove deleted blocks from the block fragment chains.  */
5835   reorder_fix_fragments (block);
5836
5837   VARRAY_FREE (block_stack);
5838 }
5839
5840 /* Helper function for reorder_blocks.  Reset TREE_ASM_WRITTEN.  */
5841
5842 static void
5843 reorder_blocks_0 (block)
5844      tree block;
5845 {
5846   while (block)
5847     {
5848       TREE_ASM_WRITTEN (block) = 0;
5849       reorder_blocks_0 (BLOCK_SUBBLOCKS (block));
5850       block = BLOCK_CHAIN (block);
5851     }
5852 }
5853
5854 static void
5855 reorder_blocks_1 (insns, current_block, p_block_stack)
5856      rtx insns;
5857      tree current_block;
5858      varray_type *p_block_stack;
5859 {
5860   rtx insn;
5861
5862   for (insn = insns; insn; insn = NEXT_INSN (insn))
5863     {
5864       if (GET_CODE (insn) == NOTE)
5865         {
5866           if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG)
5867             {
5868               tree block = NOTE_BLOCK (insn);
5869
5870               /* If we have seen this block before, that means it now
5871                  spans multiple address regions.  Create a new fragment.  */
5872               if (TREE_ASM_WRITTEN (block))
5873                 {
5874                   tree new_block = copy_node (block);
5875                   tree origin;
5876
5877                   origin = (BLOCK_FRAGMENT_ORIGIN (block)
5878                             ? BLOCK_FRAGMENT_ORIGIN (block)
5879                             : block);
5880                   BLOCK_FRAGMENT_ORIGIN (new_block) = origin;
5881                   BLOCK_FRAGMENT_CHAIN (new_block)
5882                     = BLOCK_FRAGMENT_CHAIN (origin);
5883                   BLOCK_FRAGMENT_CHAIN (origin) = new_block;
5884
5885                   NOTE_BLOCK (insn) = new_block;
5886                   block = new_block;
5887                 }
5888
5889               BLOCK_SUBBLOCKS (block) = 0;
5890               TREE_ASM_WRITTEN (block) = 1;
5891               BLOCK_SUPERCONTEXT (block) = current_block;
5892               BLOCK_CHAIN (block) = BLOCK_SUBBLOCKS (current_block);
5893               BLOCK_SUBBLOCKS (current_block) = block;
5894               current_block = block;
5895               VARRAY_PUSH_TREE (*p_block_stack, block);
5896             }
5897           else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
5898             {
5899               NOTE_BLOCK (insn) = VARRAY_TOP_TREE (*p_block_stack);
5900               VARRAY_POP (*p_block_stack);
5901               BLOCK_SUBBLOCKS (current_block)
5902                 = blocks_nreverse (BLOCK_SUBBLOCKS (current_block));
5903               current_block = BLOCK_SUPERCONTEXT (current_block);
5904             }
5905         }
5906       else if (GET_CODE (insn) == CALL_INSN
5907                && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
5908         {
5909           rtx cp = PATTERN (insn);
5910           reorder_blocks_1 (XEXP (cp, 0), current_block, p_block_stack);
5911           if (XEXP (cp, 1))
5912             reorder_blocks_1 (XEXP (cp, 1), current_block, p_block_stack);
5913           if (XEXP (cp, 2))
5914             reorder_blocks_1 (XEXP (cp, 2), current_block, p_block_stack);
5915         }
5916     }
5917 }
5918
5919 /* Rationalize BLOCK_FRAGMENT_ORIGIN.  If an origin block no longer
5920    appears in the block tree, select one of the fragments to become
5921    the new origin block.  */
5922
5923 static void
5924 reorder_fix_fragments (block)
5925     tree block;
5926 {
5927   while (block)
5928     {
5929       tree dup_origin = BLOCK_FRAGMENT_ORIGIN (block);
5930       tree new_origin = NULL_TREE;
5931
5932       if (dup_origin)
5933         {
5934           if (! TREE_ASM_WRITTEN (dup_origin))
5935             {
5936               new_origin = BLOCK_FRAGMENT_CHAIN (dup_origin);
5937
5938               /* Find the first of the remaining fragments.  There must
5939                  be at least one -- the current block.  */
5940               while (! TREE_ASM_WRITTEN (new_origin))
5941                 new_origin = BLOCK_FRAGMENT_CHAIN (new_origin);
5942               BLOCK_FRAGMENT_ORIGIN (new_origin) = NULL_TREE;
5943             }
5944         }
5945       else if (! dup_origin)
5946         new_origin = block;
5947
5948       /* Re-root the rest of the fragments to the new origin.  In the
5949          case that DUP_ORIGIN was null, that means BLOCK was the origin
5950          of a chain of fragments and we want to remove those fragments
5951          that didn't make it to the output.  */
5952       if (new_origin)
5953         {
5954           tree *pp = &BLOCK_FRAGMENT_CHAIN (new_origin);
5955           tree chain = *pp;
5956
5957           while (chain)
5958             {
5959               if (TREE_ASM_WRITTEN (chain))
5960                 {
5961                   BLOCK_FRAGMENT_ORIGIN (chain) = new_origin;
5962                   *pp = chain;
5963                   pp = &BLOCK_FRAGMENT_CHAIN (chain);
5964                 }
5965               chain = BLOCK_FRAGMENT_CHAIN (chain);
5966             }
5967           *pp = NULL_TREE;
5968         }
5969
5970       reorder_fix_fragments (BLOCK_SUBBLOCKS (block));
5971       block = BLOCK_CHAIN (block);
5972     }
5973 }
5974
5975 /* Reverse the order of elements in the chain T of blocks,
5976    and return the new head of the chain (old last element).  */
5977
5978 static tree
5979 blocks_nreverse (t)
5980      tree t;
5981 {
5982   tree prev = 0, decl, next;
5983   for (decl = t; decl; decl = next)
5984     {
5985       next = BLOCK_CHAIN (decl);
5986       BLOCK_CHAIN (decl) = prev;
5987       prev = decl;
5988     }
5989   return prev;
5990 }
5991
5992 /* Count the subblocks of the list starting with BLOCK.  If VECTOR is
5993    non-NULL, list them all into VECTOR, in a depth-first preorder
5994    traversal of the block tree.  Also clear TREE_ASM_WRITTEN in all
5995    blocks.  */
5996
5997 static int
5998 all_blocks (block, vector)
5999      tree block;
6000      tree *vector;
6001 {
6002   int n_blocks = 0;
6003
6004   while (block)
6005     {
6006       TREE_ASM_WRITTEN (block) = 0;
6007
6008       /* Record this block.  */
6009       if (vector)
6010         vector[n_blocks] = block;
6011
6012       ++n_blocks;
6013
6014       /* Record the subblocks, and their subblocks...  */
6015       n_blocks += all_blocks (BLOCK_SUBBLOCKS (block),
6016                               vector ? vector + n_blocks : 0);
6017       block = BLOCK_CHAIN (block);
6018     }
6019
6020   return n_blocks;
6021 }
6022
6023 /* Return a vector containing all the blocks rooted at BLOCK.  The
6024    number of elements in the vector is stored in N_BLOCKS_P.  The
6025    vector is dynamically allocated; it is the caller's responsibility
6026    to call `free' on the pointer returned.  */
6027
6028 static tree *
6029 get_block_vector (block, n_blocks_p)
6030      tree block;
6031      int *n_blocks_p;
6032 {
6033   tree *block_vector;
6034
6035   *n_blocks_p = all_blocks (block, NULL);
6036   block_vector = (tree *) xmalloc (*n_blocks_p * sizeof (tree));
6037   all_blocks (block, block_vector);
6038
6039   return block_vector;
6040 }
6041
6042 static int next_block_index = 2;
6043
6044 /* Set BLOCK_NUMBER for all the blocks in FN.  */
6045
6046 void
6047 number_blocks (fn)
6048      tree fn;
6049 {
6050   int i;
6051   int n_blocks;
6052   tree *block_vector;
6053
6054   /* For SDB and XCOFF debugging output, we start numbering the blocks
6055      from 1 within each function, rather than keeping a running
6056      count.  */
6057 #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
6058   if (write_symbols == SDB_DEBUG || write_symbols == XCOFF_DEBUG)
6059     next_block_index = 1;
6060 #endif
6061
6062   block_vector = get_block_vector (DECL_INITIAL (fn), &n_blocks);
6063
6064   /* The top-level BLOCK isn't numbered at all.  */
6065   for (i = 1; i < n_blocks; ++i)
6066     /* We number the blocks from two.  */
6067     BLOCK_NUMBER (block_vector[i]) = next_block_index++;
6068
6069   free (block_vector);
6070
6071   return;
6072 }
6073 \f
6074 /* Allocate a function structure and reset its contents to the defaults.  */
6075
6076 static void
6077 prepare_function_start ()
6078 {
6079   cfun = (struct function *) ggc_alloc_cleared (sizeof (struct function));
6080
6081   init_stmt_for_function ();
6082   init_eh_for_function ();
6083
6084   cse_not_expected = ! optimize;
6085
6086   /* Caller save not needed yet.  */
6087   caller_save_needed = 0;
6088
6089   /* No stack slots have been made yet.  */
6090   stack_slot_list = 0;
6091
6092   current_function_has_nonlocal_label = 0;
6093   current_function_has_nonlocal_goto = 0;
6094
6095   /* There is no stack slot for handling nonlocal gotos.  */
6096   nonlocal_goto_handler_slots = 0;
6097   nonlocal_goto_stack_level = 0;
6098
6099   /* No labels have been declared for nonlocal use.  */
6100   nonlocal_labels = 0;
6101   nonlocal_goto_handler_labels = 0;
6102
6103   /* No function calls so far in this function.  */
6104   function_call_count = 0;
6105
6106   /* No parm regs have been allocated.
6107      (This is important for output_inline_function.)  */
6108   max_parm_reg = LAST_VIRTUAL_REGISTER + 1;
6109
6110   /* Initialize the RTL mechanism.  */
6111   init_emit ();
6112
6113   /* Initialize the queue of pending postincrement and postdecrements,
6114      and some other info in expr.c.  */
6115   init_expr ();
6116
6117   /* We haven't done register allocation yet.  */
6118   reg_renumber = 0;
6119
6120   init_varasm_status (cfun);
6121
6122   /* Clear out data used for inlining.  */
6123   cfun->inlinable = 0;
6124   cfun->original_decl_initial = 0;
6125   cfun->original_arg_vector = 0;
6126
6127   cfun->stack_alignment_needed = STACK_BOUNDARY;
6128   cfun->preferred_stack_boundary = STACK_BOUNDARY;
6129
6130   /* Set if a call to setjmp is seen.  */
6131   current_function_calls_setjmp = 0;
6132
6133   /* Set if a call to longjmp is seen.  */
6134   current_function_calls_longjmp = 0;
6135
6136   current_function_calls_alloca = 0;
6137   current_function_contains_functions = 0;
6138   current_function_is_leaf = 0;
6139   current_function_nothrow = 0;
6140   current_function_sp_is_unchanging = 0;
6141   current_function_uses_only_leaf_regs = 0;
6142   current_function_has_computed_jump = 0;
6143   current_function_is_thunk = 0;
6144
6145   current_function_returns_pcc_struct = 0;
6146   current_function_returns_struct = 0;
6147   current_function_epilogue_delay_list = 0;
6148   current_function_uses_const_pool = 0;
6149   current_function_uses_pic_offset_table = 0;
6150   current_function_cannot_inline = 0;
6151
6152   /* We have not yet needed to make a label to jump to for tail-recursion.  */
6153   tail_recursion_label = 0;
6154
6155   /* We haven't had a need to make a save area for ap yet.  */
6156   arg_pointer_save_area = 0;
6157
6158   /* No stack slots allocated yet.  */
6159   frame_offset = 0;
6160
6161   /* No SAVE_EXPRs in this function yet.  */
6162   save_expr_regs = 0;
6163
6164   /* No RTL_EXPRs in this function yet.  */
6165   rtl_expr_chain = 0;
6166
6167   /* Set up to allocate temporaries.  */
6168   init_temp_slots ();
6169
6170   /* Indicate that we need to distinguish between the return value of the
6171      present function and the return value of a function being called.  */
6172   rtx_equal_function_value_matters = 1;
6173
6174   /* Indicate that we have not instantiated virtual registers yet.  */
6175   virtuals_instantiated = 0;
6176
6177   /* Indicate that we want CONCATs now.  */
6178   generating_concat_p = 1;
6179
6180   /* Indicate we have no need of a frame pointer yet.  */
6181   frame_pointer_needed = 0;
6182
6183   /* By default assume not varargs or stdarg.  */
6184   current_function_varargs = 0;
6185   current_function_stdarg = 0;
6186
6187   /* We haven't made any trampolines for this function yet.  */
6188   trampoline_list = 0;
6189
6190   init_pending_stack_adjust ();
6191   inhibit_defer_pop = 0;
6192
6193   current_function_outgoing_args_size = 0;
6194
6195   if (init_lang_status)
6196     (*init_lang_status) (cfun);
6197   if (init_machine_status)
6198     (*init_machine_status) (cfun);
6199 }
6200
6201 /* Initialize the rtl expansion mechanism so that we can do simple things
6202    like generate sequences.  This is used to provide a context during global
6203    initialization of some passes.  */
6204 void
6205 init_dummy_function_start ()
6206 {
6207   prepare_function_start ();
6208 }
6209
6210 /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node)
6211    and initialize static variables for generating RTL for the statements
6212    of the function.  */
6213
6214 void
6215 init_function_start (subr, filename, line)
6216      tree subr;
6217      const char *filename;
6218      int line;
6219 {
6220   prepare_function_start ();
6221
6222   current_function_name = (*decl_printable_name) (subr, 2);
6223   cfun->decl = subr;
6224
6225   /* Nonzero if this is a nested function that uses a static chain.  */
6226
6227   current_function_needs_context
6228     = (decl_function_context (current_function_decl) != 0
6229        && ! DECL_NO_STATIC_CHAIN (current_function_decl));
6230
6231   /* Within function body, compute a type's size as soon it is laid out.  */
6232   immediate_size_expand++;
6233
6234   /* Prevent ever trying to delete the first instruction of a function.
6235      Also tell final how to output a linenum before the function prologue.
6236      Note linenums could be missing, e.g. when compiling a Java .class file.  */
6237   if (line > 0)
6238     emit_line_note (filename, line);
6239
6240   /* Make sure first insn is a note even if we don't want linenums.
6241      This makes sure the first insn will never be deleted.
6242      Also, final expects a note to appear there.  */
6243   emit_note (NULL, NOTE_INSN_DELETED);
6244
6245   /* Set flags used by final.c.  */
6246   if (aggregate_value_p (DECL_RESULT (subr)))
6247     {
6248 #ifdef PCC_STATIC_STRUCT_RETURN
6249       current_function_returns_pcc_struct = 1;
6250 #endif
6251       current_function_returns_struct = 1;
6252     }
6253
6254   /* Warn if this value is an aggregate type,
6255      regardless of which calling convention we are using for it.  */
6256   if (warn_aggregate_return
6257       && AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr))))
6258     warning ("function returns an aggregate");
6259
6260   current_function_returns_pointer
6261     = POINTER_TYPE_P (TREE_TYPE (DECL_RESULT (subr)));
6262 }
6263
6264 /* Make sure all values used by the optimization passes have sane
6265    defaults.  */
6266 void
6267 init_function_for_compilation ()
6268 {
6269   reg_renumber = 0;
6270
6271   /* No prologue/epilogue insns yet.  */
6272   VARRAY_GROW (prologue, 0);
6273   VARRAY_GROW (epilogue, 0);
6274   VARRAY_GROW (sibcall_epilogue, 0);
6275 }
6276
6277 /* Indicate that the current function uses extra args
6278    not explicitly mentioned in the argument list in any fashion.  */
6279
6280 void
6281 mark_varargs ()
6282 {
6283   current_function_varargs = 1;
6284 }
6285
6286 /* Expand a call to __main at the beginning of a possible main function.  */
6287
6288 #if defined(INIT_SECTION_ASM_OP) && !defined(INVOKE__main)
6289 #undef HAS_INIT_SECTION
6290 #define HAS_INIT_SECTION
6291 #endif
6292
6293 void
6294 expand_main_function ()
6295 {
6296 #ifdef FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN
6297   if (FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN)
6298     {
6299       int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
6300       rtx tmp;
6301
6302       /* Forcibly align the stack.  */
6303 #ifdef STACK_GROWS_DOWNWARD
6304       tmp = expand_simple_binop (Pmode, AND, stack_pointer_rtx, GEN_INT(-align),
6305                                  stack_pointer_rtx, 1, OPTAB_WIDEN);
6306 #else
6307       tmp = expand_simple_binop (Pmode, PLUS, stack_pointer_rtx,
6308                                  GEN_INT (align - 1), NULL_RTX, 1, OPTAB_WIDEN);
6309       tmp = expand_simple_binop (Pmode, AND, tmp, GEN_INT (-align),
6310                                  stack_pointer_rtx, 1, OPTAB_WIDEN);
6311 #endif
6312       if (tmp != stack_pointer_rtx)
6313         emit_move_insn (stack_pointer_rtx, tmp);
6314
6315       /* Enlist allocate_dynamic_stack_space to pick up the pieces.  */
6316       tmp = force_reg (Pmode, const0_rtx);
6317       allocate_dynamic_stack_space (tmp, NULL_RTX, BIGGEST_ALIGNMENT);
6318     }
6319 #endif
6320
6321 #ifndef HAS_INIT_SECTION
6322   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, NAME__MAIN), 0,
6323                      VOIDmode, 0);
6324 #endif
6325 }
6326 \f
6327 extern struct obstack permanent_obstack;
6328
6329 /* The PENDING_SIZES represent the sizes of variable-sized types.
6330    Create RTL for the various sizes now (using temporary variables),
6331    so that we can refer to the sizes from the RTL we are generating
6332    for the current function.  The PENDING_SIZES are a TREE_LIST.  The
6333    TREE_VALUE of each node is a SAVE_EXPR.  */
6334
6335 void
6336 expand_pending_sizes (pending_sizes)
6337      tree pending_sizes;
6338 {
6339   tree tem;
6340
6341   /* Evaluate now the sizes of any types declared among the arguments.  */
6342   for (tem = pending_sizes; tem; tem = TREE_CHAIN (tem))
6343     {
6344       expand_expr (TREE_VALUE (tem), const0_rtx, VOIDmode,
6345                    EXPAND_MEMORY_USE_BAD);
6346       /* Flush the queue in case this parameter declaration has
6347          side-effects.  */
6348       emit_queue ();
6349     }
6350 }
6351
6352 /* Start the RTL for a new function, and set variables used for
6353    emitting RTL.
6354    SUBR is the FUNCTION_DECL node.
6355    PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with
6356    the function's parameters, which must be run at any return statement.  */
6357
6358 void
6359 expand_function_start (subr, parms_have_cleanups)
6360      tree subr;
6361      int parms_have_cleanups;
6362 {
6363   tree tem;
6364   rtx last_ptr = NULL_RTX;
6365
6366   /* Make sure volatile mem refs aren't considered
6367      valid operands of arithmetic insns.  */
6368   init_recog_no_volatile ();
6369
6370   /* Set this before generating any memory accesses.  */
6371   current_function_check_memory_usage
6372     = (flag_check_memory_usage
6373        && ! DECL_NO_CHECK_MEMORY_USAGE (current_function_decl));
6374
6375   current_function_instrument_entry_exit
6376     = (flag_instrument_function_entry_exit
6377        && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr));
6378
6379   current_function_limit_stack
6380     = (stack_limit_rtx != NULL_RTX && ! DECL_NO_LIMIT_STACK (subr));
6381
6382   /* If function gets a static chain arg, store it in the stack frame.
6383      Do this first, so it gets the first stack slot offset.  */
6384   if (current_function_needs_context)
6385     {
6386       last_ptr = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0);
6387
6388       /* Delay copying static chain if it is not a register to avoid
6389          conflicts with regs used for parameters.  */
6390       if (! SMALL_REGISTER_CLASSES
6391           || GET_CODE (static_chain_incoming_rtx) == REG)
6392         emit_move_insn (last_ptr, static_chain_incoming_rtx);
6393     }
6394
6395   /* If the parameters of this function need cleaning up, get a label
6396      for the beginning of the code which executes those cleanups.  This must
6397      be done before doing anything with return_label.  */
6398   if (parms_have_cleanups)
6399     cleanup_label = gen_label_rtx ();
6400   else
6401     cleanup_label = 0;
6402
6403   /* Make the label for return statements to jump to.  Do not special
6404      case machines with special return instructions -- they will be
6405      handled later during jump, ifcvt, or epilogue creation.  */
6406   return_label = gen_label_rtx ();
6407
6408   /* Initialize rtx used to return the value.  */
6409   /* Do this before assign_parms so that we copy the struct value address
6410      before any library calls that assign parms might generate.  */
6411
6412   /* Decide whether to return the value in memory or in a register.  */
6413   if (aggregate_value_p (DECL_RESULT (subr)))
6414     {
6415       /* Returning something that won't go in a register.  */
6416       rtx value_address = 0;
6417
6418 #ifdef PCC_STATIC_STRUCT_RETURN
6419       if (current_function_returns_pcc_struct)
6420         {
6421           int size = int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr)));
6422           value_address = assemble_static_space (size);
6423         }
6424       else
6425 #endif
6426         {
6427           /* Expect to be passed the address of a place to store the value.
6428              If it is passed as an argument, assign_parms will take care of
6429              it.  */
6430           if (struct_value_incoming_rtx)
6431             {
6432               value_address = gen_reg_rtx (Pmode);
6433               emit_move_insn (value_address, struct_value_incoming_rtx);
6434             }
6435         }
6436       if (value_address)
6437         {
6438           rtx x = gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr)), value_address);
6439           set_mem_attributes (x, DECL_RESULT (subr), 1);
6440           SET_DECL_RTL (DECL_RESULT (subr), x);
6441         }
6442     }
6443   else if (DECL_MODE (DECL_RESULT (subr)) == VOIDmode)
6444     /* If return mode is void, this decl rtl should not be used.  */
6445     SET_DECL_RTL (DECL_RESULT (subr), NULL_RTX);
6446   else
6447     {
6448       /* Compute the return values into a pseudo reg, which we will copy
6449          into the true return register after the cleanups are done.  */
6450
6451       /* In order to figure out what mode to use for the pseudo, we
6452          figure out what the mode of the eventual return register will
6453          actually be, and use that.  */
6454       rtx hard_reg
6455         = hard_function_value (TREE_TYPE (DECL_RESULT (subr)),
6456                                subr, 1);
6457
6458       /* Structures that are returned in registers are not aggregate_value_p,
6459          so we may see a PARALLEL.  Don't play pseudo games with this.  */
6460       if (! REG_P (hard_reg))
6461         SET_DECL_RTL (DECL_RESULT (subr), hard_reg);
6462       else
6463         {
6464           /* Create the pseudo.  */
6465           SET_DECL_RTL (DECL_RESULT (subr), gen_reg_rtx (GET_MODE (hard_reg)));
6466
6467           /* Needed because we may need to move this to memory
6468              in case it's a named return value whose address is taken.  */
6469           DECL_REGISTER (DECL_RESULT (subr)) = 1;
6470         }
6471     }
6472
6473   /* Initialize rtx for parameters and local variables.
6474      In some cases this requires emitting insns.  */
6475
6476   assign_parms (subr);
6477
6478   /* Copy the static chain now if it wasn't a register.  The delay is to
6479      avoid conflicts with the parameter passing registers.  */
6480
6481   if (SMALL_REGISTER_CLASSES && current_function_needs_context)
6482       if (GET_CODE (static_chain_incoming_rtx) != REG)
6483         emit_move_insn (last_ptr, static_chain_incoming_rtx);
6484
6485   /* The following was moved from init_function_start.
6486      The move is supposed to make sdb output more accurate.  */
6487   /* Indicate the beginning of the function body,
6488      as opposed to parm setup.  */
6489   emit_note (NULL, NOTE_INSN_FUNCTION_BEG);
6490
6491   if (GET_CODE (get_last_insn ()) != NOTE)
6492     emit_note (NULL, NOTE_INSN_DELETED);
6493   parm_birth_insn = get_last_insn ();
6494
6495   context_display = 0;
6496   if (current_function_needs_context)
6497     {
6498       /* Fetch static chain values for containing functions.  */
6499       tem = decl_function_context (current_function_decl);
6500       /* Copy the static chain pointer into a pseudo.  If we have
6501          small register classes, copy the value from memory if
6502          static_chain_incoming_rtx is a REG.  */
6503       if (tem)
6504         {
6505           /* If the static chain originally came in a register, put it back
6506              there, then move it out in the next insn.  The reason for
6507              this peculiar code is to satisfy function integration.  */
6508           if (SMALL_REGISTER_CLASSES
6509               && GET_CODE (static_chain_incoming_rtx) == REG)
6510             emit_move_insn (static_chain_incoming_rtx, last_ptr);
6511           last_ptr = copy_to_reg (static_chain_incoming_rtx);
6512         }
6513
6514       while (tem)
6515         {
6516           tree rtlexp = make_node (RTL_EXPR);
6517
6518           RTL_EXPR_RTL (rtlexp) = last_ptr;
6519           context_display = tree_cons (tem, rtlexp, context_display);
6520           tem = decl_function_context (tem);
6521           if (tem == 0)
6522             break;
6523           /* Chain thru stack frames, assuming pointer to next lexical frame
6524              is found at the place we always store it.  */
6525 #ifdef FRAME_GROWS_DOWNWARD
6526           last_ptr = plus_constant (last_ptr,
6527                                     -(HOST_WIDE_INT) GET_MODE_SIZE (Pmode));
6528 #endif
6529           last_ptr = gen_rtx_MEM (Pmode, memory_address (Pmode, last_ptr));
6530           set_mem_alias_set (last_ptr, get_frame_alias_set ());
6531           last_ptr = copy_to_reg (last_ptr);
6532
6533           /* If we are not optimizing, ensure that we know that this
6534              piece of context is live over the entire function.  */
6535           if (! optimize)
6536             save_expr_regs = gen_rtx_EXPR_LIST (VOIDmode, last_ptr,
6537                                                 save_expr_regs);
6538         }
6539     }
6540
6541   if (current_function_instrument_entry_exit)
6542     {
6543       rtx fun = DECL_RTL (current_function_decl);
6544       if (GET_CODE (fun) == MEM)
6545         fun = XEXP (fun, 0);
6546       else
6547         abort ();
6548       emit_library_call (profile_function_entry_libfunc, 0, VOIDmode, 2,
6549                          fun, Pmode,
6550                          expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
6551                                                      0,
6552                                                      hard_frame_pointer_rtx),
6553                          Pmode);
6554     }
6555
6556 #ifdef PROFILE_HOOK
6557   if (profile_flag)
6558     PROFILE_HOOK (profile_label_no);
6559 #endif
6560
6561   /* After the display initializations is where the tail-recursion label
6562      should go, if we end up needing one.   Ensure we have a NOTE here
6563      since some things (like trampolines) get placed before this.  */
6564   tail_recursion_reentry = emit_note (NULL, NOTE_INSN_DELETED);
6565
6566   /* Evaluate now the sizes of any types declared among the arguments.  */
6567   expand_pending_sizes (nreverse (get_pending_sizes ()));
6568
6569   /* Make sure there is a line number after the function entry setup code.  */
6570   force_next_line_note ();
6571 }
6572 \f
6573 /* Undo the effects of init_dummy_function_start.  */
6574 void
6575 expand_dummy_function_end ()
6576 {
6577   /* End any sequences that failed to be closed due to syntax errors.  */
6578   while (in_sequence_p ())
6579     end_sequence ();
6580
6581   /* Outside function body, can't compute type's actual size
6582      until next function's body starts.  */
6583
6584   free_after_parsing (cfun);
6585   free_after_compilation (cfun);
6586   cfun = 0;
6587 }
6588
6589 /* Call DOIT for each hard register used as a return value from
6590    the current function.  */
6591
6592 void
6593 diddle_return_value (doit, arg)
6594      void (*doit) PARAMS ((rtx, void *));
6595      void *arg;
6596 {
6597   rtx outgoing = current_function_return_rtx;
6598
6599   if (! outgoing)
6600     return;
6601
6602   if (GET_CODE (outgoing) == REG)
6603     (*doit) (outgoing, arg);
6604   else if (GET_CODE (outgoing) == PARALLEL)
6605     {
6606       int i;
6607
6608       for (i = 0; i < XVECLEN (outgoing, 0); i++)
6609         {
6610           rtx x = XEXP (XVECEXP (outgoing, 0, i), 0);
6611
6612           if (GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
6613             (*doit) (x, arg);
6614         }
6615     }
6616 }
6617
6618 static void
6619 do_clobber_return_reg (reg, arg)
6620      rtx reg;
6621      void *arg ATTRIBUTE_UNUSED;
6622 {
6623   emit_insn (gen_rtx_CLOBBER (VOIDmode, reg));
6624 }
6625
6626 void
6627 clobber_return_register ()
6628 {
6629   diddle_return_value (do_clobber_return_reg, NULL);
6630
6631   /* In case we do use pseudo to return value, clobber it too.  */
6632   if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl)))
6633     {
6634       tree decl_result = DECL_RESULT (current_function_decl);
6635       rtx decl_rtl = DECL_RTL (decl_result);
6636       if (REG_P (decl_rtl) && REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER)
6637         {
6638           do_clobber_return_reg (decl_rtl, NULL);
6639         }
6640     }
6641 }
6642
6643 static void
6644 do_use_return_reg (reg, arg)
6645      rtx reg;
6646      void *arg ATTRIBUTE_UNUSED;
6647 {
6648   emit_insn (gen_rtx_USE (VOIDmode, reg));
6649 }
6650
6651 void
6652 use_return_register ()
6653 {
6654   diddle_return_value (do_use_return_reg, NULL);
6655 }
6656
6657 /* Generate RTL for the end of the current function.
6658    FILENAME and LINE are the current position in the source file.
6659
6660    It is up to language-specific callers to do cleanups for parameters--
6661    or else, supply 1 for END_BINDINGS and we will call expand_end_bindings.  */
6662
6663 void
6664 expand_function_end (filename, line, end_bindings)
6665      const char *filename;
6666      int line;
6667      int end_bindings;
6668 {
6669   tree link;
6670   rtx clobber_after;
6671
6672 #ifdef TRAMPOLINE_TEMPLATE
6673   static rtx initial_trampoline;
6674 #endif
6675
6676   finish_expr_for_function ();
6677
6678   /* If arg_pointer_save_area was referenced only from a nested
6679      function, we will not have initialized it yet.  Do that now.  */
6680   if (arg_pointer_save_area && ! cfun->arg_pointer_save_area_init)
6681     get_arg_pointer_save_area (cfun);
6682
6683 #ifdef NON_SAVING_SETJMP
6684   /* Don't put any variables in registers if we call setjmp
6685      on a machine that fails to restore the registers.  */
6686   if (NON_SAVING_SETJMP && current_function_calls_setjmp)
6687     {
6688       if (DECL_INITIAL (current_function_decl) != error_mark_node)
6689         setjmp_protect (DECL_INITIAL (current_function_decl));
6690
6691       setjmp_protect_args ();
6692     }
6693 #endif
6694
6695   /* Initialize any trampolines required by this function.  */
6696   for (link = trampoline_list; link; link = TREE_CHAIN (link))
6697     {
6698       tree function = TREE_PURPOSE (link);
6699       rtx context ATTRIBUTE_UNUSED = lookup_static_chain (function);
6700       rtx tramp = RTL_EXPR_RTL (TREE_VALUE (link));
6701 #ifdef TRAMPOLINE_TEMPLATE
6702       rtx blktramp;
6703 #endif
6704       rtx seq;
6705
6706 #ifdef TRAMPOLINE_TEMPLATE
6707       /* First make sure this compilation has a template for
6708          initializing trampolines.  */
6709       if (initial_trampoline == 0)
6710         {
6711           initial_trampoline
6712             = gen_rtx_MEM (BLKmode, assemble_trampoline_template ());
6713           set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT);
6714
6715           ggc_add_rtx_root (&initial_trampoline, 1);
6716         }
6717 #endif
6718
6719       /* Generate insns to initialize the trampoline.  */
6720       start_sequence ();
6721       tramp = round_trampoline_addr (XEXP (tramp, 0));
6722 #ifdef TRAMPOLINE_TEMPLATE
6723       blktramp = replace_equiv_address (initial_trampoline, tramp);
6724       emit_block_move (blktramp, initial_trampoline,
6725                        GEN_INT (TRAMPOLINE_SIZE));
6726 #endif
6727       INITIALIZE_TRAMPOLINE (tramp, XEXP (DECL_RTL (function), 0), context);
6728       seq = get_insns ();
6729       end_sequence ();
6730
6731       /* Put those insns at entry to the containing function (this one).  */
6732       emit_insns_before (seq, tail_recursion_reentry);
6733     }
6734
6735   /* If we are doing stack checking and this function makes calls,
6736      do a stack probe at the start of the function to ensure we have enough
6737      space for another stack frame.  */
6738   if (flag_stack_check && ! STACK_CHECK_BUILTIN)
6739     {
6740       rtx insn, seq;
6741
6742       for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
6743         if (GET_CODE (insn) == CALL_INSN)
6744           {
6745             start_sequence ();
6746             probe_stack_range (STACK_CHECK_PROTECT,
6747                                GEN_INT (STACK_CHECK_MAX_FRAME_SIZE));
6748             seq = get_insns ();
6749             end_sequence ();
6750             emit_insns_before (seq, tail_recursion_reentry);
6751             break;
6752           }
6753     }
6754
6755   /* Warn about unused parms if extra warnings were specified.  */
6756   /* Either ``-W -Wunused'' or ``-Wunused-parameter'' enables this
6757      warning.  WARN_UNUSED_PARAMETER is negative when set by
6758      -Wunused.  */
6759   if (warn_unused_parameter > 0
6760       || (warn_unused_parameter < 0 && extra_warnings))
6761     {
6762       tree decl;
6763
6764       for (decl = DECL_ARGUMENTS (current_function_decl);
6765            decl; decl = TREE_CHAIN (decl))
6766         if (! TREE_USED (decl) && TREE_CODE (decl) == PARM_DECL
6767             && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
6768           warning_with_decl (decl, "unused parameter `%s'");
6769     }
6770
6771   /* Delete handlers for nonlocal gotos if nothing uses them.  */
6772   if (nonlocal_goto_handler_slots != 0
6773       && ! current_function_has_nonlocal_label)
6774     delete_handlers ();
6775
6776   /* End any sequences that failed to be closed due to syntax errors.  */
6777   while (in_sequence_p ())
6778     end_sequence ();
6779
6780   /* Outside function body, can't compute type's actual size
6781      until next function's body starts.  */
6782   immediate_size_expand--;
6783
6784   clear_pending_stack_adjust ();
6785   do_pending_stack_adjust ();
6786
6787   /* Mark the end of the function body.
6788      If control reaches this insn, the function can drop through
6789      without returning a value.  */
6790   emit_note (NULL, NOTE_INSN_FUNCTION_END);
6791
6792   /* Must mark the last line number note in the function, so that the test
6793      coverage code can avoid counting the last line twice.  This just tells
6794      the code to ignore the immediately following line note, since there
6795      already exists a copy of this note somewhere above.  This line number
6796      note is still needed for debugging though, so we can't delete it.  */
6797   if (flag_test_coverage)
6798     emit_note (NULL, NOTE_INSN_REPEATED_LINE_NUMBER);
6799
6800   /* Output a linenumber for the end of the function.
6801      SDB depends on this.  */
6802   emit_line_note_force (filename, line);
6803
6804   /* Before the return label (if any), clobber the return
6805      registers so that they are not propogated live to the rest of
6806      the function.  This can only happen with functions that drop
6807      through; if there had been a return statement, there would
6808      have either been a return rtx, or a jump to the return label.
6809
6810      We delay actual code generation after the current_function_value_rtx
6811      is computed.  */
6812   clobber_after = get_last_insn ();
6813
6814   /* Output the label for the actual return from the function,
6815      if one is expected.  This happens either because a function epilogue
6816      is used instead of a return instruction, or because a return was done
6817      with a goto in order to run local cleanups, or because of pcc-style
6818      structure returning.  */
6819   if (return_label)
6820     emit_label (return_label);
6821
6822   /* C++ uses this.  */
6823   if (end_bindings)
6824     expand_end_bindings (0, 0, 0);
6825
6826   if (current_function_instrument_entry_exit)
6827     {
6828       rtx fun = DECL_RTL (current_function_decl);
6829       if (GET_CODE (fun) == MEM)
6830         fun = XEXP (fun, 0);
6831       else
6832         abort ();
6833       emit_library_call (profile_function_exit_libfunc, 0, VOIDmode, 2,
6834                          fun, Pmode,
6835                          expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
6836                                                      0,
6837                                                      hard_frame_pointer_rtx),
6838                          Pmode);
6839     }
6840
6841   /* Let except.c know where it should emit the call to unregister
6842      the function context for sjlj exceptions.  */
6843   if (flag_exceptions && USING_SJLJ_EXCEPTIONS)
6844     sjlj_emit_function_exit_after (get_last_insn ());
6845
6846   /* If we had calls to alloca, and this machine needs
6847      an accurate stack pointer to exit the function,
6848      insert some code to save and restore the stack pointer.  */
6849 #ifdef EXIT_IGNORE_STACK
6850   if (! EXIT_IGNORE_STACK)
6851 #endif
6852     if (current_function_calls_alloca)
6853       {
6854         rtx tem = 0;
6855
6856         emit_stack_save (SAVE_FUNCTION, &tem, parm_birth_insn);
6857         emit_stack_restore (SAVE_FUNCTION, tem, NULL_RTX);
6858       }
6859
6860   /* If scalar return value was computed in a pseudo-reg, or was a named
6861      return value that got dumped to the stack, copy that to the hard
6862      return register.  */
6863   if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl)))
6864     {
6865       tree decl_result = DECL_RESULT (current_function_decl);
6866       rtx decl_rtl = DECL_RTL (decl_result);
6867
6868       if (REG_P (decl_rtl)
6869           ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER
6870           : DECL_REGISTER (decl_result))
6871         {
6872           rtx real_decl_rtl;
6873
6874 #ifdef FUNCTION_OUTGOING_VALUE
6875           real_decl_rtl = FUNCTION_OUTGOING_VALUE (TREE_TYPE (decl_result),
6876                                                    current_function_decl);
6877 #else
6878           real_decl_rtl = FUNCTION_VALUE (TREE_TYPE (decl_result),
6879                                           current_function_decl);
6880 #endif
6881           REG_FUNCTION_VALUE_P (real_decl_rtl) = 1;
6882
6883           /* If this is a BLKmode structure being returned in registers,
6884              then use the mode computed in expand_return.  Note that if
6885              decl_rtl is memory, then its mode may have been changed,
6886              but that current_function_return_rtx has not.  */
6887           if (GET_MODE (real_decl_rtl) == BLKmode)
6888             PUT_MODE (real_decl_rtl, GET_MODE (current_function_return_rtx));
6889
6890           /* If a named return value dumped decl_return to memory, then
6891              we may need to re-do the PROMOTE_MODE signed/unsigned
6892              extension.  */
6893           if (GET_MODE (real_decl_rtl) != GET_MODE (decl_rtl))
6894             {
6895               int unsignedp = TREE_UNSIGNED (TREE_TYPE (decl_result));
6896
6897 #ifdef PROMOTE_FUNCTION_RETURN
6898               promote_mode (TREE_TYPE (decl_result), GET_MODE (decl_rtl),
6899                             &unsignedp, 1);
6900 #endif
6901
6902               convert_move (real_decl_rtl, decl_rtl, unsignedp);
6903             }
6904           else if (GET_CODE (real_decl_rtl) == PARALLEL)
6905             emit_group_load (real_decl_rtl, decl_rtl,
6906                              int_size_in_bytes (TREE_TYPE (decl_result)),
6907                              TYPE_ALIGN (TREE_TYPE (decl_result)));
6908           else
6909             emit_move_insn (real_decl_rtl, decl_rtl);
6910
6911           /* The delay slot scheduler assumes that current_function_return_rtx
6912              holds the hard register containing the return value, not a
6913              temporary pseudo.  */
6914           current_function_return_rtx = real_decl_rtl;
6915         }
6916     }
6917
6918   /* If returning a structure, arrange to return the address of the value
6919      in a place where debuggers expect to find it.
6920
6921      If returning a structure PCC style,
6922      the caller also depends on this value.
6923      And current_function_returns_pcc_struct is not necessarily set.  */
6924   if (current_function_returns_struct
6925       || current_function_returns_pcc_struct)
6926     {
6927       rtx value_address
6928         = XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
6929       tree type = TREE_TYPE (DECL_RESULT (current_function_decl));
6930 #ifdef FUNCTION_OUTGOING_VALUE
6931       rtx outgoing
6932         = FUNCTION_OUTGOING_VALUE (build_pointer_type (type),
6933                                    current_function_decl);
6934 #else
6935       rtx outgoing
6936         = FUNCTION_VALUE (build_pointer_type (type), current_function_decl);
6937 #endif
6938
6939       /* Mark this as a function return value so integrate will delete the
6940          assignment and USE below when inlining this function.  */
6941       REG_FUNCTION_VALUE_P (outgoing) = 1;
6942
6943 #ifdef POINTERS_EXTEND_UNSIGNED
6944       /* The address may be ptr_mode and OUTGOING may be Pmode.  */
6945       if (GET_MODE (outgoing) != GET_MODE (value_address))
6946         value_address = convert_memory_address (GET_MODE (outgoing),
6947                                                 value_address);
6948 #endif
6949
6950       emit_move_insn (outgoing, value_address);
6951
6952       /* Show return register used to hold result (in this case the address
6953          of the result.  */
6954       current_function_return_rtx = outgoing;
6955     }
6956
6957   /* If this is an implementation of throw, do what's necessary to
6958      communicate between __builtin_eh_return and the epilogue.  */
6959   expand_eh_return ();
6960
6961   /* Emit the actual code to clobber return register.  */
6962   {
6963     rtx seq, after;
6964
6965     start_sequence ();
6966     clobber_return_register ();
6967     seq = gen_sequence ();
6968     end_sequence ();
6969
6970     after = emit_insn_after (seq, clobber_after);
6971
6972     if (clobber_after != after)
6973       cfun->x_clobber_return_insn = after;
6974   }
6975
6976   /* ??? This should no longer be necessary since stupid is no longer with
6977      us, but there are some parts of the compiler (eg reload_combine, and
6978      sh mach_dep_reorg) that still try and compute their own lifetime info
6979      instead of using the general framework.  */
6980   use_return_register ();
6981
6982   /* Fix up any gotos that jumped out to the outermost
6983      binding level of the function.
6984      Must follow emitting RETURN_LABEL.  */
6985
6986   /* If you have any cleanups to do at this point,
6987      and they need to create temporary variables,
6988      then you will lose.  */
6989   expand_fixups (get_insns ());
6990 }
6991
6992 rtx
6993 get_arg_pointer_save_area (f)
6994      struct function *f;
6995 {
6996   rtx ret = f->x_arg_pointer_save_area;
6997
6998   if (! ret)
6999     {
7000       ret = assign_stack_local_1 (Pmode, GET_MODE_SIZE (Pmode), 0, f);
7001       f->x_arg_pointer_save_area = ret;
7002     }
7003
7004   if (f == cfun && ! f->arg_pointer_save_area_init)
7005     {
7006       rtx seq;
7007
7008       /* Save the arg pointer at the beginning of the function.  The
7009          generated stack slot may not be a valid memory address, so we
7010          have to check it and fix it if necessary.  */
7011       start_sequence ();
7012       emit_move_insn (validize_mem (ret), virtual_incoming_args_rtx);
7013       seq = gen_sequence ();
7014       end_sequence ();
7015
7016       push_topmost_sequence ();
7017       emit_insn_after (seq, get_insns ());
7018       pop_topmost_sequence ();
7019     }
7020
7021   return ret;
7022 }
7023 \f
7024 /* Extend a vector that records the INSN_UIDs of INSNS (either a
7025    sequence or a single insn).  */
7026
7027 static void
7028 record_insns (insns, vecp)
7029      rtx insns;
7030      varray_type *vecp;
7031 {
7032   if (GET_CODE (insns) == SEQUENCE)
7033     {
7034       int len = XVECLEN (insns, 0);
7035       int i = VARRAY_SIZE (*vecp);
7036
7037       VARRAY_GROW (*vecp, i + len);
7038       while (--len >= 0)
7039         {
7040           VARRAY_INT (*vecp, i) = INSN_UID (XVECEXP (insns, 0, len));
7041           ++i;
7042         }
7043     }
7044   else
7045     {
7046       int i = VARRAY_SIZE (*vecp);
7047       VARRAY_GROW (*vecp, i + 1);
7048       VARRAY_INT (*vecp, i) = INSN_UID (insns);
7049     }
7050 }
7051
7052 /* Determine how many INSN_UIDs in VEC are part of INSN.  */
7053
7054 static int
7055 contains (insn, vec)
7056      rtx insn;
7057      varray_type vec;
7058 {
7059   int i, j;
7060
7061   if (GET_CODE (insn) == INSN
7062       && GET_CODE (PATTERN (insn)) == SEQUENCE)
7063     {
7064       int count = 0;
7065       for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
7066         for (j = VARRAY_SIZE (vec) - 1; j >= 0; --j)
7067           if (INSN_UID (XVECEXP (PATTERN (insn), 0, i)) == VARRAY_INT (vec, j))
7068             count++;
7069       return count;
7070     }
7071   else
7072     {
7073       for (j = VARRAY_SIZE (vec) - 1; j >= 0; --j)
7074         if (INSN_UID (insn) == VARRAY_INT (vec, j))
7075           return 1;
7076     }
7077   return 0;
7078 }
7079
7080 int
7081 prologue_epilogue_contains (insn)
7082      rtx insn;
7083 {
7084   if (contains (insn, prologue))
7085     return 1;
7086   if (contains (insn, epilogue))
7087     return 1;
7088   return 0;
7089 }
7090
7091 int
7092 sibcall_epilogue_contains (insn)
7093      rtx insn;
7094 {
7095   if (sibcall_epilogue)
7096     return contains (insn, sibcall_epilogue);
7097   return 0;
7098 }
7099
7100 #ifdef HAVE_return
7101 /* Insert gen_return at the end of block BB.  This also means updating
7102    block_for_insn appropriately.  */
7103
7104 static void
7105 emit_return_into_block (bb, line_note)
7106      basic_block bb;
7107      rtx line_note;
7108 {
7109   rtx p, end;
7110
7111   p = NEXT_INSN (bb->end);
7112   end = emit_jump_insn_after (gen_return (), bb->end);
7113   if (line_note)
7114     emit_line_note_after (NOTE_SOURCE_FILE (line_note),
7115                           NOTE_LINE_NUMBER (line_note), PREV_INSN (bb->end));
7116 }
7117 #endif /* HAVE_return */
7118
7119 #ifdef HAVE_epilogue
7120
7121 /* Modify SEQ, a SEQUENCE that is part of the epilogue, to no modifications
7122    to the stack pointer.  */
7123
7124 static void
7125 keep_stack_depressed (seq)
7126      rtx seq;
7127 {
7128   int i;
7129   rtx sp_from_reg = 0;
7130   int sp_modified_unknown = 0;
7131
7132   /* If the epilogue is just a single instruction, it's OK as is */
7133
7134   if (GET_CODE (seq) != SEQUENCE)
7135     return;
7136
7137   /* Scan all insns in SEQ looking for ones that modified the stack
7138      pointer.  Record if it modified the stack pointer by copying it
7139      from the frame pointer or if it modified it in some other way.
7140      Then modify any subsequent stack pointer references to take that
7141      into account.  We start by only allowing SP to be copied from a
7142      register (presumably FP) and then be subsequently referenced.  */
7143
7144   for (i = 0; i < XVECLEN (seq, 0); i++)
7145     {
7146       rtx insn = XVECEXP (seq, 0, i);
7147
7148       if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
7149         continue;
7150
7151       if (reg_set_p (stack_pointer_rtx, insn))
7152         {
7153           rtx set = single_set (insn);
7154
7155           /* If SP is set as a side-effect, we can't support this.  */
7156           if (set == 0)
7157             abort ();
7158
7159           if (GET_CODE (SET_SRC (set)) == REG)
7160             sp_from_reg = SET_SRC (set);
7161           else
7162             sp_modified_unknown = 1;
7163
7164           /* Don't allow the SP modification to happen.  We don't call
7165              delete_insn here since INSN isn't in any chain.  */
7166           PUT_CODE (insn, NOTE);
7167           NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
7168           NOTE_SOURCE_FILE (insn) = 0;
7169         }
7170       else if (reg_referenced_p (stack_pointer_rtx, PATTERN (insn)))
7171         {
7172           if (sp_modified_unknown)
7173             abort ();
7174
7175           else if (sp_from_reg != 0)
7176             PATTERN (insn)
7177               = replace_rtx (PATTERN (insn), stack_pointer_rtx, sp_from_reg);
7178         }
7179     }
7180 }
7181 #endif
7182
7183 /* Generate the prologue and epilogue RTL if the machine supports it.  Thread
7184    this into place with notes indicating where the prologue ends and where
7185    the epilogue begins.  Update the basic block information when possible.  */
7186
7187 void
7188 thread_prologue_and_epilogue_insns (f)
7189      rtx f ATTRIBUTE_UNUSED;
7190 {
7191   int inserted = 0;
7192   edge e;
7193 #if defined (HAVE_sibcall_epilogue) || defined (HAVE_epilogue) || defined (HAVE_return) || defined (HAVE_prologue)
7194   rtx seq;
7195 #endif
7196 #ifdef HAVE_prologue
7197   rtx prologue_end = NULL_RTX;
7198 #endif
7199 #if defined (HAVE_epilogue) || defined(HAVE_return)
7200   rtx epilogue_end = NULL_RTX;
7201 #endif
7202
7203 #ifdef HAVE_prologue
7204   if (HAVE_prologue)
7205     {
7206       start_sequence ();
7207       seq = gen_prologue ();
7208       emit_insn (seq);
7209
7210       /* Retain a map of the prologue insns.  */
7211       if (GET_CODE (seq) != SEQUENCE)
7212         seq = get_insns ();
7213       record_insns (seq, &prologue);
7214       prologue_end = emit_note (NULL, NOTE_INSN_PROLOGUE_END);
7215
7216       seq = gen_sequence ();
7217       end_sequence ();
7218
7219       /* Can't deal with multiple successsors of the entry block
7220          at the moment.  Function should always have at least one
7221          entry point.  */
7222       if (!ENTRY_BLOCK_PTR->succ || ENTRY_BLOCK_PTR->succ->succ_next)
7223         abort ();
7224
7225       insert_insn_on_edge (seq, ENTRY_BLOCK_PTR->succ);
7226       inserted = 1;
7227     }
7228 #endif
7229
7230   /* If the exit block has no non-fake predecessors, we don't need
7231      an epilogue.  */
7232   for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
7233     if ((e->flags & EDGE_FAKE) == 0)
7234       break;
7235   if (e == NULL)
7236     goto epilogue_done;
7237
7238 #ifdef HAVE_return
7239   if (optimize && HAVE_return)
7240     {
7241       /* If we're allowed to generate a simple return instruction,
7242          then by definition we don't need a full epilogue.  Examine
7243          the block that falls through to EXIT.   If it does not
7244          contain any code, examine its predecessors and try to
7245          emit (conditional) return instructions.  */
7246
7247       basic_block last;
7248       edge e_next;
7249       rtx label;
7250
7251       for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
7252         if (e->flags & EDGE_FALLTHRU)
7253           break;
7254       if (e == NULL)
7255         goto epilogue_done;
7256       last = e->src;
7257
7258       /* Verify that there are no active instructions in the last block.  */
7259       label = last->end;
7260       while (label && GET_CODE (label) != CODE_LABEL)
7261         {
7262           if (active_insn_p (label))
7263             break;
7264           label = PREV_INSN (label);
7265         }
7266
7267       if (last->head == label && GET_CODE (label) == CODE_LABEL)
7268         {
7269           rtx epilogue_line_note = NULL_RTX;
7270
7271           /* Locate the line number associated with the closing brace,
7272              if we can find one.  */
7273           for (seq = get_last_insn ();
7274                seq && ! active_insn_p (seq);
7275                seq = PREV_INSN (seq))
7276             if (GET_CODE (seq) == NOTE && NOTE_LINE_NUMBER (seq) > 0)
7277               {
7278                 epilogue_line_note = seq;
7279                 break;
7280               }
7281
7282           for (e = last->pred; e; e = e_next)
7283             {
7284               basic_block bb = e->src;
7285               rtx jump;
7286
7287               e_next = e->pred_next;
7288               if (bb == ENTRY_BLOCK_PTR)
7289                 continue;
7290
7291               jump = bb->end;
7292               if ((GET_CODE (jump) != JUMP_INSN) || JUMP_LABEL (jump) != label)
7293                 continue;
7294
7295               /* If we have an unconditional jump, we can replace that
7296                  with a simple return instruction.  */
7297               if (simplejump_p (jump))
7298                 {
7299                   emit_return_into_block (bb, epilogue_line_note);
7300                   delete_insn (jump);
7301                 }
7302
7303               /* If we have a conditional jump, we can try to replace
7304                  that with a conditional return instruction.  */
7305               else if (condjump_p (jump))
7306                 {
7307                   rtx ret, *loc;
7308
7309                   ret = SET_SRC (PATTERN (jump));
7310                   if (GET_CODE (XEXP (ret, 1)) == LABEL_REF)
7311                     loc = &XEXP (ret, 1);
7312                   else
7313                     loc = &XEXP (ret, 2);
7314                   ret = gen_rtx_RETURN (VOIDmode);
7315
7316                   if (! validate_change (jump, loc, ret, 0))
7317                     continue;
7318                   if (JUMP_LABEL (jump))
7319                     LABEL_NUSES (JUMP_LABEL (jump))--;
7320
7321                   /* If this block has only one successor, it both jumps
7322                      and falls through to the fallthru block, so we can't
7323                      delete the edge.  */
7324                   if (bb->succ->succ_next == NULL)
7325                     continue;
7326                 }
7327               else
7328                 continue;
7329
7330               /* Fix up the CFG for the successful change we just made.  */
7331               redirect_edge_succ (e, EXIT_BLOCK_PTR);
7332             }
7333
7334           /* Emit a return insn for the exit fallthru block.  Whether
7335              this is still reachable will be determined later.  */
7336
7337           emit_barrier_after (last->end);
7338           emit_return_into_block (last, epilogue_line_note);
7339           epilogue_end = last->end;
7340           last->succ->flags &= ~EDGE_FALLTHRU;
7341           goto epilogue_done;
7342         }
7343     }
7344 #endif
7345 #ifdef HAVE_epilogue
7346   if (HAVE_epilogue)
7347     {
7348       /* Find the edge that falls through to EXIT.  Other edges may exist
7349          due to RETURN instructions, but those don't need epilogues.
7350          There really shouldn't be a mixture -- either all should have
7351          been converted or none, however...  */
7352
7353       for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
7354         if (e->flags & EDGE_FALLTHRU)
7355           break;
7356       if (e == NULL)
7357         goto epilogue_done;
7358
7359       start_sequence ();
7360       epilogue_end = emit_note (NULL, NOTE_INSN_EPILOGUE_BEG);
7361
7362       seq = gen_epilogue ();
7363
7364       /* If this function returns with the stack depressed, massage
7365          the epilogue to actually do that.  */
7366       if (TREE_CODE (TREE_TYPE (current_function_decl)) == FUNCTION_TYPE
7367           && TYPE_RETURNS_STACK_DEPRESSED (TREE_TYPE (current_function_decl)))
7368         keep_stack_depressed (seq);
7369
7370       emit_jump_insn (seq);
7371
7372       /* Retain a map of the epilogue insns.  */
7373       if (GET_CODE (seq) != SEQUENCE)
7374         seq = get_insns ();
7375       record_insns (seq, &epilogue);
7376
7377       seq = gen_sequence ();
7378       end_sequence ();
7379
7380       insert_insn_on_edge (seq, e);
7381       inserted = 1;
7382     }
7383 #endif
7384 epilogue_done:
7385
7386   if (inserted)
7387     commit_edge_insertions ();
7388
7389 #ifdef HAVE_sibcall_epilogue
7390   /* Emit sibling epilogues before any sibling call sites.  */
7391   for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
7392     {
7393       basic_block bb = e->src;
7394       rtx insn = bb->end;
7395       rtx i;
7396       rtx newinsn;
7397
7398       if (GET_CODE (insn) != CALL_INSN
7399           || ! SIBLING_CALL_P (insn))
7400         continue;
7401
7402       start_sequence ();
7403       seq = gen_sibcall_epilogue ();
7404       end_sequence ();
7405
7406       i = PREV_INSN (insn);
7407       newinsn = emit_insn_before (seq, insn);
7408
7409       /* Retain a map of the epilogue insns.  Used in life analysis to
7410          avoid getting rid of sibcall epilogue insns.  */
7411       record_insns (GET_CODE (seq) == SEQUENCE
7412                     ? seq : newinsn, &sibcall_epilogue);
7413     }
7414 #endif
7415
7416 #ifdef HAVE_prologue
7417   if (prologue_end)
7418     {
7419       rtx insn, prev;
7420
7421       /* GDB handles `break f' by setting a breakpoint on the first
7422          line note after the prologue.  Which means (1) that if
7423          there are line number notes before where we inserted the
7424          prologue we should move them, and (2) we should generate a
7425          note before the end of the first basic block, if there isn't
7426          one already there.
7427
7428          ??? This behaviour is completely broken when dealing with
7429          multiple entry functions.  We simply place the note always
7430          into first basic block and let alternate entry points
7431          to be missed.
7432        */
7433
7434       for (insn = prologue_end; insn; insn = prev)
7435         {
7436           prev = PREV_INSN (insn);
7437           if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
7438             {
7439               /* Note that we cannot reorder the first insn in the
7440                  chain, since rest_of_compilation relies on that
7441                  remaining constant.  */
7442               if (prev == NULL)
7443                 break;
7444               reorder_insns (insn, insn, prologue_end);
7445             }
7446         }
7447
7448       /* Find the last line number note in the first block.  */
7449       for (insn = BASIC_BLOCK (0)->end;
7450            insn != prologue_end && insn;
7451            insn = PREV_INSN (insn))
7452         if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
7453           break;
7454
7455       /* If we didn't find one, make a copy of the first line number
7456          we run across.  */
7457       if (! insn)
7458         {
7459           for (insn = next_active_insn (prologue_end);
7460                insn;
7461                insn = PREV_INSN (insn))
7462             if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
7463               {
7464                 emit_line_note_after (NOTE_SOURCE_FILE (insn),
7465                                       NOTE_LINE_NUMBER (insn),
7466                                       prologue_end);
7467                 break;
7468               }
7469         }
7470     }
7471 #endif
7472 #ifdef HAVE_epilogue
7473   if (epilogue_end)
7474     {
7475       rtx insn, next;
7476
7477       /* Similarly, move any line notes that appear after the epilogue.
7478          There is no need, however, to be quite so anal about the existance
7479          of such a note.  */
7480       for (insn = epilogue_end; insn; insn = next)
7481         {
7482           next = NEXT_INSN (insn);
7483           if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
7484             reorder_insns (insn, insn, PREV_INSN (epilogue_end));
7485         }
7486     }
7487 #endif
7488 }
7489
7490 /* Reposition the prologue-end and epilogue-begin notes after instruction
7491    scheduling and delayed branch scheduling.  */
7492
7493 void
7494 reposition_prologue_and_epilogue_notes (f)
7495      rtx f ATTRIBUTE_UNUSED;
7496 {
7497 #if defined (HAVE_prologue) || defined (HAVE_epilogue)
7498   int len;
7499
7500   if ((len = VARRAY_SIZE (prologue)) > 0)
7501     {
7502       rtx insn, note = 0;
7503
7504       /* Scan from the beginning until we reach the last prologue insn.
7505          We apparently can't depend on basic_block_{head,end} after
7506          reorg has run.  */
7507       for (insn = f; len && insn; insn = NEXT_INSN (insn))
7508         {
7509           if (GET_CODE (insn) == NOTE)
7510             {
7511               if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PROLOGUE_END)
7512                 note = insn;
7513             }
7514           else if ((len -= contains (insn, prologue)) == 0)
7515             {
7516               rtx next;
7517               /* Find the prologue-end note if we haven't already, and
7518                  move it to just after the last prologue insn.  */
7519               if (note == 0)
7520                 {
7521                   for (note = insn; (note = NEXT_INSN (note));)
7522                     if (GET_CODE (note) == NOTE
7523                         && NOTE_LINE_NUMBER (note) == NOTE_INSN_PROLOGUE_END)
7524                       break;
7525                 }
7526
7527               next = NEXT_INSN (note);
7528
7529               /* Whether or not we can depend on BLOCK_HEAD,
7530                  attempt to keep it up-to-date.  */
7531               if (BLOCK_HEAD (0) == note)
7532                 BLOCK_HEAD (0) = next;
7533
7534               remove_insn (note);
7535               /* Avoid placing note between CODE_LABEL and BASIC_BLOCK note.  */
7536               if (GET_CODE (insn) == CODE_LABEL)
7537                 insn = NEXT_INSN (insn);
7538               add_insn_after (note, insn);
7539             }
7540         }
7541     }
7542
7543   if ((len = VARRAY_SIZE (epilogue)) > 0)
7544     {
7545       rtx insn, note = 0;
7546
7547       /* Scan from the end until we reach the first epilogue insn.
7548          We apparently can't depend on basic_block_{head,end} after
7549          reorg has run.  */
7550       for (insn = get_last_insn (); len && insn; insn = PREV_INSN (insn))
7551         {
7552           if (GET_CODE (insn) == NOTE)
7553             {
7554               if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EPILOGUE_BEG)
7555                 note = insn;
7556             }
7557           else if ((len -= contains (insn, epilogue)) == 0)
7558             {
7559               /* Find the epilogue-begin note if we haven't already, and
7560                  move it to just before the first epilogue insn.  */
7561               if (note == 0)
7562                 {
7563                   for (note = insn; (note = PREV_INSN (note));)
7564                     if (GET_CODE (note) == NOTE
7565                         && NOTE_LINE_NUMBER (note) == NOTE_INSN_EPILOGUE_BEG)
7566                       break;
7567                 }
7568
7569               /* Whether or not we can depend on BLOCK_HEAD,
7570                  attempt to keep it up-to-date.  */
7571               if (n_basic_blocks
7572                   && BLOCK_HEAD (n_basic_blocks-1) == insn)
7573                 BLOCK_HEAD (n_basic_blocks-1) = note;
7574
7575               remove_insn (note);
7576               add_insn_before (note, insn);
7577             }
7578         }
7579     }
7580 #endif /* HAVE_prologue or HAVE_epilogue */
7581 }
7582
7583 /* Mark P for GC.  */
7584
7585 static void
7586 mark_function_status (p)
7587      struct function *p;
7588 {
7589   struct var_refs_queue *q;
7590   struct temp_slot *t;
7591   int i;
7592   rtx *r;
7593
7594   if (p == 0)
7595     return;
7596
7597   ggc_mark_rtx (p->arg_offset_rtx);
7598
7599   if (p->x_parm_reg_stack_loc)
7600     for (i = p->x_max_parm_reg, r = p->x_parm_reg_stack_loc;
7601          i > 0; --i, ++r)
7602       ggc_mark_rtx (*r);
7603
7604   ggc_mark_rtx (p->return_rtx);
7605   ggc_mark_rtx (p->x_cleanup_label);
7606   ggc_mark_rtx (p->x_return_label);
7607   ggc_mark_rtx (p->x_save_expr_regs);
7608   ggc_mark_rtx (p->x_stack_slot_list);
7609   ggc_mark_rtx (p->x_parm_birth_insn);
7610   ggc_mark_rtx (p->x_tail_recursion_label);
7611   ggc_mark_rtx (p->x_tail_recursion_reentry);
7612   ggc_mark_rtx (p->internal_arg_pointer);
7613   ggc_mark_rtx (p->x_arg_pointer_save_area);
7614   ggc_mark_tree (p->x_rtl_expr_chain);
7615   ggc_mark_rtx (p->x_last_parm_insn);
7616   ggc_mark_tree (p->x_context_display);
7617   ggc_mark_tree (p->x_trampoline_list);
7618   ggc_mark_rtx (p->epilogue_delay_list);
7619   ggc_mark_rtx (p->x_clobber_return_insn);
7620
7621   for (t = p->x_temp_slots; t != 0; t = t->next)
7622     {
7623       ggc_mark (t);
7624       ggc_mark_rtx (t->slot);
7625       ggc_mark_rtx (t->address);
7626       ggc_mark_tree (t->rtl_expr);
7627       ggc_mark_tree (t->type);
7628     }
7629
7630   for (q = p->fixup_var_refs_queue; q != 0; q = q->next)
7631     {
7632       ggc_mark (q);
7633       ggc_mark_rtx (q->modified);
7634       }
7635
7636   ggc_mark_rtx (p->x_nonlocal_goto_handler_slots);
7637   ggc_mark_rtx (p->x_nonlocal_goto_handler_labels);
7638   ggc_mark_rtx (p->x_nonlocal_goto_stack_level);
7639   ggc_mark_tree (p->x_nonlocal_labels);
7640
7641   mark_hard_reg_initial_vals (p);
7642 }
7643
7644 /* Mark the struct function pointed to by *ARG for GC, if it is not
7645    NULL.  This is used to mark the current function and the outer
7646    function chain.  */
7647
7648 static void
7649 maybe_mark_struct_function (arg)
7650      void *arg;
7651 {
7652   struct function *f = *(struct function **) arg;
7653
7654   if (f == 0)
7655     return;
7656
7657   ggc_mark_struct_function (f);
7658 }
7659
7660 /* Mark a struct function * for GC.  This is called from ggc-common.c.  */
7661
7662 void
7663 ggc_mark_struct_function (f)
7664      struct function *f;
7665 {
7666   ggc_mark (f);
7667   ggc_mark_tree (f->decl);
7668
7669   mark_function_status (f);
7670   mark_eh_status (f->eh);
7671   mark_stmt_status (f->stmt);
7672   mark_expr_status (f->expr);
7673   mark_emit_status (f->emit);
7674   mark_varasm_status (f->varasm);
7675
7676   if (mark_machine_status)
7677     (*mark_machine_status) (f);
7678   if (mark_lang_status)
7679     (*mark_lang_status) (f);
7680
7681   if (f->original_arg_vector)
7682     ggc_mark_rtvec ((rtvec) f->original_arg_vector);
7683   if (f->original_decl_initial)
7684     ggc_mark_tree (f->original_decl_initial);
7685   if (f->outer)
7686     ggc_mark_struct_function (f->outer);
7687 }
7688
7689 /* Called once, at initialization, to initialize function.c.  */
7690
7691 void
7692 init_function_once ()
7693 {
7694   ggc_add_root (&cfun, 1, sizeof cfun, maybe_mark_struct_function);
7695   ggc_add_root (&outer_function_chain, 1, sizeof outer_function_chain,
7696                 maybe_mark_struct_function);
7697
7698   VARRAY_INT_INIT (prologue, 0, "prologue");
7699   VARRAY_INT_INIT (epilogue, 0, "epilogue");
7700   VARRAY_INT_INIT (sibcall_epilogue, 0, "sibcall_epilogue");
7701 }