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