gcc/function.c

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