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