gcc/integrate.c

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