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