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