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