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   CUMULATIVE_ARGS args_so_far;
4344   /* Total space needed so far for args on the stack,
4345      given as a constant and a tree-expression.  */
4346   struct args_size stack_args_size;
4347   tree fntype = TREE_TYPE (fndecl);
4348   tree fnargs = DECL_ARGUMENTS (fndecl);
4349   /* This is used for the arg pointer when referring to stack args.  */
4350   rtx internal_arg_pointer;
4351   /* This is a dummy PARM_DECL that we used for the function result if
4352      the function returns a structure.  */
4353   tree function_result_decl = 0;
4354 #ifdef SETUP_INCOMING_VARARGS
4355   int varargs_setup = 0;
4356 #endif
4357   int reg_parm_stack_space = 0;
4358   rtx conversion_insns = 0;
4359
4360   /* Nonzero if function takes extra anonymous args.
4361      This means the last named arg must be on the stack
4362      right before the anonymous ones.  */
4363   int stdarg
4364     = (TYPE_ARG_TYPES (fntype) != 0
4365        && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
4366            != void_type_node));
4367
4368   current_function_stdarg = stdarg;
4369
4370   /* If the reg that the virtual arg pointer will be translated into is
4371      not a fixed reg or is the stack pointer, make a copy of the virtual
4372      arg pointer, and address parms via the copy.  The frame pointer is
4373      considered fixed even though it is not marked as such.
4374
4375      The second time through, simply use ap to avoid generating rtx.  */
4376
4377   if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
4378        || ! (fixed_regs[ARG_POINTER_REGNUM]
4379              || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
4380     internal_arg_pointer = copy_to_reg (virtual_incoming_args_rtx);
4381   else
4382     internal_arg_pointer = virtual_incoming_args_rtx;
4383   current_function_internal_arg_pointer = internal_arg_pointer;
4384
4385   stack_args_size.constant = 0;
4386   stack_args_size.var = 0;
4387
4388   /* If struct value address is treated as the first argument, make it so.  */
4389   if (aggregate_value_p (DECL_RESULT (fndecl))
4390       && ! current_function_returns_pcc_struct
4391       && struct_value_incoming_rtx == 0)
4392     {
4393       tree type = build_pointer_type (TREE_TYPE (fntype));
4394
4395       function_result_decl = build_decl (PARM_DECL, NULL_TREE, type);
4396
4397       DECL_ARG_TYPE (function_result_decl) = type;
4398       TREE_CHAIN (function_result_decl) = fnargs;
4399       fnargs = function_result_decl;
4400     }
4401
4402   max_parm_reg = LAST_VIRTUAL_REGISTER + 1;
4403   parm_reg_stack_loc = (rtx *) ggc_alloc_cleared (max_parm_reg * sizeof (rtx));
4404
4405 #ifdef REG_PARM_STACK_SPACE
4406 #ifdef MAYBE_REG_PARM_STACK_SPACE
4407   reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
4408 #else
4409   reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
4410 #endif
4411 #endif
4412
4413 #ifdef INIT_CUMULATIVE_INCOMING_ARGS
4414   INIT_CUMULATIVE_INCOMING_ARGS (args_so_far, fntype, NULL_RTX);
4415 #else
4416   INIT_CUMULATIVE_ARGS (args_so_far, fntype, NULL_RTX, fndecl);
4417 #endif
4418
4419   /* We haven't yet found an argument that we must push and pretend the
4420      caller did.  */
4421   current_function_pretend_args_size = 0;
4422
4423   for (parm = fnargs; parm; parm = TREE_CHAIN (parm))
4424     {
4425       rtx entry_parm;
4426       rtx stack_parm;
4427       enum machine_mode promoted_mode, passed_mode;
4428       enum machine_mode nominal_mode, promoted_nominal_mode;
4429       int unsignedp;
4430       struct locate_and_pad_arg_data locate;
4431       int passed_pointer = 0;
4432       int did_conversion = 0;
4433       tree passed_type = DECL_ARG_TYPE (parm);
4434       tree nominal_type = TREE_TYPE (parm);
4435       int last_named = 0, named_arg;
4436       int in_regs;
4437       int partial = 0;
4438
4439       /* Set LAST_NAMED if this is last named arg before last
4440          anonymous args.  */
4441       if (stdarg)
4442         {
4443           tree tem;
4444
4445           for (tem = TREE_CHAIN (parm); tem; tem = TREE_CHAIN (tem))
4446             if (DECL_NAME (tem))
4447               break;
4448
4449           if (tem == 0)
4450             last_named = 1;
4451         }
4452       /* Set NAMED_ARG if this arg should be treated as a named arg.  For
4453          most machines, if this is a varargs/stdarg function, then we treat
4454          the last named arg as if it were anonymous too.  */
4455       named_arg = STRICT_ARGUMENT_NAMING ? 1 : ! last_named;
4456
4457       if (TREE_TYPE (parm) == error_mark_node
4458           /* This can happen after weird syntax errors
4459              or if an enum type is defined among the parms.  */
4460           || TREE_CODE (parm) != PARM_DECL
4461           || passed_type == NULL)
4462         {
4463           SET_DECL_RTL (parm, gen_rtx_MEM (BLKmode, const0_rtx));
4464           DECL_INCOMING_RTL (parm) = DECL_RTL (parm);
4465           TREE_USED (parm) = 1;
4466           continue;
4467         }
4468
4469       /* Find mode of arg as it is passed, and mode of arg
4470          as it should be during execution of this function.  */
4471       passed_mode = TYPE_MODE (passed_type);
4472       nominal_mode = TYPE_MODE (nominal_type);
4473
4474       /* If the parm's mode is VOID, its value doesn't matter,
4475          and avoid the usual things like emit_move_insn that could crash.  */
4476       if (nominal_mode == VOIDmode)
4477         {
4478           SET_DECL_RTL (parm, const0_rtx);
4479           DECL_INCOMING_RTL (parm) = DECL_RTL (parm);
4480           continue;
4481         }
4482
4483       /* If the parm is to be passed as a transparent union, use the
4484          type of the first field for the tests below.  We have already
4485          verified that the modes are the same.  */
4486       if (DECL_TRANSPARENT_UNION (parm)
4487           || (TREE_CODE (passed_type) == UNION_TYPE
4488               && TYPE_TRANSPARENT_UNION (passed_type)))
4489         passed_type = TREE_TYPE (TYPE_FIELDS (passed_type));
4490
4491       /* See if this arg was passed by invisible reference.  It is if
4492          it is an object whose size depends on the contents of the
4493          object itself or if the machine requires these objects be passed
4494          that way.  */
4495
4496       if ((TREE_CODE (TYPE_SIZE (passed_type)) != INTEGER_CST
4497            && contains_placeholder_p (TYPE_SIZE (passed_type)))
4498           || TREE_ADDRESSABLE (passed_type)
4499 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
4500           || FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, passed_mode,
4501                                              passed_type, named_arg)
4502 #endif
4503           )
4504         {
4505           passed_type = nominal_type = build_pointer_type (passed_type);
4506           passed_pointer = 1;
4507           passed_mode = nominal_mode = Pmode;
4508         }
4509       /* See if the frontend wants to pass this by invisible reference.  */
4510       else if (passed_type != nominal_type
4511                && POINTER_TYPE_P (passed_type)
4512                && TREE_TYPE (passed_type) == nominal_type)
4513         {
4514           nominal_type = passed_type;
4515           passed_pointer = 1;
4516           passed_mode = nominal_mode = Pmode;
4517         }
4518
4519       promoted_mode = passed_mode;
4520
4521 #ifdef PROMOTE_FUNCTION_ARGS
4522       /* Compute the mode in which the arg is actually extended to.  */
4523       unsignedp = TREE_UNSIGNED (passed_type);
4524       promoted_mode = promote_mode (passed_type, promoted_mode, &unsignedp, 1);
4525 #endif
4526
4527       /* Let machine desc say which reg (if any) the parm arrives in.
4528          0 means it arrives on the stack.  */
4529 #ifdef FUNCTION_INCOMING_ARG
4530       entry_parm = FUNCTION_INCOMING_ARG (args_so_far, promoted_mode,
4531                                           passed_type, named_arg);
4532 #else
4533       entry_parm = FUNCTION_ARG (args_so_far, promoted_mode,
4534                                  passed_type, named_arg);
4535 #endif
4536
4537       if (entry_parm == 0)
4538         promoted_mode = passed_mode;
4539
4540 #ifdef SETUP_INCOMING_VARARGS
4541       /* If this is the last named parameter, do any required setup for
4542          varargs or stdargs.  We need to know about the case of this being an
4543          addressable type, in which case we skip the registers it
4544          would have arrived in.
4545
4546          For stdargs, LAST_NAMED will be set for two parameters, the one that
4547          is actually the last named, and the dummy parameter.  We only
4548          want to do this action once.
4549
4550          Also, indicate when RTL generation is to be suppressed.  */
4551       if (last_named && !varargs_setup)
4552         {
4553           SETUP_INCOMING_VARARGS (args_so_far, promoted_mode, passed_type,
4554                                   current_function_pretend_args_size, 0);
4555           varargs_setup = 1;
4556         }
4557 #endif
4558
4559       /* Determine parm's home in the stack,
4560          in case it arrives in the stack or we should pretend it did.
4561
4562          Compute the stack position and rtx where the argument arrives
4563          and its size.
4564
4565          There is one complexity here:  If this was a parameter that would
4566          have been passed in registers, but wasn't only because it is
4567          __builtin_va_alist, we want locate_and_pad_parm to treat it as if
4568          it came in a register so that REG_PARM_STACK_SPACE isn't skipped.
4569          In this case, we call FUNCTION_ARG with NAMED set to 1 instead of
4570          0 as it was the previous time.  */
4571       in_regs = entry_parm != 0;
4572 #ifdef STACK_PARMS_IN_REG_PARM_AREA
4573       in_regs = 1;
4574 #endif
4575       if (!in_regs && !named_arg)
4576         {
4577           int pretend_named = PRETEND_OUTGOING_VARARGS_NAMED;
4578           if (pretend_named)
4579             {
4580 #ifdef FUNCTION_INCOMING_ARG
4581               in_regs = FUNCTION_INCOMING_ARG (args_so_far, promoted_mode,
4582                                                passed_type,
4583                                                pretend_named) != 0;
4584 #else
4585               in_regs = FUNCTION_ARG (args_so_far, promoted_mode,
4586                                       passed_type,
4587                                       pretend_named) != 0;
4588 #endif
4589             }
4590         }
4591
4592       /* If this parameter was passed both in registers and in the stack,
4593          use the copy on the stack.  */
4594       if (MUST_PASS_IN_STACK (promoted_mode, passed_type))
4595         entry_parm = 0;
4596
4597 #ifdef FUNCTION_ARG_PARTIAL_NREGS
4598       if (entry_parm)
4599         partial = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, promoted_mode,
4600                                               passed_type, named_arg);
4601 #endif
4602
4603       memset (&locate, 0, sizeof (locate));
4604       locate_and_pad_parm (promoted_mode, passed_type, in_regs,
4605                            entry_parm ? partial : 0, fndecl,
4606                            &stack_args_size, &locate);
4607
4608       {
4609         rtx offset_rtx;
4610
4611         /* If we're passing this arg using a reg, make its stack home
4612            the aligned stack slot.  */
4613         if (entry_parm)
4614           offset_rtx = ARGS_SIZE_RTX (locate.slot_offset);
4615         else
4616           offset_rtx = ARGS_SIZE_RTX (locate.offset);
4617
4618         if (offset_rtx == const0_rtx)
4619           stack_parm = gen_rtx_MEM (promoted_mode, internal_arg_pointer);
4620         else
4621           stack_parm = gen_rtx_MEM (promoted_mode,
4622                                     gen_rtx_PLUS (Pmode,
4623                                                   internal_arg_pointer,
4624                                                   offset_rtx));
4625
4626         set_mem_attributes (stack_parm, parm, 1);
4627
4628         /* Set also REG_ATTRS if parameter was passed in a register.  */
4629         if (entry_parm)
4630           set_reg_attrs_for_parm (entry_parm, stack_parm);
4631       }
4632
4633       /* If this parm was passed part in regs and part in memory,
4634          pretend it arrived entirely in memory
4635          by pushing the register-part onto the stack.
4636
4637          In the special case of a DImode or DFmode that is split,
4638          we could put it together in a pseudoreg directly,
4639          but for now that's not worth bothering with.  */
4640
4641       if (partial)
4642         {
4643 #ifndef MAYBE_REG_PARM_STACK_SPACE
4644           /* When REG_PARM_STACK_SPACE is nonzero, stack space for
4645              split parameters was allocated by our caller, so we
4646              won't be pushing it in the prolog.  */
4647           if (reg_parm_stack_space)
4648 #endif
4649           current_function_pretend_args_size
4650             = (((partial * UNITS_PER_WORD) + (PARM_BOUNDARY / BITS_PER_UNIT) - 1)
4651                / (PARM_BOUNDARY / BITS_PER_UNIT)
4652                * (PARM_BOUNDARY / BITS_PER_UNIT));
4653
4654           /* Handle calls that pass values in multiple non-contiguous
4655              locations.  The Irix 6 ABI has examples of this.  */
4656           if (GET_CODE (entry_parm) == PARALLEL)
4657             emit_group_store (validize_mem (stack_parm), entry_parm,
4658                               int_size_in_bytes (TREE_TYPE (parm)));
4659
4660           else
4661             move_block_from_reg (REGNO (entry_parm), validize_mem (stack_parm),
4662                                  partial, int_size_in_bytes (TREE_TYPE (parm)));
4663
4664           entry_parm = stack_parm;
4665         }
4666
4667       /* If we didn't decide this parm came in a register,
4668          by default it came on the stack.  */
4669       if (entry_parm == 0)
4670         entry_parm = stack_parm;
4671
4672       /* Record permanently how this parm was passed.  */
4673       DECL_INCOMING_RTL (parm) = entry_parm;
4674
4675       /* If there is actually space on the stack for this parm,
4676          count it in stack_args_size; otherwise set stack_parm to 0
4677          to indicate there is no preallocated stack slot for the parm.  */
4678
4679       if (entry_parm == stack_parm
4680           || (GET_CODE (entry_parm) == PARALLEL
4681               && XEXP (XVECEXP (entry_parm, 0, 0), 0) == NULL_RTX)
4682 #if defined (REG_PARM_STACK_SPACE) && ! defined (MAYBE_REG_PARM_STACK_SPACE)
4683           /* On some machines, even if a parm value arrives in a register
4684              there is still an (uninitialized) stack slot allocated for it.
4685
4686              ??? When MAYBE_REG_PARM_STACK_SPACE is defined, we can't tell
4687              whether this parameter already has a stack slot allocated,
4688              because an arg block exists only if current_function_args_size
4689              is larger than some threshold, and we haven't calculated that
4690              yet.  So, for now, we just assume that stack slots never exist
4691              in this case.  */
4692           || REG_PARM_STACK_SPACE (fndecl) > 0
4693 #endif
4694           )
4695         {
4696           stack_args_size.constant += locate.size.constant;
4697           if (locate.size.var)
4698             ADD_PARM_SIZE (stack_args_size, locate.size.var);
4699         }
4700       else
4701         /* No stack slot was pushed for this parm.  */
4702         stack_parm = 0;
4703
4704       /* Update info on where next arg arrives in registers.  */
4705
4706       FUNCTION_ARG_ADVANCE (args_so_far, promoted_mode,
4707                             passed_type, named_arg);
4708
4709       /* If we can't trust the parm stack slot to be aligned enough
4710          for its ultimate type, don't use that slot after entry.
4711          We'll make another stack slot, if we need one.  */
4712       {
4713         unsigned int thisparm_boundary
4714           = FUNCTION_ARG_BOUNDARY (promoted_mode, passed_type);
4715
4716         if (GET_MODE_ALIGNMENT (nominal_mode) > thisparm_boundary)
4717           stack_parm = 0;
4718       }
4719
4720       /* If parm was passed in memory, and we need to convert it on entry,
4721          don't store it back in that same slot.  */
4722       if (entry_parm == stack_parm
4723           && nominal_mode != BLKmode && nominal_mode != passed_mode)
4724         stack_parm = 0;
4725
4726       /* When an argument is passed in multiple locations, we can't
4727          make use of this information, but we can save some copying if
4728          the whole argument is passed in a single register.  */
4729       if (GET_CODE (entry_parm) == PARALLEL
4730           && nominal_mode != BLKmode && passed_mode != BLKmode)
4731         {
4732           int i, len = XVECLEN (entry_parm, 0);
4733
4734           for (i = 0; i < len; i++)
4735             if (XEXP (XVECEXP (entry_parm, 0, i), 0) != NULL_RTX
4736                 && GET_CODE (XEXP (XVECEXP (entry_parm, 0, i), 0)) == REG
4737                 && (GET_MODE (XEXP (XVECEXP (entry_parm, 0, i), 0))
4738                     == passed_mode)
4739                 && INTVAL (XEXP (XVECEXP (entry_parm, 0, i), 1)) == 0)
4740               {
4741                 entry_parm = XEXP (XVECEXP (entry_parm, 0, i), 0);
4742                 DECL_INCOMING_RTL (parm) = entry_parm;
4743                 break;
4744               }
4745         }
4746
4747       /* ENTRY_PARM is an RTX for the parameter as it arrives,
4748          in the mode in which it arrives.
4749          STACK_PARM is an RTX for a stack slot where the parameter can live
4750          during the function (in case we want to put it there).
4751          STACK_PARM is 0 if no stack slot was pushed for it.
4752
4753          Now output code if necessary to convert ENTRY_PARM to
4754          the type in which this function declares it,
4755          and store that result in an appropriate place,
4756          which may be a pseudo reg, may be STACK_PARM,
4757          or may be a local stack slot if STACK_PARM is 0.
4758
4759          Set DECL_RTL to that place.  */
4760
4761       if (nominal_mode == BLKmode || GET_CODE (entry_parm) == PARALLEL)
4762         {
4763           /* If a BLKmode arrives in registers, copy it to a stack slot.
4764              Handle calls that pass values in multiple non-contiguous
4765              locations.  The Irix 6 ABI has examples of this.  */
4766           if (GET_CODE (entry_parm) == REG
4767               || GET_CODE (entry_parm) == PARALLEL)
4768             {
4769               int size_stored
4770                 = CEIL_ROUND (int_size_in_bytes (TREE_TYPE (parm)),
4771                               UNITS_PER_WORD);
4772
4773               /* Note that we will be storing an integral number of words.
4774                  So we have to be careful to ensure that we allocate an
4775                  integral number of words.  We do this below in the
4776                  assign_stack_local if space was not allocated in the argument
4777                  list.  If it was, this will not work if PARM_BOUNDARY is not
4778                  a multiple of BITS_PER_WORD.  It isn't clear how to fix this
4779                  if it becomes a problem.  */
4780
4781               if (stack_parm == 0)
4782                 {
4783                   stack_parm
4784                     = assign_stack_local (GET_MODE (entry_parm),
4785                                           size_stored, 0);
4786                   set_mem_attributes (stack_parm, parm, 1);
4787                 }
4788
4789               else if (PARM_BOUNDARY % BITS_PER_WORD != 0)
4790                 abort ();
4791
4792               /* Handle calls that pass values in multiple non-contiguous
4793                  locations.  The Irix 6 ABI has examples of this.  */
4794               if (GET_CODE (entry_parm) == PARALLEL)
4795                 emit_group_store (validize_mem (stack_parm), entry_parm,
4796                                   int_size_in_bytes (TREE_TYPE (parm)));
4797               else
4798                 move_block_from_reg (REGNO (entry_parm),
4799                                      validize_mem (stack_parm),
4800                                      size_stored / UNITS_PER_WORD,
4801                                      int_size_in_bytes (TREE_TYPE (parm)));
4802             }
4803           SET_DECL_RTL (parm, stack_parm);
4804         }
4805       else if (! ((! optimize
4806                    && ! DECL_REGISTER (parm))
4807                   || TREE_SIDE_EFFECTS (parm)
4808                   /* If -ffloat-store specified, don't put explicit
4809                      float variables into registers.  */
4810                   || (flag_float_store
4811                       && TREE_CODE (TREE_TYPE (parm)) == REAL_TYPE))
4812                /* Always assign pseudo to structure return or item passed
4813                   by invisible reference.  */
4814                || passed_pointer || parm == function_result_decl)
4815         {
4816           /* Store the parm in a pseudoregister during the function, but we
4817              may need to do it in a wider mode.  */
4818
4819           rtx parmreg;
4820           unsigned int regno, regnoi = 0, regnor = 0;
4821
4822           unsignedp = TREE_UNSIGNED (TREE_TYPE (parm));
4823
4824           promoted_nominal_mode
4825             = promote_mode (TREE_TYPE (parm), nominal_mode, &unsignedp, 0);
4826
4827           parmreg = gen_reg_rtx (promoted_nominal_mode);
4828           mark_user_reg (parmreg);
4829
4830           /* If this was an item that we received a pointer to, set DECL_RTL
4831              appropriately.  */
4832           if (passed_pointer)
4833             {
4834               rtx x = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (passed_type)),
4835                                    parmreg);
4836               set_mem_attributes (x, parm, 1);
4837               SET_DECL_RTL (parm, x);
4838             }
4839           else
4840             {
4841               SET_DECL_RTL (parm, parmreg);
4842               maybe_set_unchanging (DECL_RTL (parm), parm);
4843             }
4844
4845           /* Copy the value into the register.  */
4846           if (nominal_mode != passed_mode
4847               || promoted_nominal_mode != promoted_mode)
4848             {
4849               int save_tree_used;
4850               /* ENTRY_PARM has been converted to PROMOTED_MODE, its
4851                  mode, by the caller.  We now have to convert it to
4852                  NOMINAL_MODE, if different.  However, PARMREG may be in
4853                  a different mode than NOMINAL_MODE if it is being stored
4854                  promoted.
4855
4856                  If ENTRY_PARM is a hard register, it might be in a register
4857                  not valid for operating in its mode (e.g., an odd-numbered
4858                  register for a DFmode).  In that case, moves are the only
4859                  thing valid, so we can't do a convert from there.  This
4860                  occurs when the calling sequence allow such misaligned
4861                  usages.
4862
4863                  In addition, the conversion may involve a call, which could
4864                  clobber parameters which haven't been copied to pseudo
4865                  registers yet.  Therefore, we must first copy the parm to
4866                  a pseudo reg here, and save the conversion until after all
4867                  parameters have been moved.  */
4868
4869               rtx tempreg = gen_reg_rtx (GET_MODE (entry_parm));
4870
4871               emit_move_insn (tempreg, validize_mem (entry_parm));
4872
4873               push_to_sequence (conversion_insns);
4874               tempreg = convert_to_mode (nominal_mode, tempreg, unsignedp);
4875
4876               if (GET_CODE (tempreg) == SUBREG
4877                   && GET_MODE (tempreg) == nominal_mode
4878                   && GET_CODE (SUBREG_REG (tempreg)) == REG
4879                   && nominal_mode == passed_mode
4880                   && GET_MODE (SUBREG_REG (tempreg)) == GET_MODE (entry_parm)
4881                   && GET_MODE_SIZE (GET_MODE (tempreg))
4882                      < GET_MODE_SIZE (GET_MODE (entry_parm)))
4883                 {
4884                   /* The argument is already sign/zero extended, so note it
4885                      into the subreg.  */
4886                   SUBREG_PROMOTED_VAR_P (tempreg) = 1;
4887                   SUBREG_PROMOTED_UNSIGNED_SET (tempreg, unsignedp);
4888                 }
4889
4890               /* TREE_USED gets set erroneously during expand_assignment.  */
4891               save_tree_used = TREE_USED (parm);
4892               expand_assignment (parm,
4893                                  make_tree (nominal_type, tempreg), 0, 0);
4894               TREE_USED (parm) = save_tree_used;
4895               conversion_insns = get_insns ();
4896               did_conversion = 1;
4897               end_sequence ();
4898             }
4899           else
4900             emit_move_insn (parmreg, validize_mem (entry_parm));
4901
4902           /* If we were passed a pointer but the actual value
4903              can safely live in a register, put it in one.  */
4904           if (passed_pointer && TYPE_MODE (TREE_TYPE (parm)) != BLKmode
4905               /* If by-reference argument was promoted, demote it.  */
4906               && (TYPE_MODE (TREE_TYPE (parm)) != GET_MODE (DECL_RTL (parm))
4907                   || ! ((! optimize
4908                          && ! DECL_REGISTER (parm))
4909                         || TREE_SIDE_EFFECTS (parm)
4910                         /* If -ffloat-store specified, don't put explicit
4911                            float variables into registers.  */
4912                         || (flag_float_store
4913                             && TREE_CODE (TREE_TYPE (parm)) == REAL_TYPE))))
4914             {
4915               /* We can't use nominal_mode, because it will have been set to
4916                  Pmode above.  We must use the actual mode of the parm.  */
4917               parmreg = gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm)));
4918               mark_user_reg (parmreg);
4919               if (GET_MODE (parmreg) != GET_MODE (DECL_RTL (parm)))
4920                 {
4921                   rtx tempreg = gen_reg_rtx (GET_MODE (DECL_RTL (parm)));
4922                   int unsigned_p = TREE_UNSIGNED (TREE_TYPE (parm));
4923                   push_to_sequence (conversion_insns);
4924                   emit_move_insn (tempreg, DECL_RTL (parm));
4925                   SET_DECL_RTL (parm,
4926                                 convert_to_mode (GET_MODE (parmreg),
4927                                                  tempreg,
4928                                                  unsigned_p));
4929                   emit_move_insn (parmreg, DECL_RTL (parm));
4930                   conversion_insns = get_insns();
4931                   did_conversion = 1;
4932                   end_sequence ();
4933                 }
4934               else
4935                 emit_move_insn (parmreg, DECL_RTL (parm));
4936               SET_DECL_RTL (parm, parmreg);
4937               /* STACK_PARM is the pointer, not the parm, and PARMREG is
4938                  now the parm.  */
4939               stack_parm = 0;
4940             }
4941 #ifdef FUNCTION_ARG_CALLEE_COPIES
4942           /* If we are passed an arg by reference and it is our responsibility
4943              to make a copy, do it now.
4944              PASSED_TYPE and PASSED mode now refer to the pointer, not the
4945              original argument, so we must recreate them in the call to
4946              FUNCTION_ARG_CALLEE_COPIES.  */
4947           /* ??? Later add code to handle the case that if the argument isn't
4948              modified, don't do the copy.  */
4949
4950           else if (passed_pointer
4951                    && FUNCTION_ARG_CALLEE_COPIES (args_so_far,
4952                                                   TYPE_MODE (DECL_ARG_TYPE (parm)),
4953                                                   DECL_ARG_TYPE (parm),
4954                                                   named_arg)
4955                    && ! TREE_ADDRESSABLE (DECL_ARG_TYPE (parm)))
4956             {
4957               rtx copy;
4958               tree type = DECL_ARG_TYPE (parm);
4959
4960               /* This sequence may involve a library call perhaps clobbering
4961                  registers that haven't been copied to pseudos yet.  */
4962
4963               push_to_sequence (conversion_insns);
4964
4965               if (!COMPLETE_TYPE_P (type)
4966                   || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4967                 /* This is a variable sized object.  */
4968                 copy = gen_rtx_MEM (BLKmode,
4969                                     allocate_dynamic_stack_space
4970                                     (expr_size (parm), NULL_RTX,
4971                                      TYPE_ALIGN (type)));
4972               else
4973                 copy = assign_stack_temp (TYPE_MODE (type),
4974                                           int_size_in_bytes (type), 1);
4975               set_mem_attributes (copy, parm, 1);
4976
4977               store_expr (parm, copy, 0);
4978               emit_move_insn (parmreg, XEXP (copy, 0));
4979               conversion_insns = get_insns ();
4980               did_conversion = 1;
4981               end_sequence ();
4982             }
4983 #endif /* FUNCTION_ARG_CALLEE_COPIES */
4984
4985           /* In any case, record the parm's desired stack location
4986              in case we later discover it must live in the stack.
4987
4988              If it is a COMPLEX value, store the stack location for both
4989              halves.  */
4990
4991           if (GET_CODE (parmreg) == CONCAT)
4992             regno = MAX (REGNO (XEXP (parmreg, 0)), REGNO (XEXP (parmreg, 1)));
4993           else
4994             regno = REGNO (parmreg);
4995
4996           if (regno >= max_parm_reg)
4997             {
4998               rtx *new;
4999               int old_max_parm_reg = max_parm_reg;
5000
5001               /* It's slow to expand this one register at a time,
5002                  but it's also rare and we need max_parm_reg to be
5003                  precisely correct.  */
5004               max_parm_reg = regno + 1;
5005               new = (rtx *) ggc_realloc (parm_reg_stack_loc,
5006                                       max_parm_reg * sizeof (rtx));
5007               memset ((char *) (new + old_max_parm_reg), 0,
5008                      (max_parm_reg - old_max_parm_reg) * sizeof (rtx));
5009               parm_reg_stack_loc = new;
5010             }
5011
5012           if (GET_CODE (parmreg) == CONCAT)
5013             {
5014               enum machine_mode submode = GET_MODE (XEXP (parmreg, 0));
5015
5016               regnor = REGNO (gen_realpart (submode, parmreg));
5017               regnoi = REGNO (gen_imagpart (submode, parmreg));
5018
5019               if (stack_parm != 0)
5020                 {
5021                   parm_reg_stack_loc[regnor]
5022                     = gen_realpart (submode, stack_parm);
5023                   parm_reg_stack_loc[regnoi]
5024                     = gen_imagpart (submode, stack_parm);
5025                 }
5026               else
5027                 {
5028                   parm_reg_stack_loc[regnor] = 0;
5029                   parm_reg_stack_loc[regnoi] = 0;
5030                 }
5031             }
5032           else
5033             parm_reg_stack_loc[REGNO (parmreg)] = stack_parm;
5034
5035           /* Mark the register as eliminable if we did no conversion
5036              and it was copied from memory at a fixed offset,
5037              and the arg pointer was not copied to a pseudo-reg.
5038              If the arg pointer is a pseudo reg or the offset formed
5039              an invalid address, such memory-equivalences
5040              as we make here would screw up life analysis for it.  */
5041           if (nominal_mode == passed_mode
5042               && ! did_conversion
5043               && stack_parm != 0
5044               && GET_CODE (stack_parm) == MEM
5045               && locate.offset.var == 0
5046               && reg_mentioned_p (virtual_incoming_args_rtx,
5047                                   XEXP (stack_parm, 0)))
5048             {
5049               rtx linsn = get_last_insn ();
5050               rtx sinsn, set;
5051
5052               /* Mark complex types separately.  */
5053               if (GET_CODE (parmreg) == CONCAT)
5054                 /* Scan backwards for the set of the real and
5055                    imaginary parts.  */
5056                 for (sinsn = linsn; sinsn != 0;
5057                      sinsn = prev_nonnote_insn (sinsn))
5058                   {
5059                     set = single_set (sinsn);
5060                     if (set != 0
5061                         && SET_DEST (set) == regno_reg_rtx [regnoi])
5062                       REG_NOTES (sinsn)
5063                         = gen_rtx_EXPR_LIST (REG_EQUIV,
5064                                              parm_reg_stack_loc[regnoi],
5065                                              REG_NOTES (sinsn));
5066                     else if (set != 0
5067                              && SET_DEST (set) == regno_reg_rtx [regnor])
5068                       REG_NOTES (sinsn)
5069                         = gen_rtx_EXPR_LIST (REG_EQUIV,
5070                                              parm_reg_stack_loc[regnor],
5071                                              REG_NOTES (sinsn));
5072                   }
5073               else if ((set = single_set (linsn)) != 0
5074                        && SET_DEST (set) == parmreg)
5075                 REG_NOTES (linsn)
5076                   = gen_rtx_EXPR_LIST (REG_EQUIV,
5077                                        stack_parm, REG_NOTES (linsn));
5078             }
5079
5080           /* For pointer data type, suggest pointer register.  */
5081           if (POINTER_TYPE_P (TREE_TYPE (parm)))
5082             mark_reg_pointer (parmreg,
5083                               TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm))));
5084
5085           /* If something wants our address, try to use ADDRESSOF.  */
5086           if (TREE_ADDRESSABLE (parm))
5087             {
5088               /* If we end up putting something into the stack,
5089                  fixup_var_refs_insns will need to make a pass over
5090                  all the instructions.  It looks through the pending
5091                  sequences -- but it can't see the ones in the
5092                  CONVERSION_INSNS, if they're not on the sequence
5093                  stack.  So, we go back to that sequence, just so that
5094                  the fixups will happen.  */
5095               push_to_sequence (conversion_insns);
5096               put_var_into_stack (parm, /*rescan=*/true);
5097               conversion_insns = get_insns ();
5098               end_sequence ();
5099             }
5100         }
5101       else
5102         {
5103           /* Value must be stored in the stack slot STACK_PARM
5104              during function execution.  */
5105
5106           if (promoted_mode != nominal_mode)
5107             {
5108               /* Conversion is required.  */
5109               rtx tempreg = gen_reg_rtx (GET_MODE (entry_parm));
5110
5111               emit_move_insn (tempreg, validize_mem (entry_parm));
5112
5113               push_to_sequence (conversion_insns);
5114               entry_parm = convert_to_mode (nominal_mode, tempreg,
5115                                             TREE_UNSIGNED (TREE_TYPE (parm)));
5116               if (stack_parm)
5117                 /* ??? This may need a big-endian conversion on sparc64.  */
5118                 stack_parm = adjust_address (stack_parm, nominal_mode, 0);
5119
5120               conversion_insns = get_insns ();
5121               did_conversion = 1;
5122               end_sequence ();
5123             }
5124
5125           if (entry_parm != stack_parm)
5126             {
5127               if (stack_parm == 0)
5128                 {
5129                   stack_parm
5130                     = assign_stack_local (GET_MODE (entry_parm),
5131                                           GET_MODE_SIZE (GET_MODE (entry_parm)),
5132                                           0);
5133                   set_mem_attributes (stack_parm, parm, 1);
5134                 }
5135
5136               if (promoted_mode != nominal_mode)
5137                 {
5138                   push_to_sequence (conversion_insns);
5139                   emit_move_insn (validize_mem (stack_parm),
5140                                   validize_mem (entry_parm));
5141                   conversion_insns = get_insns ();
5142                   end_sequence ();
5143                 }
5144               else
5145                 emit_move_insn (validize_mem (stack_parm),
5146                                 validize_mem (entry_parm));
5147             }
5148
5149           SET_DECL_RTL (parm, stack_parm);
5150         }
5151     }
5152
5153   /* Output all parameter conversion instructions (possibly including calls)
5154      now that all parameters have been copied out of hard registers.  */
5155   emit_insn (conversion_insns);
5156
5157   /* If we are receiving a struct value address as the first argument, set up
5158      the RTL for the function result. As this might require code to convert
5159      the transmitted address to Pmode, we do this here to ensure that possible
5160      preliminary conversions of the address have been emitted already.  */
5161   if (function_result_decl)
5162     {
5163       tree result = DECL_RESULT (fndecl);
5164       rtx addr = DECL_RTL (function_result_decl);
5165       rtx x;
5166
5167 #ifdef POINTERS_EXTEND_UNSIGNED
5168       if (GET_MODE (addr) != Pmode)
5169         addr = convert_memory_address (Pmode, addr);
5170 #endif
5171
5172       x = gen_rtx_MEM (DECL_MODE (result), addr);
5173       set_mem_attributes (x, result, 1);
5174       SET_DECL_RTL (result, x);
5175     }
5176
5177   last_parm_insn = get_last_insn ();
5178
5179   current_function_args_size = stack_args_size.constant;
5180
5181   /* Adjust function incoming argument size for alignment and
5182      minimum length.  */
5183
5184 #ifdef REG_PARM_STACK_SPACE
5185 #ifndef MAYBE_REG_PARM_STACK_SPACE
5186   current_function_args_size = MAX (current_function_args_size,
5187                                     REG_PARM_STACK_SPACE (fndecl));
5188 #endif
5189 #endif
5190
5191 #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
5192
5193   current_function_args_size
5194     = ((current_function_args_size + STACK_BYTES - 1)
5195        / STACK_BYTES) * STACK_BYTES;
5196
5197 #ifdef ARGS_GROW_DOWNWARD
5198   current_function_arg_offset_rtx
5199     = (stack_args_size.var == 0 ? GEN_INT (-stack_args_size.constant)
5200        : expand_expr (size_diffop (stack_args_size.var,
5201                                    size_int (-stack_args_size.constant)),
5202                       NULL_RTX, VOIDmode, 0));
5203 #else
5204   current_function_arg_offset_rtx = ARGS_SIZE_RTX (stack_args_size);
5205 #endif
5206
5207   /* See how many bytes, if any, of its args a function should try to pop
5208      on return.  */
5209
5210   current_function_pops_args = RETURN_POPS_ARGS (fndecl, TREE_TYPE (fndecl),
5211                                                  current_function_args_size);
5212
5213   /* For stdarg.h function, save info about
5214      regs and stack space used by the named args.  */
5215
5216   current_function_args_info = args_so_far;
5217
5218   /* Set the rtx used for the function return value.  Put this in its
5219      own variable so any optimizers that need this information don't have
5220      to include tree.h.  Do this here so it gets done when an inlined
5221      function gets output.  */
5222
5223   current_function_return_rtx
5224     = (DECL_RTL_SET_P (DECL_RESULT (fndecl))
5225        ? DECL_RTL (DECL_RESULT (fndecl)) : NULL_RTX);
5226
5227   /* If scalar return value was computed in a pseudo-reg, or was a named
5228      return value that got dumped to the stack, copy that to the hard
5229      return register.  */
5230   if (DECL_RTL_SET_P (DECL_RESULT (fndecl)))
5231     {
5232       tree decl_result = DECL_RESULT (fndecl);
5233       rtx decl_rtl = DECL_RTL (decl_result);
5234
5235       if (REG_P (decl_rtl)
5236           ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER
5237           : DECL_REGISTER (decl_result))
5238         {
5239           rtx real_decl_rtl;
5240
5241 #ifdef FUNCTION_OUTGOING_VALUE
5242           real_decl_rtl = FUNCTION_OUTGOING_VALUE (TREE_TYPE (decl_result),
5243                                                    fndecl);
5244 #else
5245           real_decl_rtl = FUNCTION_VALUE (TREE_TYPE (decl_result),
5246                                           fndecl);
5247 #endif
5248           REG_FUNCTION_VALUE_P (real_decl_rtl) = 1;
5249           /* The delay slot scheduler assumes that current_function_return_rtx
5250              holds the hard register containing the return value, not a
5251              temporary pseudo.  */
5252           current_function_return_rtx = real_decl_rtl;
5253         }
5254     }
5255 }
5256 \f
5257 /* Indicate whether REGNO is an incoming argument to the current function
5258    that was promoted to a wider mode.  If so, return the RTX for the
5259    register (to get its mode).  PMODE and PUNSIGNEDP are set to the mode
5260    that REGNO is promoted from and whether the promotion was signed or
5261    unsigned.  */
5262
5263 #ifdef PROMOTE_FUNCTION_ARGS
5264
5265 rtx
5266 promoted_input_arg (regno, pmode, punsignedp)
5267      unsigned int regno;
5268      enum machine_mode *pmode;
5269      int *punsignedp;
5270 {
5271   tree arg;
5272
5273   for (arg = DECL_ARGUMENTS (current_function_decl); arg;
5274        arg = TREE_CHAIN (arg))
5275     if (GET_CODE (DECL_INCOMING_RTL (arg)) == REG
5276         && REGNO (DECL_INCOMING_RTL (arg)) == regno
5277         && TYPE_MODE (DECL_ARG_TYPE (arg)) == TYPE_MODE (TREE_TYPE (arg)))
5278       {
5279         enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg));
5280         int unsignedp = TREE_UNSIGNED (TREE_TYPE (arg));
5281
5282         mode = promote_mode (TREE_TYPE (arg), mode, &unsignedp, 1);
5283         if (mode == GET_MODE (DECL_INCOMING_RTL (arg))
5284             && mode != DECL_MODE (arg))
5285           {
5286             *pmode = DECL_MODE (arg);
5287             *punsignedp = unsignedp;
5288             return DECL_INCOMING_RTL (arg);
5289           }
5290       }
5291
5292   return 0;
5293 }
5294
5295 #endif
5296 \f
5297 /* Compute the size and offset from the start of the stacked arguments for a
5298    parm passed in mode PASSED_MODE and with type TYPE.
5299
5300    INITIAL_OFFSET_PTR points to the current offset into the stacked
5301    arguments.
5302
5303    The starting offset and size for this parm are returned in
5304    LOCATE->OFFSET and LOCATE->SIZE, respectively.  When IN_REGS is
5305    nonzero, the offset is that of stack slot, which is returned in
5306    LOCATE->SLOT_OFFSET.  LOCATE->ALIGNMENT_PAD is the amount of
5307    padding required from the initial offset ptr to the stack slot.
5308
5309    IN_REGS is nonzero if the argument will be passed in registers.  It will
5310    never be set if REG_PARM_STACK_SPACE is not defined.
5311
5312    FNDECL is the function in which the argument was defined.
5313
5314    There are two types of rounding that are done.  The first, controlled by
5315    FUNCTION_ARG_BOUNDARY, forces the offset from the start of the argument
5316    list to be aligned to the specific boundary (in bits).  This rounding
5317    affects the initial and starting offsets, but not the argument size.
5318
5319    The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY,
5320    optionally rounds the size of the parm to PARM_BOUNDARY.  The
5321    initial offset is not affected by this rounding, while the size always
5322    is and the starting offset may be.  */
5323
5324 /*  LOCATE->OFFSET will be negative for ARGS_GROW_DOWNWARD case;
5325     INITIAL_OFFSET_PTR is positive because locate_and_pad_parm's
5326     callers pass in the total size of args so far as
5327     INITIAL_OFFSET_PTR.  LOCATE->SIZE is always positive.  */
5328
5329 void
5330 locate_and_pad_parm (passed_mode, type, in_regs, partial, fndecl,
5331                      initial_offset_ptr, locate)
5332      enum machine_mode passed_mode;
5333      tree type;
5334      int in_regs;
5335      int partial;
5336      tree fndecl ATTRIBUTE_UNUSED;
5337      struct args_size *initial_offset_ptr;
5338      struct locate_and_pad_arg_data *locate;
5339 {
5340   tree sizetree;
5341   enum direction where_pad;
5342   int boundary;
5343   int reg_parm_stack_space = 0;
5344   int part_size_in_regs;
5345
5346 #ifdef REG_PARM_STACK_SPACE
5347 #ifdef MAYBE_REG_PARM_STACK_SPACE
5348   reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
5349 #else
5350   reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
5351 #endif
5352
5353   /* If we have found a stack parm before we reach the end of the
5354      area reserved for registers, skip that area.  */
5355   if (! in_regs)
5356     {
5357       if (reg_parm_stack_space > 0)
5358         {
5359           if (initial_offset_ptr->var)
5360             {
5361               initial_offset_ptr->var
5362                 = size_binop (MAX_EXPR, ARGS_SIZE_TREE (*initial_offset_ptr),
5363                               ssize_int (reg_parm_stack_space));
5364               initial_offset_ptr->constant = 0;
5365             }
5366           else if (initial_offset_ptr->constant < reg_parm_stack_space)
5367             initial_offset_ptr->constant = reg_parm_stack_space;
5368         }
5369     }
5370 #endif /* REG_PARM_STACK_SPACE */
5371
5372   part_size_in_regs = 0;
5373   if (reg_parm_stack_space == 0)
5374     part_size_in_regs = ((partial * UNITS_PER_WORD)
5375                          / (PARM_BOUNDARY / BITS_PER_UNIT)
5376                          * (PARM_BOUNDARY / BITS_PER_UNIT));
5377
5378   sizetree
5379     = type ? size_in_bytes (type) : size_int (GET_MODE_SIZE (passed_mode));
5380   where_pad = FUNCTION_ARG_PADDING (passed_mode, type);
5381   boundary = FUNCTION_ARG_BOUNDARY (passed_mode, type);
5382
5383 #ifdef ARGS_GROW_DOWNWARD
5384   locate->slot_offset.constant = -initial_offset_ptr->constant;
5385   if (initial_offset_ptr->var)
5386     locate->slot_offset.var = size_binop (MINUS_EXPR, ssize_int (0),
5387                                           initial_offset_ptr->var);
5388
5389   {
5390     tree s2 = sizetree;
5391     if (where_pad != none
5392         && (!host_integerp (sizetree, 1)
5393             || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % PARM_BOUNDARY))
5394       s2 = round_up (s2, PARM_BOUNDARY / BITS_PER_UNIT);
5395     SUB_PARM_SIZE (locate->slot_offset, s2);
5396   }
5397
5398   locate->slot_offset.constant += part_size_in_regs;
5399
5400   if (!in_regs
5401 #ifdef REG_PARM_STACK_SPACE
5402       || REG_PARM_STACK_SPACE (fndecl) > 0
5403 #endif
5404      )
5405     pad_to_arg_alignment (&locate->slot_offset, boundary,
5406                           &locate->alignment_pad);
5407
5408   locate->size.constant = (-initial_offset_ptr->constant
5409                            - locate->slot_offset.constant);
5410   if (initial_offset_ptr->var)
5411     locate->size.var = size_binop (MINUS_EXPR,
5412                                    size_binop (MINUS_EXPR,
5413                                                ssize_int (0),
5414                                                initial_offset_ptr->var),
5415                                    locate->slot_offset.var);
5416
5417   /* Pad_below needs the pre-rounded size to know how much to pad
5418      below.  */
5419   locate->offset = locate->slot_offset;
5420   if (where_pad == downward)
5421     pad_below (&locate->offset, passed_mode, sizetree);
5422
5423 #else /* !ARGS_GROW_DOWNWARD */
5424   if (!in_regs
5425 #ifdef REG_PARM_STACK_SPACE
5426       || REG_PARM_STACK_SPACE (fndecl) > 0
5427 #endif
5428       )
5429     pad_to_arg_alignment (initial_offset_ptr, boundary,
5430                           &locate->alignment_pad);
5431   locate->slot_offset = *initial_offset_ptr;
5432
5433 #ifdef PUSH_ROUNDING
5434   if (passed_mode != BLKmode)
5435     sizetree = size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree)));
5436 #endif
5437
5438   /* Pad_below needs the pre-rounded size to know how much to pad below
5439      so this must be done before rounding up.  */
5440   locate->offset = locate->slot_offset;
5441   if (where_pad == downward)
5442     pad_below (&locate->offset, passed_mode, sizetree);
5443
5444   if (where_pad != none
5445       && (!host_integerp (sizetree, 1)
5446           || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % PARM_BOUNDARY))
5447     sizetree = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT);
5448
5449   ADD_PARM_SIZE (locate->size, sizetree);
5450
5451   locate->size.constant -= part_size_in_regs;
5452 #endif /* ARGS_GROW_DOWNWARD */
5453 }
5454
5455 /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY.
5456    BOUNDARY is measured in bits, but must be a multiple of a storage unit.  */
5457
5458 static void
5459 pad_to_arg_alignment (offset_ptr, boundary, alignment_pad)
5460      struct args_size *offset_ptr;
5461      int boundary;
5462      struct args_size *alignment_pad;
5463 {
5464   tree save_var = NULL_TREE;
5465   HOST_WIDE_INT save_constant = 0;
5466
5467   int boundary_in_bytes = boundary / BITS_PER_UNIT;
5468
5469   if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
5470     {
5471       save_var = offset_ptr->var;
5472       save_constant = offset_ptr->constant;
5473     }
5474
5475   alignment_pad->var = NULL_TREE;
5476   alignment_pad->constant = 0;
5477
5478   if (boundary > BITS_PER_UNIT)
5479     {
5480       if (offset_ptr->var)
5481         {
5482           offset_ptr->var =
5483 #ifdef ARGS_GROW_DOWNWARD
5484             round_down
5485 #else
5486             round_up
5487 #endif
5488               (ARGS_SIZE_TREE (*offset_ptr),
5489                boundary / BITS_PER_UNIT);
5490           /* ARGS_SIZE_TREE includes constant term.  */
5491           offset_ptr->constant = 0;
5492           if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
5493             alignment_pad->var = size_binop (MINUS_EXPR, offset_ptr->var,
5494                                              save_var);
5495         }
5496       else
5497         {
5498           offset_ptr->constant =
5499 #ifdef ARGS_GROW_DOWNWARD
5500             FLOOR_ROUND (offset_ptr->constant, boundary_in_bytes);
5501 #else
5502             CEIL_ROUND (offset_ptr->constant, boundary_in_bytes);
5503 #endif
5504             if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
5505               alignment_pad->constant = offset_ptr->constant - save_constant;
5506         }
5507     }
5508 }
5509
5510 static void
5511 pad_below (offset_ptr, passed_mode, sizetree)
5512      struct args_size *offset_ptr;
5513      enum machine_mode passed_mode;
5514      tree sizetree;
5515 {
5516   if (passed_mode != BLKmode)
5517     {
5518       if (GET_MODE_BITSIZE (passed_mode) % PARM_BOUNDARY)
5519         offset_ptr->constant
5520           += (((GET_MODE_BITSIZE (passed_mode) + PARM_BOUNDARY - 1)
5521                / PARM_BOUNDARY * PARM_BOUNDARY / BITS_PER_UNIT)
5522               - GET_MODE_SIZE (passed_mode));
5523     }
5524   else
5525     {
5526       if (TREE_CODE (sizetree) != INTEGER_CST
5527           || (TREE_INT_CST_LOW (sizetree) * BITS_PER_UNIT) % PARM_BOUNDARY)
5528         {
5529           /* Round the size up to multiple of PARM_BOUNDARY bits.  */
5530           tree s2 = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT);
5531           /* Add it in.  */
5532           ADD_PARM_SIZE (*offset_ptr, s2);
5533           SUB_PARM_SIZE (*offset_ptr, sizetree);
5534         }
5535     }
5536 }
5537 \f
5538 /* Walk the tree of blocks describing the binding levels within a function
5539    and warn about uninitialized variables.
5540    This is done after calling flow_analysis and before global_alloc
5541    clobbers the pseudo-regs to hard regs.  */
5542
5543 void
5544 uninitialized_vars_warning (block)
5545      tree block;
5546 {
5547   tree decl, sub;
5548   for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
5549     {
5550       if (warn_uninitialized
5551           && TREE_CODE (decl) == VAR_DECL
5552           /* These warnings are unreliable for and aggregates
5553              because assigning the fields one by one can fail to convince
5554              flow.c that the entire aggregate was initialized.
5555              Unions are troublesome because members may be shorter.  */
5556           && ! AGGREGATE_TYPE_P (TREE_TYPE (decl))
5557           && DECL_RTL (decl) != 0
5558           && GET_CODE (DECL_RTL (decl)) == REG
5559           /* Global optimizations can make it difficult to determine if a
5560              particular variable has been initialized.  However, a VAR_DECL
5561              with a nonzero DECL_INITIAL had an initializer, so do not
5562              claim it is potentially uninitialized.
5563
5564              We do not care about the actual value in DECL_INITIAL, so we do
5565              not worry that it may be a dangling pointer.  */
5566           && DECL_INITIAL (decl) == NULL_TREE
5567           && regno_uninitialized (REGNO (DECL_RTL (decl))))
5568         warning_with_decl (decl,
5569                            "`%s' might be used uninitialized in this function");
5570       if (extra_warnings
5571           && TREE_CODE (decl) == VAR_DECL
5572           && DECL_RTL (decl) != 0
5573           && GET_CODE (DECL_RTL (decl)) == REG
5574           && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl))))
5575         warning_with_decl (decl,
5576                            "variable `%s' might be clobbered by `longjmp' or `vfork'");
5577     }
5578   for (sub = BLOCK_SUBBLOCKS (block); sub; sub = TREE_CHAIN (sub))
5579     uninitialized_vars_warning (sub);
5580 }
5581
5582 /* Do the appropriate part of uninitialized_vars_warning
5583    but for arguments instead of local variables.  */
5584
5585 void
5586 setjmp_args_warning ()
5587 {
5588   tree decl;
5589   for (decl = DECL_ARGUMENTS (current_function_decl);
5590        decl; decl = TREE_CHAIN (decl))
5591     if (DECL_RTL (decl) != 0
5592         && GET_CODE (DECL_RTL (decl)) == REG
5593         && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl))))
5594       warning_with_decl (decl,
5595                          "argument `%s' might be clobbered by `longjmp' or `vfork'");
5596 }
5597
5598 /* If this function call setjmp, put all vars into the stack
5599    unless they were declared `register'.  */
5600
5601 void
5602 setjmp_protect (block)
5603      tree block;
5604 {
5605   tree decl, sub;
5606   for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
5607     if ((TREE_CODE (decl) == VAR_DECL
5608          || TREE_CODE (decl) == PARM_DECL)
5609         && DECL_RTL (decl) != 0
5610         && (GET_CODE (DECL_RTL (decl)) == REG
5611             || (GET_CODE (DECL_RTL (decl)) == MEM
5612                 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF))
5613         /* If this variable came from an inline function, it must be
5614            that its life doesn't overlap the setjmp.  If there was a
5615            setjmp in the function, it would already be in memory.  We
5616            must exclude such variable because their DECL_RTL might be
5617            set to strange things such as virtual_stack_vars_rtx.  */
5618         && ! DECL_FROM_INLINE (decl)
5619         && (
5620 #ifdef NON_SAVING_SETJMP
5621             /* If longjmp doesn't restore the registers,
5622                don't put anything in them.  */
5623             NON_SAVING_SETJMP
5624             ||
5625 #endif
5626             ! DECL_REGISTER (decl)))
5627       put_var_into_stack (decl, /*rescan=*/true);
5628   for (sub = BLOCK_SUBBLOCKS (block); sub; sub = TREE_CHAIN (sub))
5629     setjmp_protect (sub);
5630 }
5631 \f
5632 /* Like the previous function, but for args instead of local variables.  */
5633
5634 void
5635 setjmp_protect_args ()
5636 {
5637   tree decl;
5638   for (decl = DECL_ARGUMENTS (current_function_decl);
5639        decl; decl = TREE_CHAIN (decl))
5640     if ((TREE_CODE (decl) == VAR_DECL
5641          || TREE_CODE (decl) == PARM_DECL)
5642         && DECL_RTL (decl) != 0
5643         && (GET_CODE (DECL_RTL (decl)) == REG
5644             || (GET_CODE (DECL_RTL (decl)) == MEM
5645                 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF))
5646         && (
5647             /* If longjmp doesn't restore the registers,
5648                don't put anything in them.  */
5649 #ifdef NON_SAVING_SETJMP
5650             NON_SAVING_SETJMP
5651             ||
5652 #endif
5653             ! DECL_REGISTER (decl)))
5654       put_var_into_stack (decl, /*rescan=*/true);
5655 }
5656 \f
5657 /* Return the context-pointer register corresponding to DECL,
5658    or 0 if it does not need one.  */
5659
5660 rtx
5661 lookup_static_chain (decl)
5662      tree decl;
5663 {
5664   tree context = decl_function_context (decl);
5665   tree link;
5666
5667   if (context == 0
5668       || (TREE_CODE (decl) == FUNCTION_DECL && DECL_NO_STATIC_CHAIN (decl)))
5669     return 0;
5670
5671   /* We treat inline_function_decl as an alias for the current function
5672      because that is the inline function whose vars, types, etc.
5673      are being merged into the current function.
5674      See expand_inline_function.  */
5675   if (context == current_function_decl || context == inline_function_decl)
5676     return virtual_stack_vars_rtx;
5677
5678   for (link = context_display; link; link = TREE_CHAIN (link))
5679     if (TREE_PURPOSE (link) == context)
5680       return RTL_EXPR_RTL (TREE_VALUE (link));
5681
5682   abort ();
5683 }
5684 \f
5685 /* Convert a stack slot address ADDR for variable VAR
5686    (from a containing function)
5687    into an address valid in this function (using a static chain).  */
5688
5689 rtx
5690 fix_lexical_addr (addr, var)
5691      rtx addr;
5692      tree var;
5693 {
5694   rtx basereg;
5695   HOST_WIDE_INT displacement;
5696   tree context = decl_function_context (var);
5697   struct function *fp;
5698   rtx base = 0;
5699
5700   /* If this is the present function, we need not do anything.  */
5701   if (context == current_function_decl || context == inline_function_decl)
5702     return addr;
5703
5704   fp = find_function_data (context);
5705
5706   if (GET_CODE (addr) == ADDRESSOF && GET_CODE (XEXP (addr, 0)) == MEM)
5707     addr = XEXP (XEXP (addr, 0), 0);
5708
5709   /* Decode given address as base reg plus displacement.  */
5710   if (GET_CODE (addr) == REG)
5711     basereg = addr, displacement = 0;
5712   else if (GET_CODE (addr) == PLUS && GET_CODE (XEXP (addr, 1)) == CONST_INT)
5713     basereg = XEXP (addr, 0), displacement = INTVAL (XEXP (addr, 1));
5714   else
5715     abort ();
5716
5717   /* We accept vars reached via the containing function's
5718      incoming arg pointer and via its stack variables pointer.  */
5719   if (basereg == fp->internal_arg_pointer)
5720     {
5721       /* If reached via arg pointer, get the arg pointer value
5722          out of that function's stack frame.
5723
5724          There are two cases:  If a separate ap is needed, allocate a
5725          slot in the outer function for it and dereference it that way.
5726          This is correct even if the real ap is actually a pseudo.
5727          Otherwise, just adjust the offset from the frame pointer to
5728          compensate.  */
5729
5730 #ifdef NEED_SEPARATE_AP
5731       rtx addr;
5732
5733       addr = get_arg_pointer_save_area (fp);
5734       addr = fix_lexical_addr (XEXP (addr, 0), var);
5735       addr = memory_address (Pmode, addr);
5736
5737       base = gen_rtx_MEM (Pmode, addr);
5738       set_mem_alias_set (base, get_frame_alias_set ());
5739       base = copy_to_reg (base);
5740 #else
5741       displacement += (FIRST_PARM_OFFSET (context) - STARTING_FRAME_OFFSET);
5742       base = lookup_static_chain (var);
5743 #endif
5744     }
5745
5746   else if (basereg == virtual_stack_vars_rtx)
5747     {
5748       /* This is the same code as lookup_static_chain, duplicated here to
5749          avoid an extra call to decl_function_context.  */
5750       tree link;
5751
5752       for (link = context_display; link; link = TREE_CHAIN (link))
5753         if (TREE_PURPOSE (link) == context)
5754           {
5755             base = RTL_EXPR_RTL (TREE_VALUE (link));
5756             break;
5757           }
5758     }
5759
5760   if (base == 0)
5761     abort ();
5762
5763   /* Use same offset, relative to appropriate static chain or argument
5764      pointer.  */
5765   return plus_constant (base, displacement);
5766 }
5767 \f
5768 /* Return the address of the trampoline for entering nested fn FUNCTION.
5769    If necessary, allocate a trampoline (in the stack frame)
5770    and emit rtl to initialize its contents (at entry to this function).  */
5771
5772 rtx
5773 trampoline_address (function)
5774      tree function;
5775 {
5776   tree link;
5777   tree rtlexp;
5778   rtx tramp;
5779   struct function *fp;
5780   tree fn_context;
5781
5782   /* Find an existing trampoline and return it.  */
5783   for (link = trampoline_list; link; link = TREE_CHAIN (link))
5784     if (TREE_PURPOSE (link) == function)
5785       return
5786         adjust_trampoline_addr (XEXP (RTL_EXPR_RTL (TREE_VALUE (link)), 0));
5787
5788   for (fp = outer_function_chain; fp; fp = fp->outer)
5789     for (link = fp->x_trampoline_list; link; link = TREE_CHAIN (link))
5790       if (TREE_PURPOSE (link) == function)
5791         {
5792           tramp = fix_lexical_addr (XEXP (RTL_EXPR_RTL (TREE_VALUE (link)), 0),
5793                                     function);
5794           return adjust_trampoline_addr (tramp);
5795         }
5796
5797   /* None exists; we must make one.  */
5798
5799   /* Find the `struct function' for the function containing FUNCTION.  */
5800   fp = 0;
5801   fn_context = decl_function_context (function);
5802   if (fn_context != current_function_decl
5803       && fn_context != inline_function_decl)
5804     fp = find_function_data (fn_context);
5805
5806   /* Allocate run-time space for this trampoline
5807      (usually in the defining function's stack frame).  */
5808 #ifdef ALLOCATE_TRAMPOLINE
5809   tramp = ALLOCATE_TRAMPOLINE (fp);
5810 #else
5811   /* If rounding needed, allocate extra space
5812      to ensure we have TRAMPOLINE_SIZE bytes left after rounding up.  */
5813 #define TRAMPOLINE_REAL_SIZE \
5814   (TRAMPOLINE_SIZE + (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT) - 1)
5815   tramp = assign_stack_local_1 (BLKmode, TRAMPOLINE_REAL_SIZE, 0,
5816                                 fp ? fp : cfun);
5817 #endif
5818
5819   /* Record the trampoline for reuse and note it for later initialization
5820      by expand_function_end.  */
5821   if (fp != 0)
5822     {
5823       rtlexp = make_node (RTL_EXPR);
5824       RTL_EXPR_RTL (rtlexp) = tramp;
5825       fp->x_trampoline_list = tree_cons (function, rtlexp,
5826                                          fp->x_trampoline_list);
5827     }
5828   else
5829     {
5830       /* Make the RTL_EXPR node temporary, not momentary, so that the
5831          trampoline_list doesn't become garbage.  */
5832       rtlexp = make_node (RTL_EXPR);
5833
5834       RTL_EXPR_RTL (rtlexp) = tramp;
5835       trampoline_list = tree_cons (function, rtlexp, trampoline_list);
5836     }
5837
5838   tramp = fix_lexical_addr (XEXP (tramp, 0), function);
5839   return adjust_trampoline_addr (tramp);
5840 }
5841
5842 /* Given a trampoline address,
5843    round it to multiple of TRAMPOLINE_ALIGNMENT.  */
5844
5845 static rtx
5846 round_trampoline_addr (tramp)
5847      rtx tramp;
5848 {
5849   /* Round address up to desired boundary.  */
5850   rtx temp = gen_reg_rtx (Pmode);
5851   rtx addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
5852   rtx mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
5853
5854   temp  = expand_simple_binop (Pmode, PLUS, tramp, addend,
5855                                temp, 0, OPTAB_LIB_WIDEN);
5856   tramp = expand_simple_binop (Pmode, AND, temp, mask,
5857                                temp, 0, OPTAB_LIB_WIDEN);
5858
5859   return tramp;
5860 }
5861
5862 /* Given a trampoline address, round it then apply any
5863    platform-specific adjustments so that the result can be used for a
5864    function call .  */
5865
5866 static rtx
5867 adjust_trampoline_addr (tramp)
5868      rtx tramp;
5869 {
5870   tramp = round_trampoline_addr (tramp);
5871 #ifdef TRAMPOLINE_ADJUST_ADDRESS
5872   TRAMPOLINE_ADJUST_ADDRESS (tramp);
5873 #endif
5874   return tramp;
5875 }
5876 \f
5877 /* Put all this function's BLOCK nodes including those that are chained
5878    onto the first block into a vector, and return it.
5879    Also store in each NOTE for the beginning or end of a block
5880    the index of that block in the vector.
5881    The arguments are BLOCK, the chain of top-level blocks of the function,
5882    and INSNS, the insn chain of the function.  */
5883
5884 void
5885 identify_blocks ()
5886 {
5887   int n_blocks;
5888   tree *block_vector, *last_block_vector;
5889   tree *block_stack;
5890   tree block = DECL_INITIAL (current_function_decl);
5891
5892   if (block == 0)
5893     return;
5894
5895   /* Fill the BLOCK_VECTOR with all of the BLOCKs in this function, in
5896      depth-first order.  */
5897   block_vector = get_block_vector (block, &n_blocks);
5898   block_stack = (tree *) xmalloc (n_blocks * sizeof (tree));
5899
5900   last_block_vector = identify_blocks_1 (get_insns (),
5901                                          block_vector + 1,
5902                                          block_vector + n_blocks,
5903                                          block_stack);
5904
5905   /* If we didn't use all of the subblocks, we've misplaced block notes.  */
5906   /* ??? This appears to happen all the time.  Latent bugs elsewhere?  */
5907   if (0 && last_block_vector != block_vector + n_blocks)
5908     abort ();
5909
5910   free (block_vector);
5911   free (block_stack);
5912 }
5913
5914 /* Subroutine of identify_blocks.  Do the block substitution on the
5915    insn chain beginning with INSNS.  Recurse for CALL_PLACEHOLDER chains.
5916
5917    BLOCK_STACK is pushed and popped for each BLOCK_BEGIN/BLOCK_END pair.
5918    BLOCK_VECTOR is incremented for each block seen.  */
5919
5920 static tree *
5921 identify_blocks_1 (insns, block_vector, end_block_vector, orig_block_stack)
5922      rtx insns;
5923      tree *block_vector;
5924      tree *end_block_vector;
5925      tree *orig_block_stack;
5926 {
5927   rtx insn;
5928   tree *block_stack = orig_block_stack;
5929
5930   for (insn = insns; insn; insn = NEXT_INSN (insn))
5931     {
5932       if (GET_CODE (insn) == NOTE)
5933         {
5934           if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG)
5935             {
5936               tree b;
5937
5938               /* If there are more block notes than BLOCKs, something
5939                  is badly wrong.  */
5940               if (block_vector == end_block_vector)
5941                 abort ();
5942
5943               b = *block_vector++;
5944               NOTE_BLOCK (insn) = b;
5945               *block_stack++ = b;
5946             }
5947           else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
5948             {
5949               /* If there are more NOTE_INSN_BLOCK_ENDs than
5950                  NOTE_INSN_BLOCK_BEGs, something is badly wrong.  */
5951               if (block_stack == orig_block_stack)
5952                 abort ();
5953
5954               NOTE_BLOCK (insn) = *--block_stack;
5955             }
5956         }
5957       else if (GET_CODE (insn) == CALL_INSN
5958                && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
5959         {
5960           rtx cp = PATTERN (insn);
5961
5962           block_vector = identify_blocks_1 (XEXP (cp, 0), block_vector,
5963                                             end_block_vector, block_stack);
5964           if (XEXP (cp, 1))
5965             block_vector = identify_blocks_1 (XEXP (cp, 1), block_vector,
5966                                               end_block_vector, block_stack);
5967           if (XEXP (cp, 2))
5968             block_vector = identify_blocks_1 (XEXP (cp, 2), block_vector,
5969                                               end_block_vector, block_stack);
5970         }
5971     }
5972
5973   /* If there are more NOTE_INSN_BLOCK_BEGINs than NOTE_INSN_BLOCK_ENDs,
5974      something is badly wrong.  */
5975   if (block_stack != orig_block_stack)
5976     abort ();
5977
5978   return block_vector;
5979 }
5980
5981 /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
5982    and create duplicate blocks.  */
5983 /* ??? Need an option to either create block fragments or to create
5984    abstract origin duplicates of a source block.  It really depends
5985    on what optimization has been performed.  */
5986
5987 void
5988 reorder_blocks ()
5989 {
5990   tree block = DECL_INITIAL (current_function_decl);
5991   varray_type block_stack;
5992
5993   if (block == NULL_TREE)
5994     return;
5995
5996   VARRAY_TREE_INIT (block_stack, 10, "block_stack");
5997
5998   /* Reset the TREE_ASM_WRITTEN bit for all blocks.  */
5999   reorder_blocks_0 (block);
6000
6001   /* Prune the old trees away, so that they don't get in the way.  */
6002   BLOCK_SUBBLOCKS (block) = NULL_TREE;
6003   BLOCK_CHAIN (block) = NULL_TREE;
6004
6005   /* Recreate the block tree from the note nesting.  */
6006   reorder_blocks_1 (get_insns (), block, &block_stack);
6007   BLOCK_SUBBLOCKS (block) = blocks_nreverse (BLOCK_SUBBLOCKS (block));
6008
6009   /* Remove deleted blocks from the block fragment chains.  */
6010   reorder_fix_fragments (block);
6011 }
6012
6013 /* Helper function for reorder_blocks.  Reset TREE_ASM_WRITTEN.  */
6014
6015 static void
6016 reorder_blocks_0 (block)
6017      tree block;
6018 {
6019   while (block)
6020     {
6021       TREE_ASM_WRITTEN (block) = 0;
6022       reorder_blocks_0 (BLOCK_SUBBLOCKS (block));
6023       block = BLOCK_CHAIN (block);
6024     }
6025 }
6026
6027 static void
6028 reorder_blocks_1 (insns, current_block, p_block_stack)
6029      rtx insns;
6030      tree current_block;
6031      varray_type *p_block_stack;
6032 {
6033   rtx insn;
6034
6035   for (insn = insns; insn; insn = NEXT_INSN (insn))
6036     {
6037       if (GET_CODE (insn) == NOTE)
6038         {
6039           if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG)
6040             {
6041               tree block = NOTE_BLOCK (insn);
6042
6043               /* If we have seen this block before, that means it now
6044                  spans multiple address regions.  Create a new fragment.  */
6045               if (TREE_ASM_WRITTEN (block))
6046                 {
6047                   tree new_block = copy_node (block);
6048                   tree origin;
6049
6050                   origin = (BLOCK_FRAGMENT_ORIGIN (block)
6051                             ? BLOCK_FRAGMENT_ORIGIN (block)
6052                             : block);
6053                   BLOCK_FRAGMENT_ORIGIN (new_block) = origin;
6054                   BLOCK_FRAGMENT_CHAIN (new_block)
6055                     = BLOCK_FRAGMENT_CHAIN (origin);
6056                   BLOCK_FRAGMENT_CHAIN (origin) = new_block;
6057
6058                   NOTE_BLOCK (insn) = new_block;
6059                   block = new_block;
6060                 }
6061
6062               BLOCK_SUBBLOCKS (block) = 0;
6063               TREE_ASM_WRITTEN (block) = 1;
6064               /* When there's only one block for the entire function,
6065                  current_block == block and we mustn't do this, it
6066                  will cause infinite recursion.  */
6067               if (block != current_block)
6068                 {
6069                   BLOCK_SUPERCONTEXT (block) = current_block;
6070                   BLOCK_CHAIN (block) = BLOCK_SUBBLOCKS (current_block);
6071                   BLOCK_SUBBLOCKS (current_block) = block;
6072                   current_block = block;
6073                 }
6074               VARRAY_PUSH_TREE (*p_block_stack, block);
6075             }
6076           else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
6077             {
6078               NOTE_BLOCK (insn) = VARRAY_TOP_TREE (*p_block_stack);
6079               VARRAY_POP (*p_block_stack);
6080               BLOCK_SUBBLOCKS (current_block)
6081                 = blocks_nreverse (BLOCK_SUBBLOCKS (current_block));
6082               current_block = BLOCK_SUPERCONTEXT (current_block);
6083             }
6084         }
6085       else if (GET_CODE (insn) == CALL_INSN
6086                && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
6087         {
6088           rtx cp = PATTERN (insn);
6089           reorder_blocks_1 (XEXP (cp, 0), current_block, p_block_stack);
6090           if (XEXP (cp, 1))
6091             reorder_blocks_1 (XEXP (cp, 1), current_block, p_block_stack);
6092           if (XEXP (cp, 2))
6093             reorder_blocks_1 (XEXP (cp, 2), current_block, p_block_stack);
6094         }
6095     }
6096 }
6097
6098 /* Rationalize BLOCK_FRAGMENT_ORIGIN.  If an origin block no longer
6099    appears in the block tree, select one of the fragments to become
6100    the new origin block.  */
6101
6102 static void
6103 reorder_fix_fragments (block)
6104      tree block;
6105 {
6106   while (block)
6107     {
6108       tree dup_origin = BLOCK_FRAGMENT_ORIGIN (block);
6109       tree new_origin = NULL_TREE;
6110
6111       if (dup_origin)
6112         {
6113           if (! TREE_ASM_WRITTEN (dup_origin))
6114             {
6115               new_origin = BLOCK_FRAGMENT_CHAIN (dup_origin);
6116
6117               /* Find the first of the remaining fragments.  There must
6118                  be at least one -- the current block.  */
6119               while (! TREE_ASM_WRITTEN (new_origin))
6120                 new_origin = BLOCK_FRAGMENT_CHAIN (new_origin);
6121               BLOCK_FRAGMENT_ORIGIN (new_origin) = NULL_TREE;
6122             }
6123         }
6124       else if (! dup_origin)
6125         new_origin = block;
6126
6127       /* Re-root the rest of the fragments to the new origin.  In the
6128          case that DUP_ORIGIN was null, that means BLOCK was the origin
6129          of a chain of fragments and we want to remove those fragments
6130          that didn't make it to the output.  */
6131       if (new_origin)
6132         {
6133           tree *pp = &BLOCK_FRAGMENT_CHAIN (new_origin);
6134           tree chain = *pp;
6135
6136           while (chain)
6137             {
6138               if (TREE_ASM_WRITTEN (chain))
6139                 {
6140                   BLOCK_FRAGMENT_ORIGIN (chain) = new_origin;
6141                   *pp = chain;
6142                   pp = &BLOCK_FRAGMENT_CHAIN (chain);
6143                 }
6144               chain = BLOCK_FRAGMENT_CHAIN (chain);
6145             }
6146           *pp = NULL_TREE;
6147         }
6148
6149       reorder_fix_fragments (BLOCK_SUBBLOCKS (block));
6150       block = BLOCK_CHAIN (block);
6151     }
6152 }
6153
6154 /* Reverse the order of elements in the chain T of blocks,
6155    and return the new head of the chain (old last element).  */
6156
6157 static tree
6158 blocks_nreverse (t)
6159      tree t;
6160 {
6161   tree prev = 0, decl, next;
6162   for (decl = t; decl; decl = next)
6163     {
6164       next = BLOCK_CHAIN (decl);
6165       BLOCK_CHAIN (decl) = prev;
6166       prev = decl;
6167     }
6168   return prev;
6169 }
6170
6171 /* Count the subblocks of the list starting with BLOCK.  If VECTOR is
6172    non-NULL, list them all into VECTOR, in a depth-first preorder
6173    traversal of the block tree.  Also clear TREE_ASM_WRITTEN in all
6174    blocks.  */
6175
6176 static int
6177 all_blocks (block, vector)
6178      tree block;
6179      tree *vector;
6180 {
6181   int n_blocks = 0;
6182
6183   while (block)
6184     {
6185       TREE_ASM_WRITTEN (block) = 0;
6186
6187       /* Record this block.  */
6188       if (vector)
6189         vector[n_blocks] = block;
6190
6191       ++n_blocks;
6192
6193       /* Record the subblocks, and their subblocks...  */
6194       n_blocks += all_blocks (BLOCK_SUBBLOCKS (block),
6195                               vector ? vector + n_blocks : 0);
6196       block = BLOCK_CHAIN (block);
6197     }
6198
6199   return n_blocks;
6200 }
6201
6202 /* Return a vector containing all the blocks rooted at BLOCK.  The
6203    number of elements in the vector is stored in N_BLOCKS_P.  The
6204    vector is dynamically allocated; it is the caller's responsibility
6205    to call `free' on the pointer returned.  */
6206
6207 static tree *
6208 get_block_vector (block, n_blocks_p)
6209      tree block;
6210      int *n_blocks_p;
6211 {
6212   tree *block_vector;
6213
6214   *n_blocks_p = all_blocks (block, NULL);
6215   block_vector = (tree *) xmalloc (*n_blocks_p * sizeof (tree));
6216   all_blocks (block, block_vector);
6217
6218   return block_vector;
6219 }
6220
6221 static GTY(()) int next_block_index = 2;
6222
6223 /* Set BLOCK_NUMBER for all the blocks in FN.  */
6224
6225 void
6226 number_blocks (fn)
6227      tree fn;
6228 {
6229   int i;
6230   int n_blocks;
6231   tree *block_vector;
6232
6233   /* For SDB and XCOFF debugging output, we start numbering the blocks
6234      from 1 within each function, rather than keeping a running
6235      count.  */
6236 #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
6237   if (write_symbols == SDB_DEBUG || write_symbols == XCOFF_DEBUG)
6238     next_block_index = 1;
6239 #endif
6240
6241   block_vector = get_block_vector (DECL_INITIAL (fn), &n_blocks);
6242
6243   /* The top-level BLOCK isn't numbered at all.  */
6244   for (i = 1; i < n_blocks; ++i)
6245     /* We number the blocks from two.  */
6246     BLOCK_NUMBER (block_vector[i]) = next_block_index++;
6247
6248   free (block_vector);
6249
6250   return;
6251 }
6252
6253 /* If VAR is present in a subblock of BLOCK, return the subblock.  */
6254
6255 tree
6256 debug_find_var_in_block_tree (var, block)
6257      tree var;
6258      tree block;
6259 {
6260   tree t;
6261
6262   for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))
6263     if (t == var)
6264       return block;
6265
6266   for (t = BLOCK_SUBBLOCKS (block); t; t = TREE_CHAIN (t))
6267     {
6268       tree ret = debug_find_var_in_block_tree (var, t);
6269       if (ret)
6270         return ret;
6271     }
6272
6273   return NULL_TREE;
6274 }
6275 \f
6276 /* Allocate a function structure and reset its contents to the defaults.  */
6277
6278 static void
6279 prepare_function_start ()
6280 {
6281   cfun = (struct function *) ggc_alloc_cleared (sizeof (struct function));
6282
6283   init_stmt_for_function ();
6284   init_eh_for_function ();
6285
6286   cse_not_expected = ! optimize;
6287
6288   /* Caller save not needed yet.  */
6289   caller_save_needed = 0;
6290
6291   /* No stack slots have been made yet.  */
6292   stack_slot_list = 0;
6293
6294   current_function_has_nonlocal_label = 0;
6295   current_function_has_nonlocal_goto = 0;
6296
6297   /* There is no stack slot for handling nonlocal gotos.  */
6298   nonlocal_goto_handler_slots = 0;
6299   nonlocal_goto_stack_level = 0;
6300
6301   /* No labels have been declared for nonlocal use.  */
6302   nonlocal_labels = 0;
6303   nonlocal_goto_handler_labels = 0;
6304
6305   /* No function calls so far in this function.  */
6306   function_call_count = 0;
6307
6308   /* No parm regs have been allocated.
6309      (This is important for output_inline_function.)  */
6310   max_parm_reg = LAST_VIRTUAL_REGISTER + 1;
6311
6312   /* Initialize the RTL mechanism.  */
6313   init_emit ();
6314
6315   /* Initialize the queue of pending postincrement and postdecrements,
6316      and some other info in expr.c.  */
6317   init_expr ();
6318
6319   /* We haven't done register allocation yet.  */
6320   reg_renumber = 0;
6321
6322   init_varasm_status (cfun);
6323
6324   /* Clear out data used for inlining.  */
6325   cfun->inlinable = 0;
6326   cfun->original_decl_initial = 0;
6327   cfun->original_arg_vector = 0;
6328
6329   cfun->stack_alignment_needed = STACK_BOUNDARY;
6330   cfun->preferred_stack_boundary = STACK_BOUNDARY;
6331
6332   /* Set if a call to setjmp is seen.  */
6333   current_function_calls_setjmp = 0;
6334
6335   /* Set if a call to longjmp is seen.  */
6336   current_function_calls_longjmp = 0;
6337
6338   current_function_calls_alloca = 0;
6339   current_function_calls_eh_return = 0;
6340   current_function_calls_constant_p = 0;
6341   current_function_contains_functions = 0;
6342   current_function_is_leaf = 0;
6343   current_function_nothrow = 0;
6344   current_function_sp_is_unchanging = 0;
6345   current_function_uses_only_leaf_regs = 0;
6346   current_function_has_computed_jump = 0;
6347   current_function_is_thunk = 0;
6348
6349   current_function_returns_pcc_struct = 0;
6350   current_function_returns_struct = 0;
6351   current_function_epilogue_delay_list = 0;
6352   current_function_uses_const_pool = 0;
6353   current_function_uses_pic_offset_table = 0;
6354   current_function_cannot_inline = 0;
6355
6356   /* We have not yet needed to make a label to jump to for tail-recursion.  */
6357   tail_recursion_label = 0;
6358
6359   /* We haven't had a need to make a save area for ap yet.  */
6360   arg_pointer_save_area = 0;
6361
6362   /* No stack slots allocated yet.  */
6363   frame_offset = 0;
6364
6365   /* No SAVE_EXPRs in this function yet.  */
6366   save_expr_regs = 0;
6367
6368   /* No RTL_EXPRs in this function yet.  */
6369   rtl_expr_chain = 0;
6370
6371   /* Set up to allocate temporaries.  */
6372   init_temp_slots ();
6373
6374   /* Indicate that we need to distinguish between the return value of the
6375      present function and the return value of a function being called.  */
6376   rtx_equal_function_value_matters = 1;
6377
6378   /* Indicate that we have not instantiated virtual registers yet.  */
6379   virtuals_instantiated = 0;
6380
6381   /* Indicate that we want CONCATs now.  */
6382   generating_concat_p = 1;
6383
6384   /* Indicate we have no need of a frame pointer yet.  */
6385   frame_pointer_needed = 0;
6386
6387   /* By default assume not stdarg.  */
6388   current_function_stdarg = 0;
6389
6390   /* We haven't made any trampolines for this function yet.  */
6391   trampoline_list = 0;
6392
6393   init_pending_stack_adjust ();
6394   inhibit_defer_pop = 0;
6395
6396   current_function_outgoing_args_size = 0;
6397
6398   current_function_funcdef_no = funcdef_no++;
6399
6400   cfun->arc_profile = profile_arc_flag || flag_test_coverage;
6401
6402   cfun->function_frequency = FUNCTION_FREQUENCY_NORMAL;
6403
6404   cfun->max_jumptable_ents = 0;
6405
6406   (*lang_hooks.function.init) (cfun);
6407   if (init_machine_status)
6408     cfun->machine = (*init_machine_status) ();
6409 }
6410
6411 /* Initialize the rtl expansion mechanism so that we can do simple things
6412    like generate sequences.  This is used to provide a context during global
6413    initialization of some passes.  */
6414 void
6415 init_dummy_function_start ()
6416 {
6417   prepare_function_start ();
6418 }
6419
6420 /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node)
6421    and initialize static variables for generating RTL for the statements
6422    of the function.  */
6423
6424 void
6425 init_function_start (subr, filename, line)
6426      tree subr;
6427      const char *filename;
6428      int line;
6429 {
6430   prepare_function_start ();
6431
6432   current_function_name = (*lang_hooks.decl_printable_name) (subr, 2);
6433   cfun->decl = subr;
6434
6435   /* Nonzero if this is a nested function that uses a static chain.  */
6436
6437   current_function_needs_context
6438     = (decl_function_context (current_function_decl) != 0
6439        && ! DECL_NO_STATIC_CHAIN (current_function_decl));
6440
6441   /* Within function body, compute a type's size as soon it is laid out.  */
6442   immediate_size_expand++;
6443
6444   /* Prevent ever trying to delete the first instruction of a function.
6445      Also tell final how to output a linenum before the function prologue.
6446      Note linenums could be missing, e.g. when compiling a Java .class file.  */
6447   if (line > 0)
6448     emit_line_note (filename, line);
6449
6450   /* Make sure first insn is a note even if we don't want linenums.
6451      This makes sure the first insn will never be deleted.
6452      Also, final expects a note to appear there.  */
6453   emit_note (NULL, NOTE_INSN_DELETED);
6454
6455   /* Set flags used by final.c.  */
6456   if (aggregate_value_p (DECL_RESULT (subr)))
6457     {
6458 #ifdef PCC_STATIC_STRUCT_RETURN
6459       current_function_returns_pcc_struct = 1;
6460 #endif
6461       current_function_returns_struct = 1;
6462     }
6463
6464   /* Warn if this value is an aggregate type,
6465      regardless of which calling convention we are using for it.  */
6466   if (warn_aggregate_return
6467       && AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr))))
6468     warning ("function returns an aggregate");
6469
6470   current_function_returns_pointer
6471     = POINTER_TYPE_P (TREE_TYPE (DECL_RESULT (subr)));
6472 }
6473
6474 /* Make sure all values used by the optimization passes have sane
6475    defaults.  */
6476 void
6477 init_function_for_compilation ()
6478 {
6479   reg_renumber = 0;
6480
6481   /* No prologue/epilogue insns yet.  */
6482   VARRAY_GROW (prologue, 0);
6483   VARRAY_GROW (epilogue, 0);
6484   VARRAY_GROW (sibcall_epilogue, 0);
6485 }
6486
6487 /* Expand a call to __main at the beginning of a possible main function.  */
6488
6489 #if defined(INIT_SECTION_ASM_OP) && !defined(INVOKE__main)
6490 #undef HAS_INIT_SECTION
6491 #define HAS_INIT_SECTION
6492 #endif
6493
6494 void
6495 expand_main_function ()
6496 {
6497 #ifdef FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN
6498   if (FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN)
6499     {
6500       int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
6501       rtx tmp, seq;
6502
6503       start_sequence ();
6504       /* Forcibly align the stack.  */
6505 #ifdef STACK_GROWS_DOWNWARD
6506       tmp = expand_simple_binop (Pmode, AND, stack_pointer_rtx, GEN_INT(-align),
6507                                  stack_pointer_rtx, 1, OPTAB_WIDEN);
6508 #else
6509       tmp = expand_simple_binop (Pmode, PLUS, stack_pointer_rtx,
6510                                  GEN_INT (align - 1), NULL_RTX, 1, OPTAB_WIDEN);
6511       tmp = expand_simple_binop (Pmode, AND, tmp, GEN_INT (-align),
6512                                  stack_pointer_rtx, 1, OPTAB_WIDEN);
6513 #endif
6514       if (tmp != stack_pointer_rtx)
6515         emit_move_insn (stack_pointer_rtx, tmp);
6516
6517       /* Enlist allocate_dynamic_stack_space to pick up the pieces.  */
6518       tmp = force_reg (Pmode, const0_rtx);
6519       allocate_dynamic_stack_space (tmp, NULL_RTX, BIGGEST_ALIGNMENT);
6520       seq = get_insns ();
6521       end_sequence ();
6522
6523       for (tmp = get_last_insn (); tmp; tmp = PREV_INSN (tmp))
6524         if (NOTE_P (tmp) && NOTE_LINE_NUMBER (tmp) == NOTE_INSN_FUNCTION_BEG)
6525           break;
6526       if (tmp)
6527         emit_insn_before (seq, tmp);
6528       else
6529         emit_insn (seq);
6530     }
6531 #endif
6532
6533 #ifndef HAS_INIT_SECTION
6534   emit_library_call (init_one_libfunc (NAME__MAIN), LCT_NORMAL, VOIDmode, 0);
6535 #endif
6536 }
6537 \f
6538 /* The PENDING_SIZES represent the sizes of variable-sized types.
6539    Create RTL for the various sizes now (using temporary variables),
6540    so that we can refer to the sizes from the RTL we are generating
6541    for the current function.  The PENDING_SIZES are a TREE_LIST.  The
6542    TREE_VALUE of each node is a SAVE_EXPR.  */
6543
6544 void
6545 expand_pending_sizes (pending_sizes)
6546      tree pending_sizes;
6547 {
6548   tree tem;
6549
6550   /* Evaluate now the sizes of any types declared among the arguments.  */
6551   for (tem = pending_sizes; tem; tem = TREE_CHAIN (tem))
6552     {
6553       expand_expr (TREE_VALUE (tem), const0_rtx, VOIDmode, 0);
6554       /* Flush the queue in case this parameter declaration has
6555          side-effects.  */
6556       emit_queue ();
6557     }
6558 }
6559
6560 /* Start the RTL for a new function, and set variables used for
6561    emitting RTL.
6562    SUBR is the FUNCTION_DECL node.
6563    PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with
6564    the function's parameters, which must be run at any return statement.  */
6565
6566 void
6567 expand_function_start (subr, parms_have_cleanups)
6568      tree subr;
6569      int parms_have_cleanups;
6570 {
6571   tree tem;
6572   rtx last_ptr = NULL_RTX;
6573
6574   /* Make sure volatile mem refs aren't considered
6575      valid operands of arithmetic insns.  */
6576   init_recog_no_volatile ();
6577
6578   current_function_instrument_entry_exit
6579     = (flag_instrument_function_entry_exit
6580        && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr));
6581
6582   current_function_profile
6583     = (profile_flag
6584        && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr));
6585
6586   current_function_limit_stack
6587     = (stack_limit_rtx != NULL_RTX && ! DECL_NO_LIMIT_STACK (subr));
6588
6589   /* If function gets a static chain arg, store it in the stack frame.
6590      Do this first, so it gets the first stack slot offset.  */
6591   if (current_function_needs_context)
6592     {
6593       last_ptr = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0);
6594
6595       /* Delay copying static chain if it is not a register to avoid
6596          conflicts with regs used for parameters.  */
6597       if (! SMALL_REGISTER_CLASSES
6598           || GET_CODE (static_chain_incoming_rtx) == REG)
6599         emit_move_insn (last_ptr, static_chain_incoming_rtx);
6600     }
6601
6602   /* If the parameters of this function need cleaning up, get a label
6603      for the beginning of the code which executes those cleanups.  This must
6604      be done before doing anything with return_label.  */
6605   if (parms_have_cleanups)
6606     cleanup_label = gen_label_rtx ();
6607   else
6608     cleanup_label = 0;
6609
6610   /* Make the label for return statements to jump to.  Do not special
6611      case machines with special return instructions -- they will be
6612      handled later during jump, ifcvt, or epilogue creation.  */
6613   return_label = gen_label_rtx ();
6614
6615   /* Initialize rtx used to return the value.  */
6616   /* Do this before assign_parms so that we copy the struct value address
6617      before any library calls that assign parms might generate.  */
6618
6619   /* Decide whether to return the value in memory or in a register.  */
6620   if (aggregate_value_p (DECL_RESULT (subr)))
6621     {
6622       /* Returning something that won't go in a register.  */
6623       rtx value_address = 0;
6624
6625 #ifdef PCC_STATIC_STRUCT_RETURN
6626       if (current_function_returns_pcc_struct)
6627         {
6628           int size = int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr)));
6629           value_address = assemble_static_space (size);
6630         }
6631       else
6632 #endif
6633         {
6634           /* Expect to be passed the address of a place to store the value.
6635              If it is passed as an argument, assign_parms will take care of
6636              it.  */
6637           if (struct_value_incoming_rtx)
6638             {
6639               value_address = gen_reg_rtx (Pmode);
6640               emit_move_insn (value_address, struct_value_incoming_rtx);
6641             }
6642         }
6643       if (value_address)
6644         {
6645           rtx x = gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr)), value_address);
6646           set_mem_attributes (x, DECL_RESULT (subr), 1);
6647           SET_DECL_RTL (DECL_RESULT (subr), x);
6648         }
6649     }
6650   else if (DECL_MODE (DECL_RESULT (subr)) == VOIDmode)
6651     /* If return mode is void, this decl rtl should not be used.  */
6652     SET_DECL_RTL (DECL_RESULT (subr), NULL_RTX);
6653   else
6654     {
6655       /* Compute the return values into a pseudo reg, which we will copy
6656          into the true return register after the cleanups are done.  */
6657
6658       /* In order to figure out what mode to use for the pseudo, we
6659          figure out what the mode of the eventual return register will
6660          actually be, and use that.  */
6661       rtx hard_reg
6662         = hard_function_value (TREE_TYPE (DECL_RESULT (subr)),
6663                                subr, 1);
6664
6665       /* Structures that are returned in registers are not aggregate_value_p,
6666          so we may see a PARALLEL or a REG.  */
6667       if (REG_P (hard_reg))
6668         SET_DECL_RTL (DECL_RESULT (subr), gen_reg_rtx (GET_MODE (hard_reg)));
6669       else if (GET_CODE (hard_reg) == PARALLEL)
6670         SET_DECL_RTL (DECL_RESULT (subr), gen_group_rtx (hard_reg));
6671       else
6672         abort ();
6673
6674       /* Set DECL_REGISTER flag so that expand_function_end will copy the
6675          result to the real return register(s).  */
6676       DECL_REGISTER (DECL_RESULT (subr)) = 1;
6677     }
6678
6679   /* Initialize rtx for parameters and local variables.
6680      In some cases this requires emitting insns.  */
6681
6682   assign_parms (subr);
6683
6684   /* Copy the static chain now if it wasn't a register.  The delay is to
6685      avoid conflicts with the parameter passing registers.  */
6686
6687   if (SMALL_REGISTER_CLASSES && current_function_needs_context)
6688     if (GET_CODE (static_chain_incoming_rtx) != REG)
6689       emit_move_insn (last_ptr, static_chain_incoming_rtx);
6690
6691   /* The following was moved from init_function_start.
6692      The move is supposed to make sdb output more accurate.  */
6693   /* Indicate the beginning of the function body,
6694      as opposed to parm setup.  */
6695   emit_note (NULL, NOTE_INSN_FUNCTION_BEG);
6696
6697   if (GET_CODE (get_last_insn ()) != NOTE)
6698     emit_note (NULL, NOTE_INSN_DELETED);
6699   parm_birth_insn = get_last_insn ();
6700
6701   context_display = 0;
6702   if (current_function_needs_context)
6703     {
6704       /* Fetch static chain values for containing functions.  */
6705       tem = decl_function_context (current_function_decl);
6706       /* Copy the static chain pointer into a pseudo.  If we have
6707          small register classes, copy the value from memory if
6708          static_chain_incoming_rtx is a REG.  */
6709       if (tem)
6710         {
6711           /* If the static chain originally came in a register, put it back
6712              there, then move it out in the next insn.  The reason for
6713              this peculiar code is to satisfy function integration.  */
6714           if (SMALL_REGISTER_CLASSES
6715               && GET_CODE (static_chain_incoming_rtx) == REG)
6716             emit_move_insn (static_chain_incoming_rtx, last_ptr);
6717           last_ptr = copy_to_reg (static_chain_incoming_rtx);
6718         }
6719
6720       while (tem)
6721         {
6722           tree rtlexp = make_node (RTL_EXPR);
6723
6724           RTL_EXPR_RTL (rtlexp) = last_ptr;
6725           context_display = tree_cons (tem, rtlexp, context_display);
6726           tem = decl_function_context (tem);
6727           if (tem == 0)
6728             break;
6729           /* Chain thru stack frames, assuming pointer to next lexical frame
6730              is found at the place we always store it.  */
6731 #ifdef FRAME_GROWS_DOWNWARD
6732           last_ptr = plus_constant (last_ptr,
6733                                     -(HOST_WIDE_INT) GET_MODE_SIZE (Pmode));
6734 #endif
6735           last_ptr = gen_rtx_MEM (Pmode, memory_address (Pmode, last_ptr));
6736           set_mem_alias_set (last_ptr, get_frame_alias_set ());
6737           last_ptr = copy_to_reg (last_ptr);
6738
6739           /* If we are not optimizing, ensure that we know that this
6740              piece of context is live over the entire function.  */
6741           if (! optimize)
6742             save_expr_regs = gen_rtx_EXPR_LIST (VOIDmode, last_ptr,
6743                                                 save_expr_regs);
6744         }
6745     }
6746
6747   if (current_function_instrument_entry_exit)
6748     {
6749       rtx fun = DECL_RTL (current_function_decl);
6750       if (GET_CODE (fun) == MEM)
6751         fun = XEXP (fun, 0);
6752       else
6753         abort ();
6754       emit_library_call (profile_function_entry_libfunc, LCT_NORMAL, VOIDmode,
6755                          2, fun, Pmode,
6756                          expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
6757                                                      0,
6758                                                      hard_frame_pointer_rtx),
6759                          Pmode);
6760     }
6761
6762   if (current_function_profile)
6763     {
6764 #ifdef PROFILE_HOOK
6765       PROFILE_HOOK (current_function_funcdef_no);
6766 #endif
6767     }
6768
6769   /* After the display initializations is where the tail-recursion label
6770      should go, if we end up needing one.   Ensure we have a NOTE here
6771      since some things (like trampolines) get placed before this.  */
6772   tail_recursion_reentry = emit_note (NULL, NOTE_INSN_DELETED);
6773
6774   /* Evaluate now the sizes of any types declared among the arguments.  */
6775   expand_pending_sizes (nreverse (get_pending_sizes ()));
6776
6777   /* Make sure there is a line number after the function entry setup code.  */
6778   force_next_line_note ();
6779 }
6780 \f
6781 /* Undo the effects of init_dummy_function_start.  */
6782 void
6783 expand_dummy_function_end ()
6784 {
6785   /* End any sequences that failed to be closed due to syntax errors.  */
6786   while (in_sequence_p ())
6787     end_sequence ();
6788
6789   /* Outside function body, can't compute type's actual size
6790      until next function's body starts.  */
6791
6792   free_after_parsing (cfun);
6793   free_after_compilation (cfun);
6794   cfun = 0;
6795 }
6796
6797 /* Call DOIT for each hard register used as a return value from
6798    the current function.  */
6799
6800 void
6801 diddle_return_value (doit, arg)
6802      void (*doit) PARAMS ((rtx, void *));
6803      void *arg;
6804 {
6805   rtx outgoing = current_function_return_rtx;
6806
6807   if (! outgoing)
6808     return;
6809
6810   if (GET_CODE (outgoing) == REG)
6811     (*doit) (outgoing, arg);
6812   else if (GET_CODE (outgoing) == PARALLEL)
6813     {
6814       int i;
6815
6816       for (i = 0; i < XVECLEN (outgoing, 0); i++)
6817         {
6818           rtx x = XEXP (XVECEXP (outgoing, 0, i), 0);
6819
6820           if (GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
6821             (*doit) (x, arg);
6822         }
6823     }
6824 }
6825
6826 static void
6827 do_clobber_return_reg (reg, arg)
6828      rtx reg;
6829      void *arg ATTRIBUTE_UNUSED;
6830 {
6831   emit_insn (gen_rtx_CLOBBER (VOIDmode, reg));
6832 }
6833
6834 void
6835 clobber_return_register ()
6836 {
6837   diddle_return_value (do_clobber_return_reg, NULL);
6838
6839   /* In case we do use pseudo to return value, clobber it too.  */
6840   if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl)))
6841     {
6842       tree decl_result = DECL_RESULT (current_function_decl);
6843       rtx decl_rtl = DECL_RTL (decl_result);
6844       if (REG_P (decl_rtl) && REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER)
6845         {
6846           do_clobber_return_reg (decl_rtl, NULL);
6847         }
6848     }
6849 }
6850
6851 static void
6852 do_use_return_reg (reg, arg)
6853      rtx reg;
6854      void *arg ATTRIBUTE_UNUSED;
6855 {
6856   emit_insn (gen_rtx_USE (VOIDmode, reg));
6857 }
6858
6859 void
6860 use_return_register ()
6861 {
6862   diddle_return_value (do_use_return_reg, NULL);
6863 }
6864
6865 static GTY(()) rtx initial_trampoline;
6866
6867 /* Generate RTL for the end of the current function.
6868    FILENAME and LINE are the current position in the source file.
6869
6870    It is up to language-specific callers to do cleanups for parameters--
6871    or else, supply 1 for END_BINDINGS and we will call expand_end_bindings.  */
6872
6873 void
6874 expand_function_end (filename, line, end_bindings)
6875      const char *filename;
6876      int line;
6877      int end_bindings;
6878 {
6879   tree link;
6880   rtx clobber_after;
6881
6882   finish_expr_for_function ();
6883
6884   /* If arg_pointer_save_area was referenced only from a nested
6885      function, we will not have initialized it yet.  Do that now.  */
6886   if (arg_pointer_save_area && ! cfun->arg_pointer_save_area_init)
6887     get_arg_pointer_save_area (cfun);
6888
6889 #ifdef NON_SAVING_SETJMP
6890   /* Don't put any variables in registers if we call setjmp
6891      on a machine that fails to restore the registers.  */
6892   if (NON_SAVING_SETJMP && current_function_calls_setjmp)
6893     {
6894       if (DECL_INITIAL (current_function_decl) != error_mark_node)
6895         setjmp_protect (DECL_INITIAL (current_function_decl));
6896
6897       setjmp_protect_args ();
6898     }
6899 #endif
6900
6901   /* Initialize any trampolines required by this function.  */
6902   for (link = trampoline_list; link; link = TREE_CHAIN (link))
6903     {
6904       tree function = TREE_PURPOSE (link);
6905       rtx context ATTRIBUTE_UNUSED = lookup_static_chain (function);
6906       rtx tramp = RTL_EXPR_RTL (TREE_VALUE (link));
6907 #ifdef TRAMPOLINE_TEMPLATE
6908       rtx blktramp;
6909 #endif
6910       rtx seq;
6911
6912 #ifdef TRAMPOLINE_TEMPLATE
6913       /* First make sure this compilation has a template for
6914          initializing trampolines.  */
6915       if (initial_trampoline == 0)
6916         {
6917           initial_trampoline
6918             = gen_rtx_MEM (BLKmode, assemble_trampoline_template ());
6919           set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT);
6920         }
6921 #endif
6922
6923       /* Generate insns to initialize the trampoline.  */
6924       start_sequence ();
6925       tramp = round_trampoline_addr (XEXP (tramp, 0));
6926 #ifdef TRAMPOLINE_TEMPLATE
6927       blktramp = replace_equiv_address (initial_trampoline, tramp);
6928       emit_block_move (blktramp, initial_trampoline,
6929                        GEN_INT (TRAMPOLINE_SIZE), BLOCK_OP_NORMAL);
6930 #endif
6931       INITIALIZE_TRAMPOLINE (tramp, XEXP (DECL_RTL (function), 0), context);
6932       seq = get_insns ();
6933       end_sequence ();
6934
6935       /* Put those insns at entry to the containing function (this one).  */
6936       emit_insn_before (seq, tail_recursion_reentry);
6937     }
6938
6939   /* If we are doing stack checking and this function makes calls,
6940      do a stack probe at the start of the function to ensure we have enough
6941      space for another stack frame.  */
6942   if (flag_stack_check && ! STACK_CHECK_BUILTIN)
6943     {
6944       rtx insn, seq;
6945
6946       for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
6947         if (GET_CODE (insn) == CALL_INSN)
6948           {
6949             start_sequence ();
6950             probe_stack_range (STACK_CHECK_PROTECT,
6951                                GEN_INT (STACK_CHECK_MAX_FRAME_SIZE));
6952             seq = get_insns ();
6953             end_sequence ();
6954             emit_insn_before (seq, tail_recursion_reentry);
6955             break;
6956           }
6957     }
6958
6959   /* Possibly warn about unused parameters.  */
6960   if (warn_unused_parameter)
6961     {
6962       tree decl;
6963
6964       for (decl = DECL_ARGUMENTS (current_function_decl);
6965            decl; decl = TREE_CHAIN (decl))
6966         if (! TREE_USED (decl) && TREE_CODE (decl) == PARM_DECL
6967             && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
6968           warning_with_decl (decl, "unused parameter `%s'");
6969     }
6970
6971   /* Delete handlers for nonlocal gotos if nothing uses them.  */
6972   if (nonlocal_goto_handler_slots != 0
6973       && ! current_function_has_nonlocal_label)
6974     delete_handlers ();
6975
6976   /* End any sequences that failed to be closed due to syntax errors.  */
6977   while (in_sequence_p ())
6978     end_sequence ();
6979
6980   /* Outside function body, can't compute type's actual size
6981      until next function's body starts.  */
6982   immediate_size_expand--;
6983
6984   clear_pending_stack_adjust ();
6985   do_pending_stack_adjust ();
6986
6987   /* Mark the end of the function body.
6988      If control reaches this insn, the function can drop through
6989      without returning a value.  */
6990   emit_note (NULL, NOTE_INSN_FUNCTION_END);
6991
6992   /* Must mark the last line number note in the function, so that the test
6993      coverage code can avoid counting the last line twice.  This just tells
6994      the code to ignore the immediately following line note, since there
6995      already exists a copy of this note somewhere above.  This line number
6996      note is still needed for debugging though, so we can't delete it.  */
6997   if (flag_test_coverage)
6998     emit_note (NULL, NOTE_INSN_REPEATED_LINE_NUMBER);
6999
7000   /* Output a linenumber for the end of the function.
7001      SDB depends on this.  */
7002   emit_line_note_force (filename, line);
7003
7004   /* Before the return label (if any), clobber the return
7005      registers so that they are not propagated live to the rest of
7006      the function.  This can only happen with functions that drop
7007      through; if there had been a return statement, there would
7008      have either been a return rtx, or a jump to the return label.
7009
7010      We delay actual code generation after the current_function_value_rtx
7011      is computed.  */
7012   clobber_after = get_last_insn ();
7013
7014   /* Output the label for the actual return from the function,
7015      if one is expected.  This happens either because a function epilogue
7016      is used instead of a return instruction, or because a return was done
7017      with a goto in order to run local cleanups, or because of pcc-style
7018      structure returning.  */
7019   if (return_label)
7020     emit_label (return_label);
7021
7022   /* C++ uses this.  */
7023   if (end_bindings)
7024     expand_end_bindings (0, 0, 0);
7025
7026   if (current_function_instrument_entry_exit)
7027     {
7028       rtx fun = DECL_RTL (current_function_decl);
7029       if (GET_CODE (fun) == MEM)
7030         fun = XEXP (fun, 0);
7031       else
7032         abort ();
7033       emit_library_call (profile_function_exit_libfunc, LCT_NORMAL, VOIDmode,
7034                          2, fun, Pmode,
7035                          expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
7036                                                      0,
7037                                                      hard_frame_pointer_rtx),
7038                          Pmode);
7039     }
7040
7041   /* Let except.c know where it should emit the call to unregister
7042      the function context for sjlj exceptions.  */
7043   if (flag_exceptions && USING_SJLJ_EXCEPTIONS)
7044     sjlj_emit_function_exit_after (get_last_insn ());
7045
7046   /* If we had calls to alloca, and this machine needs
7047      an accurate stack pointer to exit the function,
7048      insert some code to save and restore the stack pointer.  */
7049 #ifdef EXIT_IGNORE_STACK
7050   if (! EXIT_IGNORE_STACK)
7051 #endif
7052     if (current_function_calls_alloca)
7053       {
7054         rtx tem = 0;
7055
7056         emit_stack_save (SAVE_FUNCTION, &tem, parm_birth_insn);
7057         emit_stack_restore (SAVE_FUNCTION, tem, NULL_RTX);
7058       }
7059
7060   /* If scalar return value was computed in a pseudo-reg, or was a named
7061      return value that got dumped to the stack, copy that to the hard
7062      return register.  */
7063   if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl)))
7064     {
7065       tree decl_result = DECL_RESULT (current_function_decl);
7066       rtx decl_rtl = DECL_RTL (decl_result);
7067
7068       if (REG_P (decl_rtl)
7069           ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER
7070           : DECL_REGISTER (decl_result))
7071         {
7072           rtx real_decl_rtl = current_function_return_rtx;
7073
7074           /* This should be set in assign_parms.  */
7075           if (! REG_FUNCTION_VALUE_P (real_decl_rtl))
7076             abort ();
7077
7078           /* If this is a BLKmode structure being returned in registers,
7079              then use the mode computed in expand_return.  Note that if
7080              decl_rtl is memory, then its mode may have been changed,
7081              but that current_function_return_rtx has not.  */
7082           if (GET_MODE (real_decl_rtl) == BLKmode)
7083             PUT_MODE (real_decl_rtl, GET_MODE (decl_rtl));
7084
7085           /* If a named return value dumped decl_return to memory, then
7086              we may need to re-do the PROMOTE_MODE signed/unsigned
7087              extension.  */
7088           if (GET_MODE (real_decl_rtl) != GET_MODE (decl_rtl))
7089             {
7090               int unsignedp = TREE_UNSIGNED (TREE_TYPE (decl_result));
7091
7092 #ifdef PROMOTE_FUNCTION_RETURN
7093               promote_mode (TREE_TYPE (decl_result), GET_MODE (decl_rtl),
7094                             &unsignedp, 1);
7095 #endif
7096
7097               convert_move (real_decl_rtl, decl_rtl, unsignedp);
7098             }
7099           else if (GET_CODE (real_decl_rtl) == PARALLEL)
7100             {
7101               /* If expand_function_start has created a PARALLEL for decl_rtl,
7102                  move the result to the real return registers.  Otherwise, do
7103                  a group load from decl_rtl for a named return.  */
7104               if (GET_CODE (decl_rtl) == PARALLEL)
7105                 emit_group_move (real_decl_rtl, decl_rtl);
7106               else
7107                 emit_group_load (real_decl_rtl, decl_rtl,
7108                                  int_size_in_bytes (TREE_TYPE (decl_result)));
7109             }
7110           else
7111             emit_move_insn (real_decl_rtl, decl_rtl);
7112         }
7113     }
7114
7115   /* If returning a structure, arrange to return the address of the value
7116      in a place where debuggers expect to find it.
7117
7118      If returning a structure PCC style,
7119      the caller also depends on this value.
7120      And current_function_returns_pcc_struct is not necessarily set.  */
7121   if (current_function_returns_struct
7122       || current_function_returns_pcc_struct)
7123     {
7124       rtx value_address
7125         = XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
7126       tree type = TREE_TYPE (DECL_RESULT (current_function_decl));
7127 #ifdef FUNCTION_OUTGOING_VALUE
7128       rtx outgoing
7129         = FUNCTION_OUTGOING_VALUE (build_pointer_type (type),
7130                                    current_function_decl);
7131 #else
7132       rtx outgoing
7133         = FUNCTION_VALUE (build_pointer_type (type), current_function_decl);
7134 #endif
7135
7136       /* Mark this as a function return value so integrate will delete the
7137          assignment and USE below when inlining this function.  */
7138       REG_FUNCTION_VALUE_P (outgoing) = 1;
7139
7140 #ifdef POINTERS_EXTEND_UNSIGNED
7141       /* The address may be ptr_mode and OUTGOING may be Pmode.  */
7142       if (GET_MODE (outgoing) != GET_MODE (value_address))
7143         value_address = convert_memory_address (GET_MODE (outgoing),
7144                                                 value_address);
7145 #endif
7146
7147       emit_move_insn (outgoing, value_address);
7148
7149       /* Show return register used to hold result (in this case the address
7150          of the result.  */
7151       current_function_return_rtx = outgoing;
7152     }
7153
7154   /* If this is an implementation of throw, do what's necessary to
7155      communicate between __builtin_eh_return and the epilogue.  */
7156   expand_eh_return ();
7157
7158   /* Emit the actual code to clobber return register.  */
7159   {
7160     rtx seq, after;
7161
7162     start_sequence ();
7163     clobber_return_register ();
7164     seq = get_insns ();
7165     end_sequence ();
7166
7167     after = emit_insn_after (seq, clobber_after);
7168
7169     if (clobber_after != after)
7170       cfun->x_clobber_return_insn = after;
7171   }
7172
7173   /* ??? This should no longer be necessary since stupid is no longer with
7174      us, but there are some parts of the compiler (eg reload_combine, and
7175      sh mach_dep_reorg) that still try and compute their own lifetime info
7176      instead of using the general framework.  */
7177   use_return_register ();
7178
7179   /* Fix up any gotos that jumped out to the outermost
7180      binding level of the function.
7181      Must follow emitting RETURN_LABEL.  */
7182
7183   /* If you have any cleanups to do at this point,
7184      and they need to create temporary variables,
7185      then you will lose.  */
7186   expand_fixups (get_insns ());
7187 }
7188
7189 rtx
7190 get_arg_pointer_save_area (f)
7191      struct function *f;
7192 {
7193   rtx ret = f->x_arg_pointer_save_area;
7194
7195   if (! ret)
7196     {
7197       ret = assign_stack_local_1 (Pmode, GET_MODE_SIZE (Pmode), 0, f);
7198       f->x_arg_pointer_save_area = ret;
7199     }
7200
7201   if (f == cfun && ! f->arg_pointer_save_area_init)
7202     {
7203       rtx seq;
7204
7205       /* Save the arg pointer at the beginning of the function.  The
7206          generated stack slot may not be a valid memory address, so we
7207          have to check it and fix it if necessary.  */
7208       start_sequence ();
7209       emit_move_insn (validize_mem (ret), virtual_incoming_args_rtx);
7210       seq = get_insns ();
7211       end_sequence ();
7212
7213       push_topmost_sequence ();
7214       emit_insn_after (seq, get_insns ());
7215       pop_topmost_sequence ();
7216     }
7217
7218   return ret;
7219 }
7220 \f
7221 /* Extend a vector that records the INSN_UIDs of INSNS
7222    (a list of one or more insns).  */
7223
7224 static void
7225 record_insns (insns, vecp)
7226      rtx insns;
7227      varray_type *vecp;
7228 {
7229   int i, len;
7230   rtx tmp;
7231
7232   tmp = insns;
7233   len = 0;
7234   while (tmp != NULL_RTX)
7235     {
7236       len++;
7237       tmp = NEXT_INSN (tmp);
7238     }
7239
7240   i = VARRAY_SIZE (*vecp);
7241   VARRAY_GROW (*vecp, i + len);
7242   tmp = insns;
7243   while (tmp != NULL_RTX)
7244     {
7245       VARRAY_INT (*vecp, i) = INSN_UID (tmp);
7246       i++;
7247       tmp = NEXT_INSN (tmp);
7248     }
7249 }
7250
7251 /* Determine how many INSN_UIDs in VEC are part of INSN.  Because we can
7252    be running after reorg, SEQUENCE rtl is possible.  */
7253
7254 static int
7255 contains (insn, vec)
7256      rtx insn;
7257      varray_type vec;
7258 {
7259   int i, j;
7260
7261   if (GET_CODE (insn) == INSN
7262       && GET_CODE (PATTERN (insn)) == SEQUENCE)
7263     {
7264       int count = 0;
7265       for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
7266         for (j = VARRAY_SIZE (vec) - 1; j >= 0; --j)
7267           if (INSN_UID (XVECEXP (PATTERN (insn), 0, i)) == VARRAY_INT (vec, j))
7268             count++;
7269       return count;
7270     }
7271   else
7272     {
7273       for (j = VARRAY_SIZE (vec) - 1; j >= 0; --j)
7274         if (INSN_UID (insn) == VARRAY_INT (vec, j))
7275           return 1;
7276     }
7277   return 0;
7278 }
7279
7280 int
7281 prologue_epilogue_contains (insn)
7282      rtx insn;
7283 {
7284   if (contains (insn, prologue))
7285     return 1;
7286   if (contains (insn, epilogue))
7287     return 1;
7288   return 0;
7289 }
7290
7291 int
7292 sibcall_epilogue_contains (insn)
7293      rtx insn;
7294 {
7295   if (sibcall_epilogue)
7296     return contains (insn, sibcall_epilogue);
7297   return 0;
7298 }
7299
7300 #ifdef HAVE_return
7301 /* Insert gen_return at the end of block BB.  This also means updating
7302    block_for_insn appropriately.  */
7303
7304 static void
7305 emit_return_into_block (bb, line_note)
7306      basic_block bb;
7307      rtx line_note;
7308 {
7309   emit_jump_insn_after (gen_return (), bb->end);
7310   if (line_note)
7311     emit_line_note_after (NOTE_SOURCE_FILE (line_note),
7312                           NOTE_LINE_NUMBER (line_note), PREV_INSN (bb->end));
7313 }
7314 #endif /* HAVE_return */
7315
7316 #if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX)
7317
7318 /* These functions convert the epilogue into a variant that does not modify the
7319    stack pointer.  This is used in cases where a function returns an object
7320    whose size is not known until it is computed.  The called function leaves the
7321    object on the stack, leaves the stack depressed, and returns a pointer to
7322    the object.
7323
7324    What we need to do is track all modifications and references to the stack
7325    pointer, deleting the modifications and changing the references to point to
7326    the location the stack pointer would have pointed to had the modifications
7327    taken place.
7328
7329    These functions need to be portable so we need to make as few assumptions
7330    about the epilogue as we can.  However, the epilogue basically contains
7331    three things: instructions to reset the stack pointer, instructions to
7332    reload registers, possibly including the frame pointer, and an
7333    instruction to return to the caller.
7334
7335    If we can't be sure of what a relevant epilogue insn is doing, we abort.
7336    We also make no attempt to validate the insns we make since if they are
7337    invalid, we probably can't do anything valid.  The intent is that these
7338    routines get "smarter" as more and more machines start to use them and
7339    they try operating on different epilogues.
7340
7341    We use the following structure to track what the part of the epilogue that
7342    we've already processed has done.  We keep two copies of the SP equivalence,
7343    one for use during the insn we are processing and one for use in the next
7344    insn.  The difference is because one part of a PARALLEL may adjust SP
7345    and the other may use it.  */
7346
7347 struct epi_info
7348 {
7349   rtx sp_equiv_reg;             /* REG that SP is set from, perhaps SP.  */
7350   HOST_WIDE_INT sp_offset;      /* Offset from SP_EQUIV_REG of present SP.  */
7351   rtx new_sp_equiv_reg;         /* REG to be used at end of insn.  */
7352   HOST_WIDE_INT new_sp_offset;  /* Offset to be used at end of insn.  */
7353   rtx equiv_reg_src;            /* If nonzero, the value that SP_EQUIV_REG
7354                                    should be set to once we no longer need
7355                                    its value.  */
7356 };
7357
7358 static void handle_epilogue_set PARAMS ((rtx, struct epi_info *));
7359 static void emit_equiv_load PARAMS ((struct epi_info *));
7360
7361 /* Modify INSN, a list of one or more insns that is part of the epilogue, to
7362    no modifications to the stack pointer.  Return the new list of insns.  */
7363
7364 static rtx
7365 keep_stack_depressed (insns)
7366      rtx insns;
7367 {
7368   int j;
7369   struct epi_info info;
7370   rtx insn, next;
7371
7372   /* If the epilogue is just a single instruction, it ust be OK as is.  */
7373
7374   if (NEXT_INSN (insns) == NULL_RTX)
7375     return insns;
7376
7377   /* Otherwise, start a sequence, initialize the information we have, and
7378      process all the insns we were given.  */
7379   start_sequence ();
7380
7381   info.sp_equiv_reg = stack_pointer_rtx;
7382   info.sp_offset = 0;
7383   info.equiv_reg_src = 0;
7384
7385   insn = insns;
7386   next = NULL_RTX;
7387   while (insn != NULL_RTX)
7388     {
7389       next = NEXT_INSN (insn);
7390
7391       if (!INSN_P (insn))
7392         {
7393           add_insn (insn);
7394           insn = next;
7395           continue;
7396         }
7397
7398       /* If this insn references the register that SP is equivalent to and
7399          we have a pending load to that register, we must force out the load
7400          first and then indicate we no longer know what SP's equivalent is.  */
7401       if (info.equiv_reg_src != 0
7402           && reg_referenced_p (info.sp_equiv_reg, PATTERN (insn)))
7403         {
7404           emit_equiv_load (&info);
7405           info.sp_equiv_reg = 0;
7406         }
7407
7408       info.new_sp_equiv_reg = info.sp_equiv_reg;
7409       info.new_sp_offset = info.sp_offset;
7410
7411       /* If this is a (RETURN) and the return address is on the stack,
7412          update the address and change to an indirect jump.  */
7413       if (GET_CODE (PATTERN (insn)) == RETURN
7414           || (GET_CODE (PATTERN (insn)) == PARALLEL
7415               && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == RETURN))
7416         {
7417           rtx retaddr = INCOMING_RETURN_ADDR_RTX;
7418           rtx base = 0;
7419           HOST_WIDE_INT offset = 0;
7420           rtx jump_insn, jump_set;
7421
7422           /* If the return address is in a register, we can emit the insn
7423              unchanged.  Otherwise, it must be a MEM and we see what the
7424              base register and offset are.  In any case, we have to emit any
7425              pending load to the equivalent reg of SP, if any.  */
7426           if (GET_CODE (retaddr) == REG)
7427             {
7428               emit_equiv_load (&info);
7429               add_insn (insn);
7430               insn = next;
7431               continue;
7432             }
7433           else if (GET_CODE (retaddr) == MEM
7434                    && GET_CODE (XEXP (retaddr, 0)) == REG)
7435             base = gen_rtx_REG (Pmode, REGNO (XEXP (retaddr, 0))), offset = 0;
7436           else if (GET_CODE (retaddr) == MEM
7437                    && GET_CODE (XEXP (retaddr, 0)) == PLUS
7438                    && GET_CODE (XEXP (XEXP (retaddr, 0), 0)) == REG
7439                    && GET_CODE (XEXP (XEXP (retaddr, 0), 1)) == CONST_INT)
7440             {
7441               base = gen_rtx_REG (Pmode, REGNO (XEXP (XEXP (retaddr, 0), 0)));
7442               offset = INTVAL (XEXP (XEXP (retaddr, 0), 1));
7443             }
7444           else
7445             abort ();
7446
7447           /* If the base of the location containing the return pointer
7448              is SP, we must update it with the replacement address.  Otherwise,
7449              just build the necessary MEM.  */
7450           retaddr = plus_constant (base, offset);
7451           if (base == stack_pointer_rtx)
7452             retaddr = simplify_replace_rtx (retaddr, stack_pointer_rtx,
7453                                             plus_constant (info.sp_equiv_reg,
7454                                                            info.sp_offset));
7455
7456           retaddr = gen_rtx_MEM (Pmode, retaddr);
7457
7458           /* If there is a pending load to the equivalent register for SP
7459              and we reference that register, we must load our address into
7460              a scratch register and then do that load.  */
7461           if (info.equiv_reg_src
7462               && reg_overlap_mentioned_p (info.equiv_reg_src, retaddr))
7463             {
7464               unsigned int regno;
7465               rtx reg;
7466
7467               for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
7468                 if (HARD_REGNO_MODE_OK (regno, Pmode)
7469                     && !fixed_regs[regno]
7470                     && TEST_HARD_REG_BIT (regs_invalidated_by_call, regno)
7471                     && !REGNO_REG_SET_P (EXIT_BLOCK_PTR->global_live_at_start,
7472                                          regno)
7473                     && !refers_to_regno_p (regno,
7474                                            regno + HARD_REGNO_NREGS (regno,
7475                                                                      Pmode),
7476                                            info.equiv_reg_src, NULL))
7477                   break;
7478
7479               if (regno == FIRST_PSEUDO_REGISTER)
7480                 abort ();
7481
7482               reg = gen_rtx_REG (Pmode, regno);
7483               emit_move_insn (reg, retaddr);
7484               retaddr = reg;
7485             }
7486
7487           emit_equiv_load (&info);
7488           jump_insn = emit_jump_insn (gen_indirect_jump (retaddr));
7489
7490           /* Show the SET in the above insn is a RETURN.  */
7491           jump_set = single_set (jump_insn);
7492           if (jump_set == 0)
7493             abort ();
7494           else
7495             SET_IS_RETURN_P (jump_set) = 1;
7496         }
7497
7498       /* If SP is not mentioned in the pattern and its equivalent register, if
7499          any, is not modified, just emit it.  Otherwise, if neither is set,
7500          replace the reference to SP and emit the insn.  If none of those are
7501          true, handle each SET individually.  */
7502       else if (!reg_mentioned_p (stack_pointer_rtx, PATTERN (insn))
7503                && (info.sp_equiv_reg == stack_pointer_rtx
7504                    || !reg_set_p (info.sp_equiv_reg, insn)))
7505         add_insn (insn);
7506       else if (! reg_set_p (stack_pointer_rtx, insn)
7507                && (info.sp_equiv_reg == stack_pointer_rtx
7508                    || !reg_set_p (info.sp_equiv_reg, insn)))
7509         {
7510           if (! validate_replace_rtx (stack_pointer_rtx,
7511                                       plus_constant (info.sp_equiv_reg,
7512                                                      info.sp_offset),
7513                                       insn))
7514             abort ();
7515
7516           add_insn (insn);
7517         }
7518       else if (GET_CODE (PATTERN (insn)) == SET)
7519         handle_epilogue_set (PATTERN (insn), &info);
7520       else if (GET_CODE (PATTERN (insn)) == PARALLEL)
7521         {
7522           for (j = 0; j < XVECLEN (PATTERN (insn), 0); j++)
7523             if (GET_CODE (XVECEXP (PATTERN (insn), 0, j)) == SET)
7524               handle_epilogue_set (XVECEXP (PATTERN (insn), 0, j), &info);
7525         }
7526       else
7527         add_insn (insn);
7528
7529       info.sp_equiv_reg = info.new_sp_equiv_reg;
7530       info.sp_offset = info.new_sp_offset;
7531
7532       insn = next;
7533     }
7534
7535   insns = get_insns ();
7536   end_sequence ();
7537   return insns;
7538 }
7539
7540 /* SET is a SET from an insn in the epilogue.  P is a pointer to the epi_info
7541    structure that contains information about what we've seen so far.  We
7542    process this SET by either updating that data or by emitting one or
7543    more insns.  */
7544
7545 static void
7546 handle_epilogue_set (set, p)
7547      rtx set;
7548      struct epi_info *p;
7549 {
7550   /* First handle the case where we are setting SP.  Record what it is being
7551      set from.  If unknown, abort.  */
7552   if (reg_set_p (stack_pointer_rtx, set))
7553     {
7554       if (SET_DEST (set) != stack_pointer_rtx)
7555         abort ();
7556
7557       if (GET_CODE (SET_SRC (set)) == PLUS
7558           && GET_CODE (XEXP (SET_SRC (set), 1)) == CONST_INT)
7559         {
7560           p->new_sp_equiv_reg = XEXP (SET_SRC (set), 0);
7561           p->new_sp_offset = INTVAL (XEXP (SET_SRC (set), 1));
7562         }
7563       else
7564         p->new_sp_equiv_reg = SET_SRC (set), p->new_sp_offset = 0;
7565
7566       /* If we are adjusting SP, we adjust from the old data.  */
7567       if (p->new_sp_equiv_reg == stack_pointer_rtx)
7568         {
7569           p->new_sp_equiv_reg = p->sp_equiv_reg;
7570           p->new_sp_offset += p->sp_offset;
7571         }
7572
7573       if (p->new_sp_equiv_reg == 0 || GET_CODE (p->new_sp_equiv_reg) != REG)
7574         abort ();
7575
7576       return;
7577     }
7578
7579   /* Next handle the case where we are setting SP's equivalent register.
7580      If we already have a value to set it to, abort.  We could update, but
7581      there seems little point in handling that case.  Note that we have
7582      to allow for the case where we are setting the register set in
7583      the previous part of a PARALLEL inside a single insn.  But use the
7584      old offset for any updates within this insn.  */
7585   else if (p->new_sp_equiv_reg != 0 && reg_set_p (p->new_sp_equiv_reg, set))
7586     {
7587       if (!rtx_equal_p (p->new_sp_equiv_reg, SET_DEST (set))
7588           || p->equiv_reg_src != 0)
7589         abort ();
7590       else
7591         p->equiv_reg_src
7592           = simplify_replace_rtx (SET_SRC (set), stack_pointer_rtx,
7593                                   plus_constant (p->sp_equiv_reg,
7594                                                  p->sp_offset));
7595     }
7596
7597   /* Otherwise, replace any references to SP in the insn to its new value
7598      and emit the insn.  */
7599   else
7600     {
7601       SET_SRC (set) = simplify_replace_rtx (SET_SRC (set), stack_pointer_rtx,
7602                                             plus_constant (p->sp_equiv_reg,
7603                                                            p->sp_offset));
7604       SET_DEST (set) = simplify_replace_rtx (SET_DEST (set), stack_pointer_rtx,
7605                                              plus_constant (p->sp_equiv_reg,
7606                                                             p->sp_offset));
7607       emit_insn (set);
7608     }
7609 }
7610
7611 /* Emit an insn to do the load shown in p->equiv_reg_src, if needed.  */
7612
7613 static void
7614 emit_equiv_load (p)
7615      struct epi_info *p;
7616 {
7617   if (p->equiv_reg_src != 0)
7618     emit_move_insn (p->sp_equiv_reg, p->equiv_reg_src);
7619
7620   p->equiv_reg_src = 0;
7621 }
7622 #endif
7623
7624 /* Generate the prologue and epilogue RTL if the machine supports it.  Thread
7625    this into place with notes indicating where the prologue ends and where
7626    the epilogue begins.  Update the basic block information when possible.  */
7627
7628 void
7629 thread_prologue_and_epilogue_insns (f)
7630      rtx f ATTRIBUTE_UNUSED;
7631 {
7632   int inserted = 0;
7633   edge e;
7634 #if defined (HAVE_sibcall_epilogue) || defined (HAVE_epilogue) || defined (HAVE_return) || defined (HAVE_prologue)
7635   rtx seq;
7636 #endif
7637 #ifdef HAVE_prologue
7638   rtx prologue_end = NULL_RTX;
7639 #endif
7640 #if defined (HAVE_epilogue) || defined(HAVE_return)
7641   rtx epilogue_end = NULL_RTX;
7642 #endif
7643
7644 #ifdef HAVE_prologue
7645   if (HAVE_prologue)
7646     {
7647       start_sequence ();
7648       seq = gen_prologue ();
7649       emit_insn (seq);
7650
7651       /* Retain a map of the prologue insns.  */
7652       record_insns (seq, &prologue);
7653       prologue_end = emit_note (NULL, NOTE_INSN_PROLOGUE_END);
7654
7655       seq = get_insns ();
7656       end_sequence ();
7657
7658       /* Can't deal with multiple successors of the entry block
7659          at the moment.  Function should always have at least one
7660          entry point.  */
7661       if (!ENTRY_BLOCK_PTR->succ || ENTRY_BLOCK_PTR->succ->succ_next)
7662         abort ();
7663
7664       insert_insn_on_edge (seq, ENTRY_BLOCK_PTR->succ);
7665       inserted = 1;
7666     }
7667 #endif
7668
7669   /* If the exit block has no non-fake predecessors, we don't need
7670      an epilogue.  */
7671   for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
7672     if ((e->flags & EDGE_FAKE) == 0)
7673       break;
7674   if (e == NULL)
7675     goto epilogue_done;
7676
7677 #ifdef HAVE_return
7678   if (optimize && HAVE_return)
7679     {
7680       /* If we're allowed to generate a simple return instruction,
7681          then by definition we don't need a full epilogue.  Examine
7682          the block that falls through to EXIT.   If it does not
7683          contain any code, examine its predecessors and try to
7684          emit (conditional) return instructions.  */
7685
7686       basic_block last;
7687       edge e_next;
7688       rtx label;
7689
7690       for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
7691         if (e->flags & EDGE_FALLTHRU)
7692           break;
7693       if (e == NULL)
7694         goto epilogue_done;
7695       last = e->src;
7696
7697       /* Verify that there are no active instructions in the last block.  */
7698       label = last->end;
7699       while (label && GET_CODE (label) != CODE_LABEL)
7700         {
7701           if (active_insn_p (label))
7702             break;
7703           label = PREV_INSN (label);
7704         }
7705
7706       if (last->head == label && GET_CODE (label) == CODE_LABEL)
7707         {
7708           rtx epilogue_line_note = NULL_RTX;
7709
7710           /* Locate the line number associated with the closing brace,
7711              if we can find one.  */
7712           for (seq = get_last_insn ();
7713                seq && ! active_insn_p (seq);
7714                seq = PREV_INSN (seq))
7715             if (GET_CODE (seq) == NOTE && NOTE_LINE_NUMBER (seq) > 0)
7716               {
7717                 epilogue_line_note = seq;
7718                 break;
7719               }
7720
7721           for (e = last->pred; e; e = e_next)
7722             {
7723               basic_block bb = e->src;
7724               rtx jump;
7725
7726               e_next = e->pred_next;
7727               if (bb == ENTRY_BLOCK_PTR)
7728                 continue;
7729
7730               jump = bb->end;
7731               if ((GET_CODE (jump) != JUMP_INSN) || JUMP_LABEL (jump) != label)
7732                 continue;
7733
7734               /* If we have an unconditional jump, we can replace that
7735                  with a simple return instruction.  */
7736               if (simplejump_p (jump))
7737                 {
7738                   emit_return_into_block (bb, epilogue_line_note);
7739                   delete_insn (jump);
7740                 }
7741
7742               /* If we have a conditional jump, we can try to replace
7743                  that with a conditional return instruction.  */
7744               else if (condjump_p (jump))
7745                 {
7746                   if (! redirect_jump (jump, 0, 0))
7747                     continue;
7748
7749                   /* If this block has only one successor, it both jumps
7750                      and falls through to the fallthru block, so we can't
7751                      delete the edge.  */
7752                   if (bb->succ->succ_next == NULL)
7753                     continue;
7754                 }
7755               else
7756                 continue;
7757
7758               /* Fix up the CFG for the successful change we just made.  */
7759               redirect_edge_succ (e, EXIT_BLOCK_PTR);
7760             }
7761
7762           /* Emit a return insn for the exit fallthru block.  Whether
7763              this is still reachable will be determined later.  */
7764
7765           emit_barrier_after (last->end);
7766           emit_return_into_block (last, epilogue_line_note);
7767           epilogue_end = last->end;
7768           last->succ->flags &= ~EDGE_FALLTHRU;
7769           goto epilogue_done;
7770         }
7771     }
7772 #endif
7773 #ifdef HAVE_epilogue
7774   if (HAVE_epilogue)
7775     {
7776       /* Find the edge that falls through to EXIT.  Other edges may exist
7777          due to RETURN instructions, but those don't need epilogues.
7778          There really shouldn't be a mixture -- either all should have
7779          been converted or none, however...  */
7780
7781       for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
7782         if (e->flags & EDGE_FALLTHRU)
7783           break;
7784       if (e == NULL)
7785         goto epilogue_done;
7786
7787       start_sequence ();
7788       epilogue_end = emit_note (NULL, NOTE_INSN_EPILOGUE_BEG);
7789
7790       seq = gen_epilogue ();
7791
7792 #ifdef INCOMING_RETURN_ADDR_RTX
7793       /* If this function returns with the stack depressed and we can support
7794          it, massage the epilogue to actually do that.  */
7795       if (TREE_CODE (TREE_TYPE (current_function_decl)) == FUNCTION_TYPE
7796           && TYPE_RETURNS_STACK_DEPRESSED (TREE_TYPE (current_function_decl)))
7797         seq = keep_stack_depressed (seq);
7798 #endif
7799
7800       emit_jump_insn (seq);
7801
7802       /* Retain a map of the epilogue insns.  */
7803       record_insns (seq, &epilogue);
7804
7805       seq = get_insns ();
7806       end_sequence ();
7807
7808       insert_insn_on_edge (seq, e);
7809       inserted = 1;
7810     }
7811 #endif
7812 epilogue_done:
7813
7814   if (inserted)
7815     commit_edge_insertions ();
7816
7817 #ifdef HAVE_sibcall_epilogue
7818   /* Emit sibling epilogues before any sibling call sites.  */
7819   for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
7820     {
7821       basic_block bb = e->src;
7822       rtx insn = bb->end;
7823       rtx i;
7824       rtx newinsn;
7825
7826       if (GET_CODE (insn) != CALL_INSN
7827           || ! SIBLING_CALL_P (insn))
7828         continue;
7829
7830       start_sequence ();
7831       emit_insn (gen_sibcall_epilogue ());
7832       seq = get_insns ();
7833       end_sequence ();
7834
7835       /* Retain a map of the epilogue insns.  Used in life analysis to
7836          avoid getting rid of sibcall epilogue insns.  Do this before we
7837          actually emit the sequence.  */
7838       record_insns (seq, &sibcall_epilogue);
7839
7840       i = PREV_INSN (insn);
7841       newinsn = emit_insn_before (seq, insn);
7842     }
7843 #endif
7844
7845 #ifdef HAVE_prologue
7846   if (prologue_end)
7847     {
7848       rtx insn, prev;
7849
7850       /* GDB handles `break f' by setting a breakpoint on the first
7851          line note after the prologue.  Which means (1) that if
7852          there are line number notes before where we inserted the
7853          prologue we should move them, and (2) we should generate a
7854          note before the end of the first basic block, if there isn't
7855          one already there.
7856
7857          ??? This behavior is completely broken when dealing with
7858          multiple entry functions.  We simply place the note always
7859          into first basic block and let alternate entry points
7860          to be missed.
7861        */
7862
7863       for (insn = prologue_end; insn; insn = prev)
7864         {
7865           prev = PREV_INSN (insn);
7866           if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
7867             {
7868               /* Note that we cannot reorder the first insn in the
7869                  chain, since rest_of_compilation relies on that
7870                  remaining constant.  */
7871               if (prev == NULL)
7872                 break;
7873               reorder_insns (insn, insn, prologue_end);
7874             }
7875         }
7876
7877       /* Find the last line number note in the first block.  */
7878       for (insn = ENTRY_BLOCK_PTR->next_bb->end;
7879            insn != prologue_end && insn;
7880            insn = PREV_INSN (insn))
7881         if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
7882           break;
7883
7884       /* If we didn't find one, make a copy of the first line number
7885          we run across.  */
7886       if (! insn)
7887         {
7888           for (insn = next_active_insn (prologue_end);
7889                insn;
7890                insn = PREV_INSN (insn))
7891             if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
7892               {
7893                 emit_line_note_after (NOTE_SOURCE_FILE (insn),
7894                                       NOTE_LINE_NUMBER (insn),
7895                                       prologue_end);
7896                 break;
7897               }
7898         }
7899     }
7900 #endif
7901 #ifdef HAVE_epilogue
7902   if (epilogue_end)
7903     {
7904       rtx insn, next;
7905
7906       /* Similarly, move any line notes that appear after the epilogue.
7907          There is no need, however, to be quite so anal about the existence
7908          of such a note.  */
7909       for (insn = epilogue_end; insn; insn = next)
7910         {
7911           next = NEXT_INSN (insn);
7912           if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
7913             reorder_insns (insn, insn, PREV_INSN (epilogue_end));
7914         }
7915     }
7916 #endif
7917 }
7918
7919 /* Reposition the prologue-end and epilogue-begin notes after instruction
7920    scheduling and delayed branch scheduling.  */
7921
7922 void
7923 reposition_prologue_and_epilogue_notes (f)
7924      rtx f ATTRIBUTE_UNUSED;
7925 {
7926 #if defined (HAVE_prologue) || defined (HAVE_epilogue)
7927   rtx insn, last, note;
7928   int len;
7929
7930   if ((len = VARRAY_SIZE (prologue)) > 0)
7931     {
7932       last = 0, note = 0;
7933
7934       /* Scan from the beginning until we reach the last prologue insn.
7935          We apparently can't depend on basic_block_{head,end} after
7936          reorg has run.  */
7937       for (insn = f; insn; insn = NEXT_INSN (insn))
7938         {
7939           if (GET_CODE (insn) == NOTE)
7940             {
7941               if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PROLOGUE_END)
7942                 note = insn;
7943             }
7944           else if (contains (insn, prologue))
7945             {
7946               last = insn;
7947               if (--len == 0)
7948                 break;
7949             }
7950         }
7951
7952       if (last)
7953         {
7954           /* Find the prologue-end note if we haven't already, and
7955              move it to just after the last prologue insn.  */
7956           if (note == 0)
7957             {
7958               for (note = last; (note = NEXT_INSN (note));)
7959                 if (GET_CODE (note) == NOTE
7960                     && NOTE_LINE_NUMBER (note) == NOTE_INSN_PROLOGUE_END)
7961                   break;
7962             }
7963
7964           /* Avoid placing note between CODE_LABEL and BASIC_BLOCK note.  */
7965           if (GET_CODE (last) == CODE_LABEL)
7966             last = NEXT_INSN (last);
7967           reorder_insns (note, note, last);
7968         }
7969     }
7970
7971   if ((len = VARRAY_SIZE (epilogue)) > 0)
7972     {
7973       last = 0, note = 0;
7974
7975       /* Scan from the end until we reach the first epilogue insn.
7976          We apparently can't depend on basic_block_{head,end} after
7977          reorg has run.  */
7978       for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
7979         {
7980           if (GET_CODE (insn) == NOTE)
7981             {
7982               if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EPILOGUE_BEG)
7983                 note = insn;
7984             }
7985           else if (contains (insn, epilogue))
7986             {
7987               last = insn;
7988               if (--len == 0)
7989                 break;
7990             }
7991         }
7992
7993       if (last)
7994         {
7995           /* Find the epilogue-begin note if we haven't already, and
7996              move it to just before the first epilogue insn.  */
7997           if (note == 0)
7998             {
7999               for (note = insn; (note = PREV_INSN (note));)
8000                 if (GET_CODE (note) == NOTE
8001                     && NOTE_LINE_NUMBER (note) == NOTE_INSN_EPILOGUE_BEG)
8002                   break;
8003             }
8004
8005           if (PREV_INSN (last) != note)
8006             reorder_insns (note, note, PREV_INSN (last));
8007         }
8008     }
8009 #endif /* HAVE_prologue or HAVE_epilogue */
8010 }
8011
8012 /* Called once, at initialization, to initialize function.c.  */
8013
8014 void
8015 init_function_once ()
8016 {
8017   VARRAY_INT_INIT (prologue, 0, "prologue");
8018   VARRAY_INT_INIT (epilogue, 0, "epilogue");
8019   VARRAY_INT_INIT (sibcall_epilogue, 0, "sibcall_epilogue");
8020 }
8021
8022 #include "gt-function.h"