gcc/function.c

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