gcc/integrate.c

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