gcc/integrate.c

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