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