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