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