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