gcc/function.c

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