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 hard 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 (GET_CODE (sub) == MEM)
3079         sub = adjust_address_nv (sub, GET_MODE (x), 0);
3080       else if (GET_CODE (sub) == REG
3081                && (MEM_VOLATILE_P (x) || GET_MODE (x) == BLKmode))
3082         ;
3083       else if (GET_CODE (sub) == REG && GET_MODE (x) != GET_MODE (sub))
3084         {
3085           int size_x, size_sub;
3086
3087           if (may_postpone)
3088             {
3089               /* Postpone for now, so that we do not emit bitfield arithmetics
3090                  unless there is some benefit from it.  */
3091               if (!postponed_insns || XEXP (postponed_insns, 0) != insn)
3092                 postponed_insns = alloc_INSN_LIST (insn, postponed_insns);
3093               return true;
3094             }
3095
3096           if (!insn)
3097             {
3098               /* When processing REG_NOTES look at the list of
3099                  replacements done on the insn to find the register that X
3100                  was replaced by.  */
3101               rtx tem;
3102
3103               for (tem = purge_bitfield_addressof_replacements;
3104                    tem != NULL_RTX;
3105                    tem = XEXP (XEXP (tem, 1), 1))
3106                 if (rtx_equal_p (x, XEXP (tem, 0)))
3107                   {
3108                     *loc = XEXP (XEXP (tem, 1), 0);
3109                     return true;
3110                   }
3111
3112               /* See comment for purge_addressof_replacements.  */
3113               for (tem = purge_addressof_replacements;
3114                    tem != NULL_RTX;
3115                    tem = XEXP (XEXP (tem, 1), 1))
3116                 if (rtx_equal_p (XEXP (x, 0), XEXP (tem, 0)))
3117                   {
3118                     rtx z = XEXP (XEXP (tem, 1), 0);
3119
3120                     if (GET_MODE (x) == GET_MODE (z)
3121                         || (GET_CODE (XEXP (XEXP (tem, 1), 0)) != REG
3122                             && GET_CODE (XEXP (XEXP (tem, 1), 0)) != SUBREG))
3123                       abort ();
3124
3125                     /* It can happen that the note may speak of things
3126                        in a wider (or just different) mode than the
3127                        code did.  This is especially true of
3128                        REG_RETVAL.  */
3129
3130                     if (GET_CODE (z) == SUBREG && SUBREG_BYTE (z) == 0)
3131                       z = SUBREG_REG (z);
3132
3133                     if (GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD
3134                         && (GET_MODE_SIZE (GET_MODE (x))
3135                             > GET_MODE_SIZE (GET_MODE (z))))
3136                       {
3137                         /* This can occur as a result in invalid
3138                            pointer casts, e.g. float f; ...
3139                            *(long long int *)&f.
3140                            ??? We could emit a warning here, but
3141                            without a line number that wouldn't be
3142                            very helpful.  */
3143                         z = gen_rtx_SUBREG (GET_MODE (x), z, 0);
3144                       }
3145                     else
3146                       z = gen_lowpart (GET_MODE (x), z);
3147
3148                     *loc = z;
3149                     return true;
3150                   }
3151
3152               /* When we are processing the REG_NOTES of the last instruction
3153                  of a libcall, there will be typically no replacements
3154                  for that insn; the replacements happened before, piecemeal
3155                  fashion.  OTOH we are not interested in the details of
3156                  this for the REG_EQUAL note, we want to know the big picture,
3157                  which can be succinctly described with a simple SUBREG.
3158                  Note that removing the REG_EQUAL note is not an option
3159                  on the last insn of a libcall, so we must do a replacement.  */
3160               if (! purge_addressof_replacements
3161                   && ! purge_bitfield_addressof_replacements)
3162                 {
3163                   /* In compile/990107-1.c:7 compiled at -O1 -m1 for sh-elf,
3164                      we got
3165                      (mem:DI (addressof:SI (reg/v:DF 160) 159 0x401c8510)
3166                       [0 S8 A32]), which can be expressed with a simple
3167                      same-size subreg  */
3168                   if ((GET_MODE_SIZE (GET_MODE (x))
3169                        == GET_MODE_SIZE (GET_MODE (sub)))
3170                       /* Again, invalid pointer casts (as in
3171                          compile/990203-1.c) can require paradoxical
3172                          subregs.  */
3173                       || (GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD
3174                           && (GET_MODE_SIZE (GET_MODE (x))
3175                               > GET_MODE_SIZE (GET_MODE (sub)))))
3176                     {
3177                       *loc = gen_rtx_SUBREG (GET_MODE (x), sub, 0);
3178                       return true;
3179                     }
3180                   /* ??? Are there other cases we should handle?  */
3181                 }
3182               /* Sometimes we may not be able to find the replacement.  For
3183                  example when the original insn was a MEM in a wider mode,
3184                  and the note is part of a sign extension of a narrowed
3185                  version of that MEM.  Gcc testcase compile/990829-1.c can
3186                  generate an example of this situation.  Rather than complain
3187                  we return false, which will prompt our caller to remove the
3188                  offending note.  */
3189               return false;
3190             }
3191
3192           size_x = GET_MODE_BITSIZE (GET_MODE (x));
3193           size_sub = GET_MODE_BITSIZE (GET_MODE (sub));
3194
3195           /* Do not frob unchanging MEMs.  If a later reference forces the
3196              pseudo to the stack, we can wind up with multiple writes to
3197              an unchanging memory, which is invalid.  */
3198           if (RTX_UNCHANGING_P (x) && size_x != size_sub)
3199             ;
3200
3201           /* Don't even consider working with paradoxical subregs,
3202              or the moral equivalent seen here.  */
3203           else if (size_x <= size_sub
3204                    && int_mode_for_mode (GET_MODE (sub)) != BLKmode)
3205             {
3206               /* Do a bitfield insertion to mirror what would happen
3207                  in memory.  */
3208
3209               rtx val, seq;
3210
3211               if (store)
3212                 {
3213                   rtx p = PREV_INSN (insn);
3214
3215                   start_sequence ();
3216                   val = gen_reg_rtx (GET_MODE (x));
3217                   if (! validate_change (insn, loc, val, 0))
3218                     {
3219                       /* Discard the current sequence and put the
3220                          ADDRESSOF on stack.  */
3221                       end_sequence ();
3222                       goto give_up;
3223                     }
3224                   seq = get_insns ();
3225                   end_sequence ();
3226                   emit_insn_before (seq, insn);
3227                   compute_insns_for_mem (p ? NEXT_INSN (p) : get_insns (),
3228                                          insn, ht);
3229
3230                   start_sequence ();
3231                   store_bit_field (sub, size_x, 0, GET_MODE (x),
3232                                    val, GET_MODE_SIZE (GET_MODE (sub)));
3233
3234                   /* Make sure to unshare any shared rtl that store_bit_field
3235                      might have created.  */
3236                   unshare_all_rtl_again (get_insns ());
3237
3238                   seq = get_insns ();
3239                   end_sequence ();
3240                   p = emit_insn_after (seq, insn);
3241                   if (NEXT_INSN (insn))
3242                     compute_insns_for_mem (NEXT_INSN (insn),
3243                                            p ? NEXT_INSN (p) : NULL_RTX,
3244                                            ht);
3245                 }
3246               else
3247                 {
3248                   rtx p = PREV_INSN (insn);
3249
3250                   start_sequence ();
3251                   val = extract_bit_field (sub, size_x, 0, 1, NULL_RTX,
3252                                            GET_MODE (x), GET_MODE (x),
3253                                            GET_MODE_SIZE (GET_MODE (sub)));
3254
3255                   if (! validate_change (insn, loc, val, 0))
3256                     {
3257                       /* Discard the current sequence and put the
3258                          ADDRESSOF on stack.  */
3259                       end_sequence ();
3260                       goto give_up;
3261                     }
3262
3263                   seq = get_insns ();
3264                   end_sequence ();
3265                   emit_insn_before (seq, insn);
3266                   compute_insns_for_mem (p ? NEXT_INSN (p) : get_insns (),
3267                                          insn, ht);
3268                 }
3269
3270               /* Remember the replacement so that the same one can be done
3271                  on the REG_NOTES.  */
3272               purge_bitfield_addressof_replacements
3273                 = gen_rtx_EXPR_LIST (VOIDmode, x,
3274                                      gen_rtx_EXPR_LIST
3275                                      (VOIDmode, val,
3276                                       purge_bitfield_addressof_replacements));
3277
3278               /* We replaced with a reg -- all done.  */
3279               return true;
3280             }
3281         }
3282
3283       else if (validate_change (insn, loc, sub, 0))
3284         {
3285           /* Remember the replacement so that the same one can be done
3286              on the REG_NOTES.  */
3287           if (GET_CODE (sub) == REG || GET_CODE (sub) == SUBREG)
3288             {
3289               rtx tem;
3290
3291               for (tem = purge_addressof_replacements;
3292                    tem != NULL_RTX;
3293                    tem = XEXP (XEXP (tem, 1), 1))
3294                 if (rtx_equal_p (XEXP (x, 0), XEXP (tem, 0)))
3295                   {
3296                     XEXP (XEXP (tem, 1), 0) = sub;
3297                     return true;
3298                   }
3299               purge_addressof_replacements
3300                 = gen_rtx (EXPR_LIST, VOIDmode, XEXP (x, 0),
3301                            gen_rtx_EXPR_LIST (VOIDmode, sub,
3302                                               purge_addressof_replacements));
3303               return true;
3304             }
3305           goto restart;
3306         }
3307     }
3308
3309  give_up:
3310   /* Scan all subexpressions.  */
3311   fmt = GET_RTX_FORMAT (code);
3312   for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
3313     {
3314       if (*fmt == 'e')
3315         result &= purge_addressof_1 (&XEXP (x, i), insn, force, 0,
3316                                      may_postpone, ht);
3317       else if (*fmt == 'E')
3318         for (j = 0; j < XVECLEN (x, i); j++)
3319           result &= purge_addressof_1 (&XVECEXP (x, i, j), insn, force, 0,
3320                                        may_postpone, ht);
3321     }
3322
3323   return result;
3324 }
3325
3326 /* Return a hash value for K, a REG.  */
3327
3328 static hashval_t
3329 insns_for_mem_hash (k)
3330      const void * k;
3331 {
3332   /* Use the address of the key for the hash value.  */
3333   struct insns_for_mem_entry *m = (struct insns_for_mem_entry *) k;
3334   return htab_hash_pointer (m->key);
3335 }
3336
3337 /* Return nonzero if K1 and K2 (two REGs) are the same.  */
3338
3339 static int
3340 insns_for_mem_comp (k1, k2)
3341      const void * k1;
3342      const void * k2;
3343 {
3344   struct insns_for_mem_entry *m1 = (struct insns_for_mem_entry *) k1;
3345   struct insns_for_mem_entry *m2 = (struct insns_for_mem_entry *) k2;
3346   return m1->key == m2->key;
3347 }
3348
3349 struct insns_for_mem_walk_info
3350 {
3351   /* The hash table that we are using to record which INSNs use which
3352      MEMs.  */
3353   htab_t ht;
3354
3355   /* The INSN we are currently processing.  */
3356   rtx insn;
3357
3358   /* Zero if we are walking to find ADDRESSOFs, one if we are walking
3359      to find the insns that use the REGs in the ADDRESSOFs.  */
3360   int pass;
3361 };
3362
3363 /* Called from compute_insns_for_mem via for_each_rtx.  If R is a REG
3364    that might be used in an ADDRESSOF expression, record this INSN in
3365    the hash table given by DATA (which is really a pointer to an
3366    insns_for_mem_walk_info structure).  */
3367
3368 static int
3369 insns_for_mem_walk (r, data)
3370      rtx *r;
3371      void *data;
3372 {
3373   struct insns_for_mem_walk_info *ifmwi
3374     = (struct insns_for_mem_walk_info *) data;
3375   struct insns_for_mem_entry tmp;
3376   tmp.insns = NULL_RTX;
3377
3378   if (ifmwi->pass == 0 && *r && GET_CODE (*r) == ADDRESSOF
3379       && GET_CODE (XEXP (*r, 0)) == REG)
3380     {
3381       PTR *e;
3382       tmp.key = XEXP (*r, 0);
3383       e = htab_find_slot (ifmwi->ht, &tmp, INSERT);
3384       if (*e == NULL)
3385         {
3386           *e = ggc_alloc (sizeof (tmp));
3387           memcpy (*e, &tmp, sizeof (tmp));
3388         }
3389     }
3390   else if (ifmwi->pass == 1 && *r && GET_CODE (*r) == REG)
3391     {
3392       struct insns_for_mem_entry *ifme;
3393       tmp.key = *r;
3394       ifme = (struct insns_for_mem_entry *) htab_find (ifmwi->ht, &tmp);
3395
3396       /* If we have not already recorded this INSN, do so now.  Since
3397          we process the INSNs in order, we know that if we have
3398          recorded it it must be at the front of the list.  */
3399       if (ifme && (!ifme->insns || XEXP (ifme->insns, 0) != ifmwi->insn))
3400         ifme->insns = gen_rtx_EXPR_LIST (VOIDmode, ifmwi->insn,
3401                                          ifme->insns);
3402     }
3403
3404   return 0;
3405 }
3406
3407 /* Walk the INSNS, until we reach LAST_INSN, recording which INSNs use
3408    which REGs in HT.  */
3409
3410 static void
3411 compute_insns_for_mem (insns, last_insn, ht)
3412      rtx insns;
3413      rtx last_insn;
3414      htab_t ht;
3415 {
3416   rtx insn;
3417   struct insns_for_mem_walk_info ifmwi;
3418   ifmwi.ht = ht;
3419
3420   for (ifmwi.pass = 0; ifmwi.pass < 2; ++ifmwi.pass)
3421     for (insn = insns; insn != last_insn; insn = NEXT_INSN (insn))
3422       if (INSN_P (insn))
3423         {
3424           ifmwi.insn = insn;
3425           for_each_rtx (&insn, insns_for_mem_walk, &ifmwi);
3426         }
3427 }
3428
3429 /* Helper function for purge_addressof called through for_each_rtx.
3430    Returns true iff the rtl is an ADDRESSOF.  */
3431
3432 static int
3433 is_addressof (rtl, data)
3434      rtx *rtl;
3435      void *data ATTRIBUTE_UNUSED;
3436 {
3437   return GET_CODE (*rtl) == ADDRESSOF;
3438 }
3439
3440 /* Eliminate all occurrences of ADDRESSOF from INSNS.  Elide any remaining
3441    (MEM (ADDRESSOF)) patterns, and force any needed registers into the
3442    stack.  */
3443
3444 void
3445 purge_addressof (insns)
3446      rtx insns;
3447 {
3448   rtx insn, tmp;
3449   htab_t ht;
3450
3451   /* When we actually purge ADDRESSOFs, we turn REGs into MEMs.  That
3452      requires a fixup pass over the instruction stream to correct
3453      INSNs that depended on the REG being a REG, and not a MEM.  But,
3454      these fixup passes are slow.  Furthermore, most MEMs are not
3455      mentioned in very many instructions.  So, we speed up the process
3456      by pre-calculating which REGs occur in which INSNs; that allows
3457      us to perform the fixup passes much more quickly.  */
3458   ht = htab_create_ggc (1000, insns_for_mem_hash, insns_for_mem_comp, NULL);
3459   compute_insns_for_mem (insns, NULL_RTX, ht);
3460
3461   postponed_insns = NULL;
3462
3463   for (insn = insns; insn; insn = NEXT_INSN (insn))
3464     if (INSN_P (insn))
3465       {
3466         if (! purge_addressof_1 (&PATTERN (insn), insn,
3467                                  asm_noperands (PATTERN (insn)) > 0, 0, 1, ht))
3468           /* If we could not replace the ADDRESSOFs in the insn,
3469              something is wrong.  */
3470           abort ();
3471
3472         if (! purge_addressof_1 (&REG_NOTES (insn), NULL_RTX, 0, 0, 0, ht))
3473           {
3474             /* If we could not replace the ADDRESSOFs in the insn's notes,
3475                we can just remove the offending notes instead.  */
3476             rtx note;
3477
3478             for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
3479               {
3480                 /* If we find a REG_RETVAL note then the insn is a libcall.
3481                    Such insns must have REG_EQUAL notes as well, in order
3482                    for later passes of the compiler to work.  So it is not
3483                    safe to delete the notes here, and instead we abort.  */
3484                 if (REG_NOTE_KIND (note) == REG_RETVAL)
3485                   abort ();
3486                 if (for_each_rtx (&note, is_addressof, NULL))
3487                   remove_note (insn, note);
3488               }
3489           }
3490       }
3491
3492   /* Process the postponed insns.  */
3493   while (postponed_insns)
3494     {
3495       insn = XEXP (postponed_insns, 0);
3496       tmp = postponed_insns;
3497       postponed_insns = XEXP (postponed_insns, 1);
3498       free_INSN_LIST_node (tmp);
3499
3500       if (! purge_addressof_1 (&PATTERN (insn), insn,
3501                                asm_noperands (PATTERN (insn)) > 0, 0, 0, ht))
3502         abort ();
3503     }
3504
3505   /* Clean up.  */
3506   purge_bitfield_addressof_replacements = 0;
3507   purge_addressof_replacements = 0;
3508
3509   /* REGs are shared.  purge_addressof will destructively replace a REG
3510      with a MEM, which creates shared MEMs.
3511
3512      Unfortunately, the children of put_reg_into_stack assume that MEMs
3513      referring to the same stack slot are shared (fixup_var_refs and
3514      the associated hash table code).
3515
3516      So, we have to do another unsharing pass after we have flushed any
3517      REGs that had their address taken into the stack.
3518
3519      It may be worth tracking whether or not we converted any REGs into
3520      MEMs to avoid this overhead when it is not needed.  */
3521   unshare_all_rtl_again (get_insns ());
3522 }
3523 \f
3524 /* Convert a SET of a hard subreg to a set of the appropriate hard
3525    register.  A subroutine of purge_hard_subreg_sets.  */
3526
3527 static void
3528 purge_single_hard_subreg_set (pattern)
3529      rtx pattern;
3530 {
3531   rtx reg = SET_DEST (pattern);
3532   enum machine_mode mode = GET_MODE (SET_DEST (pattern));
3533   int offset = 0;
3534
3535   if (GET_CODE (reg) == SUBREG && GET_CODE (SUBREG_REG (reg)) == REG
3536       && REGNO (SUBREG_REG (reg)) < FIRST_PSEUDO_REGISTER)
3537     {
3538       offset = subreg_regno_offset (REGNO (SUBREG_REG (reg)),
3539                                     GET_MODE (SUBREG_REG (reg)),
3540                                     SUBREG_BYTE (reg),
3541                                     GET_MODE (reg));
3542       reg = SUBREG_REG (reg);
3543     }
3544
3545
3546   if (GET_CODE (reg) == REG && REGNO (reg) < FIRST_PSEUDO_REGISTER)
3547     {
3548       reg = gen_rtx_REG (mode, REGNO (reg) + offset);
3549       SET_DEST (pattern) = reg;
3550     }
3551 }
3552
3553 /* Eliminate all occurrences of SETs of hard subregs from INSNS.  The
3554    only such SETs that we expect to see are those left in because
3555    integrate can't handle sets of parts of a return value register.
3556
3557    We don't use alter_subreg because we only want to eliminate subregs
3558    of hard registers.  */
3559
3560 void
3561 purge_hard_subreg_sets (insn)
3562      rtx insn;
3563 {
3564   for (; insn; insn = NEXT_INSN (insn))
3565     {
3566       if (INSN_P (insn))
3567         {
3568           rtx pattern = PATTERN (insn);
3569           switch (GET_CODE (pattern))
3570             {
3571             case SET:
3572               if (GET_CODE (SET_DEST (pattern)) == SUBREG)
3573                 purge_single_hard_subreg_set (pattern);
3574               break;
3575             case PARALLEL:
3576               {
3577                 int j;
3578                 for (j = XVECLEN (pattern, 0) - 1; j >= 0; j--)
3579                   {
3580                     rtx inner_pattern = XVECEXP (pattern, 0, j);
3581                     if (GET_CODE (inner_pattern) == SET
3582                         && GET_CODE (SET_DEST (inner_pattern)) == SUBREG)
3583                       purge_single_hard_subreg_set (inner_pattern);
3584                   }
3585               }
3586               break;
3587             default:
3588               break;
3589             }
3590         }
3591     }
3592 }
3593 \f
3594 /* Pass through the INSNS of function FNDECL and convert virtual register
3595    references to hard register references.  */
3596
3597 void
3598 instantiate_virtual_regs (fndecl, insns)
3599      tree fndecl;
3600      rtx insns;
3601 {
3602   rtx insn;
3603   unsigned int i;
3604
3605   /* Compute the offsets to use for this function.  */
3606   in_arg_offset = FIRST_PARM_OFFSET (fndecl);
3607   var_offset = STARTING_FRAME_OFFSET;
3608   dynamic_offset = STACK_DYNAMIC_OFFSET (fndecl);
3609   out_arg_offset = STACK_POINTER_OFFSET;
3610   cfa_offset = ARG_POINTER_CFA_OFFSET (fndecl);
3611
3612   /* Scan all variables and parameters of this function.  For each that is
3613      in memory, instantiate all virtual registers if the result is a valid
3614      address.  If not, we do it later.  That will handle most uses of virtual
3615      regs on many machines.  */
3616   instantiate_decls (fndecl, 1);
3617
3618   /* Initialize recognition, indicating that volatile is OK.  */
3619   init_recog ();
3620
3621   /* Scan through all the insns, instantiating every virtual register still
3622      present.  */
3623   for (insn = insns; insn; insn = NEXT_INSN (insn))
3624     if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN
3625         || GET_CODE (insn) == CALL_INSN)
3626       {
3627         instantiate_virtual_regs_1 (&PATTERN (insn), insn, 1);
3628         if (INSN_DELETED_P (insn))
3629           continue;
3630         instantiate_virtual_regs_1 (&REG_NOTES (insn), NULL_RTX, 0);
3631         /* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE.  */
3632         if (GET_CODE (insn) == CALL_INSN)
3633           instantiate_virtual_regs_1 (&CALL_INSN_FUNCTION_USAGE (insn),
3634                                       NULL_RTX, 0);
3635
3636         /* Past this point all ASM statements should match.  Verify that
3637            to avoid failures later in the compilation process.  */
3638         if (asm_noperands (PATTERN (insn)) >= 0
3639             && ! check_asm_operands (PATTERN (insn)))
3640           instantiate_virtual_regs_lossage (insn);
3641       }
3642
3643   /* Instantiate the stack slots for the parm registers, for later use in
3644      addressof elimination.  */
3645   for (i = 0; i < max_parm_reg; ++i)
3646     if (parm_reg_stack_loc[i])
3647       instantiate_virtual_regs_1 (&parm_reg_stack_loc[i], NULL_RTX, 0);
3648
3649   /* Now instantiate the remaining register equivalences for debugging info.
3650      These will not be valid addresses.  */
3651   instantiate_decls (fndecl, 0);
3652
3653   /* Indicate that, from now on, assign_stack_local should use
3654      frame_pointer_rtx.  */
3655   virtuals_instantiated = 1;
3656 }
3657
3658 /* Scan all decls in FNDECL (both variables and parameters) and instantiate
3659    all virtual registers in their DECL_RTL's.
3660
3661    If VALID_ONLY, do this only if the resulting address is still valid.
3662    Otherwise, always do it.  */
3663
3664 static void
3665 instantiate_decls (fndecl, valid_only)
3666      tree fndecl;
3667      int valid_only;
3668 {
3669   tree decl;
3670
3671   /* Process all parameters of the function.  */
3672   for (decl = DECL_ARGUMENTS (fndecl); decl; decl = TREE_CHAIN (decl))
3673     {
3674       HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (decl));
3675       HOST_WIDE_INT size_rtl;
3676
3677       instantiate_decl (DECL_RTL (decl), size, valid_only);
3678
3679       /* If the parameter was promoted, then the incoming RTL mode may be
3680          larger than the declared type size.  We must use the larger of
3681          the two sizes.  */
3682       size_rtl = GET_MODE_SIZE (GET_MODE (DECL_INCOMING_RTL (decl)));
3683       size = MAX (size_rtl, size);
3684       instantiate_decl (DECL_INCOMING_RTL (decl), size, valid_only);
3685     }
3686
3687   /* Now process all variables defined in the function or its subblocks.  */
3688   instantiate_decls_1 (DECL_INITIAL (fndecl), valid_only);
3689 }
3690
3691 /* Subroutine of instantiate_decls: Process all decls in the given
3692    BLOCK node and all its subblocks.  */
3693
3694 static void
3695 instantiate_decls_1 (let, valid_only)
3696      tree let;
3697      int valid_only;
3698 {
3699   tree t;
3700
3701   for (t = BLOCK_VARS (let); t; t = TREE_CHAIN (t))
3702     if (DECL_RTL_SET_P (t))
3703       instantiate_decl (DECL_RTL (t),
3704                         int_size_in_bytes (TREE_TYPE (t)),
3705                         valid_only);
3706
3707   /* Process all subblocks.  */
3708   for (t = BLOCK_SUBBLOCKS (let); t; t = TREE_CHAIN (t))
3709     instantiate_decls_1 (t, valid_only);
3710 }
3711
3712 /* Subroutine of the preceding procedures: Given RTL representing a
3713    decl and the size of the object, do any instantiation required.
3714
3715    If VALID_ONLY is nonzero, it means that the RTL should only be
3716    changed if the new address is valid.  */
3717
3718 static void
3719 instantiate_decl (x, size, valid_only)
3720      rtx x;
3721      HOST_WIDE_INT size;
3722      int valid_only;
3723 {
3724   enum machine_mode mode;
3725   rtx addr;
3726
3727   /* If this is not a MEM, no need to do anything.  Similarly if the
3728      address is a constant or a register that is not a virtual register.  */
3729
3730   if (x == 0 || GET_CODE (x) != MEM)
3731     return;
3732
3733   addr = XEXP (x, 0);
3734   if (CONSTANT_P (addr)
3735       || (GET_CODE (addr) == ADDRESSOF && GET_CODE (XEXP (addr, 0)) == REG)
3736       || (GET_CODE (addr) == REG
3737           && (REGNO (addr) < FIRST_VIRTUAL_REGISTER
3738               || REGNO (addr) > LAST_VIRTUAL_REGISTER)))
3739     return;
3740
3741   /* If we should only do this if the address is valid, copy the address.
3742      We need to do this so we can undo any changes that might make the
3743      address invalid.  This copy is unfortunate, but probably can't be
3744      avoided.  */
3745
3746   if (valid_only)
3747     addr = copy_rtx (addr);
3748
3749   instantiate_virtual_regs_1 (&addr, NULL_RTX, 0);
3750
3751   if (valid_only && size >= 0)
3752     {
3753       unsigned HOST_WIDE_INT decl_size = size;
3754
3755       /* Now verify that the resulting address is valid for every integer or
3756          floating-point mode up to and including SIZE bytes long.  We do this
3757          since the object might be accessed in any mode and frame addresses
3758          are shared.  */
3759
3760       for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
3761            mode != VOIDmode && GET_MODE_SIZE (mode) <= decl_size;
3762            mode = GET_MODE_WIDER_MODE (mode))
3763         if (! memory_address_p (mode, addr))
3764           return;
3765
3766       for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
3767            mode != VOIDmode && GET_MODE_SIZE (mode) <= decl_size;
3768            mode = GET_MODE_WIDER_MODE (mode))
3769         if (! memory_address_p (mode, addr))
3770           return;
3771     }
3772
3773   /* Put back the address now that we have updated it and we either know
3774      it is valid or we don't care whether it is valid.  */
3775
3776   XEXP (x, 0) = addr;
3777 }
3778 \f
3779 /* Given a piece of RTX and a pointer to a HOST_WIDE_INT, if the RTX
3780    is a virtual register, return the equivalent hard register and set the
3781    offset indirectly through the pointer.  Otherwise, return 0.  */
3782
3783 static rtx
3784 instantiate_new_reg (x, poffset)
3785      rtx x;
3786      HOST_WIDE_INT *poffset;
3787 {
3788   rtx new;
3789   HOST_WIDE_INT offset;
3790
3791   if (x == virtual_incoming_args_rtx)
3792     new = arg_pointer_rtx, offset = in_arg_offset;
3793   else if (x == virtual_stack_vars_rtx)
3794     new = frame_pointer_rtx, offset = var_offset;
3795   else if (x == virtual_stack_dynamic_rtx)
3796     new = stack_pointer_rtx, offset = dynamic_offset;
3797   else if (x == virtual_outgoing_args_rtx)
3798     new = stack_pointer_rtx, offset = out_arg_offset;
3799   else if (x == virtual_cfa_rtx)
3800     new = arg_pointer_rtx, offset = cfa_offset;
3801   else
3802     return 0;
3803
3804   *poffset = offset;
3805   return new;
3806 }
3807 \f
3808
3809 /* Called when instantiate_virtual_regs has failed to update the instruction.
3810    Usually this means that non-matching instruction has been emit, however for
3811    asm statements it may be the problem in the constraints.  */
3812 static void
3813 instantiate_virtual_regs_lossage (insn)
3814      rtx insn;
3815 {
3816   if (asm_noperands (PATTERN (insn)) >= 0)
3817     {
3818       error_for_asm (insn, "impossible constraint in `asm'");
3819       delete_insn (insn);
3820     }
3821   else
3822     abort ();
3823 }
3824 /* Given a pointer to a piece of rtx and an optional pointer to the
3825    containing object, instantiate any virtual registers present in it.
3826
3827    If EXTRA_INSNS, we always do the replacement and generate
3828    any extra insns before OBJECT.  If it zero, we do nothing if replacement
3829    is not valid.
3830
3831    Return 1 if we either had nothing to do or if we were able to do the
3832    needed replacement.  Return 0 otherwise; we only return zero if
3833    EXTRA_INSNS is zero.
3834
3835    We first try some simple transformations to avoid the creation of extra
3836    pseudos.  */
3837
3838 static int
3839 instantiate_virtual_regs_1 (loc, object, extra_insns)
3840      rtx *loc;
3841      rtx object;
3842      int extra_insns;
3843 {
3844   rtx x;
3845   RTX_CODE code;
3846   rtx new = 0;
3847   HOST_WIDE_INT offset = 0;
3848   rtx temp;
3849   rtx seq;
3850   int i, j;
3851   const char *fmt;
3852
3853   /* Re-start here to avoid recursion in common cases.  */
3854  restart:
3855
3856   x = *loc;
3857   if (x == 0)
3858     return 1;
3859
3860   /* We may have detected and deleted invalid asm statements.  */
3861   if (object && INSN_P (object) && INSN_DELETED_P (object))
3862     return 1;
3863
3864   code = GET_CODE (x);
3865
3866   /* Check for some special cases.  */
3867   switch (code)
3868     {
3869     case CONST_INT:
3870     case CONST_DOUBLE:
3871     case CONST_VECTOR:
3872     case CONST:
3873     case SYMBOL_REF:
3874     case CODE_LABEL:
3875     case PC:
3876     case CC0:
3877     case ASM_INPUT:
3878     case ADDR_VEC:
3879     case ADDR_DIFF_VEC:
3880     case RETURN:
3881       return 1;
3882
3883     case SET:
3884       /* We are allowed to set the virtual registers.  This means that
3885          the actual register should receive the source minus the
3886          appropriate offset.  This is used, for example, in the handling
3887          of non-local gotos.  */
3888       if ((new = instantiate_new_reg (SET_DEST (x), &offset)) != 0)
3889         {
3890           rtx src = SET_SRC (x);
3891
3892           /* We are setting the register, not using it, so the relevant
3893              offset is the negative of the offset to use were we using
3894              the register.  */
3895           offset = - offset;
3896           instantiate_virtual_regs_1 (&src, NULL_RTX, 0);
3897
3898           /* The only valid sources here are PLUS or REG.  Just do
3899              the simplest possible thing to handle them.  */
3900           if (GET_CODE (src) != REG && GET_CODE (src) != PLUS)
3901             {
3902               instantiate_virtual_regs_lossage (object);
3903               return 1;
3904             }
3905
3906           start_sequence ();
3907           if (GET_CODE (src) != REG)
3908             temp = force_operand (src, NULL_RTX);
3909           else
3910             temp = src;
3911           temp = force_operand (plus_constant (temp, offset), NULL_RTX);
3912           seq = get_insns ();
3913           end_sequence ();
3914
3915           emit_insn_before (seq, object);
3916           SET_DEST (x) = new;
3917
3918           if (! validate_change (object, &SET_SRC (x), temp, 0)
3919               || ! extra_insns)
3920             instantiate_virtual_regs_lossage (object);
3921
3922           return 1;
3923         }
3924
3925       instantiate_virtual_regs_1 (&SET_DEST (x), object, extra_insns);
3926       loc = &SET_SRC (x);
3927       goto restart;
3928
3929     case PLUS:
3930       /* Handle special case of virtual register plus constant.  */
3931       if (CONSTANT_P (XEXP (x, 1)))
3932         {
3933           rtx old, new_offset;
3934
3935           /* Check for (plus (plus VIRT foo) (const_int)) first.  */
3936           if (GET_CODE (XEXP (x, 0)) == PLUS)
3937             {
3938               if ((new = instantiate_new_reg (XEXP (XEXP (x, 0), 0), &offset)))
3939                 {
3940                   instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 1), object,
3941                                               extra_insns);
3942                   new = gen_rtx_PLUS (Pmode, new, XEXP (XEXP (x, 0), 1));
3943                 }
3944               else
3945                 {
3946                   loc = &XEXP (x, 0);
3947                   goto restart;
3948                 }
3949             }
3950
3951 #ifdef POINTERS_EXTEND_UNSIGNED
3952           /* If we have (plus (subreg (virtual-reg)) (const_int)), we know
3953              we can commute the PLUS and SUBREG because pointers into the
3954              frame are well-behaved.  */
3955           else if (GET_CODE (XEXP (x, 0)) == SUBREG && GET_MODE (x) == ptr_mode
3956                    && GET_CODE (XEXP (x, 1)) == CONST_INT
3957                    && 0 != (new
3958                             = instantiate_new_reg (SUBREG_REG (XEXP (x, 0)),
3959                                                    &offset))
3960                    && validate_change (object, loc,
3961                                        plus_constant (gen_lowpart (ptr_mode,
3962                                                                    new),
3963                                                       offset
3964                                                       + INTVAL (XEXP (x, 1))),
3965                                        0))
3966                 return 1;
3967 #endif
3968           else if ((new = instantiate_new_reg (XEXP (x, 0), &offset)) == 0)
3969             {
3970               /* We know the second operand is a constant.  Unless the
3971                  first operand is a REG (which has been already checked),
3972                  it needs to be checked.  */
3973               if (GET_CODE (XEXP (x, 0)) != REG)
3974                 {
3975                   loc = &XEXP (x, 0);
3976                   goto restart;
3977                 }
3978               return 1;
3979             }
3980
3981           new_offset = plus_constant (XEXP (x, 1), offset);
3982
3983           /* If the new constant is zero, try to replace the sum with just
3984              the register.  */
3985           if (new_offset == const0_rtx
3986               && validate_change (object, loc, new, 0))
3987             return 1;
3988
3989           /* Next try to replace the register and new offset.
3990              There are two changes to validate here and we can't assume that
3991              in the case of old offset equals new just changing the register
3992              will yield a valid insn.  In the interests of a little efficiency,
3993              however, we only call validate change once (we don't queue up the
3994              changes and then call apply_change_group).  */
3995
3996           old = XEXP (x, 0);
3997           if (offset == 0
3998               ? ! validate_change (object, &XEXP (x, 0), new, 0)
3999               : (XEXP (x, 0) = new,
4000                  ! validate_change (object, &XEXP (x, 1), new_offset, 0)))
4001             {
4002               if (! extra_insns)
4003                 {
4004                   XEXP (x, 0) = old;
4005                   return 0;
4006                 }
4007
4008               /* Otherwise copy the new constant into a register and replace
4009                  constant with that register.  */
4010               temp = gen_reg_rtx (Pmode);
4011               XEXP (x, 0) = new;
4012               if (validate_change (object, &XEXP (x, 1), temp, 0))
4013                 emit_insn_before (gen_move_insn (temp, new_offset), object);
4014               else
4015                 {
4016                   /* If that didn't work, replace this expression with a
4017                      register containing the sum.  */
4018
4019                   XEXP (x, 0) = old;
4020                   new = gen_rtx_PLUS (Pmode, new, new_offset);
4021
4022                   start_sequence ();
4023                   temp = force_operand (new, NULL_RTX);
4024                   seq = get_insns ();
4025                   end_sequence ();
4026
4027                   emit_insn_before (seq, object);
4028                   if (! validate_change (object, loc, temp, 0)
4029                       && ! validate_replace_rtx (x, temp, object))
4030                     {
4031                       instantiate_virtual_regs_lossage (object);
4032                       return 1;
4033                     }
4034                 }
4035             }
4036
4037           return 1;
4038         }
4039
4040       /* Fall through to generic two-operand expression case.  */
4041     case EXPR_LIST:
4042     case CALL:
4043     case COMPARE:
4044     case MINUS:
4045     case MULT:
4046     case DIV:      case UDIV:
4047     case MOD:      case UMOD:
4048     case AND:      case IOR:      case XOR:
4049     case ROTATERT: case ROTATE:
4050     case ASHIFTRT: case LSHIFTRT: case ASHIFT:
4051     case NE:       case EQ:
4052     case GE:       case GT:       case GEU:    case GTU:
4053     case LE:       case LT:       case LEU:    case LTU:
4054       if (XEXP (x, 1) && ! CONSTANT_P (XEXP (x, 1)))
4055         instantiate_virtual_regs_1 (&XEXP (x, 1), object, extra_insns);
4056       loc = &XEXP (x, 0);
4057       goto restart;
4058
4059     case MEM:
4060       /* Most cases of MEM that convert to valid addresses have already been
4061          handled by our scan of decls.  The only special handling we
4062          need here is to make a copy of the rtx to ensure it isn't being
4063          shared if we have to change it to a pseudo.
4064
4065          If the rtx is a simple reference to an address via a virtual register,
4066          it can potentially be shared.  In such cases, first try to make it
4067          a valid address, which can also be shared.  Otherwise, copy it and
4068          proceed normally.
4069
4070          First check for common cases that need no processing.  These are
4071          usually due to instantiation already being done on a previous instance
4072          of a shared rtx.  */
4073
4074       temp = XEXP (x, 0);
4075       if (CONSTANT_ADDRESS_P (temp)
4076 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
4077           || temp == arg_pointer_rtx
4078 #endif
4079 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
4080           || temp == hard_frame_pointer_rtx
4081 #endif
4082           || temp == frame_pointer_rtx)
4083         return 1;
4084
4085       if (GET_CODE (temp) == PLUS
4086           && CONSTANT_ADDRESS_P (XEXP (temp, 1))
4087           && (XEXP (temp, 0) == frame_pointer_rtx
4088 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
4089               || XEXP (temp, 0) == hard_frame_pointer_rtx
4090 #endif
4091 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
4092               || XEXP (temp, 0) == arg_pointer_rtx
4093 #endif
4094               ))
4095         return 1;
4096
4097       if (temp == virtual_stack_vars_rtx
4098           || temp == virtual_incoming_args_rtx
4099           || (GET_CODE (temp) == PLUS
4100               && CONSTANT_ADDRESS_P (XEXP (temp, 1))
4101               && (XEXP (temp, 0) == virtual_stack_vars_rtx
4102                   || XEXP (temp, 0) == virtual_incoming_args_rtx)))
4103         {
4104           /* This MEM may be shared.  If the substitution can be done without
4105              the need to generate new pseudos, we want to do it in place
4106              so all copies of the shared rtx benefit.  The call below will
4107              only make substitutions if the resulting address is still
4108              valid.
4109
4110              Note that we cannot pass X as the object in the recursive call
4111              since the insn being processed may not allow all valid
4112              addresses.  However, if we were not passed on object, we can
4113              only modify X without copying it if X will have a valid
4114              address.
4115
4116              ??? Also note that this can still lose if OBJECT is an insn that
4117              has less restrictions on an address that some other insn.
4118              In that case, we will modify the shared address.  This case
4119              doesn't seem very likely, though.  One case where this could
4120              happen is in the case of a USE or CLOBBER reference, but we
4121              take care of that below.  */
4122
4123           if (instantiate_virtual_regs_1 (&XEXP (x, 0),
4124                                           object ? object : x, 0))
4125             return 1;
4126
4127           /* Otherwise make a copy and process that copy.  We copy the entire
4128              RTL expression since it might be a PLUS which could also be
4129              shared.  */
4130           *loc = x = copy_rtx (x);
4131         }
4132
4133       /* Fall through to generic unary operation case.  */
4134     case PREFETCH:
4135     case SUBREG:
4136     case STRICT_LOW_PART:
4137     case NEG:          case NOT:
4138     case PRE_DEC:      case PRE_INC:      case POST_DEC:    case POST_INC:
4139     case SIGN_EXTEND:  case ZERO_EXTEND:
4140     case TRUNCATE:     case FLOAT_EXTEND: case FLOAT_TRUNCATE:
4141     case FLOAT:        case FIX:
4142     case UNSIGNED_FIX: case UNSIGNED_FLOAT:
4143     case ABS:
4144     case SQRT:
4145     case FFS:
4146     case CLZ:          case CTZ:
4147     case POPCOUNT:     case PARITY:
4148       /* These case either have just one operand or we know that we need not
4149          check the rest of the operands.  */
4150       loc = &XEXP (x, 0);
4151       goto restart;
4152
4153     case USE:
4154     case CLOBBER:
4155       /* If the operand is a MEM, see if the change is a valid MEM.  If not,
4156          go ahead and make the invalid one, but do it to a copy.  For a REG,
4157          just make the recursive call, since there's no chance of a problem.  */
4158
4159       if ((GET_CODE (XEXP (x, 0)) == MEM
4160            && instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 0), XEXP (x, 0),
4161                                           0))
4162           || (GET_CODE (XEXP (x, 0)) == REG
4163               && instantiate_virtual_regs_1 (&XEXP (x, 0), object, 0)))
4164         return 1;
4165
4166       XEXP (x, 0) = copy_rtx (XEXP (x, 0));
4167       loc = &XEXP (x, 0);
4168       goto restart;
4169
4170     case REG:
4171       /* Try to replace with a PLUS.  If that doesn't work, compute the sum
4172          in front of this insn and substitute the temporary.  */
4173       if ((new = instantiate_new_reg (x, &offset)) != 0)
4174         {
4175           temp = plus_constant (new, offset);
4176           if (!validate_change (object, loc, temp, 0))
4177             {
4178               if (! extra_insns)
4179                 return 0;
4180
4181               start_sequence ();
4182               temp = force_operand (temp, NULL_RTX);
4183               seq = get_insns ();
4184               end_sequence ();
4185
4186               emit_insn_before (seq, object);
4187               if (! validate_change (object, loc, temp, 0)
4188                   && ! validate_replace_rtx (x, temp, object))
4189                 instantiate_virtual_regs_lossage (object);
4190             }
4191         }
4192
4193       return 1;
4194
4195     case ADDRESSOF:
4196       if (GET_CODE (XEXP (x, 0)) == REG)
4197         return 1;
4198
4199       else if (GET_CODE (XEXP (x, 0)) == MEM)
4200         {
4201           /* If we have a (addressof (mem ..)), do any instantiation inside
4202              since we know we'll be making the inside valid when we finally
4203              remove the ADDRESSOF.  */
4204           instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 0), NULL_RTX, 0);
4205           return 1;
4206         }
4207       break;
4208
4209     default:
4210       break;
4211     }
4212
4213   /* Scan all subexpressions.  */
4214   fmt = GET_RTX_FORMAT (code);
4215   for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
4216     if (*fmt == 'e')
4217       {
4218         if (!instantiate_virtual_regs_1 (&XEXP (x, i), object, extra_insns))
4219           return 0;
4220       }
4221     else if (*fmt == 'E')
4222       for (j = 0; j < XVECLEN (x, i); j++)
4223         if (! instantiate_virtual_regs_1 (&XVECEXP (x, i, j), object,
4224                                           extra_insns))
4225           return 0;
4226
4227   return 1;
4228 }
4229 \f
4230 /* Optimization: assuming this function does not receive nonlocal gotos,
4231    delete the handlers for such, as well as the insns to establish
4232    and disestablish them.  */
4233
4234 static void
4235 delete_handlers ()
4236 {
4237   rtx insn;
4238   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4239     {
4240       /* Delete the handler by turning off the flag that would
4241          prevent jump_optimize from deleting it.
4242          Also permit deletion of the nonlocal labels themselves
4243          if nothing local refers to them.  */
4244       if (GET_CODE (insn) == CODE_LABEL)
4245         {
4246           tree t, last_t;
4247
4248           LABEL_PRESERVE_P (insn) = 0;
4249
4250           /* Remove it from the nonlocal_label list, to avoid confusing
4251              flow.  */
4252           for (t = nonlocal_labels, last_t = 0; t;
4253                last_t = t, t = TREE_CHAIN (t))
4254             if (DECL_RTL (TREE_VALUE (t)) == insn)
4255               break;
4256           if (t)
4257             {
4258               if (! last_t)
4259                 nonlocal_labels = TREE_CHAIN (nonlocal_labels);
4260               else
4261                 TREE_CHAIN (last_t) = TREE_CHAIN (t);
4262             }
4263         }
4264       if (GET_CODE (insn) == INSN)
4265         {
4266           int can_delete = 0;
4267           rtx t;
4268           for (t = nonlocal_goto_handler_slots; t != 0; t = XEXP (t, 1))
4269             if (reg_mentioned_p (t, PATTERN (insn)))
4270               {
4271                 can_delete = 1;
4272                 break;
4273               }
4274           if (can_delete
4275               || (nonlocal_goto_stack_level != 0
4276                   && reg_mentioned_p (nonlocal_goto_stack_level,
4277                                       PATTERN (insn))))
4278             delete_related_insns (insn);
4279         }
4280     }
4281 }
4282 \f
4283 /* Return the first insn following those generated by `assign_parms'.  */
4284
4285 rtx
4286 get_first_nonparm_insn ()
4287 {
4288   if (last_parm_insn)
4289     return NEXT_INSN (last_parm_insn);
4290   return get_insns ();
4291 }
4292
4293 /* Return 1 if EXP is an aggregate type (or a value with aggregate type).
4294    This means a type for which function calls must pass an address to the
4295    function or get an address back from the function.
4296    EXP may be a type node or an expression (whose type is tested).  */
4297
4298 int
4299 aggregate_value_p (exp)
4300      tree exp;
4301 {
4302   int i, regno, nregs;
4303   rtx reg;
4304
4305   tree type = (TYPE_P (exp)) ? exp : TREE_TYPE (exp);
4306
4307   if (TREE_CODE (type) == VOID_TYPE)
4308     return 0;
4309   if (RETURN_IN_MEMORY (type))
4310     return 1;
4311   /* Types that are TREE_ADDRESSABLE must be constructed in memory,
4312      and thus can't be returned in registers.  */
4313   if (TREE_ADDRESSABLE (type))
4314     return 1;
4315   if (flag_pcc_struct_return && AGGREGATE_TYPE_P (type))
4316     return 1;
4317   /* Make sure we have suitable call-clobbered regs to return
4318      the value in; if not, we must return it in memory.  */
4319   reg = hard_function_value (type, 0, 0);
4320
4321   /* If we have something other than a REG (e.g. a PARALLEL), then assume
4322      it is OK.  */
4323   if (GET_CODE (reg) != REG)
4324     return 0;
4325
4326   regno = REGNO (reg);
4327   nregs = HARD_REGNO_NREGS (regno, TYPE_MODE (type));
4328   for (i = 0; i < nregs; i++)
4329     if (! call_used_regs[regno + i])
4330       return 1;
4331   return 0;
4332 }
4333 \f
4334 /* Assign RTL expressions to the function's parameters.
4335    This may involve copying them into registers and using
4336    those registers as the RTL for them.  */
4337
4338 void
4339 assign_parms (fndecl)
4340      tree fndecl;
4341 {
4342   tree parm;
4343   rtx entry_parm = 0;
4344   rtx stack_parm = 0;
4345   CUMULATIVE_ARGS args_so_far;
4346   enum machine_mode promoted_mode, passed_mode;
4347   enum machine_mode nominal_mode, promoted_nominal_mode;
4348   int unsignedp;
4349   /* Total space needed so far for args on the stack,
4350      given as a constant and a tree-expression.  */
4351   struct args_size stack_args_size;
4352   tree fntype = TREE_TYPE (fndecl);
4353   tree fnargs = DECL_ARGUMENTS (fndecl);
4354   /* This is used for the arg pointer when referring to stack args.  */
4355   rtx internal_arg_pointer;
4356   /* This is a dummy PARM_DECL that we used for the function result if
4357      the function returns a structure.  */
4358   tree function_result_decl = 0;
4359 #ifdef SETUP_INCOMING_VARARGS
4360   int varargs_setup = 0;
4361 #endif
4362   rtx conversion_insns = 0;
4363   struct args_size alignment_pad;
4364
4365   /* Nonzero if function takes extra anonymous args.
4366      This means the last named arg must be on the stack
4367      right before the anonymous ones.  */
4368   int stdarg
4369     = (TYPE_ARG_TYPES (fntype) != 0
4370        && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
4371            != void_type_node));
4372
4373   current_function_stdarg = stdarg;
4374
4375   /* If the reg that the virtual arg pointer will be translated into is
4376      not a fixed reg or is the stack pointer, make a copy of the virtual
4377      arg pointer, and address parms via the copy.  The frame pointer is
4378      considered fixed even though it is not marked as such.
4379
4380      The second time through, simply use ap to avoid generating rtx.  */
4381
4382   if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
4383        || ! (fixed_regs[ARG_POINTER_REGNUM]
4384              || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
4385     internal_arg_pointer = copy_to_reg (virtual_incoming_args_rtx);
4386   else
4387     internal_arg_pointer = virtual_incoming_args_rtx;
4388   current_function_internal_arg_pointer = internal_arg_pointer;
4389
4390   stack_args_size.constant = 0;
4391   stack_args_size.var = 0;
4392
4393   /* If struct value address is treated as the first argument, make it so.  */
4394   if (aggregate_value_p (DECL_RESULT (fndecl))
4395       && ! current_function_returns_pcc_struct
4396       && struct_value_incoming_rtx == 0)
4397     {
4398       tree type = build_pointer_type (TREE_TYPE (fntype));
4399
4400       function_result_decl = build_decl (PARM_DECL, NULL_TREE, type);
4401
4402       DECL_ARG_TYPE (function_result_decl) = type;
4403       TREE_CHAIN (function_result_decl) = fnargs;
4404       fnargs = function_result_decl;
4405     }
4406
4407   max_parm_reg = LAST_VIRTUAL_REGISTER + 1;
4408   parm_reg_stack_loc = (rtx *) ggc_alloc_cleared (max_parm_reg * sizeof (rtx));
4409
4410 #ifdef INIT_CUMULATIVE_INCOMING_ARGS
4411   INIT_CUMULATIVE_INCOMING_ARGS (args_so_far, fntype, NULL_RTX);
4412 #else
4413   INIT_CUMULATIVE_ARGS (args_so_far, fntype, NULL_RTX, fndecl);
4414 #endif
4415
4416   /* We haven't yet found an argument that we must push and pretend the
4417      caller did.  */
4418   current_function_pretend_args_size = 0;
4419
4420   for (parm = fnargs; parm; parm = TREE_CHAIN (parm))
4421     {
4422       struct args_size stack_offset;
4423       struct args_size arg_size;
4424       int passed_pointer = 0;
4425       int did_conversion = 0;
4426       tree passed_type = DECL_ARG_TYPE (parm);
4427       tree nominal_type = TREE_TYPE (parm);
4428       int pretend_named;
4429       int last_named = 0, named_arg;
4430
4431       /* Set LAST_NAMED if this is last named arg before last
4432          anonymous args.  */
4433       if (stdarg)
4434         {
4435           tree tem;
4436
4437           for (tem = TREE_CHAIN (parm); tem; tem = TREE_CHAIN (tem))
4438             if (DECL_NAME (tem))
4439               break;
4440
4441           if (tem == 0)
4442             last_named = 1;
4443         }
4444       /* Set NAMED_ARG if this arg should be treated as a named arg.  For
4445          most machines, if this is a varargs/stdarg function, then we treat
4446          the last named arg as if it were anonymous too.  */
4447       named_arg = STRICT_ARGUMENT_NAMING ? 1 : ! last_named;
4448
4449       if (TREE_TYPE (parm) == error_mark_node
4450           /* This can happen after weird syntax errors
4451              or if an enum type is defined among the parms.  */
4452           || TREE_CODE (parm) != PARM_DECL
4453           || passed_type == NULL)
4454         {
4455           SET_DECL_RTL (parm, gen_rtx_MEM (BLKmode, const0_rtx));
4456           DECL_INCOMING_RTL (parm) = DECL_RTL (parm);
4457           TREE_USED (parm) = 1;
4458           continue;
4459         }
4460
4461       /* Find mode of arg as it is passed, and mode of arg
4462          as it should be during execution of this function.  */
4463       passed_mode = TYPE_MODE (passed_type);
4464       nominal_mode = TYPE_MODE (nominal_type);
4465
4466       /* If the parm's mode is VOID, its value doesn't matter,
4467          and avoid the usual things like emit_move_insn that could crash.  */
4468       if (nominal_mode == VOIDmode)
4469         {
4470           SET_DECL_RTL (parm, const0_rtx);
4471           DECL_INCOMING_RTL (parm) = DECL_RTL (parm);
4472           continue;
4473         }
4474
4475       /* If the parm is to be passed as a transparent union, use the
4476          type of the first field for the tests below.  We have already
4477          verified that the modes are the same.  */
4478       if (DECL_TRANSPARENT_UNION (parm)
4479           || (TREE_CODE (passed_type) == UNION_TYPE
4480               && TYPE_TRANSPARENT_UNION (passed_type)))
4481         passed_type = TREE_TYPE (TYPE_FIELDS (passed_type));
4482
4483       /* See if this arg was passed by invisible reference.  It is if
4484          it is an object whose size depends on the contents of the
4485          object itself or if the machine requires these objects be passed
4486          that way.  */
4487
4488       if ((TREE_CODE (TYPE_SIZE (passed_type)) != INTEGER_CST
4489            && contains_placeholder_p (TYPE_SIZE (passed_type)))
4490           || TREE_ADDRESSABLE (passed_type)
4491 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
4492           || FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, passed_mode,
4493                                               passed_type, named_arg)
4494 #endif
4495           )
4496         {
4497           passed_type = nominal_type = build_pointer_type (passed_type);
4498           passed_pointer = 1;
4499           passed_mode = nominal_mode = Pmode;
4500         }
4501       /* See if the frontend wants to pass this by invisible reference.  */
4502       else if (passed_type != nominal_type
4503                && POINTER_TYPE_P (passed_type)
4504                && TREE_TYPE (passed_type) == nominal_type)
4505         {
4506           nominal_type = passed_type;
4507           passed_pointer = 1;
4508           passed_mode = nominal_mode = Pmode;
4509         }
4510
4511       promoted_mode = passed_mode;
4512
4513 #ifdef PROMOTE_FUNCTION_ARGS
4514       /* Compute the mode in which the arg is actually extended to.  */
4515       unsignedp = TREE_UNSIGNED (passed_type);
4516       promoted_mode = promote_mode (passed_type, promoted_mode, &unsignedp, 1);
4517 #endif
4518
4519       /* Let machine desc say which reg (if any) the parm arrives in.
4520          0 means it arrives on the stack.  */
4521 #ifdef FUNCTION_INCOMING_ARG
4522       entry_parm = FUNCTION_INCOMING_ARG (args_so_far, promoted_mode,
4523                                           passed_type, named_arg);
4524 #else
4525       entry_parm = FUNCTION_ARG (args_so_far, promoted_mode,
4526                                  passed_type, named_arg);
4527 #endif
4528
4529       if (entry_parm == 0)
4530         promoted_mode = passed_mode;
4531
4532 #ifdef SETUP_INCOMING_VARARGS
4533       /* If this is the last named parameter, do any required setup for
4534          varargs or stdargs.  We need to know about the case of this being an
4535          addressable type, in which case we skip the registers it
4536          would have arrived in.
4537
4538          For stdargs, LAST_NAMED will be set for two parameters, the one that
4539          is actually the last named, and the dummy parameter.  We only
4540          want to do this action once.
4541
4542          Also, indicate when RTL generation is to be suppressed.  */
4543       if (last_named && !varargs_setup)
4544         {
4545           SETUP_INCOMING_VARARGS (args_so_far, promoted_mode, passed_type,
4546                                   current_function_pretend_args_size, 0);
4547           varargs_setup = 1;
4548         }
4549 #endif
4550
4551       /* Determine parm's home in the stack,
4552          in case it arrives in the stack or we should pretend it did.
4553
4554          Compute the stack position and rtx where the argument arrives
4555          and its size.
4556
4557          There is one complexity here:  If this was a parameter that would
4558          have been passed in registers, but wasn't only because it is
4559          __builtin_va_alist, we want locate_and_pad_parm to treat it as if
4560          it came in a register so that REG_PARM_STACK_SPACE isn't skipped.
4561          In this case, we call FUNCTION_ARG with NAMED set to 1 instead of
4562          0 as it was the previous time.  */
4563
4564       pretend_named = named_arg || PRETEND_OUTGOING_VARARGS_NAMED;
4565       locate_and_pad_parm (promoted_mode, passed_type,
4566 #ifdef STACK_PARMS_IN_REG_PARM_AREA
4567                            1,
4568 #else
4569 #ifdef FUNCTION_INCOMING_ARG
4570                            FUNCTION_INCOMING_ARG (args_so_far, promoted_mode,
4571                                                   passed_type,
4572                                                   pretend_named) != 0,
4573 #else
4574                            FUNCTION_ARG (args_so_far, promoted_mode,
4575                                          passed_type,
4576                                          pretend_named) != 0,
4577 #endif
4578 #endif
4579                            fndecl, &stack_args_size, &stack_offset, &arg_size,
4580                            &alignment_pad);
4581
4582       {
4583         rtx offset_rtx = ARGS_SIZE_RTX (stack_offset);
4584
4585         if (offset_rtx == const0_rtx)
4586           stack_parm = gen_rtx_MEM (promoted_mode, internal_arg_pointer);
4587         else
4588           stack_parm = gen_rtx_MEM (promoted_mode,
4589                                     gen_rtx_PLUS (Pmode,
4590                                                   internal_arg_pointer,
4591                                                   offset_rtx));
4592
4593         set_mem_attributes (stack_parm, parm, 1);
4594
4595         /* Set also REG_ATTRS if parameter was passed in a register.  */
4596         if (entry_parm)
4597           set_reg_attrs_for_parm (entry_parm, stack_parm);
4598       }
4599
4600       /* If this parameter was passed both in registers and in the stack,
4601          use the copy on the stack.  */
4602       if (MUST_PASS_IN_STACK (promoted_mode, passed_type))
4603         entry_parm = 0;
4604
4605 #ifdef FUNCTION_ARG_PARTIAL_NREGS
4606       /* If this parm was passed part in regs and part in memory,
4607          pretend it arrived entirely in memory
4608          by pushing the register-part onto the stack.
4609
4610          In the special case of a DImode or DFmode that is split,
4611          we could put it together in a pseudoreg directly,
4612          but for now that's not worth bothering with.  */
4613
4614       if (entry_parm)
4615         {
4616           int nregs = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, promoted_mode,
4617                                                   passed_type, named_arg);
4618
4619           if (nregs > 0)
4620             {
4621 #if defined (REG_PARM_STACK_SPACE) && !defined (MAYBE_REG_PARM_STACK_SPACE)
4622               /* When REG_PARM_STACK_SPACE is nonzero, stack space for
4623                  split parameters was allocated by our caller, so we
4624                  won't be pushing it in the prolog.  */
4625               if (REG_PARM_STACK_SPACE (fndecl) == 0)
4626 #endif
4627               current_function_pretend_args_size
4628                 = (((nregs * UNITS_PER_WORD) + (PARM_BOUNDARY / BITS_PER_UNIT) - 1)
4629                    / (PARM_BOUNDARY / BITS_PER_UNIT)
4630                    * (PARM_BOUNDARY / BITS_PER_UNIT));
4631
4632               /* Handle calls that pass values in multiple non-contiguous
4633                  locations.  The Irix 6 ABI has examples of this.  */
4634               if (GET_CODE (entry_parm) == PARALLEL)
4635                 emit_group_store (validize_mem (stack_parm), entry_parm,
4636                                   int_size_in_bytes (TREE_TYPE (parm)));
4637
4638               else
4639                 move_block_from_reg (REGNO (entry_parm),
4640                                      validize_mem (stack_parm), nregs,
4641                                      int_size_in_bytes (TREE_TYPE (parm)));
4642
4643               entry_parm = stack_parm;
4644             }
4645         }
4646 #endif
4647
4648       /* If we didn't decide this parm came in a register,
4649          by default it came on the stack.  */
4650       if (entry_parm == 0)
4651         entry_parm = stack_parm;
4652
4653       /* Record permanently how this parm was passed.  */
4654       DECL_INCOMING_RTL (parm) = entry_parm;
4655
4656       /* If there is actually space on the stack for this parm,
4657          count it in stack_args_size; otherwise set stack_parm to 0
4658          to indicate there is no preallocated stack slot for the parm.  */
4659
4660       if (entry_parm == stack_parm
4661           || (GET_CODE (entry_parm) == PARALLEL
4662               && XEXP (XVECEXP (entry_parm, 0, 0), 0) == NULL_RTX)
4663 #if defined (REG_PARM_STACK_SPACE) && ! defined (MAYBE_REG_PARM_STACK_SPACE)
4664           /* On some machines, even if a parm value arrives in a register
4665              there is still an (uninitialized) stack slot allocated for it.
4666
4667              ??? When MAYBE_REG_PARM_STACK_SPACE is defined, we can't tell
4668              whether this parameter already has a stack slot allocated,
4669              because an arg block exists only if current_function_args_size
4670              is larger than some threshold, and we haven't calculated that
4671              yet.  So, for now, we just assume that stack slots never exist
4672              in this case.  */
4673           || REG_PARM_STACK_SPACE (fndecl) > 0
4674 #endif
4675           )
4676         {
4677           stack_args_size.constant += arg_size.constant;
4678           if (arg_size.var)
4679             ADD_PARM_SIZE (stack_args_size, arg_size.var);
4680         }
4681       else
4682         /* No stack slot was pushed for this parm.  */
4683         stack_parm = 0;
4684
4685       /* Update info on where next arg arrives in registers.  */
4686
4687       FUNCTION_ARG_ADVANCE (args_so_far, promoted_mode,
4688                             passed_type, named_arg);
4689
4690       /* If we can't trust the parm stack slot to be aligned enough
4691          for its ultimate type, don't use that slot after entry.
4692          We'll make another stack slot, if we need one.  */
4693       {
4694         unsigned int thisparm_boundary
4695           = FUNCTION_ARG_BOUNDARY (promoted_mode, passed_type);
4696
4697         if (GET_MODE_ALIGNMENT (nominal_mode) > thisparm_boundary)
4698           stack_parm = 0;
4699       }
4700
4701       /* If parm was passed in memory, and we need to convert it on entry,
4702          don't store it back in that same slot.  */
4703       if (entry_parm != 0
4704           && nominal_mode != BLKmode && nominal_mode != passed_mode)
4705         stack_parm = 0;
4706
4707       /* When an argument is passed in multiple locations, we can't
4708          make use of this information, but we can save some copying if
4709          the whole argument is passed in a single register.  */
4710       if (GET_CODE (entry_parm) == PARALLEL
4711           && nominal_mode != BLKmode && passed_mode != BLKmode)
4712         {
4713           int i, len = XVECLEN (entry_parm, 0);
4714
4715           for (i = 0; i < len; i++)
4716             if (XEXP (XVECEXP (entry_parm, 0, i), 0) != NULL_RTX
4717                 && GET_CODE (XEXP (XVECEXP (entry_parm, 0, i), 0)) == REG
4718                 && (GET_MODE (XEXP (XVECEXP (entry_parm, 0, i), 0))
4719                     == passed_mode)
4720                 && INTVAL (XEXP (XVECEXP (entry_parm, 0, i), 1)) == 0)
4721               {
4722                 entry_parm = XEXP (XVECEXP (entry_parm, 0, i), 0);
4723                 DECL_INCOMING_RTL (parm) = entry_parm;
4724                 break;
4725               }
4726         }
4727
4728       /* ENTRY_PARM is an RTX for the parameter as it arrives,
4729          in the mode in which it arrives.
4730          STACK_PARM is an RTX for a stack slot where the parameter can live
4731          during the function (in case we want to put it there).
4732          STACK_PARM is 0 if no stack slot was pushed for it.
4733
4734          Now output code if necessary to convert ENTRY_PARM to
4735          the type in which this function declares it,
4736          and store that result in an appropriate place,
4737          which may be a pseudo reg, may be STACK_PARM,
4738          or may be a local stack slot if STACK_PARM is 0.
4739
4740          Set DECL_RTL to that place.  */
4741
4742       if (nominal_mode == BLKmode || GET_CODE (entry_parm) == PARALLEL)
4743         {
4744           /* If a BLKmode arrives in registers, copy it to a stack slot.
4745              Handle calls that pass values in multiple non-contiguous
4746              locations.  The Irix 6 ABI has examples of this.  */
4747           if (GET_CODE (entry_parm) == REG
4748               || GET_CODE (entry_parm) == PARALLEL)
4749             {
4750               int size_stored
4751                 = CEIL_ROUND (int_size_in_bytes (TREE_TYPE (parm)),
4752                               UNITS_PER_WORD);
4753
4754               /* Note that we will be storing an integral number of words.
4755                  So we have to be careful to ensure that we allocate an
4756                  integral number of words.  We do this below in the
4757                  assign_stack_local if space was not allocated in the argument
4758                  list.  If it was, this will not work if PARM_BOUNDARY is not
4759                  a multiple of BITS_PER_WORD.  It isn't clear how to fix this
4760                  if it becomes a problem.  */
4761
4762               if (stack_parm == 0)
4763                 {
4764                   stack_parm
4765                     = assign_stack_local (GET_MODE (entry_parm),
4766                                           size_stored, 0);
4767                   set_mem_attributes (stack_parm, parm, 1);
4768                 }
4769
4770               else if (PARM_BOUNDARY % BITS_PER_WORD != 0)
4771                 abort ();
4772
4773               /* Handle calls that pass values in multiple non-contiguous
4774                  locations.  The Irix 6 ABI has examples of this.  */
4775               if (GET_CODE (entry_parm) == PARALLEL)
4776                 emit_group_store (validize_mem (stack_parm), entry_parm,
4777                                   int_size_in_bytes (TREE_TYPE (parm)));
4778               else
4779                 move_block_from_reg (REGNO (entry_parm),
4780                                      validize_mem (stack_parm),
4781                                      size_stored / UNITS_PER_WORD,
4782                                      int_size_in_bytes (TREE_TYPE (parm)));
4783             }
4784           SET_DECL_RTL (parm, stack_parm);
4785         }
4786       else if (! ((! optimize
4787                    && ! DECL_REGISTER (parm))
4788                   || TREE_SIDE_EFFECTS (parm)
4789                   /* If -ffloat-store specified, don't put explicit
4790                      float variables into registers.  */
4791                   || (flag_float_store
4792                       && TREE_CODE (TREE_TYPE (parm)) == REAL_TYPE))
4793                /* Always assign pseudo to structure return or item passed
4794                   by invisible reference.  */
4795                || passed_pointer || parm == function_result_decl)
4796         {
4797           /* Store the parm in a pseudoregister during the function, but we
4798              may need to do it in a wider mode.  */
4799
4800           rtx parmreg;
4801           unsigned int regno, regnoi = 0, regnor = 0;
4802
4803           unsignedp = TREE_UNSIGNED (TREE_TYPE (parm));
4804
4805           promoted_nominal_mode
4806             = promote_mode (TREE_TYPE (parm), nominal_mode, &unsignedp, 0);
4807
4808           parmreg = gen_reg_rtx (promoted_nominal_mode);
4809           mark_user_reg (parmreg);
4810
4811           /* If this was an item that we received a pointer to, set DECL_RTL
4812              appropriately.  */
4813           if (passed_pointer)
4814             {
4815               rtx x = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (passed_type)),
4816                                    parmreg);
4817               set_mem_attributes (x, parm, 1);
4818               SET_DECL_RTL (parm, x);
4819             }
4820           else
4821             {
4822               SET_DECL_RTL (parm, parmreg);
4823               maybe_set_unchanging (DECL_RTL (parm), parm);
4824             }
4825
4826           /* Copy the value into the register.  */
4827           if (nominal_mode != passed_mode
4828               || promoted_nominal_mode != promoted_mode)
4829             {
4830               int save_tree_used;
4831               /* ENTRY_PARM has been converted to PROMOTED_MODE, its
4832                  mode, by the caller.  We now have to convert it to
4833                  NOMINAL_MODE, if different.  However, PARMREG may be in
4834                  a different mode than NOMINAL_MODE if it is being stored
4835                  promoted.
4836
4837                  If ENTRY_PARM is a hard register, it might be in a register
4838                  not valid for operating in its mode (e.g., an odd-numbered
4839                  register for a DFmode).  In that case, moves are the only
4840                  thing valid, so we can't do a convert from there.  This
4841                  occurs when the calling sequence allow such misaligned
4842                  usages.
4843
4844                  In addition, the conversion may involve a call, which could
4845                  clobber parameters which haven't been copied to pseudo
4846                  registers yet.  Therefore, we must first copy the parm to
4847                  a pseudo reg here, and save the conversion until after all
4848                  parameters have been moved.  */
4849
4850               rtx tempreg = gen_reg_rtx (GET_MODE (entry_parm));
4851
4852               emit_move_insn (tempreg, validize_mem (entry_parm));
4853
4854               push_to_sequence (conversion_insns);
4855               tempreg = convert_to_mode (nominal_mode, tempreg, unsignedp);
4856
4857               if (GET_CODE (tempreg) == SUBREG
4858                   && GET_MODE (tempreg) == nominal_mode
4859                   && GET_CODE (SUBREG_REG (tempreg)) == REG
4860                   && nominal_mode == passed_mode
4861                   && GET_MODE (SUBREG_REG (tempreg)) == GET_MODE (entry_parm)
4862                   && GET_MODE_SIZE (GET_MODE (tempreg))
4863                      < GET_MODE_SIZE (GET_MODE (entry_parm)))
4864                 {
4865                   /* The argument is already sign/zero extended, so note it
4866                      into the subreg.  */
4867                   SUBREG_PROMOTED_VAR_P (tempreg) = 1;
4868                   SUBREG_PROMOTED_UNSIGNED_SET (tempreg, unsignedp);
4869                 }
4870
4871               /* TREE_USED gets set erroneously during expand_assignment.  */
4872               save_tree_used = TREE_USED (parm);
4873               expand_assignment (parm,
4874                                  make_tree (nominal_type, tempreg), 0, 0);
4875               TREE_USED (parm) = save_tree_used;
4876               conversion_insns = get_insns ();
4877               did_conversion = 1;
4878               end_sequence ();
4879             }
4880           else
4881             emit_move_insn (parmreg, validize_mem (entry_parm));
4882
4883           /* If we were passed a pointer but the actual value
4884              can safely live in a register, put it in one.  */
4885           if (passed_pointer && TYPE_MODE (TREE_TYPE (parm)) != BLKmode
4886               /* If by-reference argument was promoted, demote it.  */
4887               && (TYPE_MODE (TREE_TYPE (parm)) != GET_MODE (DECL_RTL (parm))
4888                   || ! ((! optimize
4889                          && ! DECL_REGISTER (parm))
4890                         || TREE_SIDE_EFFECTS (parm)
4891                         /* If -ffloat-store specified, don't put explicit
4892                            float variables into registers.  */
4893                         || (flag_float_store
4894                             && TREE_CODE (TREE_TYPE (parm)) == REAL_TYPE))))
4895             {
4896               /* We can't use nominal_mode, because it will have been set to
4897                  Pmode above.  We must use the actual mode of the parm.  */
4898               parmreg = gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm)));
4899               mark_user_reg (parmreg);
4900               if (GET_MODE (parmreg) != GET_MODE (DECL_RTL (parm)))
4901                 {
4902                   rtx tempreg = gen_reg_rtx (GET_MODE (DECL_RTL (parm)));
4903                   int unsigned_p = TREE_UNSIGNED (TREE_TYPE (parm));
4904                   push_to_sequence (conversion_insns);
4905                   emit_move_insn (tempreg, DECL_RTL (parm));
4906                   SET_DECL_RTL (parm,
4907                                 convert_to_mode (GET_MODE (parmreg),
4908                                                  tempreg,
4909                                                  unsigned_p));
4910                   emit_move_insn (parmreg, DECL_RTL (parm));
4911                   conversion_insns = get_insns();
4912                   did_conversion = 1;
4913                   end_sequence ();
4914                 }
4915               else
4916                 emit_move_insn (parmreg, DECL_RTL (parm));
4917               SET_DECL_RTL (parm, parmreg);
4918               /* STACK_PARM is the pointer, not the parm, and PARMREG is
4919                  now the parm.  */
4920               stack_parm = 0;
4921             }
4922 #ifdef FUNCTION_ARG_CALLEE_COPIES
4923           /* If we are passed an arg by reference and it is our responsibility
4924              to make a copy, do it now.
4925              PASSED_TYPE and PASSED mode now refer to the pointer, not the
4926              original argument, so we must recreate them in the call to
4927              FUNCTION_ARG_CALLEE_COPIES.  */
4928           /* ??? Later add code to handle the case that if the argument isn't
4929              modified, don't do the copy.  */
4930
4931           else if (passed_pointer
4932                    && FUNCTION_ARG_CALLEE_COPIES (args_so_far,
4933                                                   TYPE_MODE (DECL_ARG_TYPE (parm)),
4934                                                   DECL_ARG_TYPE (parm),
4935                                                   named_arg)
4936                    && ! TREE_ADDRESSABLE (DECL_ARG_TYPE (parm)))
4937             {
4938               rtx copy;
4939               tree type = DECL_ARG_TYPE (parm);
4940
4941               /* This sequence may involve a library call perhaps clobbering
4942                  registers that haven't been copied to pseudos yet.  */
4943
4944               push_to_sequence (conversion_insns);
4945
4946               if (!COMPLETE_TYPE_P (type)
4947                   || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4948                 /* This is a variable sized object.  */
4949                 copy = gen_rtx_MEM (BLKmode,
4950                                     allocate_dynamic_stack_space
4951                                     (expr_size (parm), NULL_RTX,
4952                                      TYPE_ALIGN (type)));
4953               else
4954                 copy = assign_stack_temp (TYPE_MODE (type),
4955                                           int_size_in_bytes (type), 1);
4956               set_mem_attributes (copy, parm, 1);
4957
4958               store_expr (parm, copy, 0);
4959               emit_move_insn (parmreg, XEXP (copy, 0));
4960               conversion_insns = get_insns ();
4961               did_conversion = 1;
4962               end_sequence ();
4963             }
4964 #endif /* FUNCTION_ARG_CALLEE_COPIES */
4965
4966           /* In any case, record the parm's desired stack location
4967              in case we later discover it must live in the stack.
4968
4969              If it is a COMPLEX value, store the stack location for both
4970              halves.  */
4971
4972           if (GET_CODE (parmreg) == CONCAT)
4973             regno = MAX (REGNO (XEXP (parmreg, 0)), REGNO (XEXP (parmreg, 1)));
4974           else
4975             regno = REGNO (parmreg);
4976
4977           if (regno >= max_parm_reg)
4978             {
4979               rtx *new;
4980               int old_max_parm_reg = max_parm_reg;
4981
4982               /* It's slow to expand this one register at a time,
4983                  but it's also rare and we need max_parm_reg to be
4984                  precisely correct.  */
4985               max_parm_reg = regno + 1;
4986               new = (rtx *) ggc_realloc (parm_reg_stack_loc,
4987                                       max_parm_reg * sizeof (rtx));
4988               memset ((char *) (new + old_max_parm_reg), 0,
4989                      (max_parm_reg - old_max_parm_reg) * sizeof (rtx));
4990               parm_reg_stack_loc = new;
4991             }
4992
4993           if (GET_CODE (parmreg) == CONCAT)
4994             {
4995               enum machine_mode submode = GET_MODE (XEXP (parmreg, 0));
4996
4997               regnor = REGNO (gen_realpart (submode, parmreg));
4998               regnoi = REGNO (gen_imagpart (submode, parmreg));
4999
5000               if (stack_parm != 0)
5001                 {
5002                   parm_reg_stack_loc[regnor]
5003                     = gen_realpart (submode, stack_parm);
5004                   parm_reg_stack_loc[regnoi]
5005                     = gen_imagpart (submode, stack_parm);
5006                 }
5007               else
5008                 {
5009                   parm_reg_stack_loc[regnor] = 0;
5010                   parm_reg_stack_loc[regnoi] = 0;
5011                 }
5012             }
5013           else
5014             parm_reg_stack_loc[REGNO (parmreg)] = stack_parm;
5015
5016           /* Mark the register as eliminable if we did no conversion
5017              and it was copied from memory at a fixed offset,
5018              and the arg pointer was not copied to a pseudo-reg.
5019              If the arg pointer is a pseudo reg or the offset formed
5020              an invalid address, such memory-equivalences
5021              as we make here would screw up life analysis for it.  */
5022           if (nominal_mode == passed_mode
5023               && ! did_conversion
5024               && stack_parm != 0
5025               && GET_CODE (stack_parm) == MEM
5026               && stack_offset.var == 0
5027               && reg_mentioned_p (virtual_incoming_args_rtx,
5028                                   XEXP (stack_parm, 0)))
5029             {
5030               rtx linsn = get_last_insn ();
5031               rtx sinsn, set;
5032
5033               /* Mark complex types separately.  */
5034               if (GET_CODE (parmreg) == CONCAT)
5035                 /* Scan backwards for the set of the real and
5036                    imaginary parts.  */
5037                 for (sinsn = linsn; sinsn != 0;
5038                      sinsn = prev_nonnote_insn (sinsn))
5039                   {
5040                     set = single_set (sinsn);
5041                     if (set != 0
5042                         && SET_DEST (set) == regno_reg_rtx [regnoi])
5043                       REG_NOTES (sinsn)
5044                         = gen_rtx_EXPR_LIST (REG_EQUIV,
5045                                              parm_reg_stack_loc[regnoi],
5046                                              REG_NOTES (sinsn));
5047                     else if (set != 0
5048                              && SET_DEST (set) == regno_reg_rtx [regnor])
5049                       REG_NOTES (sinsn)
5050                         = gen_rtx_EXPR_LIST (REG_EQUIV,
5051                                              parm_reg_stack_loc[regnor],
5052                                              REG_NOTES (sinsn));
5053                   }
5054               else if ((set = single_set (linsn)) != 0
5055                        && SET_DEST (set) == parmreg)
5056                 REG_NOTES (linsn)
5057                   = gen_rtx_EXPR_LIST (REG_EQUIV,
5058                                        stack_parm, REG_NOTES (linsn));
5059             }
5060
5061           /* For pointer data type, suggest pointer register.  */
5062           if (POINTER_TYPE_P (TREE_TYPE (parm)))
5063             mark_reg_pointer (parmreg,
5064                               TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm))));
5065
5066           /* If something wants our address, try to use ADDRESSOF.  */
5067           if (TREE_ADDRESSABLE (parm))
5068             {
5069               /* If we end up putting something into the stack,
5070                  fixup_var_refs_insns will need to make a pass over
5071                  all the instructions.  It looks through the pending
5072                  sequences -- but it can't see the ones in the
5073                  CONVERSION_INSNS, if they're not on the sequence
5074                  stack.  So, we go back to that sequence, just so that
5075                  the fixups will happen.  */
5076               push_to_sequence (conversion_insns);
5077               put_var_into_stack (parm, /*rescan=*/true);
5078               conversion_insns = get_insns ();
5079               end_sequence ();
5080             }
5081         }
5082       else
5083         {
5084           /* Value must be stored in the stack slot STACK_PARM
5085              during function execution.  */
5086
5087           if (promoted_mode != nominal_mode)
5088             {
5089               /* Conversion is required.  */
5090               rtx tempreg = gen_reg_rtx (GET_MODE (entry_parm));
5091
5092               emit_move_insn (tempreg, validize_mem (entry_parm));
5093
5094               push_to_sequence (conversion_insns);
5095               entry_parm = convert_to_mode (nominal_mode, tempreg,
5096                                             TREE_UNSIGNED (TREE_TYPE (parm)));
5097               if (stack_parm)
5098                 /* ??? This may need a big-endian conversion on sparc64.  */
5099                 stack_parm = adjust_address (stack_parm, nominal_mode, 0);
5100
5101               conversion_insns = get_insns ();
5102               did_conversion = 1;
5103               end_sequence ();
5104             }
5105
5106           if (entry_parm != stack_parm)
5107             {
5108               if (stack_parm == 0)
5109                 {
5110                   stack_parm
5111                     = assign_stack_local (GET_MODE (entry_parm),
5112                                           GET_MODE_SIZE (GET_MODE (entry_parm)), 0);
5113                   set_mem_attributes (stack_parm, parm, 1);
5114                 }
5115
5116               if (promoted_mode != nominal_mode)
5117                 {
5118                   push_to_sequence (conversion_insns);
5119                   emit_move_insn (validize_mem (stack_parm),
5120                                   validize_mem (entry_parm));
5121                   conversion_insns = get_insns ();
5122                   end_sequence ();
5123                 }
5124               else
5125                 emit_move_insn (validize_mem (stack_parm),
5126                                 validize_mem (entry_parm));
5127             }
5128
5129           SET_DECL_RTL (parm, stack_parm);
5130         }
5131     }
5132
5133   /* Output all parameter conversion instructions (possibly including calls)
5134      now that all parameters have been copied out of hard registers.  */
5135   emit_insn (conversion_insns);
5136
5137   /* If we are receiving a struct value address as the first argument, set up
5138      the RTL for the function result. As this might require code to convert
5139      the transmitted address to Pmode, we do this here to ensure that possible
5140      preliminary conversions of the address have been emitted already.  */
5141   if (function_result_decl)
5142     {
5143       tree result = DECL_RESULT (fndecl);
5144       rtx addr = DECL_RTL (function_result_decl);
5145       rtx x;
5146
5147 #ifdef POINTERS_EXTEND_UNSIGNED
5148       if (GET_MODE (addr) != Pmode)
5149         addr = convert_memory_address (Pmode, addr);
5150 #endif
5151
5152       x = gen_rtx_MEM (DECL_MODE (result), addr);
5153       set_mem_attributes (x, result, 1);
5154       SET_DECL_RTL (result, x);
5155     }
5156
5157   last_parm_insn = get_last_insn ();
5158
5159   current_function_args_size = stack_args_size.constant;
5160
5161   /* Adjust function incoming argument size for alignment and
5162      minimum length.  */
5163
5164 #ifdef REG_PARM_STACK_SPACE
5165 #ifndef MAYBE_REG_PARM_STACK_SPACE
5166   current_function_args_size = MAX (current_function_args_size,
5167                                     REG_PARM_STACK_SPACE (fndecl));
5168 #endif
5169 #endif
5170
5171 #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
5172
5173   current_function_args_size
5174     = ((current_function_args_size + STACK_BYTES - 1)
5175        / STACK_BYTES) * STACK_BYTES;
5176
5177 #ifdef ARGS_GROW_DOWNWARD
5178   current_function_arg_offset_rtx
5179     = (stack_args_size.var == 0 ? GEN_INT (-stack_args_size.constant)
5180        : expand_expr (size_diffop (stack_args_size.var,
5181                                    size_int (-stack_args_size.constant)),
5182                       NULL_RTX, VOIDmode, 0));
5183 #else
5184   current_function_arg_offset_rtx = ARGS_SIZE_RTX (stack_args_size);
5185 #endif
5186
5187   /* See how many bytes, if any, of its args a function should try to pop
5188      on return.  */
5189
5190   current_function_pops_args = RETURN_POPS_ARGS (fndecl, TREE_TYPE (fndecl),
5191                                                  current_function_args_size);
5192
5193   /* For stdarg.h function, save info about
5194      regs and stack space used by the named args.  */
5195
5196   current_function_args_info = args_so_far;
5197
5198   /* Set the rtx used for the function return value.  Put this in its
5199      own variable so any optimizers that need this information don't have
5200      to include tree.h.  Do this here so it gets done when an inlined
5201      function gets output.  */
5202
5203   current_function_return_rtx
5204     = (DECL_RTL_SET_P (DECL_RESULT (fndecl))
5205        ? DECL_RTL (DECL_RESULT (fndecl)) : NULL_RTX);
5206
5207   /* If scalar return value was computed in a pseudo-reg, or was a named
5208      return value that got dumped to the stack, copy that to the hard
5209      return register.  */
5210   if (DECL_RTL_SET_P (DECL_RESULT (fndecl)))
5211     {
5212       tree decl_result = DECL_RESULT (fndecl);
5213       rtx decl_rtl = DECL_RTL (decl_result);
5214
5215       if (REG_P (decl_rtl)
5216           ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER
5217           : DECL_REGISTER (decl_result))
5218         {
5219           rtx real_decl_rtl;
5220
5221 #ifdef FUNCTION_OUTGOING_VALUE
5222           real_decl_rtl = FUNCTION_OUTGOING_VALUE (TREE_TYPE (decl_result),
5223                                                    fndecl);
5224 #else
5225           real_decl_rtl = FUNCTION_VALUE (TREE_TYPE (decl_result),
5226                                           fndecl);
5227 #endif
5228           REG_FUNCTION_VALUE_P (real_decl_rtl) = 1;
5229           /* The delay slot scheduler assumes that current_function_return_rtx
5230              holds the hard register containing the return value, not a
5231              temporary pseudo.  */
5232           current_function_return_rtx = real_decl_rtl;
5233         }
5234     }
5235 }
5236 \f
5237 /* Indicate whether REGNO is an incoming argument to the current function
5238    that was promoted to a wider mode.  If so, return the RTX for the
5239    register (to get its mode).  PMODE and PUNSIGNEDP are set to the mode
5240    that REGNO is promoted from and whether the promotion was signed or
5241    unsigned.  */
5242
5243 #ifdef PROMOTE_FUNCTION_ARGS
5244
5245 rtx
5246 promoted_input_arg (regno, pmode, punsignedp)
5247      unsigned int regno;
5248      enum machine_mode *pmode;
5249      int *punsignedp;
5250 {
5251   tree arg;
5252
5253   for (arg = DECL_ARGUMENTS (current_function_decl); arg;
5254        arg = TREE_CHAIN (arg))
5255     if (GET_CODE (DECL_INCOMING_RTL (arg)) == REG
5256         && REGNO (DECL_INCOMING_RTL (arg)) == regno
5257         && TYPE_MODE (DECL_ARG_TYPE (arg)) == TYPE_MODE (TREE_TYPE (arg)))
5258       {
5259         enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg));
5260         int unsignedp = TREE_UNSIGNED (TREE_TYPE (arg));
5261
5262         mode = promote_mode (TREE_TYPE (arg), mode, &unsignedp, 1);
5263         if (mode == GET_MODE (DECL_INCOMING_RTL (arg))
5264             && mode != DECL_MODE (arg))
5265           {
5266             *pmode = DECL_MODE (arg);
5267             *punsignedp = unsignedp;
5268             return DECL_INCOMING_RTL (arg);
5269           }
5270       }
5271
5272   return 0;
5273 }
5274
5275 #endif
5276 \f
5277 /* Compute the size and offset from the start of the stacked arguments for a
5278    parm passed in mode PASSED_MODE and with type TYPE.
5279
5280    INITIAL_OFFSET_PTR points to the current offset into the stacked
5281    arguments.
5282
5283    The starting offset and size for this parm are returned in *OFFSET_PTR
5284    and *ARG_SIZE_PTR, respectively.
5285
5286    IN_REGS is nonzero if the argument will be passed in registers.  It will
5287    never be set if REG_PARM_STACK_SPACE is not defined.
5288
5289    FNDECL is the function in which the argument was defined.
5290
5291    There are two types of rounding that are done.  The first, controlled by
5292    FUNCTION_ARG_BOUNDARY, forces the offset from the start of the argument
5293    list to be aligned to the specific boundary (in bits).  This rounding
5294    affects the initial and starting offsets, but not the argument size.
5295
5296    The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY,
5297    optionally rounds the size of the parm to PARM_BOUNDARY.  The
5298    initial offset is not affected by this rounding, while the size always
5299    is and the starting offset may be.  */
5300
5301 /*  offset_ptr will be negative for ARGS_GROW_DOWNWARD case;
5302     initial_offset_ptr is positive because locate_and_pad_parm's
5303     callers pass in the total size of args so far as
5304     initial_offset_ptr. arg_size_ptr is always positive.  */
5305
5306 void
5307 locate_and_pad_parm (passed_mode, type, in_regs, fndecl,
5308                      initial_offset_ptr, offset_ptr, arg_size_ptr,
5309                      alignment_pad)
5310      enum machine_mode passed_mode;
5311      tree type;
5312      int in_regs ATTRIBUTE_UNUSED;
5313      tree fndecl ATTRIBUTE_UNUSED;
5314      struct args_size *initial_offset_ptr;
5315      struct args_size *offset_ptr;
5316      struct args_size *arg_size_ptr;
5317      struct args_size *alignment_pad;
5318
5319 {
5320   tree sizetree
5321     = type ? size_in_bytes (type) : size_int (GET_MODE_SIZE (passed_mode));
5322   enum direction where_pad = FUNCTION_ARG_PADDING (passed_mode, type);
5323   int boundary = FUNCTION_ARG_BOUNDARY (passed_mode, type);
5324 #ifdef ARGS_GROW_DOWNWARD
5325   tree s2 = sizetree;
5326 #endif
5327
5328 #ifdef REG_PARM_STACK_SPACE
5329   /* If we have found a stack parm before we reach the end of the
5330      area reserved for registers, skip that area.  */
5331   if (! in_regs)
5332     {
5333       int reg_parm_stack_space = 0;
5334
5335 #ifdef MAYBE_REG_PARM_STACK_SPACE
5336       reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
5337 #else
5338       reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
5339 #endif
5340       if (reg_parm_stack_space > 0)
5341         {
5342           if (initial_offset_ptr->var)
5343             {
5344               initial_offset_ptr->var
5345                 = size_binop (MAX_EXPR, ARGS_SIZE_TREE (*initial_offset_ptr),
5346                               ssize_int (reg_parm_stack_space));
5347               initial_offset_ptr->constant = 0;
5348             }
5349           else if (initial_offset_ptr->constant < reg_parm_stack_space)
5350             initial_offset_ptr->constant = reg_parm_stack_space;
5351         }
5352     }
5353 #endif /* REG_PARM_STACK_SPACE */
5354
5355   arg_size_ptr->var = 0;
5356   arg_size_ptr->constant = 0;
5357   alignment_pad->var = 0;
5358   alignment_pad->constant = 0;
5359
5360 #ifdef ARGS_GROW_DOWNWARD
5361   if (initial_offset_ptr->var)
5362     {
5363       offset_ptr->constant = 0;
5364       offset_ptr->var = size_binop (MINUS_EXPR, ssize_int (0),
5365                                     initial_offset_ptr->var);
5366     }
5367   else
5368     {
5369       offset_ptr->constant = -initial_offset_ptr->constant;
5370       offset_ptr->var = 0;
5371     }
5372
5373   if (where_pad != none
5374       && (!host_integerp (sizetree, 1)
5375           || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % PARM_BOUNDARY))
5376     s2 = round_up (s2, PARM_BOUNDARY / BITS_PER_UNIT);
5377   SUB_PARM_SIZE (*offset_ptr, s2);
5378
5379   if (!in_regs
5380 #ifdef REG_PARM_STACK_SPACE
5381       || REG_PARM_STACK_SPACE (fndecl) > 0
5382 #endif
5383      )
5384     pad_to_arg_alignment (offset_ptr, boundary, alignment_pad);
5385
5386   if (initial_offset_ptr->var)
5387     arg_size_ptr->var = size_binop (MINUS_EXPR,
5388                                     size_binop (MINUS_EXPR,
5389                                                 ssize_int (0),
5390                                                 initial_offset_ptr->var),
5391                                     offset_ptr->var);
5392
5393   else
5394     arg_size_ptr->constant = (-initial_offset_ptr->constant
5395                               - offset_ptr->constant);
5396
5397   /* Pad_below needs the pre-rounded size to know how much to pad below.
5398      We only pad parameters which are not in registers as they have their
5399      padding done elsewhere.  */
5400   if (where_pad == downward
5401       && !in_regs)
5402     pad_below (offset_ptr, passed_mode, sizetree);
5403
5404 #else /* !ARGS_GROW_DOWNWARD */
5405   if (!in_regs
5406 #ifdef REG_PARM_STACK_SPACE
5407       || REG_PARM_STACK_SPACE (fndecl) > 0
5408 #endif
5409       )
5410     pad_to_arg_alignment (initial_offset_ptr, boundary, alignment_pad);
5411   *offset_ptr = *initial_offset_ptr;
5412
5413 #ifdef PUSH_ROUNDING
5414   if (passed_mode != BLKmode)
5415     sizetree = size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree)));
5416 #endif
5417
5418   /* Pad_below needs the pre-rounded size to know how much to pad below
5419      so this must be done before rounding up.  */
5420   if (where_pad == downward
5421     /* However, BLKmode args passed in regs have their padding done elsewhere.
5422        The stack slot must be able to hold the entire register.  */
5423       && !(in_regs && passed_mode == BLKmode))
5424     pad_below (offset_ptr, passed_mode, sizetree);
5425
5426   if (where_pad != none
5427       && (!host_integerp (sizetree, 1)
5428           || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % PARM_BOUNDARY))
5429     sizetree = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT);
5430
5431   ADD_PARM_SIZE (*arg_size_ptr, sizetree);
5432 #endif /* ARGS_GROW_DOWNWARD */
5433 }
5434
5435 /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY.
5436    BOUNDARY is measured in bits, but must be a multiple of a storage unit.  */
5437
5438 static void
5439 pad_to_arg_alignment (offset_ptr, boundary, alignment_pad)
5440      struct args_size *offset_ptr;
5441      int boundary;
5442      struct args_size *alignment_pad;
5443 {
5444   tree save_var = NULL_TREE;
5445   HOST_WIDE_INT save_constant = 0;
5446
5447   int boundary_in_bytes = boundary / BITS_PER_UNIT;
5448
5449   if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
5450     {
5451       save_var = offset_ptr->var;
5452       save_constant = offset_ptr->constant;
5453     }
5454
5455   alignment_pad->var = NULL_TREE;
5456   alignment_pad->constant = 0;
5457
5458   if (boundary > BITS_PER_UNIT)
5459     {
5460       if (offset_ptr->var)
5461         {
5462           offset_ptr->var =
5463 #ifdef ARGS_GROW_DOWNWARD
5464             round_down
5465 #else
5466             round_up
5467 #endif
5468               (ARGS_SIZE_TREE (*offset_ptr),
5469                boundary / BITS_PER_UNIT);
5470           offset_ptr->constant = 0; /*?*/
5471           if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
5472             alignment_pad->var = size_binop (MINUS_EXPR, offset_ptr->var,
5473                                              save_var);
5474         }
5475       else
5476         {
5477           offset_ptr->constant =
5478 #ifdef ARGS_GROW_DOWNWARD
5479             FLOOR_ROUND (offset_ptr->constant, boundary_in_bytes);
5480 #else
5481             CEIL_ROUND (offset_ptr->constant, boundary_in_bytes);
5482 #endif
5483             if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
5484               alignment_pad->constant = offset_ptr->constant - save_constant;
5485         }
5486     }
5487 }
5488
5489 static void
5490 pad_below (offset_ptr, passed_mode, sizetree)
5491      struct args_size *offset_ptr;
5492      enum machine_mode passed_mode;
5493      tree sizetree;
5494 {
5495   if (passed_mode != BLKmode)
5496     {
5497       if (GET_MODE_BITSIZE (passed_mode) % PARM_BOUNDARY)
5498         offset_ptr->constant
5499           += (((GET_MODE_BITSIZE (passed_mode) + PARM_BOUNDARY - 1)
5500                / PARM_BOUNDARY * PARM_BOUNDARY / BITS_PER_UNIT)
5501               - GET_MODE_SIZE (passed_mode));
5502     }
5503   else
5504     {
5505       if (TREE_CODE (sizetree) != INTEGER_CST
5506           || (TREE_INT_CST_LOW (sizetree) * BITS_PER_UNIT) % PARM_BOUNDARY)
5507         {
5508           /* Round the size up to multiple of PARM_BOUNDARY bits.  */
5509           tree s2 = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT);
5510           /* Add it in.  */
5511           ADD_PARM_SIZE (*offset_ptr, s2);
5512           SUB_PARM_SIZE (*offset_ptr, sizetree);
5513         }
5514     }
5515 }
5516 \f
5517 /* Walk the tree of blocks describing the binding levels within a function
5518    and warn about uninitialized variables.
5519    This is done after calling flow_analysis and before global_alloc
5520    clobbers the pseudo-regs to hard regs.  */
5521
5522 void
5523 uninitialized_vars_warning (block)
5524      tree block;
5525 {
5526   tree decl, sub;
5527   for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
5528     {
5529       if (warn_uninitialized
5530           && TREE_CODE (decl) == VAR_DECL
5531           /* These warnings are unreliable for and aggregates
5532              because assigning the fields one by one can fail to convince
5533              flow.c that the entire aggregate was initialized.
5534              Unions are troublesome because members may be shorter.  */
5535           && ! AGGREGATE_TYPE_P (TREE_TYPE (decl))
5536           && DECL_RTL (decl) != 0
5537           && GET_CODE (DECL_RTL (decl)) == REG
5538           /* Global optimizations can make it difficult to determine if a
5539              particular variable has been initialized.  However, a VAR_DECL
5540              with a nonzero DECL_INITIAL had an initializer, so do not
5541              claim it is potentially uninitialized.
5542
5543              We do not care about the actual value in DECL_INITIAL, so we do
5544              not worry that it may be a dangling pointer.  */
5545           && DECL_INITIAL (decl) == NULL_TREE
5546           && regno_uninitialized (REGNO (DECL_RTL (decl))))
5547         warning_with_decl (decl,
5548                            "`%s' might be used uninitialized in this function");
5549       if (extra_warnings
5550           && TREE_CODE (decl) == VAR_DECL
5551           && DECL_RTL (decl) != 0
5552           && GET_CODE (DECL_RTL (decl)) == REG
5553           && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl))))
5554         warning_with_decl (decl,
5555                            "variable `%s' might be clobbered by `longjmp' or `vfork'");
5556     }
5557   for (sub = BLOCK_SUBBLOCKS (block); sub; sub = TREE_CHAIN (sub))
5558     uninitialized_vars_warning (sub);
5559 }
5560
5561 /* Do the appropriate part of uninitialized_vars_warning
5562    but for arguments instead of local variables.  */
5563
5564 void
5565 setjmp_args_warning ()
5566 {
5567   tree decl;
5568   for (decl = DECL_ARGUMENTS (current_function_decl);
5569        decl; decl = TREE_CHAIN (decl))
5570     if (DECL_RTL (decl) != 0
5571         && GET_CODE (DECL_RTL (decl)) == REG
5572         && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl))))
5573       warning_with_decl (decl,
5574                          "argument `%s' might be clobbered by `longjmp' or `vfork'");
5575 }
5576
5577 /* If this function call setjmp, put all vars into the stack
5578    unless they were declared `register'.  */
5579
5580 void
5581 setjmp_protect (block)
5582      tree block;
5583 {
5584   tree decl, sub;
5585   for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
5586     if ((TREE_CODE (decl) == VAR_DECL
5587          || TREE_CODE (decl) == PARM_DECL)
5588         && DECL_RTL (decl) != 0
5589         && (GET_CODE (DECL_RTL (decl)) == REG
5590             || (GET_CODE (DECL_RTL (decl)) == MEM
5591                 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF))
5592         /* If this variable came from an inline function, it must be
5593            that its life doesn't overlap the setjmp.  If there was a
5594            setjmp in the function, it would already be in memory.  We
5595            must exclude such variable because their DECL_RTL might be
5596            set to strange things such as virtual_stack_vars_rtx.  */
5597         && ! DECL_FROM_INLINE (decl)
5598         && (
5599 #ifdef NON_SAVING_SETJMP
5600             /* If longjmp doesn't restore the registers,
5601                don't put anything in them.  */
5602             NON_SAVING_SETJMP
5603             ||
5604 #endif
5605             ! DECL_REGISTER (decl)))
5606       put_var_into_stack (decl, /*rescan=*/true);
5607   for (sub = BLOCK_SUBBLOCKS (block); sub; sub = TREE_CHAIN (sub))
5608     setjmp_protect (sub);
5609 }
5610 \f
5611 /* Like the previous function, but for args instead of local variables.  */
5612
5613 void
5614 setjmp_protect_args ()
5615 {
5616   tree decl;
5617   for (decl = DECL_ARGUMENTS (current_function_decl);
5618        decl; decl = TREE_CHAIN (decl))
5619     if ((TREE_CODE (decl) == VAR_DECL
5620          || TREE_CODE (decl) == PARM_DECL)
5621         && DECL_RTL (decl) != 0
5622         && (GET_CODE (DECL_RTL (decl)) == REG
5623             || (GET_CODE (DECL_RTL (decl)) == MEM
5624                 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF))
5625         && (
5626             /* If longjmp doesn't restore the registers,
5627                don't put anything in them.  */
5628 #ifdef NON_SAVING_SETJMP
5629             NON_SAVING_SETJMP
5630             ||
5631 #endif
5632             ! DECL_REGISTER (decl)))
5633       put_var_into_stack (decl, /*rescan=*/true);
5634 }
5635 \f
5636 /* Return the context-pointer register corresponding to DECL,
5637    or 0 if it does not need one.  */
5638
5639 rtx
5640 lookup_static_chain (decl)
5641      tree decl;
5642 {
5643   tree context = decl_function_context (decl);
5644   tree link;
5645
5646   if (context == 0
5647       || (TREE_CODE (decl) == FUNCTION_DECL && DECL_NO_STATIC_CHAIN (decl)))
5648     return 0;
5649
5650   /* We treat inline_function_decl as an alias for the current function
5651      because that is the inline function whose vars, types, etc.
5652      are being merged into the current function.
5653      See expand_inline_function.  */
5654   if (context == current_function_decl || context == inline_function_decl)
5655     return virtual_stack_vars_rtx;
5656
5657   for (link = context_display; link; link = TREE_CHAIN (link))
5658     if (TREE_PURPOSE (link) == context)
5659       return RTL_EXPR_RTL (TREE_VALUE (link));
5660
5661   abort ();
5662 }
5663 \f
5664 /* Convert a stack slot address ADDR for variable VAR
5665    (from a containing function)
5666    into an address valid in this function (using a static chain).  */
5667
5668 rtx
5669 fix_lexical_addr (addr, var)
5670      rtx addr;
5671      tree var;
5672 {
5673   rtx basereg;
5674   HOST_WIDE_INT displacement;
5675   tree context = decl_function_context (var);
5676   struct function *fp;
5677   rtx base = 0;
5678
5679   /* If this is the present function, we need not do anything.  */
5680   if (context == current_function_decl || context == inline_function_decl)
5681     return addr;
5682
5683   fp = find_function_data (context);
5684
5685   if (GET_CODE (addr) == ADDRESSOF && GET_CODE (XEXP (addr, 0)) == MEM)
5686     addr = XEXP (XEXP (addr, 0), 0);
5687
5688   /* Decode given address as base reg plus displacement.  */
5689   if (GET_CODE (addr) == REG)
5690     basereg = addr, displacement = 0;
5691   else if (GET_CODE (addr) == PLUS && GET_CODE (XEXP (addr, 1)) == CONST_INT)
5692     basereg = XEXP (addr, 0), displacement = INTVAL (XEXP (addr, 1));
5693   else
5694     abort ();
5695
5696   /* We accept vars reached via the containing function's
5697      incoming arg pointer and via its stack variables pointer.  */
5698   if (basereg == fp->internal_arg_pointer)
5699     {
5700       /* If reached via arg pointer, get the arg pointer value
5701          out of that function's stack frame.
5702
5703          There are two cases:  If a separate ap is needed, allocate a
5704          slot in the outer function for it and dereference it that way.
5705          This is correct even if the real ap is actually a pseudo.
5706          Otherwise, just adjust the offset from the frame pointer to
5707          compensate.  */
5708
5709 #ifdef NEED_SEPARATE_AP
5710       rtx addr;
5711
5712       addr = get_arg_pointer_save_area (fp);
5713       addr = fix_lexical_addr (XEXP (addr, 0), var);
5714       addr = memory_address (Pmode, addr);
5715
5716       base = gen_rtx_MEM (Pmode, addr);
5717       set_mem_alias_set (base, get_frame_alias_set ());
5718       base = copy_to_reg (base);
5719 #else
5720       displacement += (FIRST_PARM_OFFSET (context) - STARTING_FRAME_OFFSET);
5721       base = lookup_static_chain (var);
5722 #endif
5723     }
5724
5725   else if (basereg == virtual_stack_vars_rtx)
5726     {
5727       /* This is the same code as lookup_static_chain, duplicated here to
5728          avoid an extra call to decl_function_context.  */
5729       tree link;
5730
5731       for (link = context_display; link; link = TREE_CHAIN (link))
5732         if (TREE_PURPOSE (link) == context)
5733           {
5734             base = RTL_EXPR_RTL (TREE_VALUE (link));
5735             break;
5736           }
5737     }
5738
5739   if (base == 0)
5740     abort ();
5741
5742   /* Use same offset, relative to appropriate static chain or argument
5743      pointer.  */
5744   return plus_constant (base, displacement);
5745 }
5746 \f
5747 /* Return the address of the trampoline for entering nested fn FUNCTION.
5748    If necessary, allocate a trampoline (in the stack frame)
5749    and emit rtl to initialize its contents (at entry to this function).  */
5750
5751 rtx
5752 trampoline_address (function)
5753      tree function;
5754 {
5755   tree link;
5756   tree rtlexp;
5757   rtx tramp;
5758   struct function *fp;
5759   tree fn_context;
5760
5761   /* Find an existing trampoline and return it.  */
5762   for (link = trampoline_list; link; link = TREE_CHAIN (link))
5763     if (TREE_PURPOSE (link) == function)
5764       return
5765         adjust_trampoline_addr (XEXP (RTL_EXPR_RTL (TREE_VALUE (link)), 0));
5766
5767   for (fp = outer_function_chain; fp; fp = fp->outer)
5768     for (link = fp->x_trampoline_list; link; link = TREE_CHAIN (link))
5769       if (TREE_PURPOSE (link) == function)
5770         {
5771           tramp = fix_lexical_addr (XEXP (RTL_EXPR_RTL (TREE_VALUE (link)), 0),
5772                                     function);
5773           return adjust_trampoline_addr (tramp);
5774         }
5775
5776   /* None exists; we must make one.  */
5777
5778   /* Find the `struct function' for the function containing FUNCTION.  */
5779   fp = 0;
5780   fn_context = decl_function_context (function);
5781   if (fn_context != current_function_decl
5782       && fn_context != inline_function_decl)
5783     fp = find_function_data (fn_context);
5784
5785   /* Allocate run-time space for this trampoline
5786      (usually in the defining function's stack frame).  */
5787 #ifdef ALLOCATE_TRAMPOLINE
5788   tramp = ALLOCATE_TRAMPOLINE (fp);
5789 #else
5790   /* If rounding needed, allocate extra space
5791      to ensure we have TRAMPOLINE_SIZE bytes left after rounding up.  */
5792 #define TRAMPOLINE_REAL_SIZE \
5793   (TRAMPOLINE_SIZE + (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT) - 1)
5794   tramp = assign_stack_local_1 (BLKmode, TRAMPOLINE_REAL_SIZE, 0,
5795                                 fp ? fp : cfun);
5796 #endif
5797
5798   /* Record the trampoline for reuse and note it for later initialization
5799      by expand_function_end.  */
5800   if (fp != 0)
5801     {
5802       rtlexp = make_node (RTL_EXPR);
5803       RTL_EXPR_RTL (rtlexp) = tramp;
5804       fp->x_trampoline_list = tree_cons (function, rtlexp,
5805                                          fp->x_trampoline_list);
5806     }
5807   else
5808     {
5809       /* Make the RTL_EXPR node temporary, not momentary, so that the
5810          trampoline_list doesn't become garbage.  */
5811       rtlexp = make_node (RTL_EXPR);
5812
5813       RTL_EXPR_RTL (rtlexp) = tramp;
5814       trampoline_list = tree_cons (function, rtlexp, trampoline_list);
5815     }
5816
5817   tramp = fix_lexical_addr (XEXP (tramp, 0), function);
5818   return adjust_trampoline_addr (tramp);
5819 }
5820
5821 /* Given a trampoline address,
5822    round it to multiple of TRAMPOLINE_ALIGNMENT.  */
5823
5824 static rtx
5825 round_trampoline_addr (tramp)
5826      rtx tramp;
5827 {
5828   /* Round address up to desired boundary.  */
5829   rtx temp = gen_reg_rtx (Pmode);
5830   rtx addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
5831   rtx mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
5832
5833   temp  = expand_simple_binop (Pmode, PLUS, tramp, addend,
5834                                temp, 0, OPTAB_LIB_WIDEN);
5835   tramp = expand_simple_binop (Pmode, AND, temp, mask,
5836                                temp, 0, OPTAB_LIB_WIDEN);
5837
5838   return tramp;
5839 }
5840
5841 /* Given a trampoline address, round it then apply any
5842    platform-specific adjustments so that the result can be used for a
5843    function call .  */
5844
5845 static rtx
5846 adjust_trampoline_addr (tramp)
5847      rtx tramp;
5848 {
5849   tramp = round_trampoline_addr (tramp);
5850 #ifdef TRAMPOLINE_ADJUST_ADDRESS
5851   TRAMPOLINE_ADJUST_ADDRESS (tramp);
5852 #endif
5853   return tramp;
5854 }
5855 \f
5856 /* Put all this function's BLOCK nodes including those that are chained
5857    onto the first block into a vector, and return it.
5858    Also store in each NOTE for the beginning or end of a block
5859    the index of that block in the vector.
5860    The arguments are BLOCK, the chain of top-level blocks of the function,
5861    and INSNS, the insn chain of the function.  */
5862
5863 void
5864 identify_blocks ()
5865 {
5866   int n_blocks;
5867   tree *block_vector, *last_block_vector;
5868   tree *block_stack;
5869   tree block = DECL_INITIAL (current_function_decl);
5870
5871   if (block == 0)
5872     return;
5873
5874   /* Fill the BLOCK_VECTOR with all of the BLOCKs in this function, in
5875      depth-first order.  */
5876   block_vector = get_block_vector (block, &n_blocks);
5877   block_stack = (tree *) xmalloc (n_blocks * sizeof (tree));
5878
5879   last_block_vector = identify_blocks_1 (get_insns (),
5880                                          block_vector + 1,
5881                                          block_vector + n_blocks,
5882                                          block_stack);
5883
5884   /* If we didn't use all of the subblocks, we've misplaced block notes.  */
5885   /* ??? This appears to happen all the time.  Latent bugs elsewhere?  */
5886   if (0 && last_block_vector != block_vector + n_blocks)
5887     abort ();
5888
5889   free (block_vector);
5890   free (block_stack);
5891 }
5892
5893 /* Subroutine of identify_blocks.  Do the block substitution on the
5894    insn chain beginning with INSNS.  Recurse for CALL_PLACEHOLDER chains.
5895
5896    BLOCK_STACK is pushed and popped for each BLOCK_BEGIN/BLOCK_END pair.
5897    BLOCK_VECTOR is incremented for each block seen.  */
5898
5899 static tree *
5900 identify_blocks_1 (insns, block_vector, end_block_vector, orig_block_stack)
5901      rtx insns;
5902      tree *block_vector;
5903      tree *end_block_vector;
5904      tree *orig_block_stack;
5905 {
5906   rtx insn;
5907   tree *block_stack = orig_block_stack;
5908
5909   for (insn = insns; insn; insn = NEXT_INSN (insn))
5910     {
5911       if (GET_CODE (insn) == NOTE)
5912         {
5913           if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG)
5914             {
5915               tree b;
5916
5917               /* If there are more block notes than BLOCKs, something
5918                  is badly wrong.  */
5919               if (block_vector == end_block_vector)
5920                 abort ();
5921
5922               b = *block_vector++;
5923               NOTE_BLOCK (insn) = b;
5924               *block_stack++ = b;
5925             }
5926           else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
5927             {
5928               /* If there are more NOTE_INSN_BLOCK_ENDs than
5929                  NOTE_INSN_BLOCK_BEGs, something is badly wrong.  */
5930               if (block_stack == orig_block_stack)
5931                 abort ();
5932
5933               NOTE_BLOCK (insn) = *--block_stack;
5934             }
5935         }
5936       else if (GET_CODE (insn) == CALL_INSN
5937                && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
5938         {
5939           rtx cp = PATTERN (insn);
5940
5941           block_vector = identify_blocks_1 (XEXP (cp, 0), block_vector,
5942                                             end_block_vector, block_stack);
5943           if (XEXP (cp, 1))
5944             block_vector = identify_blocks_1 (XEXP (cp, 1), block_vector,
5945                                               end_block_vector, block_stack);
5946           if (XEXP (cp, 2))
5947             block_vector = identify_blocks_1 (XEXP (cp, 2), block_vector,
5948                                               end_block_vector, block_stack);
5949         }
5950     }
5951
5952   /* If there are more NOTE_INSN_BLOCK_BEGINs than NOTE_INSN_BLOCK_ENDs,
5953      something is badly wrong.  */
5954   if (block_stack != orig_block_stack)
5955     abort ();
5956
5957   return block_vector;
5958 }
5959
5960 /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
5961    and create duplicate blocks.  */
5962 /* ??? Need an option to either create block fragments or to create
5963    abstract origin duplicates of a source block.  It really depends
5964    on what optimization has been performed.  */
5965
5966 void
5967 reorder_blocks ()
5968 {
5969   tree block = DECL_INITIAL (current_function_decl);
5970   varray_type block_stack;
5971
5972   if (block == NULL_TREE)
5973     return;
5974
5975   VARRAY_TREE_INIT (block_stack, 10, "block_stack");
5976
5977   /* Reset the TREE_ASM_WRITTEN bit for all blocks.  */
5978   reorder_blocks_0 (block);
5979
5980   /* Prune the old trees away, so that they don't get in the way.  */
5981   BLOCK_SUBBLOCKS (block) = NULL_TREE;
5982   BLOCK_CHAIN (block) = NULL_TREE;
5983
5984   /* Recreate the block tree from the note nesting.  */
5985   reorder_blocks_1 (get_insns (), block, &block_stack);
5986   BLOCK_SUBBLOCKS (block) = blocks_nreverse (BLOCK_SUBBLOCKS (block));
5987
5988   /* Remove deleted blocks from the block fragment chains.  */
5989   reorder_fix_fragments (block);
5990 }
5991
5992 /* Helper function for reorder_blocks.  Reset TREE_ASM_WRITTEN.  */
5993
5994 static void
5995 reorder_blocks_0 (block)
5996      tree block;
5997 {
5998   while (block)
5999     {
6000       TREE_ASM_WRITTEN (block) = 0;
6001       reorder_blocks_0 (BLOCK_SUBBLOCKS (block));
6002       block = BLOCK_CHAIN (block);
6003     }
6004 }
6005
6006 static void
6007 reorder_blocks_1 (insns, current_block, p_block_stack)
6008      rtx insns;
6009      tree current_block;
6010      varray_type *p_block_stack;
6011 {
6012   rtx insn;
6013
6014   for (insn = insns; insn; insn = NEXT_INSN (insn))
6015     {
6016       if (GET_CODE (insn) == NOTE)
6017         {
6018           if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG)
6019             {
6020               tree block = NOTE_BLOCK (insn);
6021
6022               /* If we have seen this block before, that means it now
6023                  spans multiple address regions.  Create a new fragment.  */
6024               if (TREE_ASM_WRITTEN (block))
6025                 {
6026                   tree new_block = copy_node (block);
6027                   tree origin;
6028
6029                   origin = (BLOCK_FRAGMENT_ORIGIN (block)
6030                             ? BLOCK_FRAGMENT_ORIGIN (block)
6031                             : block);
6032                   BLOCK_FRAGMENT_ORIGIN (new_block) = origin;
6033                   BLOCK_FRAGMENT_CHAIN (new_block)
6034                     = BLOCK_FRAGMENT_CHAIN (origin);
6035                   BLOCK_FRAGMENT_CHAIN (origin) = new_block;
6036
6037                   NOTE_BLOCK (insn) = new_block;
6038                   block = new_block;
6039                 }
6040
6041               BLOCK_SUBBLOCKS (block) = 0;
6042               TREE_ASM_WRITTEN (block) = 1;
6043               /* When there's only one block for the entire function,
6044                  current_block == block and we mustn't do this, it
6045                  will cause infinite recursion.  */
6046               if (block != current_block)
6047                 {
6048                   BLOCK_SUPERCONTEXT (block) = current_block;
6049                   BLOCK_CHAIN (block) = BLOCK_SUBBLOCKS (current_block);
6050                   BLOCK_SUBBLOCKS (current_block) = block;
6051                   current_block = block;
6052                 }
6053               VARRAY_PUSH_TREE (*p_block_stack, block);
6054             }
6055           else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
6056             {
6057               NOTE_BLOCK (insn) = VARRAY_TOP_TREE (*p_block_stack);
6058               VARRAY_POP (*p_block_stack);
6059               BLOCK_SUBBLOCKS (current_block)
6060                 = blocks_nreverse (BLOCK_SUBBLOCKS (current_block));
6061               current_block = BLOCK_SUPERCONTEXT (current_block);
6062             }
6063         }
6064       else if (GET_CODE (insn) == CALL_INSN
6065                && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
6066         {
6067           rtx cp = PATTERN (insn);
6068           reorder_blocks_1 (XEXP (cp, 0), current_block, p_block_stack);
6069           if (XEXP (cp, 1))
6070             reorder_blocks_1 (XEXP (cp, 1), current_block, p_block_stack);
6071           if (XEXP (cp, 2))
6072             reorder_blocks_1 (XEXP (cp, 2), current_block, p_block_stack);
6073         }
6074     }
6075 }
6076
6077 /* Rationalize BLOCK_FRAGMENT_ORIGIN.  If an origin block no longer
6078    appears in the block tree, select one of the fragments to become
6079    the new origin block.  */
6080
6081 static void
6082 reorder_fix_fragments (block)
6083      tree block;
6084 {
6085   while (block)
6086     {
6087       tree dup_origin = BLOCK_FRAGMENT_ORIGIN (block);
6088       tree new_origin = NULL_TREE;
6089
6090       if (dup_origin)
6091         {
6092           if (! TREE_ASM_WRITTEN (dup_origin))
6093             {
6094               new_origin = BLOCK_FRAGMENT_CHAIN (dup_origin);
6095
6096               /* Find the first of the remaining fragments.  There must
6097                  be at least one -- the current block.  */
6098               while (! TREE_ASM_WRITTEN (new_origin))
6099                 new_origin = BLOCK_FRAGMENT_CHAIN (new_origin);
6100               BLOCK_FRAGMENT_ORIGIN (new_origin) = NULL_TREE;
6101             }
6102         }
6103       else if (! dup_origin)
6104         new_origin = block;
6105
6106       /* Re-root the rest of the fragments to the new origin.  In the
6107          case that DUP_ORIGIN was null, that means BLOCK was the origin
6108          of a chain of fragments and we want to remove those fragments
6109          that didn't make it to the output.  */
6110       if (new_origin)
6111         {
6112           tree *pp = &BLOCK_FRAGMENT_CHAIN (new_origin);
6113           tree chain = *pp;
6114
6115           while (chain)
6116             {
6117               if (TREE_ASM_WRITTEN (chain))
6118                 {
6119                   BLOCK_FRAGMENT_ORIGIN (chain) = new_origin;
6120                   *pp = chain;
6121                   pp = &BLOCK_FRAGMENT_CHAIN (chain);
6122                 }
6123               chain = BLOCK_FRAGMENT_CHAIN (chain);
6124             }
6125           *pp = NULL_TREE;
6126         }
6127
6128       reorder_fix_fragments (BLOCK_SUBBLOCKS (block));
6129       block = BLOCK_CHAIN (block);
6130     }
6131 }
6132
6133 /* Reverse the order of elements in the chain T of blocks,
6134    and return the new head of the chain (old last element).  */
6135
6136 static tree
6137 blocks_nreverse (t)
6138      tree t;
6139 {
6140   tree prev = 0, decl, next;
6141   for (decl = t; decl; decl = next)
6142     {
6143       next = BLOCK_CHAIN (decl);
6144       BLOCK_CHAIN (decl) = prev;
6145       prev = decl;
6146     }
6147   return prev;
6148 }
6149
6150 /* Count the subblocks of the list starting with BLOCK.  If VECTOR is
6151    non-NULL, list them all into VECTOR, in a depth-first preorder
6152    traversal of the block tree.  Also clear TREE_ASM_WRITTEN in all
6153    blocks.  */
6154
6155 static int
6156 all_blocks (block, vector)
6157      tree block;
6158      tree *vector;
6159 {
6160   int n_blocks = 0;
6161
6162   while (block)
6163     {
6164       TREE_ASM_WRITTEN (block) = 0;
6165
6166       /* Record this block.  */
6167       if (vector)
6168         vector[n_blocks] = block;
6169
6170       ++n_blocks;
6171
6172       /* Record the subblocks, and their subblocks...  */
6173       n_blocks += all_blocks (BLOCK_SUBBLOCKS (block),
6174                               vector ? vector + n_blocks : 0);
6175       block = BLOCK_CHAIN (block);
6176     }
6177
6178   return n_blocks;
6179 }
6180
6181 /* Return a vector containing all the blocks rooted at BLOCK.  The
6182    number of elements in the vector is stored in N_BLOCKS_P.  The
6183    vector is dynamically allocated; it is the caller's responsibility
6184    to call `free' on the pointer returned.  */
6185
6186 static tree *
6187 get_block_vector (block, n_blocks_p)
6188      tree block;
6189      int *n_blocks_p;
6190 {
6191   tree *block_vector;
6192
6193   *n_blocks_p = all_blocks (block, NULL);
6194   block_vector = (tree *) xmalloc (*n_blocks_p * sizeof (tree));
6195   all_blocks (block, block_vector);
6196
6197   return block_vector;
6198 }
6199
6200 static GTY(()) int next_block_index = 2;
6201
6202 /* Set BLOCK_NUMBER for all the blocks in FN.  */
6203
6204 void
6205 number_blocks (fn)
6206      tree fn;
6207 {
6208   int i;
6209   int n_blocks;
6210   tree *block_vector;
6211
6212   /* For SDB and XCOFF debugging output, we start numbering the blocks
6213      from 1 within each function, rather than keeping a running
6214      count.  */
6215 #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
6216   if (write_symbols == SDB_DEBUG || write_symbols == XCOFF_DEBUG)
6217     next_block_index = 1;
6218 #endif
6219
6220   block_vector = get_block_vector (DECL_INITIAL (fn), &n_blocks);
6221
6222   /* The top-level BLOCK isn't numbered at all.  */
6223   for (i = 1; i < n_blocks; ++i)
6224     /* We number the blocks from two.  */
6225     BLOCK_NUMBER (block_vector[i]) = next_block_index++;
6226
6227   free (block_vector);
6228
6229   return;
6230 }
6231
6232 /* If VAR is present in a subblock of BLOCK, return the subblock.  */
6233
6234 tree
6235 debug_find_var_in_block_tree (var, block)
6236      tree var;
6237      tree block;
6238 {
6239   tree t;
6240
6241   for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))
6242     if (t == var)
6243       return block;
6244
6245   for (t = BLOCK_SUBBLOCKS (block); t; t = TREE_CHAIN (t))
6246     {
6247       tree ret = debug_find_var_in_block_tree (var, t);
6248       if (ret)
6249         return ret;
6250     }
6251
6252   return NULL_TREE;
6253 }
6254 \f
6255 /* Allocate a function structure and reset its contents to the defaults.  */
6256
6257 static void
6258 prepare_function_start ()
6259 {
6260   cfun = (struct function *) ggc_alloc_cleared (sizeof (struct function));
6261
6262   init_stmt_for_function ();
6263   init_eh_for_function ();
6264
6265   cse_not_expected = ! optimize;
6266
6267   /* Caller save not needed yet.  */
6268   caller_save_needed = 0;
6269
6270   /* No stack slots have been made yet.  */
6271   stack_slot_list = 0;
6272
6273   current_function_has_nonlocal_label = 0;
6274   current_function_has_nonlocal_goto = 0;
6275
6276   /* There is no stack slot for handling nonlocal gotos.  */
6277   nonlocal_goto_handler_slots = 0;
6278   nonlocal_goto_stack_level = 0;
6279
6280   /* No labels have been declared for nonlocal use.  */
6281   nonlocal_labels = 0;
6282   nonlocal_goto_handler_labels = 0;
6283
6284   /* No function calls so far in this function.  */
6285   function_call_count = 0;
6286
6287   /* No parm regs have been allocated.
6288      (This is important for output_inline_function.)  */
6289   max_parm_reg = LAST_VIRTUAL_REGISTER + 1;
6290
6291   /* Initialize the RTL mechanism.  */
6292   init_emit ();
6293
6294   /* Initialize the queue of pending postincrement and postdecrements,
6295      and some other info in expr.c.  */
6296   init_expr ();
6297
6298   /* We haven't done register allocation yet.  */
6299   reg_renumber = 0;
6300
6301   init_varasm_status (cfun);
6302
6303   /* Clear out data used for inlining.  */
6304   cfun->inlinable = 0;
6305   cfun->original_decl_initial = 0;
6306   cfun->original_arg_vector = 0;
6307
6308   cfun->stack_alignment_needed = STACK_BOUNDARY;
6309   cfun->preferred_stack_boundary = STACK_BOUNDARY;
6310
6311   /* Set if a call to setjmp is seen.  */
6312   current_function_calls_setjmp = 0;
6313
6314   /* Set if a call to longjmp is seen.  */
6315   current_function_calls_longjmp = 0;
6316
6317   current_function_calls_alloca = 0;
6318   current_function_calls_eh_return = 0;
6319   current_function_calls_constant_p = 0;
6320   current_function_contains_functions = 0;
6321   current_function_is_leaf = 0;
6322   current_function_nothrow = 0;
6323   current_function_sp_is_unchanging = 0;
6324   current_function_uses_only_leaf_regs = 0;
6325   current_function_has_computed_jump = 0;
6326   current_function_is_thunk = 0;
6327
6328   current_function_returns_pcc_struct = 0;
6329   current_function_returns_struct = 0;
6330   current_function_epilogue_delay_list = 0;
6331   current_function_uses_const_pool = 0;
6332   current_function_uses_pic_offset_table = 0;
6333   current_function_cannot_inline = 0;
6334
6335   /* We have not yet needed to make a label to jump to for tail-recursion.  */
6336   tail_recursion_label = 0;
6337
6338   /* We haven't had a need to make a save area for ap yet.  */
6339   arg_pointer_save_area = 0;
6340
6341   /* No stack slots allocated yet.  */
6342   frame_offset = 0;
6343
6344   /* No SAVE_EXPRs in this function yet.  */
6345   save_expr_regs = 0;
6346
6347   /* No RTL_EXPRs in this function yet.  */
6348   rtl_expr_chain = 0;
6349
6350   /* Set up to allocate temporaries.  */
6351   init_temp_slots ();
6352
6353   /* Indicate that we need to distinguish between the return value of the
6354      present function and the return value of a function being called.  */
6355   rtx_equal_function_value_matters = 1;
6356
6357   /* Indicate that we have not instantiated virtual registers yet.  */
6358   virtuals_instantiated = 0;
6359
6360   /* Indicate that we want CONCATs now.  */
6361   generating_concat_p = 1;
6362
6363   /* Indicate we have no need of a frame pointer yet.  */
6364   frame_pointer_needed = 0;
6365
6366   /* By default assume not stdarg.  */
6367   current_function_stdarg = 0;
6368
6369   /* We haven't made any trampolines for this function yet.  */
6370   trampoline_list = 0;
6371
6372   init_pending_stack_adjust ();
6373   inhibit_defer_pop = 0;
6374
6375   current_function_outgoing_args_size = 0;
6376
6377   current_function_funcdef_no = funcdef_no++;
6378
6379   cfun->arc_profile = profile_arc_flag || flag_test_coverage;
6380
6381   cfun->function_frequency = FUNCTION_FREQUENCY_NORMAL;
6382
6383   cfun->max_jumptable_ents = 0;
6384
6385   (*lang_hooks.function.init) (cfun);
6386   if (init_machine_status)
6387     cfun->machine = (*init_machine_status) ();
6388 }
6389
6390 /* Initialize the rtl expansion mechanism so that we can do simple things
6391    like generate sequences.  This is used to provide a context during global
6392    initialization of some passes.  */
6393 void
6394 init_dummy_function_start ()
6395 {
6396   prepare_function_start ();
6397 }
6398
6399 /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node)
6400    and initialize static variables for generating RTL for the statements
6401    of the function.  */
6402
6403 void
6404 init_function_start (subr, filename, line)
6405      tree subr;
6406      const char *filename;
6407      int line;
6408 {
6409   prepare_function_start ();
6410
6411   current_function_name = (*lang_hooks.decl_printable_name) (subr, 2);
6412   cfun->decl = subr;
6413
6414   /* Nonzero if this is a nested function that uses a static chain.  */
6415
6416   current_function_needs_context
6417     = (decl_function_context (current_function_decl) != 0
6418        && ! DECL_NO_STATIC_CHAIN (current_function_decl));
6419
6420   /* Within function body, compute a type's size as soon it is laid out.  */
6421   immediate_size_expand++;
6422
6423   /* Prevent ever trying to delete the first instruction of a function.
6424      Also tell final how to output a linenum before the function prologue.
6425      Note linenums could be missing, e.g. when compiling a Java .class file.  */
6426   if (line > 0)
6427     emit_line_note (filename, line);
6428
6429   /* Make sure first insn is a note even if we don't want linenums.
6430      This makes sure the first insn will never be deleted.
6431      Also, final expects a note to appear there.  */
6432   emit_note (NULL, NOTE_INSN_DELETED);
6433
6434   /* Set flags used by final.c.  */
6435   if (aggregate_value_p (DECL_RESULT (subr)))
6436     {
6437 #ifdef PCC_STATIC_STRUCT_RETURN
6438       current_function_returns_pcc_struct = 1;
6439 #endif
6440       current_function_returns_struct = 1;
6441     }
6442
6443   /* Warn if this value is an aggregate type,
6444      regardless of which calling convention we are using for it.  */
6445   if (warn_aggregate_return
6446       && AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr))))
6447     warning ("function returns an aggregate");
6448
6449   current_function_returns_pointer
6450     = POINTER_TYPE_P (TREE_TYPE (DECL_RESULT (subr)));
6451 }
6452
6453 /* Make sure all values used by the optimization passes have sane
6454    defaults.  */
6455 void
6456 init_function_for_compilation ()
6457 {
6458   reg_renumber = 0;
6459
6460   /* No prologue/epilogue insns yet.  */
6461   VARRAY_GROW (prologue, 0);
6462   VARRAY_GROW (epilogue, 0);
6463   VARRAY_GROW (sibcall_epilogue, 0);
6464 }
6465
6466 /* Expand a call to __main at the beginning of a possible main function.  */
6467
6468 #if defined(INIT_SECTION_ASM_OP) && !defined(INVOKE__main)
6469 #undef HAS_INIT_SECTION
6470 #define HAS_INIT_SECTION
6471 #endif
6472
6473 void
6474 expand_main_function ()
6475 {
6476 #ifdef FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN
6477   if (FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN)
6478     {
6479       int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
6480       rtx tmp, seq;
6481
6482       start_sequence ();
6483       /* Forcibly align the stack.  */
6484 #ifdef STACK_GROWS_DOWNWARD
6485       tmp = expand_simple_binop (Pmode, AND, stack_pointer_rtx, GEN_INT(-align),
6486                                  stack_pointer_rtx, 1, OPTAB_WIDEN);
6487 #else
6488       tmp = expand_simple_binop (Pmode, PLUS, stack_pointer_rtx,
6489                                  GEN_INT (align - 1), NULL_RTX, 1, OPTAB_WIDEN);
6490       tmp = expand_simple_binop (Pmode, AND, tmp, GEN_INT (-align),
6491                                  stack_pointer_rtx, 1, OPTAB_WIDEN);
6492 #endif
6493       if (tmp != stack_pointer_rtx)
6494         emit_move_insn (stack_pointer_rtx, tmp);
6495
6496       /* Enlist allocate_dynamic_stack_space to pick up the pieces.  */
6497       tmp = force_reg (Pmode, const0_rtx);
6498       allocate_dynamic_stack_space (tmp, NULL_RTX, BIGGEST_ALIGNMENT);
6499       seq = get_insns ();
6500       end_sequence ();
6501
6502       for (tmp = get_last_insn (); tmp; tmp = PREV_INSN (tmp))
6503         if (NOTE_P (tmp) && NOTE_LINE_NUMBER (tmp) == NOTE_INSN_FUNCTION_BEG)
6504           break;
6505       if (tmp)
6506         emit_insn_before (seq, tmp);
6507       else
6508         emit_insn (seq);
6509     }
6510 #endif
6511
6512 #ifndef HAS_INIT_SECTION
6513   emit_library_call (init_one_libfunc (NAME__MAIN), LCT_NORMAL, VOIDmode, 0);
6514 #endif
6515 }
6516 \f
6517 /* The PENDING_SIZES represent the sizes of variable-sized types.
6518    Create RTL for the various sizes now (using temporary variables),
6519    so that we can refer to the sizes from the RTL we are generating
6520    for the current function.  The PENDING_SIZES are a TREE_LIST.  The
6521    TREE_VALUE of each node is a SAVE_EXPR.  */
6522
6523 void
6524 expand_pending_sizes (pending_sizes)
6525      tree pending_sizes;
6526 {
6527   tree tem;
6528
6529   /* Evaluate now the sizes of any types declared among the arguments.  */
6530   for (tem = pending_sizes; tem; tem = TREE_CHAIN (tem))
6531     {
6532       expand_expr (TREE_VALUE (tem), const0_rtx, VOIDmode, 0);
6533       /* Flush the queue in case this parameter declaration has
6534          side-effects.  */
6535       emit_queue ();
6536     }
6537 }
6538
6539 /* Start the RTL for a new function, and set variables used for
6540    emitting RTL.
6541    SUBR is the FUNCTION_DECL node.
6542    PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with
6543    the function's parameters, which must be run at any return statement.  */
6544
6545 void
6546 expand_function_start (subr, parms_have_cleanups)
6547      tree subr;
6548      int parms_have_cleanups;
6549 {
6550   tree tem;
6551   rtx last_ptr = NULL_RTX;
6552
6553   /* Make sure volatile mem refs aren't considered
6554      valid operands of arithmetic insns.  */
6555   init_recog_no_volatile ();
6556
6557   current_function_instrument_entry_exit
6558     = (flag_instrument_function_entry_exit
6559        && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr));
6560
6561   current_function_profile
6562     = (profile_flag
6563        && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr));
6564
6565   current_function_limit_stack
6566     = (stack_limit_rtx != NULL_RTX && ! DECL_NO_LIMIT_STACK (subr));
6567
6568   /* If function gets a static chain arg, store it in the stack frame.
6569      Do this first, so it gets the first stack slot offset.  */
6570   if (current_function_needs_context)
6571     {
6572       last_ptr = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0);
6573
6574       /* Delay copying static chain if it is not a register to avoid
6575          conflicts with regs used for parameters.  */
6576       if (! SMALL_REGISTER_CLASSES
6577           || GET_CODE (static_chain_incoming_rtx) == REG)
6578         emit_move_insn (last_ptr, static_chain_incoming_rtx);
6579     }
6580
6581   /* If the parameters of this function need cleaning up, get a label
6582      for the beginning of the code which executes those cleanups.  This must
6583      be done before doing anything with return_label.  */
6584   if (parms_have_cleanups)
6585     cleanup_label = gen_label_rtx ();
6586   else
6587     cleanup_label = 0;
6588
6589   /* Make the label for return statements to jump to.  Do not special
6590      case machines with special return instructions -- they will be
6591      handled later during jump, ifcvt, or epilogue creation.  */
6592   return_label = gen_label_rtx ();
6593
6594   /* Initialize rtx used to return the value.  */
6595   /* Do this before assign_parms so that we copy the struct value address
6596      before any library calls that assign parms might generate.  */
6597
6598   /* Decide whether to return the value in memory or in a register.  */
6599   if (aggregate_value_p (DECL_RESULT (subr)))
6600     {
6601       /* Returning something that won't go in a register.  */
6602       rtx value_address = 0;
6603
6604 #ifdef PCC_STATIC_STRUCT_RETURN
6605       if (current_function_returns_pcc_struct)
6606         {
6607           int size = int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr)));
6608           value_address = assemble_static_space (size);
6609         }
6610       else
6611 #endif
6612         {
6613           /* Expect to be passed the address of a place to store the value.
6614              If it is passed as an argument, assign_parms will take care of
6615              it.  */
6616           if (struct_value_incoming_rtx)
6617             {
6618               value_address = gen_reg_rtx (Pmode);
6619               emit_move_insn (value_address, struct_value_incoming_rtx);
6620             }
6621         }
6622       if (value_address)
6623         {
6624           rtx x = gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr)), value_address);
6625           set_mem_attributes (x, DECL_RESULT (subr), 1);
6626           SET_DECL_RTL (DECL_RESULT (subr), x);
6627         }
6628     }
6629   else if (DECL_MODE (DECL_RESULT (subr)) == VOIDmode)
6630     /* If return mode is void, this decl rtl should not be used.  */
6631     SET_DECL_RTL (DECL_RESULT (subr), NULL_RTX);
6632   else
6633     {
6634       /* Compute the return values into a pseudo reg, which we will copy
6635          into the true return register after the cleanups are done.  */
6636
6637       /* In order to figure out what mode to use for the pseudo, we
6638          figure out what the mode of the eventual return register will
6639          actually be, and use that.  */
6640       rtx hard_reg
6641         = hard_function_value (TREE_TYPE (DECL_RESULT (subr)),
6642                                subr, 1);
6643
6644       /* Structures that are returned in registers are not aggregate_value_p,
6645          so we may see a PARALLEL or a REG.  */
6646       if (REG_P (hard_reg))
6647         SET_DECL_RTL (DECL_RESULT (subr), gen_reg_rtx (GET_MODE (hard_reg)));
6648       else if (GET_CODE (hard_reg) == PARALLEL)
6649         SET_DECL_RTL (DECL_RESULT (subr), gen_group_rtx (hard_reg));
6650       else
6651         abort ();
6652
6653       /* Set DECL_REGISTER flag so that expand_function_end will copy the
6654          result to the real return register(s).  */
6655       DECL_REGISTER (DECL_RESULT (subr)) = 1;
6656     }
6657
6658   /* Initialize rtx for parameters and local variables.
6659      In some cases this requires emitting insns.  */
6660
6661   assign_parms (subr);
6662
6663   /* Copy the static chain now if it wasn't a register.  The delay is to
6664      avoid conflicts with the parameter passing registers.  */
6665
6666   if (SMALL_REGISTER_CLASSES && current_function_needs_context)
6667     if (GET_CODE (static_chain_incoming_rtx) != REG)
6668       emit_move_insn (last_ptr, static_chain_incoming_rtx);
6669
6670   /* The following was moved from init_function_start.
6671      The move is supposed to make sdb output more accurate.  */
6672   /* Indicate the beginning of the function body,
6673      as opposed to parm setup.  */
6674   emit_note (NULL, NOTE_INSN_FUNCTION_BEG);
6675
6676   if (GET_CODE (get_last_insn ()) != NOTE)
6677     emit_note (NULL, NOTE_INSN_DELETED);
6678   parm_birth_insn = get_last_insn ();
6679
6680   context_display = 0;
6681   if (current_function_needs_context)
6682     {
6683       /* Fetch static chain values for containing functions.  */
6684       tem = decl_function_context (current_function_decl);
6685       /* Copy the static chain pointer into a pseudo.  If we have
6686          small register classes, copy the value from memory if
6687          static_chain_incoming_rtx is a REG.  */
6688       if (tem)
6689         {
6690           /* If the static chain originally came in a register, put it back
6691              there, then move it out in the next insn.  The reason for
6692              this peculiar code is to satisfy function integration.  */
6693           if (SMALL_REGISTER_CLASSES
6694               && GET_CODE (static_chain_incoming_rtx) == REG)
6695             emit_move_insn (static_chain_incoming_rtx, last_ptr);
6696           last_ptr = copy_to_reg (static_chain_incoming_rtx);
6697         }
6698
6699       while (tem)
6700         {
6701           tree rtlexp = make_node (RTL_EXPR);
6702
6703           RTL_EXPR_RTL (rtlexp) = last_ptr;
6704           context_display = tree_cons (tem, rtlexp, context_display);
6705           tem = decl_function_context (tem);
6706           if (tem == 0)
6707             break;
6708           /* Chain thru stack frames, assuming pointer to next lexical frame
6709              is found at the place we always store it.  */
6710 #ifdef FRAME_GROWS_DOWNWARD
6711           last_ptr = plus_constant (last_ptr,
6712                                     -(HOST_WIDE_INT) GET_MODE_SIZE (Pmode));
6713 #endif
6714           last_ptr = gen_rtx_MEM (Pmode, memory_address (Pmode, last_ptr));
6715           set_mem_alias_set (last_ptr, get_frame_alias_set ());
6716           last_ptr = copy_to_reg (last_ptr);
6717
6718           /* If we are not optimizing, ensure that we know that this
6719              piece of context is live over the entire function.  */
6720           if (! optimize)
6721             save_expr_regs = gen_rtx_EXPR_LIST (VOIDmode, last_ptr,
6722                                                 save_expr_regs);
6723         }
6724     }
6725
6726   if (current_function_instrument_entry_exit)
6727     {
6728       rtx fun = DECL_RTL (current_function_decl);
6729       if (GET_CODE (fun) == MEM)
6730         fun = XEXP (fun, 0);
6731       else
6732         abort ();
6733       emit_library_call (profile_function_entry_libfunc, LCT_NORMAL, VOIDmode,
6734                          2, fun, Pmode,
6735                          expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
6736                                                      0,
6737                                                      hard_frame_pointer_rtx),
6738                          Pmode);
6739     }
6740
6741   if (current_function_profile)
6742     {
6743 #ifdef PROFILE_HOOK
6744       PROFILE_HOOK (current_function_funcdef_no);
6745 #endif
6746     }
6747
6748   /* After the display initializations is where the tail-recursion label
6749      should go, if we end up needing one.   Ensure we have a NOTE here
6750      since some things (like trampolines) get placed before this.  */
6751   tail_recursion_reentry = emit_note (NULL, NOTE_INSN_DELETED);
6752
6753   /* Evaluate now the sizes of any types declared among the arguments.  */
6754   expand_pending_sizes (nreverse (get_pending_sizes ()));
6755
6756   /* Make sure there is a line number after the function entry setup code.  */
6757   force_next_line_note ();
6758 }
6759 \f
6760 /* Undo the effects of init_dummy_function_start.  */
6761 void
6762 expand_dummy_function_end ()
6763 {
6764   /* End any sequences that failed to be closed due to syntax errors.  */
6765   while (in_sequence_p ())
6766     end_sequence ();
6767
6768   /* Outside function body, can't compute type's actual size
6769      until next function's body starts.  */
6770
6771   free_after_parsing (cfun);
6772   free_after_compilation (cfun);
6773   cfun = 0;
6774 }
6775
6776 /* Call DOIT for each hard register used as a return value from
6777    the current function.  */
6778
6779 void
6780 diddle_return_value (doit, arg)
6781      void (*doit) PARAMS ((rtx, void *));
6782      void *arg;
6783 {
6784   rtx outgoing = current_function_return_rtx;
6785
6786   if (! outgoing)
6787     return;
6788
6789   if (GET_CODE (outgoing) == REG)
6790     (*doit) (outgoing, arg);
6791   else if (GET_CODE (outgoing) == PARALLEL)
6792     {
6793       int i;
6794
6795       for (i = 0; i < XVECLEN (outgoing, 0); i++)
6796         {
6797           rtx x = XEXP (XVECEXP (outgoing, 0, i), 0);
6798
6799           if (GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
6800             (*doit) (x, arg);
6801         }
6802     }
6803 }
6804
6805 static void
6806 do_clobber_return_reg (reg, arg)
6807      rtx reg;
6808      void *arg ATTRIBUTE_UNUSED;
6809 {
6810   emit_insn (gen_rtx_CLOBBER (VOIDmode, reg));
6811 }
6812
6813 void
6814 clobber_return_register ()
6815 {
6816   diddle_return_value (do_clobber_return_reg, NULL);
6817
6818   /* In case we do use pseudo to return value, clobber it too.  */
6819   if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl)))
6820     {
6821       tree decl_result = DECL_RESULT (current_function_decl);
6822       rtx decl_rtl = DECL_RTL (decl_result);
6823       if (REG_P (decl_rtl) && REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER)
6824         {
6825           do_clobber_return_reg (decl_rtl, NULL);
6826         }
6827     }
6828 }
6829
6830 static void
6831 do_use_return_reg (reg, arg)
6832      rtx reg;
6833      void *arg ATTRIBUTE_UNUSED;
6834 {
6835   emit_insn (gen_rtx_USE (VOIDmode, reg));
6836 }
6837
6838 void
6839 use_return_register ()
6840 {
6841   diddle_return_value (do_use_return_reg, NULL);
6842 }
6843
6844 static GTY(()) rtx initial_trampoline;
6845
6846 /* Generate RTL for the end of the current function.
6847    FILENAME and LINE are the current position in the source file.
6848
6849    It is up to language-specific callers to do cleanups for parameters--
6850    or else, supply 1 for END_BINDINGS and we will call expand_end_bindings.  */
6851
6852 void
6853 expand_function_end (filename, line, end_bindings)
6854      const char *filename;
6855      int line;
6856      int end_bindings;
6857 {
6858   tree link;
6859   rtx clobber_after;
6860
6861   finish_expr_for_function ();
6862
6863   /* If arg_pointer_save_area was referenced only from a nested
6864      function, we will not have initialized it yet.  Do that now.  */
6865   if (arg_pointer_save_area && ! cfun->arg_pointer_save_area_init)
6866     get_arg_pointer_save_area (cfun);
6867
6868 #ifdef NON_SAVING_SETJMP
6869   /* Don't put any variables in registers if we call setjmp
6870      on a machine that fails to restore the registers.  */
6871   if (NON_SAVING_SETJMP && current_function_calls_setjmp)
6872     {
6873       if (DECL_INITIAL (current_function_decl) != error_mark_node)
6874         setjmp_protect (DECL_INITIAL (current_function_decl));
6875
6876       setjmp_protect_args ();
6877     }
6878 #endif
6879
6880   /* Initialize any trampolines required by this function.  */
6881   for (link = trampoline_list; link; link = TREE_CHAIN (link))
6882     {
6883       tree function = TREE_PURPOSE (link);
6884       rtx context ATTRIBUTE_UNUSED = lookup_static_chain (function);
6885       rtx tramp = RTL_EXPR_RTL (TREE_VALUE (link));
6886 #ifdef TRAMPOLINE_TEMPLATE
6887       rtx blktramp;
6888 #endif
6889       rtx seq;
6890
6891 #ifdef TRAMPOLINE_TEMPLATE
6892       /* First make sure this compilation has a template for
6893          initializing trampolines.  */
6894       if (initial_trampoline == 0)
6895         {
6896           initial_trampoline
6897             = gen_rtx_MEM (BLKmode, assemble_trampoline_template ());
6898           set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT);
6899         }
6900 #endif
6901
6902       /* Generate insns to initialize the trampoline.  */
6903       start_sequence ();
6904       tramp = round_trampoline_addr (XEXP (tramp, 0));
6905 #ifdef TRAMPOLINE_TEMPLATE
6906       blktramp = replace_equiv_address (initial_trampoline, tramp);
6907       emit_block_move (blktramp, initial_trampoline,
6908                        GEN_INT (TRAMPOLINE_SIZE), BLOCK_OP_NORMAL);
6909 #endif
6910       INITIALIZE_TRAMPOLINE (tramp, XEXP (DECL_RTL (function), 0), context);
6911       seq = get_insns ();
6912       end_sequence ();
6913
6914       /* Put those insns at entry to the containing function (this one).  */
6915       emit_insn_before (seq, tail_recursion_reentry);
6916     }
6917
6918   /* If we are doing stack checking and this function makes calls,
6919      do a stack probe at the start of the function to ensure we have enough
6920      space for another stack frame.  */
6921   if (flag_stack_check && ! STACK_CHECK_BUILTIN)
6922     {
6923       rtx insn, seq;
6924
6925       for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
6926         if (GET_CODE (insn) == CALL_INSN)
6927           {
6928             start_sequence ();
6929             probe_stack_range (STACK_CHECK_PROTECT,
6930                                GEN_INT (STACK_CHECK_MAX_FRAME_SIZE));
6931             seq = get_insns ();
6932             end_sequence ();
6933             emit_insn_before (seq, tail_recursion_reentry);
6934             break;
6935           }
6936     }
6937
6938   /* Warn about unused parms if extra warnings were specified.  */
6939   /* Either ``-Wextra -Wunused'' or ``-Wunused-parameter'' enables this
6940      warning.  WARN_UNUSED_PARAMETER is negative when set by
6941      -Wunused.  Note that -Wall implies -Wunused, so ``-Wall -Wextra'' will
6942      also give these warnings.  */
6943   if (warn_unused_parameter > 0
6944       || (warn_unused_parameter < 0 && extra_warnings))
6945     {
6946       tree decl;
6947
6948       for (decl = DECL_ARGUMENTS (current_function_decl);
6949            decl; decl = TREE_CHAIN (decl))
6950         if (! TREE_USED (decl) && TREE_CODE (decl) == PARM_DECL
6951             && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
6952           warning_with_decl (decl, "unused parameter `%s'");
6953     }
6954
6955   /* Delete handlers for nonlocal gotos if nothing uses them.  */
6956   if (nonlocal_goto_handler_slots != 0
6957       && ! current_function_has_nonlocal_label)
6958     delete_handlers ();
6959
6960   /* End any sequences that failed to be closed due to syntax errors.  */
6961   while (in_sequence_p ())
6962     end_sequence ();
6963
6964   /* Outside function body, can't compute type's actual size
6965      until next function's body starts.  */
6966   immediate_size_expand--;
6967
6968   clear_pending_stack_adjust ();
6969   do_pending_stack_adjust ();
6970
6971   /* Mark the end of the function body.
6972      If control reaches this insn, the function can drop through
6973      without returning a value.  */
6974   emit_note (NULL, NOTE_INSN_FUNCTION_END);
6975
6976   /* Must mark the last line number note in the function, so that the test
6977      coverage code can avoid counting the last line twice.  This just tells
6978      the code to ignore the immediately following line note, since there
6979      already exists a copy of this note somewhere above.  This line number
6980      note is still needed for debugging though, so we can't delete it.  */
6981   if (flag_test_coverage)
6982     emit_note (NULL, NOTE_INSN_REPEATED_LINE_NUMBER);
6983
6984   /* Output a linenumber for the end of the function.
6985      SDB depends on this.  */
6986   emit_line_note_force (filename, line);
6987
6988   /* Before the return label (if any), clobber the return
6989      registers so that they are not propagated live to the rest of
6990      the function.  This can only happen with functions that drop
6991      through; if there had been a return statement, there would
6992      have either been a return rtx, or a jump to the return label.
6993
6994      We delay actual code generation after the current_function_value_rtx
6995      is computed.  */
6996   clobber_after = get_last_insn ();
6997
6998   /* Output the label for the actual return from the function,
6999      if one is expected.  This happens either because a function epilogue
7000      is used instead of a return instruction, or because a return was done
7001      with a goto in order to run local cleanups, or because of pcc-style
7002      structure returning.  */
7003   if (return_label)
7004     emit_label (return_label);
7005
7006   /* C++ uses this.  */
7007   if (end_bindings)
7008     expand_end_bindings (0, 0, 0);
7009
7010   if (current_function_instrument_entry_exit)
7011     {
7012       rtx fun = DECL_RTL (current_function_decl);
7013       if (GET_CODE (fun) == MEM)
7014         fun = XEXP (fun, 0);
7015       else
7016         abort ();
7017       emit_library_call (profile_function_exit_libfunc, LCT_NORMAL, VOIDmode,
7018                          2, fun, Pmode,
7019                          expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
7020                                                      0,
7021                                                      hard_frame_pointer_rtx),
7022                          Pmode);
7023     }
7024
7025   /* Let except.c know where it should emit the call to unregister
7026      the function context for sjlj exceptions.  */
7027   if (flag_exceptions && USING_SJLJ_EXCEPTIONS)
7028     sjlj_emit_function_exit_after (get_last_insn ());
7029
7030   /* If we had calls to alloca, and this machine needs
7031      an accurate stack pointer to exit the function,
7032      insert some code to save and restore the stack pointer.  */
7033 #ifdef EXIT_IGNORE_STACK
7034   if (! EXIT_IGNORE_STACK)
7035 #endif
7036     if (current_function_calls_alloca)
7037       {
7038         rtx tem = 0;
7039
7040         emit_stack_save (SAVE_FUNCTION, &tem, parm_birth_insn);
7041         emit_stack_restore (SAVE_FUNCTION, tem, NULL_RTX);
7042       }
7043
7044   /* If scalar return value was computed in a pseudo-reg, or was a named
7045      return value that got dumped to the stack, copy that to the hard
7046      return register.  */
7047   if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl)))
7048     {
7049       tree decl_result = DECL_RESULT (current_function_decl);
7050       rtx decl_rtl = DECL_RTL (decl_result);
7051
7052       if (REG_P (decl_rtl)
7053           ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER
7054           : DECL_REGISTER (decl_result))
7055         {
7056           rtx real_decl_rtl = current_function_return_rtx;
7057
7058           /* This should be set in assign_parms.  */
7059           if (! REG_FUNCTION_VALUE_P (real_decl_rtl))
7060             abort ();
7061
7062           /* If this is a BLKmode structure being returned in registers,
7063              then use the mode computed in expand_return.  Note that if
7064              decl_rtl is memory, then its mode may have been changed,
7065              but that current_function_return_rtx has not.  */
7066           if (GET_MODE (real_decl_rtl) == BLKmode)
7067             PUT_MODE (real_decl_rtl, GET_MODE (decl_rtl));
7068
7069           /* If a named return value dumped decl_return to memory, then
7070              we may need to re-do the PROMOTE_MODE signed/unsigned
7071              extension.  */
7072           if (GET_MODE (real_decl_rtl) != GET_MODE (decl_rtl))
7073             {
7074               int unsignedp = TREE_UNSIGNED (TREE_TYPE (decl_result));
7075
7076 #ifdef PROMOTE_FUNCTION_RETURN
7077               promote_mode (TREE_TYPE (decl_result), GET_MODE (decl_rtl),
7078                             &unsignedp, 1);
7079 #endif
7080
7081               convert_move (real_decl_rtl, decl_rtl, unsignedp);
7082             }
7083           else if (GET_CODE (real_decl_rtl) == PARALLEL)
7084             {
7085               /* If expand_function_start has created a PARALLEL for decl_rtl,
7086                  move the result to the real return registers.  Otherwise, do
7087                  a group load from decl_rtl for a named return.  */
7088               if (GET_CODE (decl_rtl) == PARALLEL)
7089                 emit_group_move (real_decl_rtl, decl_rtl);
7090               else
7091                 emit_group_load (real_decl_rtl, decl_rtl,
7092                                  int_size_in_bytes (TREE_TYPE (decl_result)));
7093             }
7094           else
7095             emit_move_insn (real_decl_rtl, decl_rtl);
7096         }
7097     }
7098
7099   /* If returning a structure, arrange to return the address of the value
7100      in a place where debuggers expect to find it.
7101
7102      If returning a structure PCC style,
7103      the caller also depends on this value.
7104      And current_function_returns_pcc_struct is not necessarily set.  */
7105   if (current_function_returns_struct
7106       || current_function_returns_pcc_struct)
7107     {
7108       rtx value_address
7109         = XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
7110       tree type = TREE_TYPE (DECL_RESULT (current_function_decl));
7111 #ifdef FUNCTION_OUTGOING_VALUE
7112       rtx outgoing
7113         = FUNCTION_OUTGOING_VALUE (build_pointer_type (type),
7114                                    current_function_decl);
7115 #else
7116       rtx outgoing
7117         = FUNCTION_VALUE (build_pointer_type (type), current_function_decl);
7118 #endif
7119
7120       /* Mark this as a function return value so integrate will delete the
7121          assignment and USE below when inlining this function.  */
7122       REG_FUNCTION_VALUE_P (outgoing) = 1;
7123
7124 #ifdef POINTERS_EXTEND_UNSIGNED
7125       /* The address may be ptr_mode and OUTGOING may be Pmode.  */
7126       if (GET_MODE (outgoing) != GET_MODE (value_address))
7127         value_address = convert_memory_address (GET_MODE (outgoing),
7128                                                 value_address);
7129 #endif
7130
7131       emit_move_insn (outgoing, value_address);
7132
7133       /* Show return register used to hold result (in this case the address
7134          of the result.  */
7135       current_function_return_rtx = outgoing;
7136     }
7137
7138   /* If this is an implementation of throw, do what's necessary to
7139      communicate between __builtin_eh_return and the epilogue.  */
7140   expand_eh_return ();
7141
7142   /* Emit the actual code to clobber return register.  */
7143   {
7144     rtx seq, after;
7145
7146     start_sequence ();
7147     clobber_return_register ();
7148     seq = get_insns ();
7149     end_sequence ();
7150
7151     after = emit_insn_after (seq, clobber_after);
7152
7153     if (clobber_after != after)
7154       cfun->x_clobber_return_insn = after;
7155   }
7156
7157   /* ??? This should no longer be necessary since stupid is no longer with
7158      us, but there are some parts of the compiler (eg reload_combine, and
7159      sh mach_dep_reorg) that still try and compute their own lifetime info
7160      instead of using the general framework.  */
7161   use_return_register ();
7162
7163   /* Fix up any gotos that jumped out to the outermost
7164      binding level of the function.
7165      Must follow emitting RETURN_LABEL.  */
7166
7167   /* If you have any cleanups to do at this point,
7168      and they need to create temporary variables,
7169      then you will lose.  */
7170   expand_fixups (get_insns ());
7171 }
7172
7173 rtx
7174 get_arg_pointer_save_area (f)
7175      struct function *f;
7176 {
7177   rtx ret = f->x_arg_pointer_save_area;
7178
7179   if (! ret)
7180     {
7181       ret = assign_stack_local_1 (Pmode, GET_MODE_SIZE (Pmode), 0, f);
7182       f->x_arg_pointer_save_area = ret;
7183     }
7184
7185   if (f == cfun && ! f->arg_pointer_save_area_init)
7186     {
7187       rtx seq;
7188
7189       /* Save the arg pointer at the beginning of the function.  The
7190          generated stack slot may not be a valid memory address, so we
7191          have to check it and fix it if necessary.  */
7192       start_sequence ();
7193       emit_move_insn (validize_mem (ret), virtual_incoming_args_rtx);
7194       seq = get_insns ();
7195       end_sequence ();
7196
7197       push_topmost_sequence ();
7198       emit_insn_after (seq, get_insns ());
7199       pop_topmost_sequence ();
7200     }
7201
7202   return ret;
7203 }
7204 \f
7205 /* Extend a vector that records the INSN_UIDs of INSNS
7206    (a list of one or more insns).  */
7207
7208 static void
7209 record_insns (insns, vecp)
7210      rtx insns;
7211      varray_type *vecp;
7212 {
7213   int i, len;
7214   rtx tmp;
7215
7216   tmp = insns;
7217   len = 0;
7218   while (tmp != NULL_RTX)
7219     {
7220       len++;
7221       tmp = NEXT_INSN (tmp);
7222     }
7223
7224   i = VARRAY_SIZE (*vecp);
7225   VARRAY_GROW (*vecp, i + len);
7226   tmp = insns;
7227   while (tmp != NULL_RTX)
7228     {
7229       VARRAY_INT (*vecp, i) = INSN_UID (tmp);
7230       i++;
7231       tmp = NEXT_INSN (tmp);
7232     }
7233 }
7234
7235 /* Determine how many INSN_UIDs in VEC are part of INSN.  Because we can
7236    be running after reorg, SEQUENCE rtl is possible.  */
7237
7238 static int
7239 contains (insn, vec)
7240      rtx insn;
7241      varray_type vec;
7242 {
7243   int i, j;
7244
7245   if (GET_CODE (insn) == INSN
7246       && GET_CODE (PATTERN (insn)) == SEQUENCE)
7247     {
7248       int count = 0;
7249       for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
7250         for (j = VARRAY_SIZE (vec) - 1; j >= 0; --j)
7251           if (INSN_UID (XVECEXP (PATTERN (insn), 0, i)) == VARRAY_INT (vec, j))
7252             count++;
7253       return count;
7254     }
7255   else
7256     {
7257       for (j = VARRAY_SIZE (vec) - 1; j >= 0; --j)
7258         if (INSN_UID (insn) == VARRAY_INT (vec, j))
7259           return 1;
7260     }
7261   return 0;
7262 }
7263
7264 int
7265 prologue_epilogue_contains (insn)
7266      rtx insn;
7267 {
7268   if (contains (insn, prologue))
7269     return 1;
7270   if (contains (insn, epilogue))
7271     return 1;
7272   return 0;
7273 }
7274
7275 int
7276 sibcall_epilogue_contains (insn)
7277      rtx insn;
7278 {
7279   if (sibcall_epilogue)
7280     return contains (insn, sibcall_epilogue);
7281   return 0;
7282 }
7283
7284 #ifdef HAVE_return
7285 /* Insert gen_return at the end of block BB.  This also means updating
7286    block_for_insn appropriately.  */
7287
7288 static void
7289 emit_return_into_block (bb, line_note)
7290      basic_block bb;
7291      rtx line_note;
7292 {
7293   emit_jump_insn_after (gen_return (), bb->end);
7294   if (line_note)
7295     emit_line_note_after (NOTE_SOURCE_FILE (line_note),
7296                           NOTE_LINE_NUMBER (line_note), PREV_INSN (bb->end));
7297 }
7298 #endif /* HAVE_return */
7299
7300 #if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX)
7301
7302 /* These functions convert the epilogue into a variant that does not modify the
7303    stack pointer.  This is used in cases where a function returns an object
7304    whose size is not known until it is computed.  The called function leaves the
7305    object on the stack, leaves the stack depressed, and returns a pointer to
7306    the object.
7307
7308    What we need to do is track all modifications and references to the stack
7309    pointer, deleting the modifications and changing the references to point to
7310    the location the stack pointer would have pointed to had the modifications
7311    taken place.
7312
7313    These functions need to be portable so we need to make as few assumptions
7314    about the epilogue as we can.  However, the epilogue basically contains
7315    three things: instructions to reset the stack pointer, instructions to
7316    reload registers, possibly including the frame pointer, and an
7317    instruction to return to the caller.
7318
7319    If we can't be sure of what a relevant epilogue insn is doing, we abort.
7320    We also make no attempt to validate the insns we make since if they are
7321    invalid, we probably can't do anything valid.  The intent is that these
7322    routines get "smarter" as more and more machines start to use them and
7323    they try operating on different epilogues.
7324
7325    We use the following structure to track what the part of the epilogue that
7326    we've already processed has done.  We keep two copies of the SP equivalence,
7327    one for use during the insn we are processing and one for use in the next
7328    insn.  The difference is because one part of a PARALLEL may adjust SP
7329    and the other may use it.  */
7330
7331 struct epi_info
7332 {
7333   rtx sp_equiv_reg;             /* REG that SP is set from, perhaps SP.  */
7334   HOST_WIDE_INT sp_offset;      /* Offset from SP_EQUIV_REG of present SP.  */
7335   rtx new_sp_equiv_reg;         /* REG to be used at end of insn.  */
7336   HOST_WIDE_INT new_sp_offset;  /* Offset to be used at end of insn.  */
7337   rtx equiv_reg_src;            /* If nonzero, the value that SP_EQUIV_REG
7338                                    should be set to once we no longer need
7339                                    its value.  */
7340 };
7341
7342 static void handle_epilogue_set PARAMS ((rtx, struct epi_info *));
7343 static void emit_equiv_load PARAMS ((struct epi_info *));
7344
7345 /* Modify INSN, a list of one or more insns that is part of the epilogue, to
7346    no modifications to the stack pointer.  Return the new list of insns.  */
7347
7348 static rtx
7349 keep_stack_depressed (insns)
7350      rtx insns;
7351 {
7352   int j;
7353   struct epi_info info;
7354   rtx insn, next;
7355
7356   /* If the epilogue is just a single instruction, it ust be OK as is.  */
7357
7358   if (NEXT_INSN (insns) == NULL_RTX)
7359     return insns;
7360
7361   /* Otherwise, start a sequence, initialize the information we have, and
7362      process all the insns we were given.  */
7363   start_sequence ();
7364
7365   info.sp_equiv_reg = stack_pointer_rtx;
7366   info.sp_offset = 0;
7367   info.equiv_reg_src = 0;
7368
7369   insn = insns;
7370   next = NULL_RTX;
7371   while (insn != NULL_RTX)
7372     {
7373       next = NEXT_INSN (insn);
7374
7375       if (!INSN_P (insn))
7376         {
7377           add_insn (insn);
7378           insn = next;
7379           continue;
7380         }
7381
7382       /* If this insn references the register that SP is equivalent to and
7383          we have a pending load to that register, we must force out the load
7384          first and then indicate we no longer know what SP's equivalent is.  */
7385       if (info.equiv_reg_src != 0
7386           && reg_referenced_p (info.sp_equiv_reg, PATTERN (insn)))
7387         {
7388           emit_equiv_load (&info);
7389           info.sp_equiv_reg = 0;
7390         }
7391
7392       info.new_sp_equiv_reg = info.sp_equiv_reg;
7393       info.new_sp_offset = info.sp_offset;
7394
7395       /* If this is a (RETURN) and the return address is on the stack,
7396          update the address and change to an indirect jump.  */
7397       if (GET_CODE (PATTERN (insn)) == RETURN
7398           || (GET_CODE (PATTERN (insn)) == PARALLEL
7399               && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == RETURN))
7400         {
7401           rtx retaddr = INCOMING_RETURN_ADDR_RTX;
7402           rtx base = 0;
7403           HOST_WIDE_INT offset = 0;
7404           rtx jump_insn, jump_set;
7405
7406           /* If the return address is in a register, we can emit the insn
7407              unchanged.  Otherwise, it must be a MEM and we see what the
7408              base register and offset are.  In any case, we have to emit any
7409              pending load to the equivalent reg of SP, if any.  */
7410           if (GET_CODE (retaddr) == REG)
7411             {
7412               emit_equiv_load (&info);
7413               add_insn (insn);
7414               insn = next;
7415               continue;
7416             }
7417           else if (GET_CODE (retaddr) == MEM
7418                    && GET_CODE (XEXP (retaddr, 0)) == REG)
7419             base = gen_rtx_REG (Pmode, REGNO (XEXP (retaddr, 0))), offset = 0;
7420           else if (GET_CODE (retaddr) == MEM
7421                    && GET_CODE (XEXP (retaddr, 0)) == PLUS
7422                    && GET_CODE (XEXP (XEXP (retaddr, 0), 0)) == REG
7423                    && GET_CODE (XEXP (XEXP (retaddr, 0), 1)) == CONST_INT)
7424             {
7425               base = gen_rtx_REG (Pmode, REGNO (XEXP (XEXP (retaddr, 0), 0)));
7426               offset = INTVAL (XEXP (XEXP (retaddr, 0), 1));
7427             }
7428           else
7429             abort ();
7430
7431           /* If the base of the location containing the return pointer
7432              is SP, we must update it with the replacement address.  Otherwise,
7433              just build the necessary MEM.  */
7434           retaddr = plus_constant (base, offset);
7435           if (base == stack_pointer_rtx)
7436             retaddr = simplify_replace_rtx (retaddr, stack_pointer_rtx,
7437                                             plus_constant (info.sp_equiv_reg,
7438                                                            info.sp_offset));
7439
7440           retaddr = gen_rtx_MEM (Pmode, retaddr);
7441
7442           /* If there is a pending load to the equivalent register for SP
7443              and we reference that register, we must load our address into
7444              a scratch register and then do that load.  */
7445           if (info.equiv_reg_src
7446               && reg_overlap_mentioned_p (info.equiv_reg_src, retaddr))
7447             {
7448               unsigned int regno;
7449               rtx reg;
7450
7451               for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
7452                 if (HARD_REGNO_MODE_OK (regno, Pmode)
7453                     && !fixed_regs[regno]
7454                     && TEST_HARD_REG_BIT (regs_invalidated_by_call, regno)
7455                     && !REGNO_REG_SET_P (EXIT_BLOCK_PTR->global_live_at_start,
7456                                          regno)
7457                     && !refers_to_regno_p (regno,
7458                                            regno + HARD_REGNO_NREGS (regno,
7459                                                                      Pmode),
7460                                            info.equiv_reg_src, NULL))
7461                   break;
7462
7463               if (regno == FIRST_PSEUDO_REGISTER)
7464                 abort ();
7465
7466               reg = gen_rtx_REG (Pmode, regno);
7467               emit_move_insn (reg, retaddr);
7468               retaddr = reg;
7469             }
7470
7471           emit_equiv_load (&info);
7472           jump_insn = emit_jump_insn (gen_indirect_jump (retaddr));
7473
7474           /* Show the SET in the above insn is a RETURN.  */
7475           jump_set = single_set (jump_insn);
7476           if (jump_set == 0)
7477             abort ();
7478           else
7479             SET_IS_RETURN_P (jump_set) = 1;
7480         }
7481
7482       /* If SP is not mentioned in the pattern and its equivalent register, if
7483          any, is not modified, just emit it.  Otherwise, if neither is set,
7484          replace the reference to SP and emit the insn.  If none of those are
7485          true, handle each SET individually.  */
7486       else if (!reg_mentioned_p (stack_pointer_rtx, PATTERN (insn))
7487                && (info.sp_equiv_reg == stack_pointer_rtx
7488                    || !reg_set_p (info.sp_equiv_reg, insn)))
7489         add_insn (insn);
7490       else if (! reg_set_p (stack_pointer_rtx, insn)
7491                && (info.sp_equiv_reg == stack_pointer_rtx
7492                    || !reg_set_p (info.sp_equiv_reg, insn)))
7493         {
7494           if (! validate_replace_rtx (stack_pointer_rtx,
7495                                       plus_constant (info.sp_equiv_reg,
7496                                                      info.sp_offset),
7497                                       insn))
7498             abort ();
7499
7500           add_insn (insn);
7501         }
7502       else if (GET_CODE (PATTERN (insn)) == SET)
7503         handle_epilogue_set (PATTERN (insn), &info);
7504       else if (GET_CODE (PATTERN (insn)) == PARALLEL)
7505         {
7506           for (j = 0; j < XVECLEN (PATTERN (insn), 0); j++)
7507             if (GET_CODE (XVECEXP (PATTERN (insn), 0, j)) == SET)
7508               handle_epilogue_set (XVECEXP (PATTERN (insn), 0, j), &info);
7509         }
7510       else
7511         add_insn (insn);
7512
7513       info.sp_equiv_reg = info.new_sp_equiv_reg;
7514       info.sp_offset = info.new_sp_offset;
7515
7516       insn = next;
7517     }
7518
7519   insns = get_insns ();
7520   end_sequence ();
7521   return insns;
7522 }
7523
7524 /* SET is a SET from an insn in the epilogue.  P is a pointer to the epi_info
7525    structure that contains information about what we've seen so far.  We
7526    process this SET by either updating that data or by emitting one or
7527    more insns.  */
7528
7529 static void
7530 handle_epilogue_set (set, p)
7531      rtx set;
7532      struct epi_info *p;
7533 {
7534   /* First handle the case where we are setting SP.  Record what it is being
7535      set from.  If unknown, abort.  */
7536   if (reg_set_p (stack_pointer_rtx, set))
7537     {
7538       if (SET_DEST (set) != stack_pointer_rtx)
7539         abort ();
7540
7541       if (GET_CODE (SET_SRC (set)) == PLUS
7542           && GET_CODE (XEXP (SET_SRC (set), 1)) == CONST_INT)
7543         {
7544           p->new_sp_equiv_reg = XEXP (SET_SRC (set), 0);
7545           p->new_sp_offset = INTVAL (XEXP (SET_SRC (set), 1));
7546         }
7547       else
7548         p->new_sp_equiv_reg = SET_SRC (set), p->new_sp_offset = 0;
7549
7550       /* If we are adjusting SP, we adjust from the old data.  */
7551       if (p->new_sp_equiv_reg == stack_pointer_rtx)
7552         {
7553           p->new_sp_equiv_reg = p->sp_equiv_reg;
7554           p->new_sp_offset += p->sp_offset;
7555         }
7556
7557       if (p->new_sp_equiv_reg == 0 || GET_CODE (p->new_sp_equiv_reg) != REG)
7558         abort ();
7559
7560       return;
7561     }
7562
7563   /* Next handle the case where we are setting SP's equivalent register.
7564      If we already have a value to set it to, abort.  We could update, but
7565      there seems little point in handling that case.  Note that we have
7566      to allow for the case where we are setting the register set in
7567      the previous part of a PARALLEL inside a single insn.  But use the
7568      old offset for any updates within this insn.  */
7569   else if (p->new_sp_equiv_reg != 0 && reg_set_p (p->new_sp_equiv_reg, set))
7570     {
7571       if (!rtx_equal_p (p->new_sp_equiv_reg, SET_DEST (set))
7572           || p->equiv_reg_src != 0)
7573         abort ();
7574       else
7575         p->equiv_reg_src
7576           = simplify_replace_rtx (SET_SRC (set), stack_pointer_rtx,
7577                                   plus_constant (p->sp_equiv_reg,
7578                                                  p->sp_offset));
7579     }
7580
7581   /* Otherwise, replace any references to SP in the insn to its new value
7582      and emit the insn.  */
7583   else
7584     {
7585       SET_SRC (set) = simplify_replace_rtx (SET_SRC (set), stack_pointer_rtx,
7586                                             plus_constant (p->sp_equiv_reg,
7587                                                            p->sp_offset));
7588       SET_DEST (set) = simplify_replace_rtx (SET_DEST (set), stack_pointer_rtx,
7589                                              plus_constant (p->sp_equiv_reg,
7590                                                             p->sp_offset));
7591       emit_insn (set);
7592     }
7593 }
7594
7595 /* Emit an insn to do the load shown in p->equiv_reg_src, if needed.  */
7596
7597 static void
7598 emit_equiv_load (p)
7599      struct epi_info *p;
7600 {
7601   if (p->equiv_reg_src != 0)
7602     emit_move_insn (p->sp_equiv_reg, p->equiv_reg_src);
7603
7604   p->equiv_reg_src = 0;
7605 }
7606 #endif
7607
7608 /* Generate the prologue and epilogue RTL if the machine supports it.  Thread
7609    this into place with notes indicating where the prologue ends and where
7610    the epilogue begins.  Update the basic block information when possible.  */
7611
7612 void
7613 thread_prologue_and_epilogue_insns (f)
7614      rtx f ATTRIBUTE_UNUSED;
7615 {
7616   int inserted = 0;
7617   edge e;
7618 #if defined (HAVE_sibcall_epilogue) || defined (HAVE_epilogue) || defined (HAVE_return) || defined (HAVE_prologue)
7619   rtx seq;
7620 #endif
7621 #ifdef HAVE_prologue
7622   rtx prologue_end = NULL_RTX;
7623 #endif
7624 #if defined (HAVE_epilogue) || defined(HAVE_return)
7625   rtx epilogue_end = NULL_RTX;
7626 #endif
7627
7628 #ifdef HAVE_prologue
7629   if (HAVE_prologue)
7630     {
7631       start_sequence ();
7632       seq = gen_prologue ();
7633       emit_insn (seq);
7634
7635       /* Retain a map of the prologue insns.  */
7636       record_insns (seq, &prologue);
7637       prologue_end = emit_note (NULL, NOTE_INSN_PROLOGUE_END);
7638
7639       seq = get_insns ();
7640       end_sequence ();
7641
7642       /* Can't deal with multiple successors of the entry block
7643          at the moment.  Function should always have at least one
7644          entry point.  */
7645       if (!ENTRY_BLOCK_PTR->succ || ENTRY_BLOCK_PTR->succ->succ_next)
7646         abort ();
7647
7648       insert_insn_on_edge (seq, ENTRY_BLOCK_PTR->succ);
7649       inserted = 1;
7650     }
7651 #endif
7652
7653   /* If the exit block has no non-fake predecessors, we don't need
7654      an epilogue.  */
7655   for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
7656     if ((e->flags & EDGE_FAKE) == 0)
7657       break;
7658   if (e == NULL)
7659     goto epilogue_done;
7660
7661 #ifdef HAVE_return
7662   if (optimize && HAVE_return)
7663     {
7664       /* If we're allowed to generate a simple return instruction,
7665          then by definition we don't need a full epilogue.  Examine
7666          the block that falls through to EXIT.   If it does not
7667          contain any code, examine its predecessors and try to
7668          emit (conditional) return instructions.  */
7669
7670       basic_block last;
7671       edge e_next;
7672       rtx label;
7673
7674       for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
7675         if (e->flags & EDGE_FALLTHRU)
7676           break;
7677       if (e == NULL)
7678         goto epilogue_done;
7679       last = e->src;
7680
7681       /* Verify that there are no active instructions in the last block.  */
7682       label = last->end;
7683       while (label && GET_CODE (label) != CODE_LABEL)
7684         {
7685           if (active_insn_p (label))
7686             break;
7687           label = PREV_INSN (label);
7688         }
7689
7690       if (last->head == label && GET_CODE (label) == CODE_LABEL)
7691         {
7692           rtx epilogue_line_note = NULL_RTX;
7693
7694           /* Locate the line number associated with the closing brace,
7695              if we can find one.  */
7696           for (seq = get_last_insn ();
7697                seq && ! active_insn_p (seq);
7698                seq = PREV_INSN (seq))
7699             if (GET_CODE (seq) == NOTE && NOTE_LINE_NUMBER (seq) > 0)
7700               {
7701                 epilogue_line_note = seq;
7702                 break;
7703               }
7704
7705           for (e = last->pred; e; e = e_next)
7706             {
7707               basic_block bb = e->src;
7708               rtx jump;
7709
7710               e_next = e->pred_next;
7711               if (bb == ENTRY_BLOCK_PTR)
7712                 continue;
7713
7714               jump = bb->end;
7715               if ((GET_CODE (jump) != JUMP_INSN) || JUMP_LABEL (jump) != label)
7716                 continue;
7717
7718               /* If we have an unconditional jump, we can replace that
7719                  with a simple return instruction.  */
7720               if (simplejump_p (jump))
7721                 {
7722                   emit_return_into_block (bb, epilogue_line_note);
7723                   delete_insn (jump);
7724                 }
7725
7726               /* If we have a conditional jump, we can try to replace
7727                  that with a conditional return instruction.  */
7728               else if (condjump_p (jump))
7729                 {
7730                   if (! redirect_jump (jump, 0, 0))
7731                     continue;
7732
7733                   /* If this block has only one successor, it both jumps
7734                      and falls through to the fallthru block, so we can't
7735                      delete the edge.  */
7736                   if (bb->succ->succ_next == NULL)
7737                     continue;
7738                 }
7739               else
7740                 continue;
7741
7742               /* Fix up the CFG for the successful change we just made.  */
7743               redirect_edge_succ (e, EXIT_BLOCK_PTR);
7744             }
7745
7746           /* Emit a return insn for the exit fallthru block.  Whether
7747              this is still reachable will be determined later.  */
7748
7749           emit_barrier_after (last->end);
7750           emit_return_into_block (last, epilogue_line_note);
7751           epilogue_end = last->end;
7752           last->succ->flags &= ~EDGE_FALLTHRU;
7753           goto epilogue_done;
7754         }
7755     }
7756 #endif
7757 #ifdef HAVE_epilogue
7758   if (HAVE_epilogue)
7759     {
7760       /* Find the edge that falls through to EXIT.  Other edges may exist
7761          due to RETURN instructions, but those don't need epilogues.
7762          There really shouldn't be a mixture -- either all should have
7763          been converted or none, however...  */
7764
7765       for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
7766         if (e->flags & EDGE_FALLTHRU)
7767           break;
7768       if (e == NULL)
7769         goto epilogue_done;
7770
7771       start_sequence ();
7772       epilogue_end = emit_note (NULL, NOTE_INSN_EPILOGUE_BEG);
7773
7774       seq = gen_epilogue ();
7775
7776 #ifdef INCOMING_RETURN_ADDR_RTX
7777       /* If this function returns with the stack depressed and we can support
7778          it, massage the epilogue to actually do that.  */
7779       if (TREE_CODE (TREE_TYPE (current_function_decl)) == FUNCTION_TYPE
7780           && TYPE_RETURNS_STACK_DEPRESSED (TREE_TYPE (current_function_decl)))
7781         seq = keep_stack_depressed (seq);
7782 #endif
7783
7784       emit_jump_insn (seq);
7785
7786       /* Retain a map of the epilogue insns.  */
7787       record_insns (seq, &epilogue);
7788
7789       seq = get_insns ();
7790       end_sequence ();
7791
7792       insert_insn_on_edge (seq, e);
7793       inserted = 1;
7794     }
7795 #endif
7796 epilogue_done:
7797
7798   if (inserted)
7799     commit_edge_insertions ();
7800
7801 #ifdef HAVE_sibcall_epilogue
7802   /* Emit sibling epilogues before any sibling call sites.  */
7803   for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
7804     {
7805       basic_block bb = e->src;
7806       rtx insn = bb->end;
7807       rtx i;
7808       rtx newinsn;
7809
7810       if (GET_CODE (insn) != CALL_INSN
7811           || ! SIBLING_CALL_P (insn))
7812         continue;
7813
7814       start_sequence ();
7815       emit_insn (gen_sibcall_epilogue ());
7816       seq = get_insns ();
7817       end_sequence ();
7818
7819       /* Retain a map of the epilogue insns.  Used in life analysis to
7820          avoid getting rid of sibcall epilogue insns.  Do this before we
7821          actually emit the sequence.  */
7822       record_insns (seq, &sibcall_epilogue);
7823
7824       i = PREV_INSN (insn);
7825       newinsn = emit_insn_before (seq, insn);
7826     }
7827 #endif
7828
7829 #ifdef HAVE_prologue
7830   if (prologue_end)
7831     {
7832       rtx insn, prev;
7833
7834       /* GDB handles `break f' by setting a breakpoint on the first
7835          line note after the prologue.  Which means (1) that if
7836          there are line number notes before where we inserted the
7837          prologue we should move them, and (2) we should generate a
7838          note before the end of the first basic block, if there isn't
7839          one already there.
7840
7841          ??? This behavior is completely broken when dealing with
7842          multiple entry functions.  We simply place the note always
7843          into first basic block and let alternate entry points
7844          to be missed.
7845        */
7846
7847       for (insn = prologue_end; insn; insn = prev)
7848         {
7849           prev = PREV_INSN (insn);
7850           if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
7851             {
7852               /* Note that we cannot reorder the first insn in the
7853                  chain, since rest_of_compilation relies on that
7854                  remaining constant.  */
7855               if (prev == NULL)
7856                 break;
7857               reorder_insns (insn, insn, prologue_end);
7858             }
7859         }
7860
7861       /* Find the last line number note in the first block.  */
7862       for (insn = ENTRY_BLOCK_PTR->next_bb->end;
7863            insn != prologue_end && insn;
7864            insn = PREV_INSN (insn))
7865         if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
7866           break;
7867
7868       /* If we didn't find one, make a copy of the first line number
7869          we run across.  */
7870       if (! insn)
7871         {
7872           for (insn = next_active_insn (prologue_end);
7873                insn;
7874                insn = PREV_INSN (insn))
7875             if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
7876               {
7877                 emit_line_note_after (NOTE_SOURCE_FILE (insn),
7878                                       NOTE_LINE_NUMBER (insn),
7879                                       prologue_end);
7880                 break;
7881               }
7882         }
7883     }
7884 #endif
7885 #ifdef HAVE_epilogue
7886   if (epilogue_end)
7887     {
7888       rtx insn, next;
7889
7890       /* Similarly, move any line notes that appear after the epilogue.
7891          There is no need, however, to be quite so anal about the existence
7892          of such a note.  */
7893       for (insn = epilogue_end; insn; insn = next)
7894         {
7895           next = NEXT_INSN (insn);
7896           if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
7897             reorder_insns (insn, insn, PREV_INSN (epilogue_end));
7898         }
7899     }
7900 #endif
7901 }
7902
7903 /* Reposition the prologue-end and epilogue-begin notes after instruction
7904    scheduling and delayed branch scheduling.  */
7905
7906 void
7907 reposition_prologue_and_epilogue_notes (f)
7908      rtx f ATTRIBUTE_UNUSED;
7909 {
7910 #if defined (HAVE_prologue) || defined (HAVE_epilogue)
7911   rtx insn, last, note;
7912   int len;
7913
7914   if ((len = VARRAY_SIZE (prologue)) > 0)
7915     {
7916       last = 0, note = 0;
7917
7918       /* Scan from the beginning until we reach the last prologue insn.
7919          We apparently can't depend on basic_block_{head,end} after
7920          reorg has run.  */
7921       for (insn = f; insn; insn = NEXT_INSN (insn))
7922         {
7923           if (GET_CODE (insn) == NOTE)
7924             {
7925               if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PROLOGUE_END)
7926                 note = insn;
7927             }
7928           else if (contains (insn, prologue))
7929             {
7930               last = insn;
7931               if (--len == 0)
7932                 break;
7933             }
7934         }
7935
7936       if (last)
7937         {
7938           /* Find the prologue-end note if we haven't already, and
7939              move it to just after the last prologue insn.  */
7940           if (note == 0)
7941             {
7942               for (note = last; (note = NEXT_INSN (note));)
7943                 if (GET_CODE (note) == NOTE
7944                     && NOTE_LINE_NUMBER (note) == NOTE_INSN_PROLOGUE_END)
7945                   break;
7946             }
7947
7948           /* Avoid placing note between CODE_LABEL and BASIC_BLOCK note.  */
7949           if (GET_CODE (last) == CODE_LABEL)
7950             last = NEXT_INSN (last);
7951           reorder_insns (note, note, last);
7952         }
7953     }
7954
7955   if ((len = VARRAY_SIZE (epilogue)) > 0)
7956     {
7957       last = 0, note = 0;
7958
7959       /* Scan from the end until we reach the first epilogue insn.
7960          We apparently can't depend on basic_block_{head,end} after
7961          reorg has run.  */
7962       for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
7963         {
7964           if (GET_CODE (insn) == NOTE)
7965             {
7966               if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EPILOGUE_BEG)
7967                 note = insn;
7968             }
7969           else if (contains (insn, epilogue))
7970             {
7971               last = insn;
7972               if (--len == 0)
7973                 break;
7974             }
7975         }
7976
7977       if (last)
7978         {
7979           /* Find the epilogue-begin note if we haven't already, and
7980              move it to just before the first epilogue insn.  */
7981           if (note == 0)
7982             {
7983               for (note = insn; (note = PREV_INSN (note));)
7984                 if (GET_CODE (note) == NOTE
7985                     && NOTE_LINE_NUMBER (note) == NOTE_INSN_EPILOGUE_BEG)
7986                   break;
7987             }
7988
7989           if (PREV_INSN (last) != note)
7990             reorder_insns (note, note, PREV_INSN (last));
7991         }
7992     }
7993 #endif /* HAVE_prologue or HAVE_epilogue */
7994 }
7995
7996 /* Called once, at initialization, to initialize function.c.  */
7997
7998 void
7999 init_function_once ()
8000 {
8001   VARRAY_INT_INIT (prologue, 0, "prologue");
8002   VARRAY_INT_INIT (epilogue, 0, "epilogue");
8003   VARRAY_INT_INIT (sibcall_epilogue, 0, "sibcall_epilogue");
8004 }
8005
8006 #include "gt-function.h"