gcc/integrate.c

   1 /* Procedure integration for GCC.
   2    Copyright (C) 1988, 1991, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001 Free Software Foundation, Inc.
   4    Contributed by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 2, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING.  If not, write to the Free
  20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  21 02111-1307, USA.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25
  26 #include "rtl.h"
  27 #include "tree.h"
  28 #include "tm_p.h"
  29 #include "regs.h"
  30 #include "flags.h"
  31 #include "debug.h"
  32 #include "insn-config.h"
  33 #include "expr.h"
  34 #include "output.h"
  35 #include "recog.h"
  36 #include "integrate.h"
  37 #include "real.h"
  38 #include "except.h"
  39 #include "function.h"
  40 #include "toplev.h"
  41 #include "intl.h"
  42 #include "loop.h"
  43 #include "params.h"
  44 #include "ggc.h"
  45
  46 #include "obstack.h"
  47 #define obstack_chunk_alloc     xmalloc
  48 #define obstack_chunk_free      free
  49
  50 extern struct obstack *function_maybepermanent_obstack;
  51
  52 /* Similar, but round to the next highest integer that meets the
  53    alignment.  */
  54 #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
  55
  56 /* Default max number of insns a function can have and still be inline.
  57    This is overridden on RISC machines.  */
  58 #ifndef INTEGRATE_THRESHOLD
  59 /* Inlining small functions might save more space then not inlining at
  60    all.  Assume 1 instruction for the call and 1.5 insns per argument.  */
  61 #define INTEGRATE_THRESHOLD(DECL) \
  62   (optimize_size \
  63    ? (1 + (3 * list_length (DECL_ARGUMENTS (DECL))) / 2) \
  64    : (8 * (8 + list_length (DECL_ARGUMENTS (DECL)))))
  65 #endif
  66
  67 /* Decide whether a function with a target specific attribute
  68    attached can be inlined.  By default we disallow this.  */
  69 #ifndef FUNCTION_ATTRIBUTE_INLINABLE_P
  70 #define FUNCTION_ATTRIBUTE_INLINABLE_P(FNDECL) 0
  71 #endif
  72 \f
  73
  74 /* Private type used by {get/has}_func_hard_reg_initial_val.  */
  75 typedef struct initial_value_pair {
  76   rtx hard_reg;
  77   rtx pseudo;
  78 } initial_value_pair;
  79 typedef struct initial_value_struct {
  80   int num_entries;
  81   int max_entries;
  82   initial_value_pair *entries;
  83 } initial_value_struct;
  84
  85 static void setup_initial_hard_reg_value_integration PARAMS ((struct function *, struct inline_remap *));
  86
  87 static rtvec initialize_for_inline      PARAMS ((tree));
  88 static void note_modified_parmregs      PARAMS ((rtx, rtx, void *));
  89 static void integrate_parm_decls        PARAMS ((tree, struct inline_remap *,
  90                                                  rtvec));
  91 static tree integrate_decl_tree         PARAMS ((tree,
  92                                                  struct inline_remap *));
  93 static void subst_constants             PARAMS ((rtx *, rtx,
  94                                                  struct inline_remap *, int));
  95 static void set_block_origin_self       PARAMS ((tree));
  96 static void set_block_abstract_flags    PARAMS ((tree, int));
  97 static void process_reg_param           PARAMS ((struct inline_remap *, rtx,
  98                                                  rtx));
  99 void set_decl_abstract_flags            PARAMS ((tree, int));
 100 static void mark_stores                 PARAMS ((rtx, rtx, void *));
 101 static void save_parm_insns             PARAMS ((rtx, rtx));
 102 static void copy_insn_list              PARAMS ((rtx, struct inline_remap *,
 103                                                  rtx));
 104 static void copy_insn_notes             PARAMS ((rtx, struct inline_remap *,
 105                                                  int));
 106 static int compare_blocks               PARAMS ((const PTR, const PTR));
 107 static int find_block                   PARAMS ((const PTR, const PTR));
 108
 109 /* Used by copy_rtx_and_substitute; this indicates whether the function is
 110    called for the purpose of inlining or some other purpose (i.e. loop
 111    unrolling).  This affects how constant pool references are handled.
 112    This variable contains the FUNCTION_DECL for the inlined function.  */
 113 static struct function *inlining = 0;
 114 \f
 115 /* Returns the Ith entry in the label_map contained in MAP.  If the
 116    Ith entry has not yet been set, return a fresh label.  This function
 117    performs a lazy initialization of label_map, thereby avoiding huge memory
 118    explosions when the label_map gets very large.  */
 119
 120 rtx
 121 get_label_from_map (map, i)
 122      struct inline_remap *map;
 123      int i;
 124 {
 125   rtx x = map->label_map[i];
 126
 127   if (x == NULL_RTX)
 128     x = map->label_map[i] = gen_label_rtx ();
 129
 130   return x;
 131 }
 132
 133 /* Zero if the current function (whose FUNCTION_DECL is FNDECL)
 134    is safe and reasonable to integrate into other functions.
 135    Nonzero means value is a warning msgid with a single %s
 136    for the function's name.  */
 137
 138 const char *
 139 function_cannot_inline_p (fndecl)
 140      register tree fndecl;
 141 {
 142   register rtx insn;
 143   tree last = tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl)));
 144
 145   /* For functions marked as inline increase the maximum size to
 146      MAX_INLINE_INSNS (-finline-limit-<n>).  For regular functions
 147      use the limit given by INTEGRATE_THRESHOLD.  */
 148
 149   int max_insns = (DECL_INLINE (fndecl))
 150                    ? (MAX_INLINE_INSNS
 151                       + 8 * list_length (DECL_ARGUMENTS (fndecl)))
 152                    : INTEGRATE_THRESHOLD (fndecl);
 153
 154   register int ninsns = 0;
 155   register tree parms;
 156
 157   if (DECL_UNINLINABLE (fndecl))
 158     return N_("function cannot be inline");
 159
 160   /* No inlines with varargs.  */
 161   if ((last && TREE_VALUE (last) != void_type_node)
 162       || current_function_varargs)
 163     return N_("varargs function cannot be inline");
 164
 165   if (current_function_calls_alloca)
 166     return N_("function using alloca cannot be inline");
 167
 168   if (current_function_calls_setjmp)
 169     return N_("function using setjmp cannot be inline");
 170
 171   if (current_function_calls_eh_return)
 172     return N_("function uses __builtin_eh_return");
 173
 174   if (current_function_contains_functions)
 175     return N_("function with nested functions cannot be inline");
 176
 177   if (forced_labels)
 178     return
 179       N_("function with label addresses used in initializers cannot inline");
 180
 181   if (current_function_cannot_inline)
 182     return current_function_cannot_inline;
 183
 184   /* If its not even close, don't even look.  */
 185   if (get_max_uid () > 3 * max_insns)
 186     return N_("function too large to be inline");
 187
 188 #if 0
 189   /* Don't inline functions which do not specify a function prototype and
 190      have BLKmode argument or take the address of a parameter.  */
 191   for (parms = DECL_ARGUMENTS (fndecl); parms; parms = TREE_CHAIN (parms))
 192     {
 193       if (TYPE_MODE (TREE_TYPE (parms)) == BLKmode)
 194         TREE_ADDRESSABLE (parms) = 1;
 195       if (last == NULL_TREE && TREE_ADDRESSABLE (parms))
 196         return N_("no prototype, and parameter address used; cannot be inline");
 197     }
 198 #endif
 199
 200   /* We can't inline functions that return structures
 201      the old-fashioned PCC way, copying into a static block.  */
 202   if (current_function_returns_pcc_struct)
 203     return N_("inline functions not supported for this return value type");
 204
 205   /* We can't inline functions that return structures of varying size.  */
 206   if (TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE
 207       && int_size_in_bytes (TREE_TYPE (TREE_TYPE (fndecl))) < 0)
 208     return N_("function with varying-size return value cannot be inline");
 209
 210   /* Cannot inline a function with a varying size argument or one that
 211      receives a transparent union.  */
 212   for (parms = DECL_ARGUMENTS (fndecl); parms; parms = TREE_CHAIN (parms))
 213     {
 214       if (int_size_in_bytes (TREE_TYPE (parms)) < 0)
 215         return N_("function with varying-size parameter cannot be inline");
 216       else if (TREE_CODE (TREE_TYPE (parms)) == UNION_TYPE
 217                && TYPE_TRANSPARENT_UNION (TREE_TYPE (parms)))
 218         return N_("function with transparent unit parameter cannot be inline");
 219     }
 220
 221   if (get_max_uid () > max_insns)
 222     {
 223       for (ninsns = 0, insn = get_first_nonparm_insn ();
 224            insn && ninsns < max_insns;
 225            insn = NEXT_INSN (insn))
 226         if (INSN_P (insn))
 227           ninsns++;
 228
 229       if (ninsns >= max_insns)
 230         return N_("function too large to be inline");
 231     }
 232
 233   /* We will not inline a function which uses computed goto.  The addresses of
 234      its local labels, which may be tucked into global storage, are of course
 235      not constant across instantiations, which causes unexpected behaviour.  */
 236   if (current_function_has_computed_jump)
 237     return N_("function with computed jump cannot inline");
 238
 239   /* We cannot inline a nested function that jumps to a nonlocal label.  */
 240   if (current_function_has_nonlocal_goto)
 241     return N_("function with nonlocal goto cannot be inline");
 242
 243   /* We can't inline functions that return a PARALLEL rtx.  */
 244   if (DECL_RTL_SET_P (DECL_RESULT (fndecl)))
 245     {
 246       rtx result = DECL_RTL (DECL_RESULT (fndecl));
 247       if (GET_CODE (result) == PARALLEL)
 248         return N_("inline functions not supported for this return value type");
 249     }
 250
 251   /* If the function has a target specific attribute attached to it,
 252      then we assume that we should not inline it.  This can be overriden
 253      by the target if it defines FUNCTION_ATTRIBUTE_INLINABLE_P.  */
 254   if (DECL_MACHINE_ATTRIBUTES (fndecl)
 255       && ! FUNCTION_ATTRIBUTE_INLINABLE_P (fndecl))
 256     return N_("function with target specific attribute(s) cannot be inlined");
 257
 258   return NULL;
 259 }
 260 \f
 261 /* Map pseudo reg number into the PARM_DECL for the parm living in the reg.
 262    Zero for a reg that isn't a parm's home.
 263    Only reg numbers less than max_parm_reg are mapped here.  */
 264 static tree *parmdecl_map;
 265
 266 /* In save_for_inline, nonzero if past the parm-initialization insns.  */
 267 static int in_nonparm_insns;
 268 \f
 269 /* Subroutine for `save_for_inline'.  Performs initialization
 270    needed to save FNDECL's insns and info for future inline expansion.  */
 271
 272 static rtvec
 273 initialize_for_inline (fndecl)
 274      tree fndecl;
 275 {
 276   int i;
 277   rtvec arg_vector;
 278   tree parms;
 279
 280   /* Clear out PARMDECL_MAP.  It was allocated in the caller's frame.  */
 281   memset ((char *) parmdecl_map, 0, max_parm_reg * sizeof (tree));
 282   arg_vector = rtvec_alloc (list_length (DECL_ARGUMENTS (fndecl)));
 283
 284   for (parms = DECL_ARGUMENTS (fndecl), i = 0;
 285        parms;
 286        parms = TREE_CHAIN (parms), i++)
 287     {
 288       rtx p = DECL_RTL (parms);
 289
 290       /* If we have (mem (addressof (mem ...))), use the inner MEM since
 291          otherwise the copy_rtx call below will not unshare the MEM since
 292          it shares ADDRESSOF.  */
 293       if (GET_CODE (p) == MEM && GET_CODE (XEXP (p, 0)) == ADDRESSOF
 294           && GET_CODE (XEXP (XEXP (p, 0), 0)) == MEM)
 295         p = XEXP (XEXP (p, 0), 0);
 296
 297       RTVEC_ELT (arg_vector, i) = p;
 298
 299       if (GET_CODE (p) == REG)
 300         parmdecl_map[REGNO (p)] = parms;
 301       else if (GET_CODE (p) == CONCAT)
 302         {
 303           rtx preal = gen_realpart (GET_MODE (XEXP (p, 0)), p);
 304           rtx pimag = gen_imagpart (GET_MODE (preal), p);
 305
 306           if (GET_CODE (preal) == REG)
 307             parmdecl_map[REGNO (preal)] = parms;
 308           if (GET_CODE (pimag) == REG)
 309             parmdecl_map[REGNO (pimag)] = parms;
 310         }
 311
 312       /* This flag is cleared later
 313          if the function ever modifies the value of the parm.  */
 314       TREE_READONLY (parms) = 1;
 315     }
 316
 317   return arg_vector;
 318 }
 319
 320 /* Copy NODE (which must be a DECL, but not a PARM_DECL).  The DECL
 321    originally was in the FROM_FN, but now it will be in the
 322    TO_FN.  */
 323
 324 tree
 325 copy_decl_for_inlining (decl, from_fn, to_fn)
 326      tree decl;
 327      tree from_fn;
 328      tree to_fn;
 329 {
 330   tree copy;
 331
 332   /* Copy the declaration.  */
 333   if (TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL)
 334     {
 335       /* For a parameter, we must make an equivalent VAR_DECL, not a
 336          new PARM_DECL.  */
 337       copy = build_decl (VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl));
 338       TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl);
 339       TREE_READONLY (copy) = TREE_READONLY (decl);
 340       TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl);
 341     }
 342   else
 343     {
 344       copy = copy_node (decl);
 345       if (DECL_LANG_SPECIFIC (copy))
 346         copy_lang_decl (copy);
 347
 348       /* TREE_ADDRESSABLE isn't used to indicate that a label's
 349          address has been taken; it's for internal bookkeeping in
 350          expand_goto_internal.  */
 351       if (TREE_CODE (copy) == LABEL_DECL)
 352         TREE_ADDRESSABLE (copy) = 0;
 353     }
 354
 355   /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
 356      declaration inspired this copy.  */
 357   DECL_ABSTRACT_ORIGIN (copy) = DECL_ORIGIN (decl);
 358
 359   /* The new variable/label has no RTL, yet.  */
 360   SET_DECL_RTL (copy, NULL_RTX);
 361
 362   /* These args would always appear unused, if not for this.  */
 363   TREE_USED (copy) = 1;
 364
 365   /* Set the context for the new declaration.  */
 366   if (!DECL_CONTEXT (decl))
 367     /* Globals stay global.  */
 368     ;
 369   else if (DECL_CONTEXT (decl) != from_fn)
 370     /* Things that weren't in the scope of the function we're inlining
 371        from aren't in the scope we're inlining too, either.  */
 372     ;
 373   else if (TREE_STATIC (decl))
 374     /* Function-scoped static variables should say in the original
 375        function.  */
 376     ;
 377   else
 378     /* Ordinary automatic local variables are now in the scope of the
 379        new function.  */
 380     DECL_CONTEXT (copy) = to_fn;
 381
 382   return copy;
 383 }
 384
 385 /* Make the insns and PARM_DECLs of the current function permanent
 386    and record other information in DECL_SAVED_INSNS to allow inlining
 387    of this function in subsequent calls.
 388
 389    This routine need not copy any insns because we are not going
 390    to immediately compile the insns in the insn chain.  There
 391    are two cases when we would compile the insns for FNDECL:
 392    (1) when FNDECL is expanded inline, and (2) when FNDECL needs to
 393    be output at the end of other compilation, because somebody took
 394    its address.  In the first case, the insns of FNDECL are copied
 395    as it is expanded inline, so FNDECL's saved insns are not
 396    modified.  In the second case, FNDECL is used for the last time,
 397    so modifying the rtl is not a problem.
 398
 399    We don't have to worry about FNDECL being inline expanded by
 400    other functions which are written at the end of compilation
 401    because flag_no_inline is turned on when we begin writing
 402    functions at the end of compilation.  */
 403
 404 void
 405 save_for_inline (fndecl)
 406      tree fndecl;
 407 {
 408   rtx insn;
 409   rtvec argvec;
 410   rtx first_nonparm_insn;
 411
 412   /* Set up PARMDECL_MAP which maps pseudo-reg number to its PARM_DECL.
 413      Later we set TREE_READONLY to 0 if the parm is modified inside the fn.
 414      Also set up ARG_VECTOR, which holds the unmodified DECL_RTX values
 415      for the parms, prior to elimination of virtual registers.
 416      These values are needed for substituting parms properly.  */
 417
 418   parmdecl_map = (tree *) xmalloc (max_parm_reg * sizeof (tree));
 419
 420   /* Make and emit a return-label if we have not already done so.  */
 421
 422   if (return_label == 0)
 423     {
 424       return_label = gen_label_rtx ();
 425       emit_label (return_label);
 426     }
 427
 428   argvec = initialize_for_inline (fndecl);
 429
 430   /* Delete basic block notes created by early run of find_basic_block.
 431      The notes would be later used by find_basic_blocks to reuse the memory
 432      for basic_block structures on already freed obstack.  */
 433   for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
 434     if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) == NOTE_INSN_BASIC_BLOCK)
 435       delete_insn (insn);
 436
 437   /* If there are insns that copy parms from the stack into pseudo registers,
 438      those insns are not copied.  `expand_inline_function' must
 439      emit the correct code to handle such things.  */
 440
 441   insn = get_insns ();
 442   if (GET_CODE (insn) != NOTE)
 443     abort ();
 444
 445   /* Get the insn which signals the end of parameter setup code.  */
 446   first_nonparm_insn = get_first_nonparm_insn ();
 447
 448   /* Now just scan the chain of insns to see what happens to our
 449      PARM_DECLs.  If a PARM_DECL is used but never modified, we
 450      can substitute its rtl directly when expanding inline (and
 451      perform constant folding when its incoming value is constant).
 452      Otherwise, we have to copy its value into a new register and track
 453      the new register's life.  */
 454   in_nonparm_insns = 0;
 455   save_parm_insns (insn, first_nonparm_insn);
 456
 457   cfun->inl_max_label_num = max_label_num ();
 458   cfun->inl_last_parm_insn = cfun->x_last_parm_insn;
 459   cfun->original_arg_vector = argvec;
 460   cfun->original_decl_initial = DECL_INITIAL (fndecl);
 461   cfun->no_debugging_symbols = (write_symbols == NO_DEBUG);
 462   DECL_SAVED_INSNS (fndecl) = cfun;
 463
 464   /* Clean up.  */
 465   free (parmdecl_map);
 466 }
 467
 468 /* Scan the chain of insns to see what happens to our PARM_DECLs.  If a
 469    PARM_DECL is used but never modified, we can substitute its rtl directly
 470    when expanding inline (and perform constant folding when its incoming
 471    value is constant). Otherwise, we have to copy its value into a new
 472    register and track the new register's life.  */
 473
 474 static void
 475 save_parm_insns (insn, first_nonparm_insn)
 476      rtx insn;
 477      rtx first_nonparm_insn;
 478 {
 479   if (insn == NULL_RTX)
 480     return;
 481
 482   for (insn = NEXT_INSN (insn); insn; insn = NEXT_INSN (insn))
 483     {
 484       if (insn == first_nonparm_insn)
 485         in_nonparm_insns = 1;
 486
 487       if (INSN_P (insn))
 488         {
 489           /* Record what interesting things happen to our parameters.  */
 490           note_stores (PATTERN (insn), note_modified_parmregs, NULL);
 491
 492           /* If this is a CALL_PLACEHOLDER insn then we need to look into the
 493              three attached sequences: normal call, sibling call and tail
 494              recursion.  */
 495           if (GET_CODE (insn) == CALL_INSN
 496               && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
 497             {
 498               int i;
 499
 500               for (i = 0; i < 3; i++)
 501                 save_parm_insns (XEXP (PATTERN (insn), i),
 502                                  first_nonparm_insn);
 503             }
 504         }
 505     }
 506 }
 507 \f
 508 /* Note whether a parameter is modified or not.  */
 509
 510 static void
 511 note_modified_parmregs (reg, x, data)
 512      rtx reg;
 513      rtx x ATTRIBUTE_UNUSED;
 514      void *data ATTRIBUTE_UNUSED;
 515 {
 516   if (GET_CODE (reg) == REG && in_nonparm_insns
 517       && REGNO (reg) < max_parm_reg
 518       && REGNO (reg) >= FIRST_PSEUDO_REGISTER
 519       && parmdecl_map[REGNO (reg)] != 0)
 520     TREE_READONLY (parmdecl_map[REGNO (reg)]) = 0;
 521 }
 522
 523 /* Unfortunately, we need a global copy of const_equiv map for communication
 524    with a function called from note_stores.  Be *very* careful that this
 525    is used properly in the presence of recursion.  */
 526
 527 varray_type global_const_equiv_varray;
 528 \f
 529 #define FIXED_BASE_PLUS_P(X) \
 530   (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == CONST_INT  \
 531    && GET_CODE (XEXP (X, 0)) == REG                             \
 532    && REGNO (XEXP (X, 0)) >= FIRST_VIRTUAL_REGISTER             \
 533    && REGNO (XEXP (X, 0)) <= LAST_VIRTUAL_REGISTER)
 534
 535 /* Called to set up a mapping for the case where a parameter is in a
 536    register.  If it is read-only and our argument is a constant, set up the
 537    constant equivalence.
 538
 539    If LOC is REG_USERVAR_P, the usual case, COPY must also have that flag set
 540    if it is a register.
 541
 542    Also, don't allow hard registers here; they might not be valid when
 543    substituted into insns.  */
 544 static void
 545 process_reg_param (map, loc, copy)
 546      struct inline_remap *map;
 547      rtx loc, copy;
 548 {
 549   if ((GET_CODE (copy) != REG && GET_CODE (copy) != SUBREG)
 550       || (GET_CODE (copy) == REG && REG_USERVAR_P (loc)
 551           && ! REG_USERVAR_P (copy))
 552       || (GET_CODE (copy) == REG
 553           && REGNO (copy) < FIRST_PSEUDO_REGISTER))
 554     {
 555       rtx temp = copy_to_mode_reg (GET_MODE (loc), copy);
 556       REG_USERVAR_P (temp) = REG_USERVAR_P (loc);
 557       if (CONSTANT_P (copy) || FIXED_BASE_PLUS_P (copy))
 558         SET_CONST_EQUIV_DATA (map, temp, copy, CONST_AGE_PARM);
 559       copy = temp;
 560     }
 561   map->reg_map[REGNO (loc)] = copy;
 562 }
 563
 564 /* Compare two BLOCKs for qsort.  The key we sort on is the
 565    BLOCK_ABSTRACT_ORIGIN of the blocks.  */
 566
 567 static int
 568 compare_blocks (v1, v2)
 569      const PTR v1;
 570      const PTR v2;
 571 {
 572   tree b1 = *((const tree *) v1);
 573   tree b2 = *((const tree *) v2);
 574
 575   return ((char *) BLOCK_ABSTRACT_ORIGIN (b1)
 576           - (char *) BLOCK_ABSTRACT_ORIGIN (b2));
 577 }
 578
 579 /* Compare two BLOCKs for bsearch.  The first pointer corresponds to
 580    an original block; the second to a remapped equivalent.  */
 581
 582 static int
 583 find_block (v1, v2)
 584      const PTR v1;
 585      const PTR v2;
 586 {
 587   const union tree_node *b1 = (const union tree_node *) v1;
 588   tree b2 = *((const tree *) v2);
 589
 590   return ((const char *) b1 - (char *) BLOCK_ABSTRACT_ORIGIN (b2));
 591 }
 592
 593 /* Integrate the procedure defined by FNDECL.  Note that this function
 594    may wind up calling itself.  Since the static variables are not
 595    reentrant, we do not assign them until after the possibility
 596    of recursion is eliminated.
 597
 598    If IGNORE is nonzero, do not produce a value.
 599    Otherwise store the value in TARGET if it is nonzero and that is convenient.
 600
 601    Value is:
 602    (rtx)-1 if we could not substitute the function
 603    0 if we substituted it and it does not produce a value
 604    else an rtx for where the value is stored.  */
 605
 606 rtx
 607 expand_inline_function (fndecl, parms, target, ignore, type,
 608                         structure_value_addr)
 609      tree fndecl, parms;
 610      rtx target;
 611      int ignore;
 612      tree type;
 613      rtx structure_value_addr;
 614 {
 615   struct function *inlining_previous;
 616   struct function *inl_f = DECL_SAVED_INSNS (fndecl);
 617   tree formal, actual, block;
 618   rtx parm_insns = inl_f->emit->x_first_insn;
 619   rtx insns = (inl_f->inl_last_parm_insn
 620                ? NEXT_INSN (inl_f->inl_last_parm_insn)
 621                : parm_insns);
 622   tree *arg_trees;
 623   rtx *arg_vals;
 624   int max_regno;
 625   register int i;
 626   int min_labelno = inl_f->emit->x_first_label_num;
 627   int max_labelno = inl_f->inl_max_label_num;
 628   int nargs;
 629   rtx loc;
 630   rtx stack_save = 0;
 631   rtx temp;
 632   struct inline_remap *map = 0;
 633 #ifdef HAVE_cc0
 634   rtx cc0_insn = 0;
 635 #endif
 636   rtvec arg_vector = (rtvec) inl_f->original_arg_vector;
 637   rtx static_chain_value = 0;
 638   int inl_max_uid;
 639   int eh_region_offset;
 640
 641   /* The pointer used to track the true location of the memory used
 642      for MAP->LABEL_MAP.  */
 643   rtx *real_label_map = 0;
 644
 645   /* Allow for equivalences of the pseudos we make for virtual fp and ap.  */
 646   max_regno = inl_f->emit->x_reg_rtx_no + 3;
 647   if (max_regno < FIRST_PSEUDO_REGISTER)
 648     abort ();
 649
 650   /* Pull out the decl for the function definition; fndecl may be a
 651      local declaration, which would break DECL_ABSTRACT_ORIGIN.  */
 652   fndecl = inl_f->decl;
 653
 654   nargs = list_length (DECL_ARGUMENTS (fndecl));
 655
 656   if (cfun->preferred_stack_boundary < inl_f->preferred_stack_boundary)
 657     cfun->preferred_stack_boundary = inl_f->preferred_stack_boundary;
 658
 659   /* Check that the parms type match and that sufficient arguments were
 660      passed.  Since the appropriate conversions or default promotions have
 661      already been applied, the machine modes should match exactly.  */
 662
 663   for (formal = DECL_ARGUMENTS (fndecl), actual = parms;
 664        formal;
 665        formal = TREE_CHAIN (formal), actual = TREE_CHAIN (actual))
 666     {
 667       tree arg;
 668       enum machine_mode mode;
 669
 670       if (actual == 0)
 671         return (rtx) (HOST_WIDE_INT) -1;
 672
 673       arg = TREE_VALUE (actual);
 674       mode = TYPE_MODE (DECL_ARG_TYPE (formal));
 675
 676       if (arg == error_mark_node
 677           || mode != TYPE_MODE (TREE_TYPE (arg))
 678           /* If they are block mode, the types should match exactly.
 679              They don't match exactly if TREE_TYPE (FORMAL) == ERROR_MARK_NODE,
 680              which could happen if the parameter has incomplete type.  */
 681           || (mode == BLKmode
 682               && (TYPE_MAIN_VARIANT (TREE_TYPE (arg))
 683                   != TYPE_MAIN_VARIANT (TREE_TYPE (formal)))))
 684         return (rtx) (HOST_WIDE_INT) -1;
 685     }
 686
 687   /* Extra arguments are valid, but will be ignored below, so we must
 688      evaluate them here for side-effects.  */
 689   for (; actual; actual = TREE_CHAIN (actual))
 690     expand_expr (TREE_VALUE (actual), const0_rtx,
 691                  TYPE_MODE (TREE_TYPE (TREE_VALUE (actual))), 0);
 692
 693   /* Expand the function arguments.  Do this first so that any
 694      new registers get created before we allocate the maps.  */
 695
 696   arg_vals = (rtx *) xmalloc (nargs * sizeof (rtx));
 697   arg_trees = (tree *) xmalloc (nargs * sizeof (tree));
 698
 699   for (formal = DECL_ARGUMENTS (fndecl), actual = parms, i = 0;
 700        formal;
 701        formal = TREE_CHAIN (formal), actual = TREE_CHAIN (actual), i++)
 702     {
 703       /* Actual parameter, converted to the type of the argument within the
 704          function.  */
 705       tree arg = convert (TREE_TYPE (formal), TREE_VALUE (actual));
 706       /* Mode of the variable used within the function.  */
 707       enum machine_mode mode = TYPE_MODE (TREE_TYPE (formal));
 708       int invisiref = 0;
 709
 710       arg_trees[i] = arg;
 711       loc = RTVEC_ELT (arg_vector, i);
 712
 713       /* If this is an object passed by invisible reference, we copy the
 714          object into a stack slot and save its address.  If this will go
 715          into memory, we do nothing now.  Otherwise, we just expand the
 716          argument.  */
 717       if (GET_CODE (loc) == MEM && GET_CODE (XEXP (loc, 0)) == REG
 718           && REGNO (XEXP (loc, 0)) > LAST_VIRTUAL_REGISTER)
 719         {
 720           rtx stack_slot = assign_temp (TREE_TYPE (arg), 1, 1, 1);
 721
 722           store_expr (arg, stack_slot, 0);
 723           arg_vals[i] = XEXP (stack_slot, 0);
 724           invisiref = 1;
 725         }
 726       else if (GET_CODE (loc) != MEM)
 727         {
 728           if (GET_MODE (loc) != TYPE_MODE (TREE_TYPE (arg)))
 729             {
 730               int unsignedp = TREE_UNSIGNED (TREE_TYPE (formal));
 731               enum machine_mode pmode = TYPE_MODE (TREE_TYPE (formal));
 732
 733               pmode = promote_mode (TREE_TYPE (formal), pmode,
 734                                     &unsignedp, 0);
 735
 736               if (GET_MODE (loc) != pmode)
 737                 abort ();
 738
 739               /* The mode if LOC and ARG can differ if LOC was a variable
 740                  that had its mode promoted via PROMOTED_MODE.  */
 741               arg_vals[i] = convert_modes (pmode,
 742                                            TYPE_MODE (TREE_TYPE (arg)),
 743                                            expand_expr (arg, NULL_RTX, mode,
 744                                                         EXPAND_SUM),
 745                                            unsignedp);
 746             }
 747           else
 748             arg_vals[i] = expand_expr (arg, NULL_RTX, mode, EXPAND_SUM);
 749         }
 750       else
 751         arg_vals[i] = 0;
 752
 753       if (arg_vals[i] != 0
 754           && (! TREE_READONLY (formal)
 755               /* If the parameter is not read-only, copy our argument through
 756                  a register.  Also, we cannot use ARG_VALS[I] if it overlaps
 757                  TARGET in any way.  In the inline function, they will likely
 758                  be two different pseudos, and `safe_from_p' will make all
 759                  sorts of smart assumptions about their not conflicting.
 760                  But if ARG_VALS[I] overlaps TARGET, these assumptions are
 761                  wrong, so put ARG_VALS[I] into a fresh register.
 762                  Don't worry about invisible references, since their stack
 763                  temps will never overlap the target.  */
 764               || (target != 0
 765                   && ! invisiref
 766                   && (GET_CODE (arg_vals[i]) == REG
 767                       || GET_CODE (arg_vals[i]) == SUBREG
 768                       || GET_CODE (arg_vals[i]) == MEM)
 769                   && reg_overlap_mentioned_p (arg_vals[i], target))
 770               /* ??? We must always copy a SUBREG into a REG, because it might
 771                  get substituted into an address, and not all ports correctly
 772                  handle SUBREGs in addresses.  */
 773               || (GET_CODE (arg_vals[i]) == SUBREG)))
 774         arg_vals[i] = copy_to_mode_reg (GET_MODE (loc), arg_vals[i]);
 775
 776       if (arg_vals[i] != 0 && GET_CODE (arg_vals[i]) == REG
 777           && POINTER_TYPE_P (TREE_TYPE (formal)))
 778         mark_reg_pointer (arg_vals[i],
 779                           TYPE_ALIGN (TREE_TYPE (TREE_TYPE (formal))));
 780     }
 781
 782   /* Allocate the structures we use to remap things.  */
 783
 784   map = (struct inline_remap *) xcalloc (1, sizeof (struct inline_remap));
 785   map->fndecl = fndecl;
 786
 787   VARRAY_TREE_INIT (map->block_map, 10, "block_map");
 788   map->reg_map = (rtx *) xcalloc (max_regno, sizeof (rtx));
 789
 790   /* We used to use alloca here, but the size of what it would try to
 791      allocate would occasionally cause it to exceed the stack limit and
 792      cause unpredictable core dumps.  */
 793   real_label_map
 794     = (rtx *) xmalloc ((max_labelno) * sizeof (rtx));
 795   map->label_map = real_label_map;
 796   map->local_return_label = NULL_RTX;
 797
 798   inl_max_uid = (inl_f->emit->x_cur_insn_uid + 1);
 799   map->insn_map = (rtx *) xcalloc (inl_max_uid, sizeof (rtx));
 800   map->min_insnno = 0;
 801   map->max_insnno = inl_max_uid;
 802
 803   map->integrating = 1;
 804   map->compare_src = NULL_RTX;
 805   map->compare_mode = VOIDmode;
 806
 807   /* const_equiv_varray maps pseudos in our routine to constants, so
 808      it needs to be large enough for all our pseudos.  This is the
 809      number we are currently using plus the number in the called
 810      routine, plus 15 for each arg, five to compute the virtual frame
 811      pointer, and five for the return value.  This should be enough
 812      for most cases.  We do not reference entries outside the range of
 813      the map.
 814
 815      ??? These numbers are quite arbitrary and were obtained by
 816      experimentation.  At some point, we should try to allocate the
 817      table after all the parameters are set up so we an more accurately
 818      estimate the number of pseudos we will need.  */
 819
 820   VARRAY_CONST_EQUIV_INIT (map->const_equiv_varray,
 821                            (max_reg_num ()
 822                             + (max_regno - FIRST_PSEUDO_REGISTER)
 823                             + 15 * nargs
 824                             + 10),
 825                            "expand_inline_function");
 826   map->const_age = 0;
 827
 828   /* Record the current insn in case we have to set up pointers to frame
 829      and argument memory blocks.  If there are no insns yet, add a dummy
 830      insn that can be used as an insertion point.  */
 831   map->insns_at_start = get_last_insn ();
 832   if (map->insns_at_start == 0)
 833     map->insns_at_start = emit_note (NULL, NOTE_INSN_DELETED);
 834
 835   map->regno_pointer_align = inl_f->emit->regno_pointer_align;
 836   map->x_regno_reg_rtx = inl_f->emit->x_regno_reg_rtx;
 837
 838   /* Update the outgoing argument size to allow for those in the inlined
 839      function.  */
 840   if (inl_f->outgoing_args_size > current_function_outgoing_args_size)
 841     current_function_outgoing_args_size = inl_f->outgoing_args_size;
 842
 843   /* If the inline function needs to make PIC references, that means
 844      that this function's PIC offset table must be used.  */
 845   if (inl_f->uses_pic_offset_table)
 846     current_function_uses_pic_offset_table = 1;
 847
 848   /* If this function needs a context, set it up.  */
 849   if (inl_f->needs_context)
 850     static_chain_value = lookup_static_chain (fndecl);
 851
 852   if (GET_CODE (parm_insns) == NOTE
 853       && NOTE_LINE_NUMBER (parm_insns) > 0)
 854     {
 855       rtx note = emit_note (NOTE_SOURCE_FILE (parm_insns),
 856                             NOTE_LINE_NUMBER (parm_insns));
 857       if (note)
 858         RTX_INTEGRATED_P (note) = 1;
 859     }
 860
 861   /* Process each argument.  For each, set up things so that the function's
 862      reference to the argument will refer to the argument being passed.
 863      We only replace REG with REG here.  Any simplifications are done
 864      via const_equiv_map.
 865
 866      We make two passes:  In the first, we deal with parameters that will
 867      be placed into registers, since we need to ensure that the allocated
 868      register number fits in const_equiv_map.  Then we store all non-register
 869      parameters into their memory location.  */
 870
 871   /* Don't try to free temp stack slots here, because we may put one of the
 872      parameters into a temp stack slot.  */
 873
 874   for (i = 0; i < nargs; i++)
 875     {
 876       rtx copy = arg_vals[i];
 877
 878       loc = RTVEC_ELT (arg_vector, i);
 879
 880       /* There are three cases, each handled separately.  */
 881       if (GET_CODE (loc) == MEM && GET_CODE (XEXP (loc, 0)) == REG
 882           && REGNO (XEXP (loc, 0)) > LAST_VIRTUAL_REGISTER)
 883         {
 884           /* This must be an object passed by invisible reference (it could
 885              also be a variable-sized object, but we forbid inlining functions
 886              with variable-sized arguments).  COPY is the address of the
 887              actual value (this computation will cause it to be copied).  We
 888              map that address for the register, noting the actual address as
 889              an equivalent in case it can be substituted into the insns.  */
 890
 891           if (GET_CODE (copy) != REG)
 892             {
 893               temp = copy_addr_to_reg (copy);
 894               if (CONSTANT_P (copy) || FIXED_BASE_PLUS_P (copy))
 895                 SET_CONST_EQUIV_DATA (map, temp, copy, CONST_AGE_PARM);
 896               copy = temp;
 897             }
 898           map->reg_map[REGNO (XEXP (loc, 0))] = copy;
 899         }
 900       else if (GET_CODE (loc) == MEM)
 901         {
 902           /* This is the case of a parameter that lives in memory.  It
 903              will live in the block we allocate in the called routine's
 904              frame that simulates the incoming argument area.  Do nothing
 905              with the parameter now; we will call store_expr later.  In
 906              this case, however, we must ensure that the virtual stack and
 907              incoming arg rtx values are expanded now so that we can be
 908              sure we have enough slots in the const equiv map since the
 909              store_expr call can easily blow the size estimate.  */
 910           if (DECL_SAVED_INSNS (fndecl)->args_size != 0)
 911             copy_rtx_and_substitute (virtual_incoming_args_rtx, map, 0);
 912         }
 913       else if (GET_CODE (loc) == REG)
 914         process_reg_param (map, loc, copy);
 915       else if (GET_CODE (loc) == CONCAT)
 916         {
 917           rtx locreal = gen_realpart (GET_MODE (XEXP (loc, 0)), loc);
 918           rtx locimag = gen_imagpart (GET_MODE (XEXP (loc, 0)), loc);
 919           rtx copyreal = gen_realpart (GET_MODE (locreal), copy);
 920           rtx copyimag = gen_imagpart (GET_MODE (locimag), copy);
 921
 922           process_reg_param (map, locreal, copyreal);
 923           process_reg_param (map, locimag, copyimag);
 924         }
 925       else
 926         abort ();
 927     }
 928
 929   /* Tell copy_rtx_and_substitute to handle constant pool SYMBOL_REFs
 930      specially.  This function can be called recursively, so we need to
 931      save the previous value.  */
 932   inlining_previous = inlining;
 933   inlining = inl_f;
 934
 935   /* Now do the parameters that will be placed in memory.  */
 936
 937   for (formal = DECL_ARGUMENTS (fndecl), i = 0;
 938        formal; formal = TREE_CHAIN (formal), i++)
 939     {
 940       loc = RTVEC_ELT (arg_vector, i);
 941
 942       if (GET_CODE (loc) == MEM
 943           /* Exclude case handled above.  */
 944           && ! (GET_CODE (XEXP (loc, 0)) == REG
 945                 && REGNO (XEXP (loc, 0)) > LAST_VIRTUAL_REGISTER))
 946         {
 947           rtx note = emit_note (DECL_SOURCE_FILE (formal),
 948                                 DECL_SOURCE_LINE (formal));
 949           if (note)
 950             RTX_INTEGRATED_P (note) = 1;
 951
 952           /* Compute the address in the area we reserved and store the
 953              value there.  */
 954           temp = copy_rtx_and_substitute (loc, map, 1);
 955           subst_constants (&temp, NULL_RTX, map, 1);
 956           apply_change_group ();
 957           if (! memory_address_p (GET_MODE (temp), XEXP (temp, 0)))
 958             temp = change_address (temp, VOIDmode, XEXP (temp, 0));
 959           store_expr (arg_trees[i], temp, 0);
 960         }
 961     }
 962
 963   /* Deal with the places that the function puts its result.
 964      We are driven by what is placed into DECL_RESULT.
 965
 966      Initially, we assume that we don't have anything special handling for
 967      REG_FUNCTION_RETURN_VALUE_P.  */
 968
 969   map->inline_target = 0;
 970   loc = (DECL_RTL_SET_P (DECL_RESULT (fndecl))
 971          ? DECL_RTL (DECL_RESULT (fndecl)) : NULL_RTX);
 972
 973   if (TYPE_MODE (type) == VOIDmode)
 974     /* There is no return value to worry about.  */
 975     ;
 976   else if (GET_CODE (loc) == MEM)
 977     {
 978       if (GET_CODE (XEXP (loc, 0)) == ADDRESSOF)
 979         {
 980           temp = copy_rtx_and_substitute (loc, map, 1);
 981           subst_constants (&temp, NULL_RTX, map, 1);
 982           apply_change_group ();
 983           target = temp;
 984         }
 985       else
 986         {
 987           if (! structure_value_addr
 988               || ! aggregate_value_p (DECL_RESULT (fndecl)))
 989             abort ();
 990
 991           /* Pass the function the address in which to return a structure
 992              value.  Note that a constructor can cause someone to call us
 993              with STRUCTURE_VALUE_ADDR, but the initialization takes place
 994              via the first parameter, rather than the struct return address.
 995
 996              We have two cases: If the address is a simple register
 997              indirect, use the mapping mechanism to point that register to
 998              our structure return address.  Otherwise, store the structure
 999              return value into the place that it will be referenced from.  */
1000
1001           if (GET_CODE (XEXP (loc, 0)) == REG)
1002             {
1003               temp = force_operand (structure_value_addr, NULL_RTX);
1004               temp = force_reg (Pmode, temp);
1005               /* A virtual register might be invalid in an insn, because
1006                  it can cause trouble in reload.  Since we don't have access
1007                  to the expanders at map translation time, make sure we have
1008                  a proper register now.
1009                  If a virtual register is actually valid, cse or combine
1010                  can put it into the mapped insns.  */
1011               if (REGNO (temp) >= FIRST_VIRTUAL_REGISTER
1012                   && REGNO (temp) <= LAST_VIRTUAL_REGISTER)
1013               temp = copy_to_mode_reg (Pmode, temp);
1014               map->reg_map[REGNO (XEXP (loc, 0))] = temp;
1015
1016               if (CONSTANT_P (structure_value_addr)
1017                   || GET_CODE (structure_value_addr) == ADDRESSOF
1018                   || (GET_CODE (structure_value_addr) == PLUS
1019                       && (XEXP (structure_value_addr, 0)
1020                           == virtual_stack_vars_rtx)
1021                       && (GET_CODE (XEXP (structure_value_addr, 1))
1022                           == CONST_INT)))
1023                 {
1024                   SET_CONST_EQUIV_DATA (map, temp, structure_value_addr,
1025                                         CONST_AGE_PARM);
1026                 }
1027             }
1028           else
1029             {
1030               temp = copy_rtx_and_substitute (loc, map, 1);
1031               subst_constants (&temp, NULL_RTX, map, 0);
1032               apply_change_group ();
1033               emit_move_insn (temp, structure_value_addr);
1034             }
1035         }
1036     }
1037   else if (ignore)
1038     /* We will ignore the result value, so don't look at its structure.
1039        Note that preparations for an aggregate return value
1040        do need to be made (above) even if it will be ignored.  */
1041     ;
1042   else if (GET_CODE (loc) == REG)
1043     {
1044       /* The function returns an object in a register and we use the return
1045          value.  Set up our target for remapping.  */
1046
1047       /* Machine mode function was declared to return.   */
1048       enum machine_mode departing_mode = TYPE_MODE (type);
1049       /* (Possibly wider) machine mode it actually computes
1050          (for the sake of callers that fail to declare it right).
1051          We have to use the mode of the result's RTL, rather than
1052          its type, since expand_function_start may have promoted it.  */
1053       enum machine_mode arriving_mode
1054         = GET_MODE (DECL_RTL (DECL_RESULT (fndecl)));
1055       rtx reg_to_map;
1056
1057       /* Don't use MEMs as direct targets because on some machines
1058          substituting a MEM for a REG makes invalid insns.
1059          Let the combiner substitute the MEM if that is valid.  */
1060       if (target == 0 || GET_CODE (target) != REG
1061           || GET_MODE (target) != departing_mode)
1062         {
1063           /* Don't make BLKmode registers.  If this looks like
1064              a BLKmode object being returned in a register, get
1065              the mode from that, otherwise abort.  */
1066           if (departing_mode == BLKmode)
1067             {
1068               if (REG == GET_CODE (DECL_RTL (DECL_RESULT (fndecl))))
1069                 {
1070                   departing_mode = GET_MODE (DECL_RTL (DECL_RESULT (fndecl)));
1071                   arriving_mode = departing_mode;
1072                 }
1073               else
1074                 abort ();
1075             }
1076
1077           target = gen_reg_rtx (departing_mode);
1078         }
1079
1080       /* If function's value was promoted before return,
1081          avoid machine mode mismatch when we substitute INLINE_TARGET.
1082          But TARGET is what we will return to the caller.  */
1083       if (arriving_mode != departing_mode)
1084         {
1085           /* Avoid creating a paradoxical subreg wider than
1086              BITS_PER_WORD, since that is illegal.  */
1087           if (GET_MODE_BITSIZE (arriving_mode) > BITS_PER_WORD)
1088             {
1089               if (!TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (departing_mode),
1090                                           GET_MODE_BITSIZE (arriving_mode)))
1091                 /* Maybe could be handled by using convert_move () ?  */
1092                 abort ();
1093               reg_to_map = gen_reg_rtx (arriving_mode);
1094               target = gen_lowpart (departing_mode, reg_to_map);
1095             }
1096           else
1097             reg_to_map = gen_rtx_SUBREG (arriving_mode, target, 0);
1098         }
1099       else
1100         reg_to_map = target;
1101
1102       /* Usually, the result value is the machine's return register.
1103          Sometimes it may be a pseudo. Handle both cases.  */
1104       if (REG_FUNCTION_VALUE_P (loc))
1105         map->inline_target = reg_to_map;
1106       else
1107         map->reg_map[REGNO (loc)] = reg_to_map;
1108     }
1109   else if (GET_CODE (loc) == CONCAT)
1110     {
1111       enum machine_mode departing_mode = TYPE_MODE (type);
1112       enum machine_mode arriving_mode
1113         = GET_MODE (DECL_RTL (DECL_RESULT (fndecl)));
1114
1115       if (departing_mode != arriving_mode)
1116         abort ();
1117       if (GET_CODE (XEXP (loc, 0)) != REG
1118           || GET_CODE (XEXP (loc, 1)) != REG)
1119         abort ();
1120
1121       /* Don't use MEMs as direct targets because on some machines
1122          substituting a MEM for a REG makes invalid insns.
1123          Let the combiner substitute the MEM if that is valid.  */
1124       if (target == 0 || GET_CODE (target) != REG
1125           || GET_MODE (target) != departing_mode)
1126         target = gen_reg_rtx (departing_mode);
1127
1128       if (GET_CODE (target) != CONCAT)
1129         abort ();
1130
1131       map->reg_map[REGNO (XEXP (loc, 0))] = XEXP (target, 0);
1132       map->reg_map[REGNO (XEXP (loc, 1))] = XEXP (target, 1);
1133     }
1134   else
1135     abort ();
1136
1137   /* Remap the exception handler data pointer from one to the other.  */
1138   temp = get_exception_pointer (inl_f);
1139   if (temp)
1140     map->reg_map[REGNO (temp)] = get_exception_pointer (cfun);
1141
1142   /* Initialize label_map.  get_label_from_map will actually make
1143      the labels.  */
1144   memset ((char *) &map->label_map[min_labelno], 0,
1145          (max_labelno - min_labelno) * sizeof (rtx));
1146
1147   /* Make copies of the decls of the symbols in the inline function, so that
1148      the copies of the variables get declared in the current function.  Set
1149      up things so that lookup_static_chain knows that to interpret registers
1150      in SAVE_EXPRs for TYPE_SIZEs as local.  */
1151   inline_function_decl = fndecl;
1152   integrate_parm_decls (DECL_ARGUMENTS (fndecl), map, arg_vector);
1153   block = integrate_decl_tree (inl_f->original_decl_initial, map);
1154   BLOCK_ABSTRACT_ORIGIN (block) = DECL_ORIGIN (fndecl);
1155   inline_function_decl = 0;
1156
1157   /* Make a fresh binding contour that we can easily remove.  Do this after
1158      expanding our arguments so cleanups are properly scoped.  */
1159   expand_start_bindings_and_block (0, block);
1160
1161   /* Sort the block-map so that it will be easy to find remapped
1162      blocks later.  */
1163   qsort (&VARRAY_TREE (map->block_map, 0),
1164          map->block_map->elements_used,
1165          sizeof (tree),
1166          compare_blocks);
1167
1168   /* Perform postincrements before actually calling the function.  */
1169   emit_queue ();
1170
1171   /* Clean up stack so that variables might have smaller offsets.  */
1172   do_pending_stack_adjust ();
1173
1174   /* Save a copy of the location of const_equiv_varray for
1175      mark_stores, called via note_stores.  */
1176   global_const_equiv_varray = map->const_equiv_varray;
1177
1178   /* If the called function does an alloca, save and restore the
1179      stack pointer around the call.  This saves stack space, but
1180      also is required if this inline is being done between two
1181      pushes.  */
1182   if (inl_f->calls_alloca)
1183     emit_stack_save (SAVE_BLOCK, &stack_save, NULL_RTX);
1184
1185   /* Map pseudos used for initial hard reg values.  */
1186   setup_initial_hard_reg_value_integration (inl_f, map);
1187
1188   /* Now copy the insns one by one.  */
1189   copy_insn_list (insns, map, static_chain_value);
1190
1191   /* Duplicate the EH regions.  This will create an offset from the
1192      region numbers in the function we're inlining to the region
1193      numbers in the calling function.  This must wait until after
1194      copy_insn_list, as we need the insn map to be complete.  */
1195   eh_region_offset = duplicate_eh_regions (inl_f, map);
1196
1197   /* Now copy the REG_NOTES for those insns.  */
1198   copy_insn_notes (insns, map, eh_region_offset);
1199
1200   /* If the insn sequence required one, emit the return label.  */
1201   if (map->local_return_label)
1202     emit_label (map->local_return_label);
1203
1204   /* Restore the stack pointer if we saved it above.  */
1205   if (inl_f->calls_alloca)
1206     emit_stack_restore (SAVE_BLOCK, stack_save, NULL_RTX);
1207
1208   if (! cfun->x_whole_function_mode_p)
1209     /* In statement-at-a-time mode, we just tell the front-end to add
1210        this block to the list of blocks at this binding level.  We
1211        can't do it the way it's done for function-at-a-time mode the
1212        superblocks have not been created yet.  */
1213     insert_block (block);
1214   else
1215     {
1216       BLOCK_CHAIN (block)
1217         = BLOCK_CHAIN (DECL_INITIAL (current_function_decl));
1218       BLOCK_CHAIN (DECL_INITIAL (current_function_decl)) = block;
1219     }
1220
1221   /* End the scope containing the copied formal parameter variables
1222      and copied LABEL_DECLs.  We pass NULL_TREE for the variables list
1223      here so that expand_end_bindings will not check for unused
1224      variables.  That's already been checked for when the inlined
1225      function was defined.  */
1226   expand_end_bindings (NULL_TREE, 1, 1);
1227
1228   /* Must mark the line number note after inlined functions as a repeat, so
1229      that the test coverage code can avoid counting the call twice.  This
1230      just tells the code to ignore the immediately following line note, since
1231      there already exists a copy of this note before the expanded inline call.
1232      This line number note is still needed for debugging though, so we can't
1233      delete it.  */
1234   if (flag_test_coverage)
1235     emit_note (0, NOTE_INSN_REPEATED_LINE_NUMBER);
1236
1237   emit_line_note (input_filename, lineno);
1238
1239   /* If the function returns a BLKmode object in a register, copy it
1240      out of the temp register into a BLKmode memory object.  */
1241   if (target
1242       && TYPE_MODE (TREE_TYPE (TREE_TYPE (fndecl))) == BLKmode
1243       && ! aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl))))
1244     target = copy_blkmode_from_reg (0, target, TREE_TYPE (TREE_TYPE (fndecl)));
1245
1246   if (structure_value_addr)
1247     {
1248       target = gen_rtx_MEM (TYPE_MODE (type),
1249                             memory_address (TYPE_MODE (type),
1250                                             structure_value_addr));
1251       set_mem_attributes (target, type, 1);
1252     }
1253
1254   /* Make sure we free the things we explicitly allocated with xmalloc.  */
1255   if (real_label_map)
1256     free (real_label_map);
1257   VARRAY_FREE (map->const_equiv_varray);
1258   free (map->reg_map);
1259   VARRAY_FREE (map->block_map);
1260   free (map->insn_map);
1261   free (map);
1262   free (arg_vals);
1263   free (arg_trees);
1264
1265   inlining = inlining_previous;
1266
1267   return target;
1268 }
1269
1270 /* Make copies of each insn in the given list using the mapping
1271    computed in expand_inline_function. This function may call itself for
1272    insns containing sequences.
1273
1274    Copying is done in two passes, first the insns and then their REG_NOTES.
1275
1276    If static_chain_value is non-zero, it represents the context-pointer
1277    register for the function.  */
1278
1279 static void
1280 copy_insn_list (insns, map, static_chain_value)
1281      rtx insns;
1282      struct inline_remap *map;
1283      rtx static_chain_value;
1284 {
1285   register int i;
1286   rtx insn;
1287   rtx temp;
1288 #ifdef HAVE_cc0
1289   rtx cc0_insn = 0;
1290 #endif
1291
1292   /* Copy the insns one by one.  Do this in two passes, first the insns and
1293      then their REG_NOTES.  */
1294
1295   /* This loop is very similar to the loop in copy_loop_body in unroll.c.  */
1296
1297   for (insn = insns; insn; insn = NEXT_INSN (insn))
1298     {
1299       rtx copy, pattern, set;
1300
1301       map->orig_asm_operands_vector = 0;
1302
1303       switch (GET_CODE (insn))
1304         {
1305         case INSN:
1306           pattern = PATTERN (insn);
1307           set = single_set (insn);
1308           copy = 0;
1309           if (GET_CODE (pattern) == USE
1310               && GET_CODE (XEXP (pattern, 0)) == REG
1311               && REG_FUNCTION_VALUE_P (XEXP (pattern, 0)))
1312             /* The (USE (REG n)) at return from the function should
1313                be ignored since we are changing (REG n) into
1314                inline_target.  */
1315             break;
1316
1317           /* Ignore setting a function value that we don't want to use.  */
1318           if (map->inline_target == 0
1319               && set != 0
1320               && GET_CODE (SET_DEST (set)) == REG
1321               && REG_FUNCTION_VALUE_P (SET_DEST (set)))
1322             {
1323               if (volatile_refs_p (SET_SRC (set)))
1324                 {
1325                   rtx new_set;
1326
1327                   /* If we must not delete the source,
1328                      load it into a new temporary.  */
1329                   copy = emit_insn (copy_rtx_and_substitute (pattern, map, 0));
1330
1331                   new_set = single_set (copy);
1332                   if (new_set == 0)
1333                     abort ();
1334
1335                   SET_DEST (new_set)
1336                     = gen_reg_rtx (GET_MODE (SET_DEST (new_set)));
1337                 }
1338               /* If the source and destination are the same and it
1339                  has a note on it, keep the insn.  */
1340               else if (rtx_equal_p (SET_DEST (set), SET_SRC (set))
1341                        && REG_NOTES (insn) != 0)
1342                 copy = emit_insn (copy_rtx_and_substitute (pattern, map, 0));
1343               else
1344                 break;
1345             }
1346
1347           /* Similarly if an ignored return value is clobbered.  */
1348           else if (map->inline_target == 0
1349                    && GET_CODE (pattern) == CLOBBER
1350                    && GET_CODE (XEXP (pattern, 0)) == REG
1351                    && REG_FUNCTION_VALUE_P (XEXP (pattern, 0)))
1352             break;
1353
1354           /* If this is setting the static chain rtx, omit it.  */
1355           else if (static_chain_value != 0
1356                    && set != 0
1357                    && GET_CODE (SET_DEST (set)) == REG
1358                    && rtx_equal_p (SET_DEST (set),
1359                                    static_chain_incoming_rtx))
1360             break;
1361
1362           /* If this is setting the static chain pseudo, set it from
1363              the value we want to give it instead.  */
1364           else if (static_chain_value != 0
1365                    && set != 0
1366                    && rtx_equal_p (SET_SRC (set),
1367                                    static_chain_incoming_rtx))
1368             {
1369               rtx newdest = copy_rtx_and_substitute (SET_DEST (set), map, 1);
1370
1371               copy = emit_move_insn (newdest, static_chain_value);
1372               static_chain_value = 0;
1373             }
1374
1375           /* If this is setting the virtual stack vars register, this must
1376              be the code at the handler for a builtin longjmp.  The value
1377              saved in the setjmp buffer will be the address of the frame
1378              we've made for this inlined instance within our frame.  But we
1379              know the offset of that value so we can use it to reconstruct
1380              our virtual stack vars register from that value.  If we are
1381              copying it from the stack pointer, leave it unchanged.  */
1382           else if (set != 0
1383                    && rtx_equal_p (SET_DEST (set), virtual_stack_vars_rtx))
1384             {
1385               HOST_WIDE_INT offset;
1386               temp = map->reg_map[REGNO (SET_DEST (set))];
1387               temp = VARRAY_CONST_EQUIV (map->const_equiv_varray,
1388                                          REGNO (temp)).rtx;
1389
1390               if (rtx_equal_p (temp, virtual_stack_vars_rtx))
1391                 offset = 0;
1392               else if (GET_CODE (temp) == PLUS
1393                        && rtx_equal_p (XEXP (temp, 0), virtual_stack_vars_rtx)
1394                        && GET_CODE (XEXP (temp, 1)) == CONST_INT)
1395                 offset = INTVAL (XEXP (temp, 1));
1396               else
1397                 abort ();
1398
1399               if (rtx_equal_p (SET_SRC (set), stack_pointer_rtx))
1400                 temp = SET_SRC (set);
1401               else
1402                 temp = force_operand (plus_constant (SET_SRC (set),
1403                                                      - offset),
1404                                       NULL_RTX);
1405
1406               copy = emit_move_insn (virtual_stack_vars_rtx, temp);
1407             }
1408
1409           else
1410             copy = emit_insn (copy_rtx_and_substitute (pattern, map, 0));
1411           /* REG_NOTES will be copied later.  */
1412
1413 #ifdef HAVE_cc0
1414           /* If this insn is setting CC0, it may need to look at
1415              the insn that uses CC0 to see what type of insn it is.
1416              In that case, the call to recog via validate_change will
1417              fail.  So don't substitute constants here.  Instead,
1418              do it when we emit the following insn.
1419
1420              For example, see the pyr.md file.  That machine has signed and
1421              unsigned compares.  The compare patterns must check the
1422              following branch insn to see which what kind of compare to
1423              emit.
1424
1425              If the previous insn set CC0, substitute constants on it as
1426              well.  */
1427           if (sets_cc0_p (PATTERN (copy)) != 0)
1428             cc0_insn = copy;
1429           else
1430             {
1431               if (cc0_insn)
1432                 try_constants (cc0_insn, map);
1433               cc0_insn = 0;
1434               try_constants (copy, map);
1435             }
1436 #else
1437           try_constants (copy, map);
1438 #endif
1439           break;
1440
1441         case JUMP_INSN:
1442           if (map->integrating && returnjump_p (insn))
1443             {
1444               if (map->local_return_label == 0)
1445                 map->local_return_label = gen_label_rtx ();
1446               pattern = gen_jump (map->local_return_label);
1447             }
1448           else
1449             pattern = copy_rtx_and_substitute (PATTERN (insn), map, 0);
1450
1451           copy = emit_jump_insn (pattern);
1452
1453 #ifdef HAVE_cc0
1454           if (cc0_insn)
1455             try_constants (cc0_insn, map);
1456           cc0_insn = 0;
1457 #endif
1458           try_constants (copy, map);
1459
1460           /* If this used to be a conditional jump insn but whose branch
1461              direction is now know, we must do something special.  */
1462           if (any_condjump_p (insn) && onlyjump_p (insn) && map->last_pc_value)
1463             {
1464 #ifdef HAVE_cc0
1465               /* If the previous insn set cc0 for us, delete it.  */
1466               if (only_sets_cc0_p (PREV_INSN (copy)))
1467                 delete_insn (PREV_INSN (copy));
1468 #endif
1469
1470               /* If this is now a no-op, delete it.  */
1471               if (map->last_pc_value == pc_rtx)
1472                 {
1473                   delete_insn (copy);
1474                   copy = 0;
1475                 }
1476               else
1477                 /* Otherwise, this is unconditional jump so we must put a
1478                    BARRIER after it.  We could do some dead code elimination
1479                    here, but jump.c will do it just as well.  */
1480                 emit_barrier ();
1481             }
1482           break;
1483
1484         case CALL_INSN:
1485           /* If this is a CALL_PLACEHOLDER insn then we need to copy the
1486              three attached sequences: normal call, sibling call and tail
1487              recursion.  */
1488           if (GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
1489             {
1490               rtx sequence[3];
1491               rtx tail_label;
1492
1493               for (i = 0; i < 3; i++)
1494                 {
1495                   rtx seq;
1496
1497                   sequence[i] = NULL_RTX;
1498                   seq = XEXP (PATTERN (insn), i);
1499                   if (seq)
1500                     {
1501                       start_sequence ();
1502                       copy_insn_list (seq, map, static_chain_value);
1503                       sequence[i] = get_insns ();
1504                       end_sequence ();
1505                     }
1506                 }
1507
1508               /* Find the new tail recursion label.
1509                  It will already be substituted into sequence[2].  */
1510               tail_label = copy_rtx_and_substitute (XEXP (PATTERN (insn), 3),
1511                                                     map, 0);
1512
1513               copy = emit_call_insn (gen_rtx_CALL_PLACEHOLDER (VOIDmode,
1514                                                                sequence[0],
1515                                                                sequence[1],
1516                                                                sequence[2],
1517                                                                tail_label));
1518               break;
1519             }
1520
1521           pattern = copy_rtx_and_substitute (PATTERN (insn), map, 0);
1522           copy = emit_call_insn (pattern);
1523
1524           SIBLING_CALL_P (copy) = SIBLING_CALL_P (insn);
1525           CONST_OR_PURE_CALL_P (copy) = CONST_OR_PURE_CALL_P (insn);
1526
1527           /* Because the USAGE information potentially contains objects other
1528              than hard registers, we need to copy it.  */
1529
1530           CALL_INSN_FUNCTION_USAGE (copy)
1531             = copy_rtx_and_substitute (CALL_INSN_FUNCTION_USAGE (insn),
1532                                        map, 0);
1533
1534 #ifdef HAVE_cc0
1535           if (cc0_insn)
1536             try_constants (cc0_insn, map);
1537           cc0_insn = 0;
1538 #endif
1539           try_constants (copy, map);
1540
1541           /* Be lazy and assume CALL_INSNs clobber all hard registers.  */
1542           for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1543             VARRAY_CONST_EQUIV (map->const_equiv_varray, i).rtx = 0;
1544           break;
1545
1546         case CODE_LABEL:
1547           copy = emit_label (get_label_from_map (map,
1548                                                  CODE_LABEL_NUMBER (insn)));
1549           LABEL_NAME (copy) = LABEL_NAME (insn);
1550           map->const_age++;
1551           break;
1552
1553         case BARRIER:
1554           copy = emit_barrier ();
1555           break;
1556
1557         case NOTE:
1558           if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL)
1559             {
1560               copy = emit_label (get_label_from_map (map,
1561                                                     CODE_LABEL_NUMBER (insn)));
1562               map->const_age++;
1563               break;
1564             }
1565
1566           /* NOTE_INSN_FUNCTION_END and NOTE_INSN_FUNCTION_BEG are
1567              discarded because it is important to have only one of
1568              each in the current function.
1569
1570              NOTE_INSN_DELETED notes aren't useful.  */
1571
1572           if (NOTE_LINE_NUMBER (insn) != NOTE_INSN_FUNCTION_END
1573               && NOTE_LINE_NUMBER (insn) != NOTE_INSN_FUNCTION_BEG
1574               && NOTE_LINE_NUMBER (insn) != NOTE_INSN_DELETED)
1575             {
1576               copy = emit_note (NOTE_SOURCE_FILE (insn),
1577                                 NOTE_LINE_NUMBER (insn));
1578               if (copy
1579                   && (NOTE_LINE_NUMBER (copy) == NOTE_INSN_BLOCK_BEG
1580                       || NOTE_LINE_NUMBER (copy) == NOTE_INSN_BLOCK_END)
1581                   && NOTE_BLOCK (insn))
1582                 {
1583                   tree *mapped_block_p;
1584
1585                   mapped_block_p
1586                     = (tree *) bsearch (NOTE_BLOCK (insn),
1587                                         &VARRAY_TREE (map->block_map, 0),
1588                                         map->block_map->elements_used,
1589                                         sizeof (tree),
1590                                         find_block);
1591
1592                   if (!mapped_block_p)
1593                     abort ();
1594                   else
1595                     NOTE_BLOCK (copy) = *mapped_block_p;
1596                 }
1597               else if (copy
1598                        && NOTE_LINE_NUMBER (copy) == NOTE_INSN_EXPECTED_VALUE)
1599                 NOTE_EXPECTED_VALUE (copy)
1600                   = copy_rtx_and_substitute (NOTE_EXPECTED_VALUE (insn),
1601                                              map, 0);
1602             }
1603           else
1604             copy = 0;
1605           break;
1606
1607         default:
1608           abort ();
1609         }
1610
1611       if (copy)
1612         RTX_INTEGRATED_P (copy) = 1;
1613
1614       map->insn_map[INSN_UID (insn)] = copy;
1615     }
1616 }
1617
1618 /* Copy the REG_NOTES.  Increment const_age, so that only constants
1619    from parameters can be substituted in.  These are the only ones
1620    that are valid across the entire function.  */
1621
1622 static void
1623 copy_insn_notes (insns, map, eh_region_offset)
1624      rtx insns;
1625      struct inline_remap *map;
1626      int eh_region_offset;
1627 {
1628   rtx insn, new_insn;
1629
1630   map->const_age++;
1631   for (insn = insns; insn; insn = NEXT_INSN (insn))
1632     {
1633       if (! INSN_P (insn))
1634         continue;
1635
1636       new_insn = map->insn_map[INSN_UID (insn)];
1637       if (! new_insn)
1638         continue;
1639
1640       if (REG_NOTES (insn))
1641         {
1642           rtx next, note = copy_rtx_and_substitute (REG_NOTES (insn), map, 0);
1643
1644           /* We must also do subst_constants, in case one of our parameters
1645              has const type and constant value.  */
1646           subst_constants (&note, NULL_RTX, map, 0);
1647           apply_change_group ();
1648           REG_NOTES (new_insn) = note;
1649
1650           /* Delete any REG_LABEL notes from the chain.  Remap any
1651              REG_EH_REGION notes.  */
1652           for (; note; note = next)
1653             {
1654               next = XEXP (note, 1);
1655               if (REG_NOTE_KIND (note) == REG_LABEL)
1656                 remove_note (new_insn, note);
1657               else if (REG_NOTE_KIND (note) == REG_EH_REGION)
1658                 XEXP (note, 0) = GEN_INT (INTVAL (XEXP (note, 0))
1659                                           + eh_region_offset);
1660             }
1661         }
1662
1663       if (GET_CODE (insn) == CALL_INSN
1664           && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
1665         {
1666           int i;
1667           for (i = 0; i < 3; i++)
1668             copy_insn_notes (XEXP (PATTERN (insn), i), map, eh_region_offset);
1669         }
1670
1671       if (GET_CODE (insn) == JUMP_INSN
1672           && GET_CODE (PATTERN (insn)) == RESX)
1673         XINT (PATTERN (new_insn), 0) += eh_region_offset;
1674     }
1675 }
1676 \f
1677 /* Given a chain of PARM_DECLs, ARGS, copy each decl into a VAR_DECL,
1678    push all of those decls and give each one the corresponding home.  */
1679
1680 static void
1681 integrate_parm_decls (args, map, arg_vector)
1682      tree args;
1683      struct inline_remap *map;
1684      rtvec arg_vector;
1685 {
1686   register tree tail;
1687   register int i;
1688
1689   for (tail = args, i = 0; tail; tail = TREE_CHAIN (tail), i++)
1690     {
1691       tree decl = copy_decl_for_inlining (tail, map->fndecl,
1692                                           current_function_decl);
1693       rtx new_decl_rtl
1694         = copy_rtx_and_substitute (RTVEC_ELT (arg_vector, i), map, 1);
1695
1696       /* We really should be setting DECL_INCOMING_RTL to something reasonable
1697          here, but that's going to require some more work.  */
1698       /* DECL_INCOMING_RTL (decl) = ?; */
1699       /* Fully instantiate the address with the equivalent form so that the
1700          debugging information contains the actual register, instead of the
1701          virtual register.   Do this by not passing an insn to
1702          subst_constants.  */
1703       subst_constants (&new_decl_rtl, NULL_RTX, map, 1);
1704       apply_change_group ();
1705       SET_DECL_RTL (decl, new_decl_rtl);
1706     }
1707 }
1708
1709 /* Given a BLOCK node LET, push decls and levels so as to construct in the
1710    current function a tree of contexts isomorphic to the one that is given.
1711
1712    MAP, if nonzero, is a pointer to an inline_remap map which indicates how
1713    registers used in the DECL_RTL field should be remapped.  If it is zero,
1714    no mapping is necessary.  */
1715
1716 static tree
1717 integrate_decl_tree (let, map)
1718      tree let;
1719      struct inline_remap *map;
1720 {
1721   tree t;
1722   tree new_block;
1723   tree *next;
1724
1725   new_block = make_node (BLOCK);
1726   VARRAY_PUSH_TREE (map->block_map, new_block);
1727   next = &BLOCK_VARS (new_block);
1728
1729   for (t = BLOCK_VARS (let); t; t = TREE_CHAIN (t))
1730     {
1731       tree d;
1732
1733       d = copy_decl_for_inlining (t, map->fndecl, current_function_decl);
1734
1735       if (DECL_RTL_SET_P (t))
1736         {
1737           rtx r;
1738
1739           SET_DECL_RTL (d, copy_rtx_and_substitute (DECL_RTL (t), map, 1));
1740
1741           /* Fully instantiate the address with the equivalent form so that the
1742              debugging information contains the actual register, instead of the
1743              virtual register.   Do this by not passing an insn to
1744              subst_constants.  */
1745           r = DECL_RTL (d);
1746           subst_constants (&r, NULL_RTX, map, 1);
1747           SET_DECL_RTL (d, r);
1748           apply_change_group ();
1749         }
1750
1751       /* Add this declaration to the list of variables in the new
1752          block.  */
1753       *next = d;
1754       next = &TREE_CHAIN (d);
1755     }
1756
1757   next = &BLOCK_SUBBLOCKS (new_block);
1758   for (t = BLOCK_SUBBLOCKS (let); t; t = BLOCK_CHAIN (t))
1759     {
1760       *next = integrate_decl_tree (t, map);
1761       BLOCK_SUPERCONTEXT (*next) = new_block;
1762       next = &BLOCK_CHAIN (*next);
1763     }
1764
1765   TREE_USED (new_block) = TREE_USED (let);
1766   BLOCK_ABSTRACT_ORIGIN (new_block) = let;
1767
1768   return new_block;
1769 }
1770 \f
1771 /* Create a new copy of an rtx. Recursively copies the operands of the rtx,
1772    except for those few rtx codes that are sharable.
1773
1774    We always return an rtx that is similar to that incoming rtx, with the
1775    exception of possibly changing a REG to a SUBREG or vice versa.  No
1776    rtl is ever emitted.
1777
1778    If FOR_LHS is nonzero, if means we are processing something that will
1779    be the LHS of a SET.  In that case, we copy RTX_UNCHANGING_P even if
1780    inlining since we need to be conservative in how it is set for
1781    such cases.
1782
1783    Handle constants that need to be placed in the constant pool by
1784    calling `force_const_mem'.  */
1785
1786 rtx
1787 copy_rtx_and_substitute (orig, map, for_lhs)
1788      register rtx orig;
1789      struct inline_remap *map;
1790      int for_lhs;
1791 {
1792   register rtx copy, temp;
1793   register int i, j;
1794   register RTX_CODE code;
1795   register enum machine_mode mode;
1796   register const char *format_ptr;
1797   int regno;
1798
1799   if (orig == 0)
1800     return 0;
1801
1802   code = GET_CODE (orig);
1803   mode = GET_MODE (orig);
1804
1805   switch (code)
1806     {
1807     case REG:
1808       /* If the stack pointer register shows up, it must be part of
1809          stack-adjustments (*not* because we eliminated the frame pointer!).
1810          Small hard registers are returned as-is.  Pseudo-registers
1811          go through their `reg_map'.  */
1812       regno = REGNO (orig);
1813       if (regno <= LAST_VIRTUAL_REGISTER
1814           || (map->integrating
1815               && DECL_SAVED_INSNS (map->fndecl)->internal_arg_pointer == orig))
1816         {
1817           /* Some hard registers are also mapped,
1818              but others are not translated.  */
1819           if (map->reg_map[regno] != 0)
1820             return map->reg_map[regno];
1821
1822           /* If this is the virtual frame pointer, make space in current
1823              function's stack frame for the stack frame of the inline function.
1824
1825              Copy the address of this area into a pseudo.  Map
1826              virtual_stack_vars_rtx to this pseudo and set up a constant
1827              equivalence for it to be the address.  This will substitute the
1828              address into insns where it can be substituted and use the new
1829              pseudo where it can't.  */
1830           else if (regno == VIRTUAL_STACK_VARS_REGNUM)
1831             {
1832               rtx loc, seq;
1833               int size = get_func_frame_size (DECL_SAVED_INSNS (map->fndecl));
1834 #ifdef FRAME_GROWS_DOWNWARD
1835               int alignment
1836                 = (DECL_SAVED_INSNS (map->fndecl)->stack_alignment_needed
1837                    / BITS_PER_UNIT);
1838
1839               /* In this case, virtual_stack_vars_rtx points to one byte
1840                  higher than the top of the frame area.  So make sure we
1841                  allocate a big enough chunk to keep the frame pointer
1842                  aligned like a real one.  */
1843               if (alignment)
1844                 size = CEIL_ROUND (size, alignment);
1845 #endif
1846               start_sequence ();
1847               loc = assign_stack_temp (BLKmode, size, 1);
1848               loc = XEXP (loc, 0);
1849 #ifdef FRAME_GROWS_DOWNWARD
1850               /* In this case, virtual_stack_vars_rtx points to one byte
1851                  higher than the top of the frame area.  So compute the offset
1852                  to one byte higher than our substitute frame.  */
1853               loc = plus_constant (loc, size);
1854 #endif
1855               map->reg_map[regno] = temp
1856                 = force_reg (Pmode, force_operand (loc, NULL_RTX));
1857
1858 #ifdef STACK_BOUNDARY
1859               mark_reg_pointer (map->reg_map[regno], STACK_BOUNDARY);
1860 #endif
1861
1862               SET_CONST_EQUIV_DATA (map, temp, loc, CONST_AGE_PARM);
1863
1864               seq = gen_sequence ();
1865               end_sequence ();
1866               emit_insn_after (seq, map->insns_at_start);
1867               return temp;
1868             }
1869           else if (regno == VIRTUAL_INCOMING_ARGS_REGNUM
1870                    || (map->integrating
1871                        && (DECL_SAVED_INSNS (map->fndecl)->internal_arg_pointer
1872                            == orig)))
1873             {
1874               /* Do the same for a block to contain any arguments referenced
1875                  in memory.  */
1876               rtx loc, seq;
1877               int size = DECL_SAVED_INSNS (map->fndecl)->args_size;
1878
1879               start_sequence ();
1880               loc = assign_stack_temp (BLKmode, size, 1);
1881               loc = XEXP (loc, 0);
1882               /* When arguments grow downward, the virtual incoming
1883                  args pointer points to the top of the argument block,
1884                  so the remapped location better do the same.  */
1885 #ifdef ARGS_GROW_DOWNWARD
1886               loc = plus_constant (loc, size);
1887 #endif
1888               map->reg_map[regno] = temp
1889                 = force_reg (Pmode, force_operand (loc, NULL_RTX));
1890
1891 #ifdef STACK_BOUNDARY
1892               mark_reg_pointer (map->reg_map[regno], STACK_BOUNDARY);
1893 #endif
1894
1895               SET_CONST_EQUIV_DATA (map, temp, loc, CONST_AGE_PARM);
1896
1897               seq = gen_sequence ();
1898               end_sequence ();
1899               emit_insn_after (seq, map->insns_at_start);
1900               return temp;
1901             }
1902           else if (REG_FUNCTION_VALUE_P (orig))
1903             {
1904               /* This is a reference to the function return value.  If
1905                  the function doesn't have a return value, error.  If the
1906                  mode doesn't agree, and it ain't BLKmode, make a SUBREG.  */
1907               if (map->inline_target == 0)
1908                 {
1909                   if (rtx_equal_function_value_matters)
1910                     /* This is an ignored return value.  We must not
1911                        leave it in with REG_FUNCTION_VALUE_P set, since
1912                        that would confuse subsequent inlining of the
1913                        current function into a later function.  */
1914                     return gen_rtx_REG (GET_MODE (orig), regno);
1915                   else
1916                     /* Must be unrolling loops or replicating code if we
1917                        reach here, so return the register unchanged.  */
1918                     return orig;
1919                 }
1920               else if (GET_MODE (map->inline_target) != BLKmode
1921                        && mode != GET_MODE (map->inline_target))
1922                 return gen_lowpart (mode, map->inline_target);
1923               else
1924                 return map->inline_target;
1925             }
1926 #if defined (LEAF_REGISTERS) && defined (LEAF_REG_REMAP)
1927           /* If leaf_renumber_regs_insn() might remap this register to
1928              some other number, make sure we don't share it with the
1929              inlined function, otherwise delayed optimization of the
1930              inlined function may change it in place, breaking our
1931              reference to it.  We may still shared it within the
1932              function, so create an entry for this register in the
1933              reg_map.  */
1934           if (map->integrating && regno < FIRST_PSEUDO_REGISTER
1935               && LEAF_REGISTERS[regno] && LEAF_REG_REMAP (regno) != regno)
1936             {
1937               if (!map->leaf_reg_map[regno][mode])
1938                 map->leaf_reg_map[regno][mode] = gen_rtx_REG (mode, regno);
1939               return map->leaf_reg_map[regno][mode];
1940             }
1941 #endif
1942           else
1943             return orig;
1944
1945           abort ();
1946         }
1947       if (map->reg_map[regno] == NULL)
1948         {
1949           map->reg_map[regno] = gen_reg_rtx (mode);
1950           REG_USERVAR_P (map->reg_map[regno]) = REG_USERVAR_P (orig);
1951           REG_LOOP_TEST_P (map->reg_map[regno]) = REG_LOOP_TEST_P (orig);
1952           RTX_UNCHANGING_P (map->reg_map[regno]) = RTX_UNCHANGING_P (orig);
1953           /* A reg with REG_FUNCTION_VALUE_P true will never reach here.  */
1954
1955           if (REG_POINTER (map->x_regno_reg_rtx[regno]))
1956             mark_reg_pointer (map->reg_map[regno],
1957                               map->regno_pointer_align[regno]);
1958         }
1959       return map->reg_map[regno];
1960
1961     case SUBREG:
1962       copy = copy_rtx_and_substitute (SUBREG_REG (orig), map, for_lhs);
1963       return simplify_gen_subreg (GET_MODE (orig), copy,
1964                                   GET_MODE (SUBREG_REG (orig)),
1965                                   SUBREG_BYTE (orig));
1966
1967     case ADDRESSOF:
1968       copy = gen_rtx_ADDRESSOF (mode,
1969                                 copy_rtx_and_substitute (XEXP (orig, 0),
1970                                                          map, for_lhs),
1971                                 0, ADDRESSOF_DECL (orig));
1972       regno = ADDRESSOF_REGNO (orig);
1973       if (map->reg_map[regno])
1974         regno = REGNO (map->reg_map[regno]);
1975       else if (regno > LAST_VIRTUAL_REGISTER)
1976         {
1977           temp = XEXP (orig, 0);
1978           map->reg_map[regno] = gen_reg_rtx (GET_MODE (temp));
1979           REG_USERVAR_P (map->reg_map[regno]) = REG_USERVAR_P (temp);
1980           REG_LOOP_TEST_P (map->reg_map[regno]) = REG_LOOP_TEST_P (temp);
1981           RTX_UNCHANGING_P (map->reg_map[regno]) = RTX_UNCHANGING_P (temp);
1982           /* A reg with REG_FUNCTION_VALUE_P true will never reach here.  */
1983
1984           if (REG_POINTER (map->x_regno_reg_rtx[regno]))
1985             mark_reg_pointer (map->reg_map[regno],
1986                               map->regno_pointer_align[regno]);
1987           regno = REGNO (map->reg_map[regno]);
1988         }
1989       ADDRESSOF_REGNO (copy) = regno;
1990       return copy;
1991
1992     case USE:
1993     case CLOBBER:
1994       /* USE and CLOBBER are ordinary, but we convert (use (subreg foo))
1995          to (use foo) if the original insn didn't have a subreg.
1996          Removing the subreg distorts the VAX movstrhi pattern
1997          by changing the mode of an operand.  */
1998       copy = copy_rtx_and_substitute (XEXP (orig, 0), map, code == CLOBBER);
1999       if (GET_CODE (copy) == SUBREG && GET_CODE (XEXP (orig, 0)) != SUBREG)
2000         copy = SUBREG_REG (copy);
2001       return gen_rtx_fmt_e (code, VOIDmode, copy);
2002
2003     /* We need to handle "deleted" labels that appear in the DECL_RTL
2004        of a LABEL_DECL.  */
2005     case NOTE:
2006       if (NOTE_LINE_NUMBER (orig) != NOTE_INSN_DELETED_LABEL)
2007         break;
2008
2009       /* ... FALLTHRU ...  */
2010     case CODE_LABEL:
2011       LABEL_PRESERVE_P (get_label_from_map (map, CODE_LABEL_NUMBER (orig)))
2012         = LABEL_PRESERVE_P (orig);
2013       return get_label_from_map (map, CODE_LABEL_NUMBER (orig));
2014
2015     case LABEL_REF:
2016       copy
2017         = gen_rtx_LABEL_REF
2018           (mode,
2019            LABEL_REF_NONLOCAL_P (orig) ? XEXP (orig, 0)
2020            : get_label_from_map (map, CODE_LABEL_NUMBER (XEXP (orig, 0))));
2021
2022       LABEL_OUTSIDE_LOOP_P (copy) = LABEL_OUTSIDE_LOOP_P (orig);
2023
2024       /* The fact that this label was previously nonlocal does not mean
2025          it still is, so we must check if it is within the range of
2026          this function's labels.  */
2027       LABEL_REF_NONLOCAL_P (copy)
2028         = (LABEL_REF_NONLOCAL_P (orig)
2029            && ! (CODE_LABEL_NUMBER (XEXP (copy, 0)) >= get_first_label_num ()
2030                  && CODE_LABEL_NUMBER (XEXP (copy, 0)) < max_label_num ()));
2031
2032       /* If we have made a nonlocal label local, it means that this
2033          inlined call will be referring to our nonlocal goto handler.
2034          So make sure we create one for this block; we normally would
2035          not since this is not otherwise considered a "call".  */
2036       if (LABEL_REF_NONLOCAL_P (orig) && ! LABEL_REF_NONLOCAL_P (copy))
2037         function_call_count++;
2038
2039       return copy;
2040
2041     case PC:
2042     case CC0:
2043     case CONST_INT:
2044       return orig;
2045
2046     case SYMBOL_REF:
2047       /* Symbols which represent the address of a label stored in the constant
2048          pool must be modified to point to a constant pool entry for the
2049          remapped label.  Otherwise, symbols are returned unchanged.  */
2050       if (CONSTANT_POOL_ADDRESS_P (orig))
2051         {
2052           struct function *f = inlining ? inlining : cfun;
2053           rtx constant = get_pool_constant_for_function (f, orig);
2054           enum machine_mode const_mode = get_pool_mode_for_function (f, orig);
2055           if (inlining)
2056             {
2057               rtx temp = force_const_mem (const_mode,
2058                                           copy_rtx_and_substitute (constant,
2059                                                                    map, 0));
2060
2061 #if 0
2062               /* Legitimizing the address here is incorrect.
2063
2064                  Since we had a SYMBOL_REF before, we can assume it is valid
2065                  to have one in this position in the insn.
2066
2067                  Also, change_address may create new registers.  These
2068                  registers will not have valid reg_map entries.  This can
2069                  cause try_constants() to fail because assumes that all
2070                  registers in the rtx have valid reg_map entries, and it may
2071                  end up replacing one of these new registers with junk.  */
2072
2073               if (! memory_address_p (GET_MODE (temp), XEXP (temp, 0)))
2074                 temp = change_address (temp, GET_MODE (temp), XEXP (temp, 0));
2075 #endif
2076
2077               temp = XEXP (temp, 0);
2078
2079 #ifdef POINTERS_EXTEND_UNSIGNED
2080               if (GET_MODE (temp) != GET_MODE (orig))
2081                 temp = convert_memory_address (GET_MODE (orig), temp);
2082 #endif
2083               return temp;
2084             }
2085           else if (GET_CODE (constant) == LABEL_REF)
2086             return XEXP (force_const_mem
2087                          (GET_MODE (orig),
2088                           copy_rtx_and_substitute (constant, map, for_lhs)),
2089                          0);
2090         }
2091
2092       return orig;
2093
2094     case CONST_DOUBLE:
2095       /* We have to make a new copy of this CONST_DOUBLE because don't want
2096          to use the old value of CONST_DOUBLE_MEM.  Also, this may be a
2097          duplicate of a CONST_DOUBLE we have already seen.  */
2098       if (GET_MODE_CLASS (GET_MODE (orig)) == MODE_FLOAT)
2099         {
2100           REAL_VALUE_TYPE d;
2101
2102           REAL_VALUE_FROM_CONST_DOUBLE (d, orig);
2103           return CONST_DOUBLE_FROM_REAL_VALUE (d, GET_MODE (orig));
2104         }
2105       else
2106         return immed_double_const (CONST_DOUBLE_LOW (orig),
2107                                    CONST_DOUBLE_HIGH (orig), VOIDmode);
2108
2109     case CONST:
2110       /* Make new constant pool entry for a constant
2111          that was in the pool of the inline function.  */
2112       if (RTX_INTEGRATED_P (orig))
2113         abort ();
2114       break;
2115
2116     case ASM_OPERANDS:
2117       /* If a single asm insn contains multiple output operands then
2118          it contains multiple ASM_OPERANDS rtx's that share the input
2119          and constraint vecs.  We must make sure that the copied insn
2120          continues to share it.  */
2121       if (map->orig_asm_operands_vector == ASM_OPERANDS_INPUT_VEC (orig))
2122         {
2123           copy = rtx_alloc (ASM_OPERANDS);
2124           copy->volatil = orig->volatil;
2125           PUT_MODE (copy, GET_MODE (orig));
2126           ASM_OPERANDS_TEMPLATE (copy) = ASM_OPERANDS_TEMPLATE (orig);
2127           ASM_OPERANDS_OUTPUT_CONSTRAINT (copy)
2128             = ASM_OPERANDS_OUTPUT_CONSTRAINT (orig);
2129           ASM_OPERANDS_OUTPUT_IDX (copy) = ASM_OPERANDS_OUTPUT_IDX (orig);
2130           ASM_OPERANDS_INPUT_VEC (copy) = map->copy_asm_operands_vector;
2131           ASM_OPERANDS_INPUT_CONSTRAINT_VEC (copy)
2132             = map->copy_asm_constraints_vector;
2133           ASM_OPERANDS_SOURCE_FILE (copy) = ASM_OPERANDS_SOURCE_FILE (orig);
2134           ASM_OPERANDS_SOURCE_LINE (copy) = ASM_OPERANDS_SOURCE_LINE (orig);
2135           return copy;
2136         }
2137       break;
2138
2139     case CALL:
2140       /* This is given special treatment because the first
2141          operand of a CALL is a (MEM ...) which may get
2142          forced into a register for cse.  This is undesirable
2143          if function-address cse isn't wanted or if we won't do cse.  */
2144 #ifndef NO_FUNCTION_CSE
2145       if (! (optimize && ! flag_no_function_cse))
2146 #endif
2147         return
2148           gen_rtx_CALL
2149             (GET_MODE (orig),
2150              gen_rtx_MEM (GET_MODE (XEXP (orig, 0)),
2151                           copy_rtx_and_substitute (XEXP (XEXP (orig, 0), 0),
2152                                                    map, 0)),
2153              copy_rtx_and_substitute (XEXP (orig, 1), map, 0));
2154       break;
2155
2156 #if 0
2157       /* Must be ifdefed out for loop unrolling to work.  */
2158     case RETURN:
2159       abort ();
2160 #endif
2161
2162     case SET:
2163       /* If this is setting fp or ap, it means that we have a nonlocal goto.
2164          Adjust the setting by the offset of the area we made.
2165          If the nonlocal goto is into the current function,
2166          this will result in unnecessarily bad code, but should work.  */
2167       if (SET_DEST (orig) == virtual_stack_vars_rtx
2168           || SET_DEST (orig) == virtual_incoming_args_rtx)
2169         {
2170           /* In case a translation hasn't occurred already, make one now.  */
2171           rtx equiv_reg;
2172           rtx equiv_loc;
2173           HOST_WIDE_INT loc_offset;
2174
2175           copy_rtx_and_substitute (SET_DEST (orig), map, for_lhs);
2176           equiv_reg = map->reg_map[REGNO (SET_DEST (orig))];
2177           equiv_loc = VARRAY_CONST_EQUIV (map->const_equiv_varray,
2178                                           REGNO (equiv_reg)).rtx;
2179           loc_offset
2180             = GET_CODE (equiv_loc) == REG ? 0 : INTVAL (XEXP (equiv_loc, 1));
2181
2182           return gen_rtx_SET (VOIDmode, SET_DEST (orig),
2183                               force_operand
2184                               (plus_constant
2185                                (copy_rtx_and_substitute (SET_SRC (orig),
2186                                                          map, 0),
2187                                 - loc_offset),
2188                                NULL_RTX));
2189         }
2190       else
2191         return gen_rtx_SET (VOIDmode,
2192                             copy_rtx_and_substitute (SET_DEST (orig), map, 1),
2193                             copy_rtx_and_substitute (SET_SRC (orig), map, 0));
2194       break;
2195
2196     case MEM:
2197       if (inlining
2198           && GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
2199           && CONSTANT_POOL_ADDRESS_P (XEXP (orig, 0)))
2200         {
2201           enum machine_mode const_mode
2202             = get_pool_mode_for_function (inlining, XEXP (orig, 0));
2203           rtx constant
2204             = get_pool_constant_for_function (inlining, XEXP (orig, 0));
2205
2206           constant = copy_rtx_and_substitute (constant, map, 0);
2207
2208           /* If this was an address of a constant pool entry that itself
2209              had to be placed in the constant pool, it might not be a
2210              valid address.  So the recursive call might have turned it
2211              into a register.  In that case, it isn't a constant any
2212              more, so return it.  This has the potential of changing a
2213              MEM into a REG, but we'll assume that it safe.  */
2214           if (! CONSTANT_P (constant))
2215             return constant;
2216
2217           return validize_mem (force_const_mem (const_mode, constant));
2218         }
2219
2220       copy = rtx_alloc (MEM);
2221       PUT_MODE (copy, mode);
2222       XEXP (copy, 0) = copy_rtx_and_substitute (XEXP (orig, 0), map, 0);
2223       MEM_COPY_ATTRIBUTES (copy, orig);
2224       return copy;
2225
2226     default:
2227       break;
2228     }
2229
2230   copy = rtx_alloc (code);
2231   PUT_MODE (copy, mode);
2232   copy->in_struct = orig->in_struct;
2233   copy->volatil = orig->volatil;
2234   copy->unchanging = orig->unchanging;
2235
2236   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
2237
2238   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
2239     {
2240       switch (*format_ptr++)
2241         {
2242         case '0':
2243           /* Copy this through the wide int field; that's safest.  */
2244           X0WINT (copy, i) = X0WINT (orig, i);
2245           break;
2246
2247         case 'e':
2248           XEXP (copy, i)
2249             = copy_rtx_and_substitute (XEXP (orig, i), map, for_lhs);
2250           break;
2251
2252         case 'u':
2253           /* Change any references to old-insns to point to the
2254              corresponding copied insns.  */
2255           XEXP (copy, i) = map->insn_map[INSN_UID (XEXP (orig, i))];
2256           break;
2257
2258         case 'E':
2259           XVEC (copy, i) = XVEC (orig, i);
2260           if (XVEC (orig, i) != NULL && XVECLEN (orig, i) != 0)
2261             {
2262               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
2263               for (j = 0; j < XVECLEN (copy, i); j++)
2264                 XVECEXP (copy, i, j)
2265                   = copy_rtx_and_substitute (XVECEXP (orig, i, j),
2266                                              map, for_lhs);
2267             }
2268           break;
2269
2270         case 'w':
2271           XWINT (copy, i) = XWINT (orig, i);
2272           break;
2273
2274         case 'i':
2275           XINT (copy, i) = XINT (orig, i);
2276           break;
2277
2278         case 's':
2279           XSTR (copy, i) = XSTR (orig, i);
2280           break;
2281
2282         case 't':
2283           XTREE (copy, i) = XTREE (orig, i);
2284           break;
2285
2286         default:
2287           abort ();
2288         }
2289     }
2290
2291   if (code == ASM_OPERANDS && map->orig_asm_operands_vector == 0)
2292     {
2293       map->orig_asm_operands_vector = ASM_OPERANDS_INPUT_VEC (orig);
2294       map->copy_asm_operands_vector = ASM_OPERANDS_INPUT_VEC (copy);
2295       map->copy_asm_constraints_vector
2296         = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (copy);
2297     }
2298
2299   return copy;
2300 }
2301 \f
2302 /* Substitute known constant values into INSN, if that is valid.  */
2303
2304 void
2305 try_constants (insn, map)
2306      rtx insn;
2307      struct inline_remap *map;
2308 {
2309   int i;
2310
2311   map->num_sets = 0;
2312
2313   /* First try just updating addresses, then other things.  This is
2314      important when we have something like the store of a constant
2315      into memory and we can update the memory address but the machine
2316      does not support a constant source.  */
2317   subst_constants (&PATTERN (insn), insn, map, 1);
2318   apply_change_group ();
2319   subst_constants (&PATTERN (insn), insn, map, 0);
2320   apply_change_group ();
2321
2322   /* Show we don't know the value of anything stored or clobbered.  */
2323   note_stores (PATTERN (insn), mark_stores, NULL);
2324   map->last_pc_value = 0;
2325 #ifdef HAVE_cc0
2326   map->last_cc0_value = 0;
2327 #endif
2328
2329   /* Set up any constant equivalences made in this insn.  */
2330   for (i = 0; i < map->num_sets; i++)
2331     {
2332       if (GET_CODE (map->equiv_sets[i].dest) == REG)
2333         {
2334           int regno = REGNO (map->equiv_sets[i].dest);
2335
2336           MAYBE_EXTEND_CONST_EQUIV_VARRAY (map, regno);
2337           if (VARRAY_CONST_EQUIV (map->const_equiv_varray, regno).rtx == 0
2338               /* Following clause is a hack to make case work where GNU C++
2339                  reassigns a variable to make cse work right.  */
2340               || ! rtx_equal_p (VARRAY_CONST_EQUIV (map->const_equiv_varray,
2341                                                     regno).rtx,
2342                                 map->equiv_sets[i].equiv))
2343             SET_CONST_EQUIV_DATA (map, map->equiv_sets[i].dest,
2344                                   map->equiv_sets[i].equiv, map->const_age);
2345         }
2346       else if (map->equiv_sets[i].dest == pc_rtx)
2347         map->last_pc_value = map->equiv_sets[i].equiv;
2348 #ifdef HAVE_cc0
2349       else if (map->equiv_sets[i].dest == cc0_rtx)
2350         map->last_cc0_value = map->equiv_sets[i].equiv;
2351 #endif
2352     }
2353 }
2354 \f
2355 /* Substitute known constants for pseudo regs in the contents of LOC,
2356    which are part of INSN.
2357    If INSN is zero, the substitution should always be done (this is used to
2358    update DECL_RTL).
2359    These changes are taken out by try_constants if the result is not valid.
2360
2361    Note that we are more concerned with determining when the result of a SET
2362    is a constant, for further propagation, than actually inserting constants
2363    into insns; cse will do the latter task better.
2364
2365    This function is also used to adjust address of items previously addressed
2366    via the virtual stack variable or virtual incoming arguments registers.
2367
2368    If MEMONLY is nonzero, only make changes inside a MEM.  */
2369
2370 static void
2371 subst_constants (loc, insn, map, memonly)
2372      rtx *loc;
2373      rtx insn;
2374      struct inline_remap *map;
2375      int memonly;
2376 {
2377   rtx x = *loc;
2378   register int i, j;
2379   register enum rtx_code code;
2380   register const char *format_ptr;
2381   int num_changes = num_validated_changes ();
2382   rtx new = 0;
2383   enum machine_mode op0_mode = MAX_MACHINE_MODE;
2384
2385   code = GET_CODE (x);
2386
2387   switch (code)
2388     {
2389     case PC:
2390     case CONST_INT:
2391     case CONST_DOUBLE:
2392     case SYMBOL_REF:
2393     case CONST:
2394     case LABEL_REF:
2395     case ADDRESS:
2396       return;
2397
2398 #ifdef HAVE_cc0
2399     case CC0:
2400       if (! memonly)
2401         validate_change (insn, loc, map->last_cc0_value, 1);
2402       return;
2403 #endif
2404
2405     case USE:
2406     case CLOBBER:
2407       /* The only thing we can do with a USE or CLOBBER is possibly do
2408          some substitutions in a MEM within it.  */
2409       if (GET_CODE (XEXP (x, 0)) == MEM)
2410         subst_constants (&XEXP (XEXP (x, 0), 0), insn, map, 0);
2411       return;
2412
2413     case REG:
2414       /* Substitute for parms and known constants.  Don't replace
2415          hard regs used as user variables with constants.  */
2416       if (! memonly)
2417         {
2418           int regno = REGNO (x);
2419           struct const_equiv_data *p;
2420
2421           if (! (regno < FIRST_PSEUDO_REGISTER && REG_USERVAR_P (x))
2422               && (size_t) regno < VARRAY_SIZE (map->const_equiv_varray)
2423               && (p = &VARRAY_CONST_EQUIV (map->const_equiv_varray, regno),
2424                   p->rtx != 0)
2425               && p->age >= map->const_age)
2426             validate_change (insn, loc, p->rtx, 1);
2427         }
2428       return;
2429
2430     case SUBREG:
2431       /* SUBREG applied to something other than a reg
2432          should be treated as ordinary, since that must
2433          be a special hack and we don't know how to treat it specially.
2434          Consider for example mulsidi3 in m68k.md.
2435          Ordinary SUBREG of a REG needs this special treatment.  */
2436       if (! memonly && GET_CODE (SUBREG_REG (x)) == REG)
2437         {
2438           rtx inner = SUBREG_REG (x);
2439           rtx new = 0;
2440
2441           /* We can't call subst_constants on &SUBREG_REG (x) because any
2442              constant or SUBREG wouldn't be valid inside our SUBEG.  Instead,
2443              see what is inside, try to form the new SUBREG and see if that is
2444              valid.  We handle two cases: extracting a full word in an
2445              integral mode and extracting the low part.  */
2446           subst_constants (&inner, NULL_RTX, map, 0);
2447           new = simplify_gen_subreg (GET_MODE (x), inner,
2448                                      GET_MODE (SUBREG_REG (x)),
2449                                      SUBREG_BYTE (x));
2450
2451           if (new)
2452             validate_change (insn, loc, new, 1);
2453           else
2454             cancel_changes (num_changes);
2455
2456           return;
2457         }
2458       break;
2459
2460     case MEM:
2461       subst_constants (&XEXP (x, 0), insn, map, 0);
2462
2463       /* If a memory address got spoiled, change it back.  */
2464       if (! memonly && insn != 0 && num_validated_changes () != num_changes
2465           && ! memory_address_p (GET_MODE (x), XEXP (x, 0)))
2466         cancel_changes (num_changes);
2467       return;
2468
2469     case SET:
2470       {
2471         /* Substitute constants in our source, and in any arguments to a
2472            complex (e..g, ZERO_EXTRACT) destination, but not in the destination
2473            itself.  */
2474         rtx *dest_loc = &SET_DEST (x);
2475         rtx dest = *dest_loc;
2476         rtx src, tem;
2477         enum machine_mode compare_mode = VOIDmode;
2478
2479         /* If SET_SRC is a COMPARE which subst_constants would turn into
2480            COMPARE of 2 VOIDmode constants, note the mode in which comparison
2481            is to be done.  */
2482         if (GET_CODE (SET_SRC (x)) == COMPARE)
2483           {
2484             src = SET_SRC (x);
2485             if (GET_MODE_CLASS (GET_MODE (src)) == MODE_CC
2486 #ifdef HAVE_cc0
2487                 || dest == cc0_rtx
2488 #endif
2489                 )
2490               {
2491                 compare_mode = GET_MODE (XEXP (src, 0));
2492                 if (compare_mode == VOIDmode)
2493                   compare_mode = GET_MODE (XEXP (src, 1));
2494               }
2495           }
2496
2497         subst_constants (&SET_SRC (x), insn, map, memonly);
2498         src = SET_SRC (x);
2499
2500         while (GET_CODE (*dest_loc) == ZERO_EXTRACT
2501                || GET_CODE (*dest_loc) == SUBREG
2502                || GET_CODE (*dest_loc) == STRICT_LOW_PART)
2503           {
2504             if (GET_CODE (*dest_loc) == ZERO_EXTRACT)
2505               {
2506                 subst_constants (&XEXP (*dest_loc, 1), insn, map, memonly);
2507                 subst_constants (&XEXP (*dest_loc, 2), insn, map, memonly);
2508               }
2509             dest_loc = &XEXP (*dest_loc, 0);
2510           }
2511
2512         /* Do substitute in the address of a destination in memory.  */
2513         if (GET_CODE (*dest_loc) == MEM)
2514           subst_constants (&XEXP (*dest_loc, 0), insn, map, 0);
2515
2516         /* Check for the case of DEST a SUBREG, both it and the underlying
2517            register are less than one word, and the SUBREG has the wider mode.
2518            In the case, we are really setting the underlying register to the
2519            source converted to the mode of DEST.  So indicate that.  */
2520         if (GET_CODE (dest) == SUBREG
2521             && GET_MODE_SIZE (GET_MODE (dest)) <= UNITS_PER_WORD
2522             && GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest))) <= UNITS_PER_WORD
2523             && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
2524                       <= GET_MODE_SIZE (GET_MODE (dest)))
2525             && (tem = gen_lowpart_if_possible (GET_MODE (SUBREG_REG (dest)),
2526                                                src)))
2527           src = tem, dest = SUBREG_REG (dest);
2528
2529         /* If storing a recognizable value save it for later recording.  */
2530         if ((map->num_sets < MAX_RECOG_OPERANDS)
2531             && (CONSTANT_P (src)
2532                 || (GET_CODE (src) == REG
2533                     && (REGNO (src) == VIRTUAL_INCOMING_ARGS_REGNUM
2534                         || REGNO (src) == VIRTUAL_STACK_VARS_REGNUM))
2535                 || (GET_CODE (src) == PLUS
2536                     && GET_CODE (XEXP (src, 0)) == REG
2537                     && (REGNO (XEXP (src, 0)) == VIRTUAL_INCOMING_ARGS_REGNUM
2538                         || REGNO (XEXP (src, 0)) == VIRTUAL_STACK_VARS_REGNUM)
2539                     && CONSTANT_P (XEXP (src, 1)))
2540                 || GET_CODE (src) == COMPARE
2541 #ifdef HAVE_cc0
2542                 || dest == cc0_rtx
2543 #endif
2544                 || (dest == pc_rtx
2545                     && (src == pc_rtx || GET_CODE (src) == RETURN
2546                         || GET_CODE (src) == LABEL_REF))))
2547           {
2548             /* Normally, this copy won't do anything.  But, if SRC is a COMPARE
2549                it will cause us to save the COMPARE with any constants
2550                substituted, which is what we want for later.  */
2551             rtx src_copy = copy_rtx (src);
2552             map->equiv_sets[map->num_sets].equiv = src_copy;
2553             map->equiv_sets[map->num_sets++].dest = dest;
2554             if (compare_mode != VOIDmode
2555                 && GET_CODE (src) == COMPARE
2556                 && (GET_MODE_CLASS (GET_MODE (src)) == MODE_CC
2557 #ifdef HAVE_cc0
2558                     || dest == cc0_rtx
2559 #endif
2560                     )
2561                 && GET_MODE (XEXP (src, 0)) == VOIDmode
2562                 && GET_MODE (XEXP (src, 1)) == VOIDmode)
2563               {
2564                 map->compare_src = src_copy;
2565                 map->compare_mode = compare_mode;
2566               }
2567           }
2568       }
2569       return;
2570
2571     default:
2572       break;
2573     }
2574
2575   format_ptr = GET_RTX_FORMAT (code);
2576
2577   /* If the first operand is an expression, save its mode for later.  */
2578   if (*format_ptr == 'e')
2579     op0_mode = GET_MODE (XEXP (x, 0));
2580
2581   for (i = 0; i < GET_RTX_LENGTH (code); i++)
2582     {
2583       switch (*format_ptr++)
2584         {
2585         case '0':
2586           break;
2587
2588         case 'e':
2589           if (XEXP (x, i))
2590             subst_constants (&XEXP (x, i), insn, map, memonly);
2591           break;
2592
2593         case 'u':
2594         case 'i':
2595         case 's':
2596         case 'w':
2597         case 'n':
2598         case 't':
2599           break;
2600
2601         case 'E':
2602           if (XVEC (x, i) != NULL && XVECLEN (x, i) != 0)
2603             for (j = 0; j < XVECLEN (x, i); j++)
2604               subst_constants (&XVECEXP (x, i, j), insn, map, memonly);
2605
2606           break;
2607
2608         default:
2609           abort ();
2610         }
2611     }
2612
2613   /* If this is a commutative operation, move a constant to the second
2614      operand unless the second operand is already a CONST_INT.  */
2615   if (! memonly
2616       && (GET_RTX_CLASS (code) == 'c' || code == NE || code == EQ)
2617       && CONSTANT_P (XEXP (x, 0)) && GET_CODE (XEXP (x, 1)) != CONST_INT)
2618     {
2619       rtx tem = XEXP (x, 0);
2620       validate_change (insn, &XEXP (x, 0), XEXP (x, 1), 1);
2621       validate_change (insn, &XEXP (x, 1), tem, 1);
2622     }
2623
2624   /* Simplify the expression in case we put in some constants.  */
2625   if (! memonly)
2626     switch (GET_RTX_CLASS (code))
2627       {
2628       case '1':
2629         if (op0_mode == MAX_MACHINE_MODE)
2630           abort ();
2631         new = simplify_unary_operation (code, GET_MODE (x),
2632                                         XEXP (x, 0), op0_mode);
2633         break;
2634
2635       case '<':
2636         {
2637           enum machine_mode op_mode = GET_MODE (XEXP (x, 0));
2638
2639           if (op_mode == VOIDmode)
2640             op_mode = GET_MODE (XEXP (x, 1));
2641           new = simplify_relational_operation (code, op_mode,
2642                                                XEXP (x, 0), XEXP (x, 1));
2643 #ifdef FLOAT_STORE_FLAG_VALUE
2644           if (new != 0 && GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2645             {
2646               enum machine_mode mode = GET_MODE (x);
2647               if (new == const0_rtx)
2648                 new = CONST0_RTX (mode);
2649               else
2650                 {
2651                   REAL_VALUE_TYPE val = FLOAT_STORE_FLAG_VALUE (mode);
2652                   new = CONST_DOUBLE_FROM_REAL_VALUE (val, mode);
2653                 }
2654             }
2655 #endif
2656           break;
2657         }
2658
2659       case '2':
2660       case 'c':
2661         new = simplify_binary_operation (code, GET_MODE (x),
2662                                          XEXP (x, 0), XEXP (x, 1));
2663         break;
2664
2665       case 'b':
2666       case '3':
2667         if (op0_mode == MAX_MACHINE_MODE)
2668           abort ();
2669
2670         if (code == IF_THEN_ELSE)
2671           {
2672             rtx op0 = XEXP (x, 0);
2673
2674             if (GET_RTX_CLASS (GET_CODE (op0)) == '<'
2675                 && GET_MODE (op0) == VOIDmode
2676                 && ! side_effects_p (op0)
2677                 && XEXP (op0, 0) == map->compare_src
2678                 && GET_MODE (XEXP (op0, 1)) == VOIDmode)
2679               {
2680                 /* We have compare of two VOIDmode constants for which
2681                    we recorded the comparison mode.  */
2682                 rtx temp =
2683                   simplify_relational_operation (GET_CODE (op0),
2684                                                  map->compare_mode,
2685                                                  XEXP (op0, 0),
2686                                                  XEXP (op0, 1));
2687
2688                 if (temp == const0_rtx)
2689                   new = XEXP (x, 2);
2690                 else if (temp == const1_rtx)
2691                   new = XEXP (x, 1);
2692               }
2693           }
2694         if (!new)
2695           new = simplify_ternary_operation (code, GET_MODE (x), op0_mode,
2696                                             XEXP (x, 0), XEXP (x, 1),
2697                                             XEXP (x, 2));
2698         break;
2699       }
2700
2701   if (new)
2702     validate_change (insn, loc, new, 1);
2703 }
2704
2705 /* Show that register modified no longer contain known constants.  We are
2706    called from note_stores with parts of the new insn.  */
2707
2708 static void
2709 mark_stores (dest, x, data)
2710      rtx dest;
2711      rtx x ATTRIBUTE_UNUSED;
2712      void *data ATTRIBUTE_UNUSED;
2713 {
2714   int regno = -1;
2715   enum machine_mode mode = VOIDmode;
2716
2717   /* DEST is always the innermost thing set, except in the case of
2718      SUBREGs of hard registers.  */
2719
2720   if (GET_CODE (dest) == REG)
2721     regno = REGNO (dest), mode = GET_MODE (dest);
2722   else if (GET_CODE (dest) == SUBREG && GET_CODE (SUBREG_REG (dest)) == REG)
2723     {
2724       regno = REGNO (SUBREG_REG (dest));
2725       if (regno < FIRST_PSEUDO_REGISTER)
2726         regno += subreg_regno_offset (REGNO (SUBREG_REG (dest)),
2727                                       GET_MODE (SUBREG_REG (dest)),
2728                                       SUBREG_BYTE (dest),
2729                                       GET_MODE (dest));
2730       mode = GET_MODE (SUBREG_REG (dest));
2731     }
2732
2733   if (regno >= 0)
2734     {
2735       unsigned int uregno = regno;
2736       unsigned int last_reg = (uregno >= FIRST_PSEUDO_REGISTER ? uregno
2737                                : uregno + HARD_REGNO_NREGS (uregno, mode) - 1);
2738       unsigned int i;
2739
2740       /* Ignore virtual stack var or virtual arg register since those
2741          are handled separately.  */
2742       if (uregno != VIRTUAL_INCOMING_ARGS_REGNUM
2743           && uregno != VIRTUAL_STACK_VARS_REGNUM)
2744         for (i = uregno; i <= last_reg; i++)
2745           if ((size_t) i < VARRAY_SIZE (global_const_equiv_varray))
2746             VARRAY_CONST_EQUIV (global_const_equiv_varray, i).rtx = 0;
2747     }
2748 }
2749 \f
2750 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
2751    given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
2752    that it points to the node itself, thus indicating that the node is its
2753    own (abstract) origin.  Additionally, if the BLOCK_ABSTRACT_ORIGIN for
2754    the given node is NULL, recursively descend the decl/block tree which
2755    it is the root of, and for each other ..._DECL or BLOCK node contained
2756    therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
2757    still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
2758    values to point to themselves.  */
2759
2760 static void
2761 set_block_origin_self (stmt)
2762      register tree stmt;
2763 {
2764   if (BLOCK_ABSTRACT_ORIGIN (stmt) == NULL_TREE)
2765     {
2766       BLOCK_ABSTRACT_ORIGIN (stmt) = stmt;
2767
2768       {
2769         register tree local_decl;
2770
2771         for (local_decl = BLOCK_VARS (stmt);
2772              local_decl != NULL_TREE;
2773              local_decl = TREE_CHAIN (local_decl))
2774           set_decl_origin_self (local_decl);    /* Potential recursion.  */
2775       }
2776
2777       {
2778         register tree subblock;
2779
2780         for (subblock = BLOCK_SUBBLOCKS (stmt);
2781              subblock != NULL_TREE;
2782              subblock = BLOCK_CHAIN (subblock))
2783           set_block_origin_self (subblock);     /* Recurse.  */
2784       }
2785     }
2786 }
2787
2788 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
2789    the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
2790    node to so that it points to the node itself, thus indicating that the
2791    node represents its own (abstract) origin.  Additionally, if the
2792    DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
2793    the decl/block tree of which the given node is the root of, and for
2794    each other ..._DECL or BLOCK node contained therein whose
2795    DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
2796    set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
2797    point to themselves.  */
2798
2799 void
2800 set_decl_origin_self (decl)
2801      register tree decl;
2802 {
2803   if (DECL_ABSTRACT_ORIGIN (decl) == NULL_TREE)
2804     {
2805       DECL_ABSTRACT_ORIGIN (decl) = decl;
2806       if (TREE_CODE (decl) == FUNCTION_DECL)
2807         {
2808           register tree arg;
2809
2810           for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg))
2811             DECL_ABSTRACT_ORIGIN (arg) = arg;
2812           if (DECL_INITIAL (decl) != NULL_TREE
2813               && DECL_INITIAL (decl) != error_mark_node)
2814             set_block_origin_self (DECL_INITIAL (decl));
2815         }
2816     }
2817 }
2818 \f
2819 /* Given a pointer to some BLOCK node, and a boolean value to set the
2820    "abstract" flags to, set that value into the BLOCK_ABSTRACT flag for
2821    the given block, and for all local decls and all local sub-blocks
2822    (recursively) which are contained therein.  */
2823
2824 static void
2825 set_block_abstract_flags (stmt, setting)
2826      register tree stmt;
2827      register int setting;
2828 {
2829   register tree local_decl;
2830   register tree subblock;
2831
2832   BLOCK_ABSTRACT (stmt) = setting;
2833
2834   for (local_decl = BLOCK_VARS (stmt);
2835        local_decl != NULL_TREE;
2836        local_decl = TREE_CHAIN (local_decl))
2837     set_decl_abstract_flags (local_decl, setting);
2838
2839   for (subblock = BLOCK_SUBBLOCKS (stmt);
2840        subblock != NULL_TREE;
2841        subblock = BLOCK_CHAIN (subblock))
2842     set_block_abstract_flags (subblock, setting);
2843 }
2844
2845 /* Given a pointer to some ..._DECL node, and a boolean value to set the
2846    "abstract" flags to, set that value into the DECL_ABSTRACT flag for the
2847    given decl, and (in the case where the decl is a FUNCTION_DECL) also
2848    set the abstract flags for all of the parameters, local vars, local
2849    blocks and sub-blocks (recursively) to the same setting.  */
2850
2851 void
2852 set_decl_abstract_flags (decl, setting)
2853      register tree decl;
2854      register int setting;
2855 {
2856   DECL_ABSTRACT (decl) = setting;
2857   if (TREE_CODE (decl) == FUNCTION_DECL)
2858     {
2859       register tree arg;
2860
2861       for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg))
2862         DECL_ABSTRACT (arg) = setting;
2863       if (DECL_INITIAL (decl) != NULL_TREE
2864           && DECL_INITIAL (decl) != error_mark_node)
2865         set_block_abstract_flags (DECL_INITIAL (decl), setting);
2866     }
2867 }
2868 \f
2869 /* Output the assembly language code for the function FNDECL
2870    from its DECL_SAVED_INSNS.  Used for inline functions that are output
2871    at end of compilation instead of where they came in the source.  */
2872
2873 void
2874 output_inline_function (fndecl)
2875      tree fndecl;
2876 {
2877   struct function *old_cfun = cfun;
2878   enum debug_info_type old_write_symbols = write_symbols;
2879   struct gcc_debug_hooks *old_debug_hooks = debug_hooks;
2880   struct function *f = DECL_SAVED_INSNS (fndecl);
2881
2882   cfun = f;
2883   current_function_decl = fndecl;
2884   clear_emit_caches ();
2885
2886   set_new_last_label_num (f->inl_max_label_num);
2887
2888   /* We're not deferring this any longer.  */
2889   DECL_DEFER_OUTPUT (fndecl) = 0;
2890
2891   /* If requested, suppress debugging information.  */
2892   if (f->no_debugging_symbols)
2893     {
2894       write_symbols = NO_DEBUG;
2895       debug_hooks = &do_nothing_debug_hooks;
2896     }
2897
2898   /* Do any preparation, such as emitting abstract debug info for the inline
2899      before it gets mangled by optimization.  */
2900   (*debug_hooks->outlining_inline_function) (fndecl);
2901
2902   /* Compile this function all the way down to assembly code.  */
2903   rest_of_compilation (fndecl);
2904
2905   /* We can't inline this anymore; rest_of_compilation destroyed the
2906      data structures describing the function.  */
2907   DECL_INLINE (fndecl) = 0;
2908   DECL_SAVED_INSNS (fndecl) = 0;
2909
2910   cfun = old_cfun;
2911   current_function_decl = old_cfun ? old_cfun->decl : 0;
2912   write_symbols = old_write_symbols;
2913   debug_hooks = old_debug_hooks;
2914 }
2915
2916 \f
2917 /* Functions to keep track of the values hard regs had at the start of
2918    the function.  */
2919
2920 rtx
2921 has_func_hard_reg_initial_val (fun, reg)
2922      struct function *fun;
2923      rtx reg;
2924 {
2925   struct initial_value_struct *ivs = fun->hard_reg_initial_vals;
2926   int i;
2927
2928   if (ivs == 0)
2929     return NULL_RTX;
2930
2931   for (i = 0; i < ivs->num_entries; i++)
2932     if (rtx_equal_p (ivs->entries[i].hard_reg, reg))
2933       return ivs->entries[i].pseudo;
2934
2935   return NULL_RTX;
2936 }
2937
2938 rtx
2939 get_func_hard_reg_initial_val (fun, reg)
2940      struct function *fun;
2941      rtx reg;
2942 {
2943   struct initial_value_struct *ivs = fun->hard_reg_initial_vals;
2944   rtx rv = has_func_hard_reg_initial_val (fun, reg);
2945
2946   if (rv)
2947     return rv;
2948
2949   if (ivs == 0)
2950     {
2951       fun->hard_reg_initial_vals = (void *) xmalloc (sizeof (initial_value_struct));
2952       ivs = fun->hard_reg_initial_vals;
2953       ivs->num_entries = 0;
2954       ivs->max_entries = 5;
2955       ivs->entries = (initial_value_pair *) xmalloc (5 * sizeof (initial_value_pair));
2956     }
2957
2958   if (ivs->num_entries >= ivs->max_entries)
2959     {
2960       ivs->max_entries += 5;
2961       ivs->entries =
2962         (initial_value_pair *) xrealloc (ivs->entries,
2963                                          ivs->max_entries
2964                                          * sizeof (initial_value_pair));
2965     }
2966
2967   ivs->entries[ivs->num_entries].hard_reg = reg;
2968   ivs->entries[ivs->num_entries].pseudo = gen_reg_rtx (GET_MODE (reg));
2969
2970   return ivs->entries[ivs->num_entries++].pseudo;
2971 }
2972
2973 rtx
2974 get_hard_reg_initial_val (mode, regno)
2975      enum machine_mode mode;
2976      int regno;
2977 {
2978   return get_func_hard_reg_initial_val (cfun, gen_rtx_REG (mode, regno));
2979 }
2980
2981 rtx
2982 has_hard_reg_initial_val (mode, regno)
2983      enum machine_mode mode;
2984      int regno;
2985 {
2986   return has_func_hard_reg_initial_val (cfun, gen_rtx_REG (mode, regno));
2987 }
2988
2989 void
2990 mark_hard_reg_initial_vals (fun)
2991      struct function *fun;
2992 {
2993   struct initial_value_struct *ivs = fun->hard_reg_initial_vals;
2994   int i;
2995
2996   if (ivs == 0)
2997     return;
2998
2999   for (i = 0; i < ivs->num_entries; i ++)
3000     {
3001       ggc_mark_rtx (ivs->entries[i].hard_reg);
3002       ggc_mark_rtx (ivs->entries[i].pseudo);
3003     }
3004 }
3005
3006 static void
3007 setup_initial_hard_reg_value_integration (inl_f, remap)
3008      struct function *inl_f;
3009      struct inline_remap *remap;
3010 {
3011   struct initial_value_struct *ivs = inl_f->hard_reg_initial_vals;
3012   int i;
3013
3014   if (ivs == 0)
3015     return;
3016
3017   for (i = 0; i < ivs->num_entries; i ++)
3018     remap->reg_map[REGNO (ivs->entries[i].pseudo)]
3019       = get_func_hard_reg_initial_val (cfun, ivs->entries[i].hard_reg);
3020 }
3021
3022
3023 void
3024 emit_initial_value_sets ()
3025 {
3026   struct initial_value_struct *ivs = cfun->hard_reg_initial_vals;
3027   int i;
3028   rtx seq;
3029
3030   if (ivs == 0)
3031     return;
3032
3033   start_sequence ();
3034   for (i = 0; i < ivs->num_entries; i++)
3035     emit_move_insn (ivs->entries[i].pseudo, ivs->entries[i].hard_reg);
3036   seq = get_insns ();
3037   end_sequence ();
3038
3039   emit_insns_after (seq, get_insns ());
3040 }