gcc/integrate.c

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