gcc/tree-inline.c

   1 /* Tree inlining.
   2    Copyright 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   3    Contributed by Alexandre Oliva <aoliva@redhat.com>
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GCC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "toplev.h"
  27 #include "tree.h"
  28 #include "tree-inline.h"
  29 #include "rtl.h"
  30 #include "expr.h"
  31 #include "flags.h"
  32 #include "params.h"
  33 #include "input.h"
  34 #include "insn-config.h"
  35 #include "varray.h"
  36 #include "hashtab.h"
  37 #include "splay-tree.h"
  38 #include "langhooks.h"
  39 #include "basic-block.h"
  40 #include "tree-iterator.h"
  41 #include "cgraph.h"
  42 #include "intl.h"
  43 #include "tree-mudflap.h"
  44 #include "tree-flow.h"
  45 #include "function.h"
  46 #include "ggc.h"
  47 #include "tree-flow.h"
  48 #include "diagnostic.h"
  49 #include "except.h"
  50 #include "debug.h"
  51 #include "pointer-set.h"
  52 #include "integrate.h"
  53
  54 /* I'm not real happy about this, but we need to handle gimple and
  55    non-gimple trees.  */
  56 #include "tree-gimple.h"
  57
  58 /* Inlining, Saving, Cloning
  59
  60    Inlining: a function body is duplicated, but the PARM_DECLs are
  61    remapped into VAR_DECLs, and non-void RETURN_EXPRs become
  62    MODIFY_EXPRs that store to a dedicated returned-value variable.
  63    The duplicated eh_region info of the copy will later be appended
  64    to the info for the caller; the eh_region info in copied throwing
  65    statements and RESX_EXPRs is adjusted accordingly.
  66
  67    Saving: make a semantically-identical copy of the function body.
  68    Necessary when we want to generate code for the body (a destructive
  69    operation), but we expect to need this body in the future (e.g. for
  70    inlining into another function).
  71
  72    Cloning: (only in C++) We have one body for a con/de/structor, and
  73    multiple function decls, each with a unique parameter list.
  74    Duplicate the body, using the given splay tree; some parameters
  75    will become constants (like 0 or 1).
  76
  77    All of these will simultaneously lookup any callgraph edges.  If
  78    we're going to inline the duplicated function body, and the given
  79    function has some cloned callgraph nodes (one for each place this
  80    function will be inlined) those callgraph edges will be duplicated.
  81    If we're saving or cloning the body, those callgraph edges will be
  82    updated to point into the new body.  (Note that the original
  83    callgraph node and edge list will not be altered.)
  84
  85    See the CALL_EXPR handling case in copy_body_r ().  */
  86
  87 /* 0 if we should not perform inlining.
  88    1 if we should expand functions calls inline at the tree level.
  89    2 if we should consider *all* functions to be inline
  90    candidates.  */
  91
  92 int flag_inline_trees = 0;
  93
  94 /* To Do:
  95
  96    o In order to make inlining-on-trees work, we pessimized
  97      function-local static constants.  In particular, they are now
  98      always output, even when not addressed.  Fix this by treating
  99      function-local static constants just like global static
 100      constants; the back-end already knows not to output them if they
 101      are not needed.
 102
 103    o Provide heuristics to clamp inlining of recursive template
 104      calls?  */
 105
 106 /* Data required for function inlining.  */
 107
 108 typedef struct inline_data
 109 {
 110   /* FUNCTION_DECL for function being inlined.  */
 111   tree callee;
 112   /* FUNCTION_DECL for function being inlined into.  */
 113   tree caller;
 114   /* struct function for function being inlined.  Usually this is the same
 115      as DECL_STRUCT_FUNCTION (callee), but can be different if saved_cfg
 116      and saved_eh are in use.  */
 117   struct function *callee_cfun;
 118   /* The VAR_DECL for the return value.  */
 119   tree retvar;
 120   /* The map from local declarations in the inlined function to
 121      equivalents in the function into which it is being inlined.  */
 122   splay_tree decl_map;
 123   /* We use the same mechanism to build clones that we do to perform
 124      inlining.  However, there are a few places where we need to
 125      distinguish between those two situations.  This flag is true if
 126      we are cloning, rather than inlining.  */
 127   bool cloning_p;
 128   /* Similarly for saving function body.  */
 129   bool saving_p;
 130   /* Callgraph node of function we are inlining into.  */
 131   struct cgraph_node *node;
 132   /* Callgraph node of currently inlined function.  */
 133   struct cgraph_node *current_node;
 134   /* Current BLOCK.  */
 135   tree block;
 136   /* Exception region the inlined call lie in.  */
 137   int eh_region;
 138   /* Take region number in the function being copied, add this value and
 139      get eh region number of the duplicate in the function we inline into.  */
 140   int eh_region_offset;
 141 } inline_data;
 142
 143 /* Prototypes.  */
 144
 145 static tree declare_return_variable (inline_data *, tree, tree, tree *);
 146 static tree copy_body_r (tree *, int *, void *);
 147 static tree copy_generic_body (inline_data *);
 148 static bool inlinable_function_p (tree);
 149 static tree remap_decl (tree, inline_data *);
 150 static tree remap_type (tree, inline_data *);
 151 static void remap_block (tree *, inline_data *);
 152 static tree remap_decl (tree, inline_data *);
 153 static tree remap_decls (tree, inline_data *);
 154 static void copy_bind_expr (tree *, int *, inline_data *);
 155 static tree mark_local_for_remap_r (tree *, int *, void *);
 156 static void unsave_expr_1 (tree);
 157 static tree unsave_r (tree *, int *, void *);
 158 static void declare_inline_vars (tree, tree);
 159 static void remap_save_expr (tree *, void *, int *);
 160
 161 static inline bool inlining_p (inline_data *id);
 162
 163 /* Insert a tree->tree mapping for ID.  Despite the name suggests
 164    that the trees should be variables, it is used for more than that.  */
 165
 166 static void
 167 insert_decl_map (inline_data *id, tree key, tree value)
 168 {
 169   splay_tree_insert (id->decl_map, (splay_tree_key) key,
 170                      (splay_tree_value) value);
 171
 172   /* Always insert an identity map as well.  If we see this same new
 173      node again, we won't want to duplicate it a second time.  */
 174   if (key != value)
 175     splay_tree_insert (id->decl_map, (splay_tree_key) value,
 176                        (splay_tree_value) value);
 177 }
 178
 179 /* Remap DECL during the copying of the BLOCK tree for the function.  */
 180
 181 static tree
 182 remap_decl (tree decl, inline_data *id)
 183 {
 184   splay_tree_node n;
 185   tree fn;
 186
 187   /* We only remap local variables in the current function.  */
 188   fn = id->callee;
 189
 190   /* See if we have remapped this declaration.  */
 191
 192   n = splay_tree_lookup (id->decl_map, (splay_tree_key) decl);
 193
 194   /* If we didn't already have an equivalent for this declaration,
 195      create one now.  */
 196   if (!n)
 197     {
 198       /* Make a copy of the variable or label.  */
 199       tree t;
 200       t = copy_decl_for_inlining (decl, fn, id->caller);
 201
 202       /* Remember it, so that if we encounter this local entity again
 203          we can reuse this copy.  Do this early because remap_type may
 204          need this decl for TYPE_STUB_DECL.  */
 205       insert_decl_map (id, decl, t);
 206
 207       /* Remap types, if necessary.  */
 208       TREE_TYPE (t) = remap_type (TREE_TYPE (t), id);
 209       if (TREE_CODE (t) == TYPE_DECL)
 210         DECL_ORIGINAL_TYPE (t) = remap_type (DECL_ORIGINAL_TYPE (t), id);
 211       else if (TREE_CODE (t) == PARM_DECL)
 212         DECL_ARG_TYPE_AS_WRITTEN (t)
 213           = remap_type (DECL_ARG_TYPE_AS_WRITTEN (t), id);
 214
 215       /* Remap sizes as necessary.  */
 216       walk_tree (&DECL_SIZE (t), copy_body_r, id, NULL);
 217       walk_tree (&DECL_SIZE_UNIT (t), copy_body_r, id, NULL);
 218
 219       /* If fields, do likewise for offset and qualifier.  */
 220       if (TREE_CODE (t) == FIELD_DECL)
 221         {
 222           walk_tree (&DECL_FIELD_OFFSET (t), copy_body_r, id, NULL);
 223           if (TREE_CODE (DECL_CONTEXT (t)) == QUAL_UNION_TYPE)
 224             walk_tree (&DECL_QUALIFIER (t), copy_body_r, id, NULL);
 225         }
 226
 227 #if 0
 228       /* FIXME handle anon aggrs.  */
 229       if (! DECL_NAME (t) && TREE_TYPE (t)
 230           && lang_hooks.tree_inlining.anon_aggr_type_p (TREE_TYPE (t)))
 231         {
 232           /* For a VAR_DECL of anonymous type, we must also copy the
 233              member VAR_DECLS here and rechain the DECL_ANON_UNION_ELEMS.  */
 234           tree members = NULL;
 235           tree src;
 236
 237           for (src = DECL_ANON_UNION_ELEMS (t); src;
 238                src = TREE_CHAIN (src))
 239             {
 240               tree member = remap_decl (TREE_VALUE (src), id);
 241
 242               gcc_assert (!TREE_PURPOSE (src));
 243               members = tree_cons (NULL, member, members);
 244             }
 245           DECL_ANON_UNION_ELEMS (t) = nreverse (members);
 246         }
 247 #endif
 248
 249       /* If we are inlining and this is a variable (not a label), declare the
 250          remapped variable in the callers' body.  */
 251       if (inlining_p (id)
 252           && (TREE_CODE (t) == VAR_DECL
 253               || TREE_CODE (t) == PARM_DECL))
 254         declare_inline_vars (id->block, t);
 255
 256       /* Remember it, so that if we encounter this local entity
 257          again we can reuse this copy.  */
 258       insert_decl_map (id, decl, t);
 259       return t;
 260     }
 261
 262   return unshare_expr ((tree) n->value);
 263 }
 264
 265 static tree
 266 remap_type (tree type, inline_data *id)
 267 {
 268   splay_tree_node node;
 269   tree new, t;
 270
 271   if (type == NULL)
 272     return type;
 273
 274   /* See if we have remapped this type.  */
 275   node = splay_tree_lookup (id->decl_map, (splay_tree_key) type);
 276   if (node)
 277     return (tree) node->value;
 278
 279   /* The type only needs remapping if it's variably modified.  */
 280   if (! variably_modified_type_p (type, id->callee))
 281     {
 282       insert_decl_map (id, type, type);
 283       return type;
 284     }
 285
 286   /* We do need a copy.  build and register it now.  If this is a pointer or
 287      reference type, remap the designated type and make a new pointer or
 288      reference type.  */
 289   if (TREE_CODE (type) == POINTER_TYPE)
 290     {
 291       new = build_pointer_type_for_mode (remap_type (TREE_TYPE (type), id),
 292                                          TYPE_MODE (type),
 293                                          TYPE_REF_CAN_ALIAS_ALL (type));
 294       insert_decl_map (id, type, new);
 295       return new;
 296     }
 297   else if (TREE_CODE (type) == REFERENCE_TYPE)
 298     {
 299       new = build_reference_type_for_mode (remap_type (TREE_TYPE (type), id),
 300                                             TYPE_MODE (type),
 301                                             TYPE_REF_CAN_ALIAS_ALL (type));
 302       insert_decl_map (id, type, new);
 303       return new;
 304     }
 305   else
 306     new = copy_node (type);
 307
 308   insert_decl_map (id, type, new);
 309
 310   /* This is a new type, not a copy of an old type.  Need to reassociate
 311      variants.  We can handle everything except the main variant lazily.  */
 312   t = TYPE_MAIN_VARIANT (type);
 313   if (type != t)
 314     {
 315       t = remap_type (t, id);
 316       TYPE_MAIN_VARIANT (new) = t;
 317       TYPE_NEXT_VARIANT (new) = TYPE_MAIN_VARIANT (t);
 318       TYPE_NEXT_VARIANT (t) = new;
 319     }
 320   else
 321     {
 322       TYPE_MAIN_VARIANT (new) = new;
 323       TYPE_NEXT_VARIANT (new) = NULL;
 324     }
 325
 326   if (TYPE_STUB_DECL (type))
 327     TYPE_STUB_DECL (new) = remap_decl (TYPE_STUB_DECL (type), id);
 328
 329   /* Lazily create pointer and reference types.  */
 330   TYPE_POINTER_TO (new) = NULL;
 331   TYPE_REFERENCE_TO (new) = NULL;
 332
 333   switch (TREE_CODE (new))
 334     {
 335     case INTEGER_TYPE:
 336     case REAL_TYPE:
 337     case ENUMERAL_TYPE:
 338     case BOOLEAN_TYPE:
 339     case CHAR_TYPE:
 340       t = TYPE_MIN_VALUE (new);
 341       if (t && TREE_CODE (t) != INTEGER_CST)
 342         walk_tree (&TYPE_MIN_VALUE (new), copy_body_r, id, NULL);
 343
 344       t = TYPE_MAX_VALUE (new);
 345       if (t && TREE_CODE (t) != INTEGER_CST)
 346         walk_tree (&TYPE_MAX_VALUE (new), copy_body_r, id, NULL);
 347       return new;
 348
 349     case FUNCTION_TYPE:
 350       TREE_TYPE (new) = remap_type (TREE_TYPE (new), id);
 351       walk_tree (&TYPE_ARG_TYPES (new), copy_body_r, id, NULL);
 352       return new;
 353
 354     case ARRAY_TYPE:
 355       TREE_TYPE (new) = remap_type (TREE_TYPE (new), id);
 356       TYPE_DOMAIN (new) = remap_type (TYPE_DOMAIN (new), id);
 357       break;
 358
 359     case RECORD_TYPE:
 360     case UNION_TYPE:
 361     case QUAL_UNION_TYPE:
 362       walk_tree (&TYPE_FIELDS (new), copy_body_r, id, NULL);
 363       break;
 364
 365     case OFFSET_TYPE:
 366     default:
 367       /* Shouldn't have been thought variable sized.  */
 368       gcc_unreachable ();
 369     }
 370
 371   walk_tree (&TYPE_SIZE (new), copy_body_r, id, NULL);
 372   walk_tree (&TYPE_SIZE_UNIT (new), copy_body_r, id, NULL);
 373
 374   return new;
 375 }
 376
 377 static tree
 378 remap_decls (tree decls, inline_data *id)
 379 {
 380   tree old_var;
 381   tree new_decls = NULL_TREE;
 382
 383   /* Remap its variables.  */
 384   for (old_var = decls; old_var; old_var = TREE_CHAIN (old_var))
 385     {
 386       tree new_var;
 387
 388       /* Remap the variable.  */
 389       new_var = remap_decl (old_var, id);
 390
 391       /* If we didn't remap this variable, so we can't mess with its
 392          TREE_CHAIN.  If we remapped this variable to the return slot, it's
 393          already declared somewhere else, so don't declare it here.  */
 394       if (!new_var || new_var == id->retvar)
 395         ;
 396       else
 397         {
 398           gcc_assert (DECL_P (new_var));
 399           TREE_CHAIN (new_var) = new_decls;
 400           new_decls = new_var;
 401         }
 402     }
 403
 404   return nreverse (new_decls);
 405 }
 406
 407 /* Copy the BLOCK to contain remapped versions of the variables
 408    therein.  And hook the new block into the block-tree.  */
 409
 410 static void
 411 remap_block (tree *block, inline_data *id)
 412 {
 413   tree old_block;
 414   tree new_block;
 415   tree fn;
 416
 417   /* Make the new block.  */
 418   old_block = *block;
 419   new_block = make_node (BLOCK);
 420   TREE_USED (new_block) = TREE_USED (old_block);
 421   BLOCK_ABSTRACT_ORIGIN (new_block) = old_block;
 422   *block = new_block;
 423
 424   /* Remap its variables.  */
 425   BLOCK_VARS (new_block) = remap_decls (BLOCK_VARS (old_block), id);
 426
 427   fn = id->caller;
 428 #if 1
 429   /* FIXME!  It shouldn't be so hard to manage blocks.  Rebuilding them in
 430      rest_of_compilation is a good start.  */
 431   if (id->cloning_p)
 432     /* We're building a clone; DECL_INITIAL is still
 433        error_mark_node, and current_binding_level is the parm
 434        binding level.  */
 435     lang_hooks.decls.insert_block (new_block);
 436   else
 437     {
 438       /* Attach this new block after the DECL_INITIAL block for the
 439          function into which this block is being inlined.  In
 440          rest_of_compilation we will straighten out the BLOCK tree.  */
 441       tree *first_block;
 442       if (DECL_INITIAL (fn))
 443         first_block = &BLOCK_CHAIN (DECL_INITIAL (fn));
 444       else
 445         first_block = &DECL_INITIAL (fn);
 446       BLOCK_CHAIN (new_block) = *first_block;
 447       *first_block = new_block;
 448     }
 449 #endif
 450   /* Remember the remapped block.  */
 451   insert_decl_map (id, old_block, new_block);
 452 }
 453
 454 static void
 455 copy_statement_list (tree *tp)
 456 {
 457   tree_stmt_iterator oi, ni;
 458   tree new;
 459
 460   new = alloc_stmt_list ();
 461   ni = tsi_start (new);
 462   oi = tsi_start (*tp);
 463   *tp = new;
 464
 465   for (; !tsi_end_p (oi); tsi_next (&oi))
 466     tsi_link_after (&ni, tsi_stmt (oi), TSI_NEW_STMT);
 467 }
 468
 469 static void
 470 copy_bind_expr (tree *tp, int *walk_subtrees, inline_data *id)
 471 {
 472   tree block = BIND_EXPR_BLOCK (*tp);
 473   /* Copy (and replace) the statement.  */
 474   copy_tree_r (tp, walk_subtrees, NULL);
 475   if (block)
 476     {
 477       remap_block (&block, id);
 478       BIND_EXPR_BLOCK (*tp) = block;
 479     }
 480
 481   if (BIND_EXPR_VARS (*tp))
 482     /* This will remap a lot of the same decls again, but this should be
 483        harmless.  */
 484     BIND_EXPR_VARS (*tp) = remap_decls (BIND_EXPR_VARS (*tp), id);
 485 }
 486
 487 /* Called from copy_body_id via walk_tree.  DATA is really an
 488    `inline_data *'.  */
 489
 490 static tree
 491 copy_body_r (tree *tp, int *walk_subtrees, void *data)
 492 {
 493   inline_data *id = (inline_data *) data;
 494   tree fn = id->callee;
 495
 496   /* Begin by recognizing trees that we'll completely rewrite for the
 497      inlining context.  Our output for these trees is completely
 498      different from out input (e.g. RETURN_EXPR is deleted, and morphs
 499      into an edge).  Further down, we'll handle trees that get
 500      duplicated and/or tweaked.  */
 501
 502   /* If this is a RETURN_STMT, change it into an EXPR_STMT and a
 503      GOTO_STMT with the RET_LABEL as its target.  */
 504   if (TREE_CODE (*tp) == RETURN_EXPR && inlining_p (id))
 505     {
 506       tree assignment = TREE_OPERAND (*tp, 0);
 507
 508       /* If we're returning something, just turn that into an
 509          assignment into the equivalent of the original RESULT_DECL.
 510          If the "assignment" is just the result decl, the result
 511          decl has already been set (e.g. a recent "foo (&result_decl,
 512          ...)"); just toss the entire RETURN_EXPR.  */
 513       if (assignment && TREE_CODE (assignment) == MODIFY_EXPR)
 514         {
 515           /* Replace the RETURN_EXPR with (a copy of) the
 516              MODIFY_EXPR hanging underneath.  */
 517           *tp = copy_node (assignment);
 518         }
 519       else /* Else the RETURN_EXPR returns no value.  */
 520         {
 521           *tp = NULL;
 522           return (void *)1;
 523         }
 524     }
 525
 526   /* Local variables and labels need to be replaced by equivalent
 527      variables.  We don't want to copy static variables; there's only
 528      one of those, no matter how many times we inline the containing
 529      function.  Similarly for globals from an outer function.  */
 530   else if (lang_hooks.tree_inlining.auto_var_in_fn_p (*tp, fn))
 531     {
 532       tree new_decl;
 533
 534       /* Remap the declaration.  */
 535       new_decl = remap_decl (*tp, id);
 536       gcc_assert (new_decl);
 537       /* Replace this variable with the copy.  */
 538       STRIP_TYPE_NOPS (new_decl);
 539       *tp = new_decl;
 540       *walk_subtrees = 0;
 541     }
 542   else if (TREE_CODE (*tp) == STATEMENT_LIST)
 543     copy_statement_list (tp);
 544   else if (TREE_CODE (*tp) == SAVE_EXPR)
 545     remap_save_expr (tp, id->decl_map, walk_subtrees);
 546   else if (TREE_CODE (*tp) == LABEL_DECL)
 547     /* These may need to be remapped for EH handling.  */
 548     remap_decl (*tp, id);
 549   else if (TREE_CODE (*tp) == BIND_EXPR)
 550     copy_bind_expr (tp, walk_subtrees, id);
 551   /* Types may need remapping as well.  */
 552   else if (TYPE_P (*tp))
 553     *tp = remap_type (*tp, id);
 554
 555   /* If this is a constant, we have to copy the node iff the type will be
 556      remapped.  copy_tree_r will not copy a constant.  */
 557   else if (CONSTANT_CLASS_P (*tp))
 558     {
 559       tree new_type = remap_type (TREE_TYPE (*tp), id);
 560
 561       if (new_type == TREE_TYPE (*tp))
 562         *walk_subtrees = 0;
 563
 564       else if (TREE_CODE (*tp) == INTEGER_CST)
 565         *tp = build_int_cst_wide (new_type, TREE_INT_CST_LOW (*tp),
 566                                   TREE_INT_CST_HIGH (*tp));
 567       else
 568         {
 569           *tp = copy_node (*tp);
 570           TREE_TYPE (*tp) = new_type;
 571         }
 572     }
 573
 574   /* Otherwise, just copy the node.  Note that copy_tree_r already
 575      knows not to copy VAR_DECLs, etc., so this is safe.  */
 576   else
 577     {
 578       tree old_node = *tp;
 579
 580       /* Here we handle trees that are not completely rewritten.
 581          First we detect some inlining-induced bogosities for
 582          discarding.  */
 583       if (TREE_CODE (*tp) == MODIFY_EXPR
 584           && TREE_OPERAND (*tp, 0) == TREE_OPERAND (*tp, 1)
 585           && (lang_hooks.tree_inlining.auto_var_in_fn_p
 586               (TREE_OPERAND (*tp, 0), fn)))
 587         {
 588           /* Some assignments VAR = VAR; don't generate any rtl code
 589              and thus don't count as variable modification.  Avoid
 590              keeping bogosities like 0 = 0.  */
 591           tree decl = TREE_OPERAND (*tp, 0), value;
 592           splay_tree_node n;
 593
 594           n = splay_tree_lookup (id->decl_map, (splay_tree_key) decl);
 595           if (n)
 596             {
 597               value = (tree) n->value;
 598               STRIP_TYPE_NOPS (value);
 599               if (TREE_CONSTANT (value) || TREE_READONLY_DECL_P (value))
 600                 {
 601                   *tp = build_empty_stmt ();
 602                   return copy_body_r (tp, walk_subtrees, data);
 603                 }
 604             }
 605         }
 606       else if (TREE_CODE (*tp) == INDIRECT_REF)
 607         {
 608           /* Get rid of *& from inline substitutions that can happen when a
 609              pointer argument is an ADDR_EXPR.  */
 610           tree decl = TREE_OPERAND (*tp, 0);
 611           splay_tree_node n;
 612
 613           n = splay_tree_lookup (id->decl_map, (splay_tree_key) decl);
 614           if (n)
 615             {
 616               *tp = build_fold_indirect_ref ((tree)n->value);
 617               *walk_subtrees = 0;
 618               return NULL;
 619             }
 620         }
 621
 622       /* Here is the "usual case".  Copy this tree node, and then
 623          tweak some special cases.  */
 624       copy_tree_r (tp, walk_subtrees, NULL);
 625       if (id->block
 626           && IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (*tp))))
 627         TREE_BLOCK (*tp) = id->block;
 628
 629       /* We're duplicating a CALL_EXPR.  Find any corresponding
 630          callgraph edges and update or duplicate them.  */
 631       if (TREE_CODE (*tp) == CALL_EXPR && id->node && get_callee_fndecl (*tp))
 632         {
 633           if (id->saving_p)
 634             {
 635               struct cgraph_node *node;
 636               struct cgraph_edge *edge;
 637
 638               /* We're saving a copy of the body, so we'll update the
 639                  callgraph nodes in place.  Note that we avoid
 640                  altering the original callgraph node; we begin with
 641                  the first clone.  */
 642               for (node = id->node->next_clone;
 643                    node;
 644                    node = node->next_clone)
 645                 {
 646                   edge = cgraph_edge (node, old_node);
 647                   gcc_assert (edge);
 648                   edge->call_expr = *tp;
 649                 }
 650             }
 651           else
 652             {
 653               struct cgraph_edge *edge;
 654
 655               /* We're cloning or inlining this body; duplicate the
 656                  associate callgraph nodes.  */
 657               edge = cgraph_edge (id->current_node, old_node);
 658               if (edge)
 659                  cgraph_clone_edge (edge, id->node, *tp,
 660                                     REG_BR_PROB_BASE, 1);
 661             }
 662         }
 663       else if (TREE_CODE (*tp) == RESX_EXPR && id->eh_region_offset)
 664         TREE_OPERAND (*tp, 0) =
 665           build_int_cst
 666             (NULL_TREE,
 667              id->eh_region_offset + TREE_INT_CST_LOW (TREE_OPERAND (*tp, 0)));
 668
 669       TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id);
 670
 671       /* The copied TARGET_EXPR has never been expanded, even if the
 672          original node was expanded already.  */
 673       if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3))
 674         {
 675           TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
 676           TREE_OPERAND (*tp, 3) = NULL_TREE;
 677         }
 678
 679       /* Variable substitution need not be simple.  In particular, the
 680          INDIRECT_REF substitution above.  Make sure that TREE_CONSTANT
 681          and friends are up-to-date.  */
 682       else if (TREE_CODE (*tp) == ADDR_EXPR)
 683         {
 684           walk_tree (&TREE_OPERAND (*tp, 0), copy_body_r, id, NULL);
 685           recompute_tree_invarant_for_addr_expr (*tp);
 686           *walk_subtrees = 0;
 687         }
 688     }
 689
 690   /* Keep iterating.  */
 691   return NULL_TREE;
 692 }
 693
 694 /* Copy basic block, scale profile accordingly.  Edges will be taken care of
 695    later  */
 696
 697 static basic_block
 698 copy_bb (inline_data *id, basic_block bb, int frequency_scale, int count_scale)
 699 {
 700   block_stmt_iterator bsi, copy_bsi;
 701   basic_block copy_basic_block;
 702
 703   /* create_basic_block() will append every new block to
 704      basic_block_info automatically.  */
 705   copy_basic_block = create_basic_block (NULL, (void *) 0, bb->prev_bb->aux);
 706   copy_basic_block->count = bb->count * count_scale / REG_BR_PROB_BASE;
 707   copy_basic_block->frequency = (bb->frequency
 708                                      * frequency_scale / REG_BR_PROB_BASE);
 709   copy_bsi = bsi_start (copy_basic_block);
 710
 711   for (bsi = bsi_start (bb);
 712        !bsi_end_p (bsi); bsi_next (&bsi))
 713     {
 714       tree stmt = bsi_stmt (bsi);
 715       tree orig_stmt = stmt;
 716
 717       walk_tree (&stmt, copy_body_r, id, NULL);
 718
 719       /* RETURN_EXPR might be removed,
 720          this is signalled by making stmt pointer NULL.  */
 721       if (stmt)
 722         {
 723           bsi_insert_after (&copy_bsi, stmt, BSI_NEW_STMT);
 724           /* If you think we can abort here, you are wrong.
 725              There is no region 0 in tree land.  */
 726           gcc_assert (lookup_stmt_eh_region_fn (id->callee_cfun, orig_stmt)
 727                       != 0);
 728
 729           if (tree_could_throw_p (stmt))
 730             {
 731               int region = lookup_stmt_eh_region_fn (id->callee_cfun, orig_stmt);
 732               /* Add an entry for the copied tree in the EH hashtable.
 733                  When saving or cloning or versioning, use the hashtable in
 734                  cfun, and just copy the EH number.  When inlining, use the
 735                  hashtable in the caller, and adjust the region number.  */
 736               if (region > 0)
 737                 add_stmt_to_eh_region (stmt, region + id->eh_region_offset);
 738
 739               /* If this tree doesn't have a region associated with it,
 740                  and there is a "current region,"
 741                  then associate this tree with the current region
 742                  and add edges associated with this region.  */
 743               if ((lookup_stmt_eh_region_fn (id->callee_cfun,
 744                                              orig_stmt) <= 0
 745                    && id->eh_region > 0)
 746                   && tree_could_throw_p (stmt))
 747                 add_stmt_to_eh_region (stmt, id->eh_region);
 748             }
 749         }
 750     }
 751   return copy_basic_block;
 752 }
 753
 754 /* Copy edges from BB into its copy constructed earlier, scale profile
 755    accordingly.  Edges will be taken care of later.  Assume aux
 756    pointers to point to the copies of each BB.  */
 757 static void
 758 copy_edges_for_bb (basic_block bb, int count_scale)
 759 {
 760   basic_block new_bb = bb->aux;
 761   edge_iterator ei;
 762   edge old_edge;
 763   block_stmt_iterator bsi;
 764   int flags;
 765
 766   /* Use the indices from the original blocks to create edges for the
 767      new ones.  */
 768   FOR_EACH_EDGE (old_edge, ei, bb->succs)
 769     {
 770       edge new;
 771
 772       flags = old_edge->flags;
 773
 774       /* Return edges do get a FALLTHRU flag when the get inlined.  */
 775       if (old_edge->dest->index == EXIT_BLOCK && !old_edge->flags
 776           && old_edge->dest->aux != EXIT_BLOCK_PTR)
 777         flags |= EDGE_FALLTHRU;
 778       new = make_edge (new_bb, old_edge->dest->aux, flags);
 779       new->count = old_edge->count * count_scale / REG_BR_PROB_BASE;
 780       new->probability = old_edge->probability;
 781     }
 782
 783   if (bb->index == ENTRY_BLOCK || bb->index == EXIT_BLOCK)
 784     return;
 785
 786   tree_purge_dead_eh_edges (new_bb);
 787   for (bsi = bsi_start (new_bb); !bsi_end_p (bsi);)
 788     {
 789       tree copy_stmt;
 790
 791       copy_stmt = bsi_stmt (bsi);
 792       update_stmt (copy_stmt);
 793       /* Do this before the possible split_block.  */
 794       bsi_next (&bsi);
 795
 796       /* If this tree could throw an exception, there are two
 797          cases where we need to add abnormal edge(s): the
 798          tree wasn't in a region and there is a "current
 799          region" in the caller; or the original tree had
 800          EH edges.  In both cases split the block after the tree,
 801          and add abnormal edge(s) as needed; we need both
 802          those from the callee and the caller.
 803          We check whether the copy can throw, because the const
 804          propagation can change an INDIRECT_REF which throws
 805          into a COMPONENT_REF which doesn't.  If the copy
 806          can throw, the original could also throw.  */
 807
 808       if (TREE_CODE (copy_stmt) == RESX_EXPR
 809           || (tree_could_throw_p (copy_stmt)
 810               && lookup_stmt_eh_region (copy_stmt) > 0))
 811         {
 812           if (!bsi_end_p (bsi))
 813             /* Note that bb's predecessor edges aren't necessarily
 814                right at this point; split_block doesn't care.  */
 815             {
 816               edge e = split_block (new_bb, copy_stmt);
 817               new_bb = e->dest;
 818               bsi = bsi_start (new_bb);
 819             }
 820
 821            make_eh_edges (copy_stmt);
 822         }
 823     }
 824 }
 825
 826 /* Wrapper for remap_decl so it can be used as a callback.  */
 827 static tree
 828 remap_decl_1 (tree decl, void *data)
 829 {
 830   return remap_decl (decl, data);
 831 }
 832
 833 /* Make a copy of the body of FN so that it can be inserted inline in
 834    another function.  Walks FN via CFG, returns new fndecl.  */
 835
 836 static tree
 837 copy_cfg_body (inline_data * id, gcov_type count, int frequency,
 838                basic_block entry_block_map, basic_block exit_block_map)
 839 {
 840   tree callee_fndecl = id->callee;
 841   /* Original cfun for the callee, doesn't change.  */
 842   struct function *callee_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
 843   /* Copy, built by this function.  */
 844   struct function *new_cfun;
 845   /* Place to copy from; when a copy of the function was saved off earlier,
 846      use that instead of the main copy.  */
 847   struct function *cfun_to_copy =
 848     (struct function *) ggc_alloc_cleared (sizeof (struct function));
 849   basic_block bb;
 850   tree new_fndecl = NULL;
 851   bool saving_or_cloning;
 852   int count_scale, frequency_scale;
 853
 854   if (ENTRY_BLOCK_PTR_FOR_FUNCTION (callee_cfun)->count)
 855     count_scale = (REG_BR_PROB_BASE * count
 856                    / ENTRY_BLOCK_PTR_FOR_FUNCTION (callee_cfun)->count);
 857   else
 858     count_scale = 1;
 859
 860   if (ENTRY_BLOCK_PTR_FOR_FUNCTION (callee_cfun)->frequency)
 861     frequency_scale = (REG_BR_PROB_BASE * frequency
 862                        /
 863                        ENTRY_BLOCK_PTR_FOR_FUNCTION (callee_cfun)->frequency);
 864   else
 865     frequency_scale = count_scale;
 866
 867   /* Register specific tree functions.  */
 868   tree_register_cfg_hooks ();
 869
 870   /* Must have a CFG here at this point.  */
 871   gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION
 872               (DECL_STRUCT_FUNCTION (callee_fndecl)));
 873
 874   *cfun_to_copy = *DECL_STRUCT_FUNCTION (callee_fndecl);
 875
 876   /* If there is a saved_cfg+saved_args lurking in the
 877      struct function, a copy of the callee body was saved there, and
 878      the 'struct cgraph edge' nodes have been fudged to point into the
 879      saved body.  Accordingly, we want to copy that saved body so the
 880      callgraph edges will be recognized and cloned properly.  */
 881   if (cfun_to_copy->saved_cfg)
 882     {
 883       cfun_to_copy->cfg = cfun_to_copy->saved_cfg;
 884       cfun_to_copy->eh = cfun_to_copy->saved_eh;
 885     }
 886   id->callee_cfun = cfun_to_copy;
 887
 888   /* If saving or cloning a function body, create new basic_block_info
 889      and label_to_block_maps.  Otherwise, we're duplicating a function
 890      body for inlining; insert our new blocks and labels into the
 891      existing varrays.  */
 892   saving_or_cloning = (id->saving_p || id->cloning_p);
 893   if (saving_or_cloning)
 894     {
 895       new_cfun =
 896         (struct function *) ggc_alloc_cleared (sizeof (struct function));
 897       *new_cfun = *DECL_STRUCT_FUNCTION (callee_fndecl);
 898       new_cfun->cfg = NULL;
 899       new_cfun->decl = new_fndecl = copy_node (callee_fndecl);
 900       new_cfun->ib_boundaries_block = (varray_type) 0;
 901       DECL_STRUCT_FUNCTION (new_fndecl) = new_cfun;
 902       push_cfun (new_cfun);
 903       init_empty_tree_cfg ();
 904
 905       ENTRY_BLOCK_PTR->count =
 906         (ENTRY_BLOCK_PTR_FOR_FUNCTION (callee_cfun)->count * count_scale /
 907          REG_BR_PROB_BASE);
 908       ENTRY_BLOCK_PTR->frequency =
 909         (ENTRY_BLOCK_PTR_FOR_FUNCTION (callee_cfun)->frequency *
 910          frequency_scale / REG_BR_PROB_BASE);
 911       EXIT_BLOCK_PTR->count =
 912         (EXIT_BLOCK_PTR_FOR_FUNCTION (callee_cfun)->count * count_scale /
 913          REG_BR_PROB_BASE);
 914       EXIT_BLOCK_PTR->frequency =
 915         (EXIT_BLOCK_PTR_FOR_FUNCTION (callee_cfun)->frequency *
 916          frequency_scale / REG_BR_PROB_BASE);
 917
 918       entry_block_map = ENTRY_BLOCK_PTR;
 919       exit_block_map = EXIT_BLOCK_PTR;
 920     }
 921
 922   ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy)->aux = entry_block_map;
 923   EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy)->aux = exit_block_map;
 924
 925
 926   /* Duplicate any exception-handling regions.  */
 927   if (cfun->eh)
 928     {
 929       if (saving_or_cloning)
 930         init_eh_for_function ();
 931       id->eh_region_offset = duplicate_eh_regions (cfun_to_copy,
 932                                                    remap_decl_1,
 933                                                    id, id->eh_region);
 934       gcc_assert (inlining_p (id) || !id->eh_region_offset);
 935     }
 936   /* Use aux pointers to map the original blocks to copy.  */
 937   FOR_EACH_BB_FN (bb, cfun_to_copy)
 938     bb->aux = copy_bb (id, bb, frequency_scale, count_scale);
 939   /* Now that we've duplicated the blocks, duplicate their edges.  */
 940   FOR_ALL_BB_FN (bb, cfun_to_copy)
 941     copy_edges_for_bb (bb, count_scale);
 942   FOR_ALL_BB_FN (bb, cfun_to_copy)
 943     bb->aux = NULL;
 944
 945   if (saving_or_cloning)
 946     pop_cfun ();
 947
 948   return new_fndecl;
 949 }
 950
 951 /* Make a copy of the body of FN so that it can be inserted inline in
 952    another function.  */
 953
 954 static tree
 955 copy_generic_body (inline_data *id)
 956 {
 957   tree body;
 958   tree fndecl = id->callee;
 959
 960   body = DECL_SAVED_TREE (fndecl);
 961   walk_tree (&body, copy_body_r, id, NULL);
 962
 963   return body;
 964 }
 965
 966 static tree
 967 copy_body (inline_data *id, gcov_type count, int frequency,
 968            basic_block entry_block_map, basic_block exit_block_map)
 969 {
 970   tree fndecl = id->callee;
 971   tree body;
 972
 973   /* If this body has a CFG, walk CFG and copy.  */
 974   gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (fndecl)));
 975   body = copy_cfg_body (id, count, frequency, entry_block_map, exit_block_map);
 976
 977   return body;
 978 }
 979
 980 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
 981    defined in function FN, or of a data member thereof.  */
 982
 983 static bool
 984 self_inlining_addr_expr (tree value, tree fn)
 985 {
 986   tree var;
 987
 988   if (TREE_CODE (value) != ADDR_EXPR)
 989     return false;
 990
 991   var = get_base_address (TREE_OPERAND (value, 0));
 992
 993   return var && lang_hooks.tree_inlining.auto_var_in_fn_p (var, fn);
 994 }
 995
 996 static void
 997 setup_one_parameter (inline_data *id, tree p, tree value, tree fn,
 998                      basic_block bb, tree *vars)
 999 {
1000   tree init_stmt;
1001   tree var;
1002   tree var_sub;
1003
1004   /* If the parameter is never assigned to, we may not need to
1005      create a new variable here at all.  Instead, we may be able
1006      to just use the argument value.  */
1007   if (TREE_READONLY (p)
1008       && !TREE_ADDRESSABLE (p)
1009       && value && !TREE_SIDE_EFFECTS (value))
1010     {
1011       /* We may produce non-gimple trees by adding NOPs or introduce
1012          invalid sharing when operand is not really constant.
1013          It is not big deal to prohibit constant propagation here as
1014          we will constant propagate in DOM1 pass anyway.  */
1015       if (is_gimple_min_invariant (value)
1016           && lang_hooks.types_compatible_p (TREE_TYPE (value), TREE_TYPE (p))
1017           /* We have to be very careful about ADDR_EXPR.  Make sure
1018              the base variable isn't a local variable of the inlined
1019              function, e.g., when doing recursive inlining, direct or
1020              mutually-recursive or whatever, which is why we don't
1021              just test whether fn == current_function_decl.  */
1022           && ! self_inlining_addr_expr (value, fn))
1023         {
1024           insert_decl_map (id, p, value);
1025           return;
1026         }
1027     }
1028
1029   /* Make an equivalent VAR_DECL.  Note that we must NOT remap the type
1030      here since the type of this decl must be visible to the calling
1031      function.  */
1032   var = copy_decl_for_inlining (p, fn, id->caller);
1033
1034   /* See if the frontend wants to pass this by invisible reference.  If
1035      so, our new VAR_DECL will have REFERENCE_TYPE, and we need to
1036      replace uses of the PARM_DECL with dereferences.  */
1037   if (TREE_TYPE (var) != TREE_TYPE (p)
1038       && POINTER_TYPE_P (TREE_TYPE (var))
1039       && TREE_TYPE (TREE_TYPE (var)) == TREE_TYPE (p))
1040     {
1041       insert_decl_map (id, var, var);
1042       var_sub = build_fold_indirect_ref (var);
1043     }
1044   else
1045     var_sub = var;
1046
1047   /* Register the VAR_DECL as the equivalent for the PARM_DECL;
1048      that way, when the PARM_DECL is encountered, it will be
1049      automatically replaced by the VAR_DECL.  */
1050   insert_decl_map (id, p, var_sub);
1051
1052   /* Declare this new variable.  */
1053   TREE_CHAIN (var) = *vars;
1054   *vars = var;
1055
1056   /* Make gimplifier happy about this variable.  */
1057   DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
1058
1059   /* Even if P was TREE_READONLY, the new VAR should not be.
1060      In the original code, we would have constructed a
1061      temporary, and then the function body would have never
1062      changed the value of P.  However, now, we will be
1063      constructing VAR directly.  The constructor body may
1064      change its value multiple times as it is being
1065      constructed.  Therefore, it must not be TREE_READONLY;
1066      the back-end assumes that TREE_READONLY variable is
1067      assigned to only once.  */
1068   if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p)))
1069     TREE_READONLY (var) = 0;
1070
1071   /* Initialize this VAR_DECL from the equivalent argument.  Convert
1072      the argument to the proper type in case it was promoted.  */
1073   if (value)
1074     {
1075       tree rhs = fold_convert (TREE_TYPE (var), value);
1076       block_stmt_iterator bsi = bsi_last (bb);
1077
1078       if (rhs == error_mark_node)
1079         return;
1080
1081       /* We want to use MODIFY_EXPR, not INIT_EXPR here so that we
1082          keep our trees in gimple form.  */
1083       init_stmt = build (MODIFY_EXPR, TREE_TYPE (var), var, rhs);
1084
1085       /* If we did not create a gimple value and we did not create a gimple
1086          cast of a gimple value, then we will need to gimplify INIT_STMTS
1087          at the end.  Note that is_gimple_cast only checks the outer
1088          tree code, not its operand.  Thus the explicit check that its
1089          operand is a gimple value.  */
1090       if (!is_gimple_val (rhs)
1091           && (!is_gimple_cast (rhs)
1092               || !is_gimple_val (TREE_OPERAND (rhs, 0))))
1093         gimplify_stmt (&init_stmt);
1094       bsi_insert_after (&bsi, init_stmt, BSI_NEW_STMT);
1095     }
1096 }
1097
1098 /* Generate code to initialize the parameters of the function at the
1099    top of the stack in ID from the ARGS (presented as a TREE_LIST).  */
1100
1101 static void
1102 initialize_inlined_parameters (inline_data *id, tree args, tree static_chain,
1103                                tree fn, basic_block bb)
1104 {
1105   tree parms;
1106   tree a;
1107   tree p;
1108   tree vars = NULL_TREE;
1109   int argnum = 0;
1110
1111   /* Figure out what the parameters are.  */
1112   parms = DECL_ARGUMENTS (fn);
1113   if (fn == current_function_decl)
1114     parms = cfun->saved_args;
1115
1116   /* Loop through the parameter declarations, replacing each with an
1117      equivalent VAR_DECL, appropriately initialized.  */
1118   for (p = parms, a = args; p;
1119        a = a ? TREE_CHAIN (a) : a, p = TREE_CHAIN (p))
1120     {
1121       tree value;
1122
1123       ++argnum;
1124
1125       /* Find the initializer.  */
1126       value = lang_hooks.tree_inlining.convert_parm_for_inlining
1127               (p, a ? TREE_VALUE (a) : NULL_TREE, fn, argnum);
1128
1129       setup_one_parameter (id, p, value, fn, bb, &vars);
1130     }
1131
1132   /* Initialize the static chain.  */
1133   p = DECL_STRUCT_FUNCTION (fn)->static_chain_decl;
1134   if (fn == current_function_decl)
1135     p = DECL_STRUCT_FUNCTION (fn)->saved_static_chain_decl;
1136   if (p)
1137     {
1138       /* No static chain?  Seems like a bug in tree-nested.c.  */
1139       gcc_assert (static_chain);
1140
1141       setup_one_parameter (id, p, static_chain, fn, bb, &vars);
1142     }
1143
1144   declare_inline_vars (id->block, vars);
1145 }
1146
1147 /* Declare a return variable to replace the RESULT_DECL for the
1148    function we are calling.  An appropriate DECL_STMT is returned.
1149    The USE_STMT is filled to contain a use of the declaration to
1150    indicate the return value of the function.
1151
1152    RETURN_SLOT_ADDR, if non-null, was a fake parameter that
1153    took the address of the result.  MODIFY_DEST, if non-null, was the LHS of
1154    the MODIFY_EXPR to which this call is the RHS.
1155
1156    The return value is a (possibly null) value that is the result of the
1157    function as seen by the callee.  *USE_P is a (possibly null) value that
1158    holds the result as seen by the caller.  */
1159
1160 static tree
1161 declare_return_variable (inline_data *id, tree return_slot_addr,
1162                          tree modify_dest, tree *use_p)
1163 {
1164   tree callee = id->callee;
1165   tree caller = id->caller;
1166   tree result = DECL_RESULT (callee);
1167   tree callee_type = TREE_TYPE (result);
1168   tree caller_type = TREE_TYPE (TREE_TYPE (callee));
1169   tree var, use;
1170
1171   /* We don't need to do anything for functions that don't return
1172      anything.  */
1173   if (!result || VOID_TYPE_P (callee_type))
1174     {
1175       *use_p = NULL_TREE;
1176       return NULL_TREE;
1177     }
1178
1179   /* If there was a return slot, then the return value is the
1180      dereferenced address of that object.  */
1181   if (return_slot_addr)
1182     {
1183       /* The front end shouldn't have used both return_slot_addr and
1184          a modify expression.  */
1185       gcc_assert (!modify_dest);
1186       if (DECL_BY_REFERENCE (result))
1187         var = return_slot_addr;
1188       else
1189         var = build_fold_indirect_ref (return_slot_addr);
1190       use = NULL;
1191       goto done;
1192     }
1193
1194   /* All types requiring non-trivial constructors should have been handled.  */
1195   gcc_assert (!TREE_ADDRESSABLE (callee_type));
1196
1197   /* Attempt to avoid creating a new temporary variable.  */
1198   if (modify_dest)
1199     {
1200       bool use_it = false;
1201
1202       /* We can't use MODIFY_DEST if there's type promotion involved.  */
1203       if (!lang_hooks.types_compatible_p (caller_type, callee_type))
1204         use_it = false;
1205
1206       /* ??? If we're assigning to a variable sized type, then we must
1207          reuse the destination variable, because we've no good way to
1208          create variable sized temporaries at this point.  */
1209       else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type)) != INTEGER_CST)
1210         use_it = true;
1211
1212       /* If the callee cannot possibly modify MODIFY_DEST, then we can
1213          reuse it as the result of the call directly.  Don't do this if
1214          it would promote MODIFY_DEST to addressable.  */
1215       else if (!TREE_STATIC (modify_dest)
1216                && !TREE_ADDRESSABLE (modify_dest)
1217                && !TREE_ADDRESSABLE (result))
1218         use_it = true;
1219
1220       if (use_it)
1221         {
1222           var = modify_dest;
1223           use = NULL;
1224           goto done;
1225         }
1226     }
1227
1228   gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type)) == INTEGER_CST);
1229
1230   var = copy_decl_for_inlining (result, callee, caller);
1231
1232   DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
1233   DECL_STRUCT_FUNCTION (caller)->unexpanded_var_list
1234     = tree_cons (NULL_TREE, var,
1235                  DECL_STRUCT_FUNCTION (caller)->unexpanded_var_list);
1236
1237   /* Do not have the rest of GCC warn about this variable as it should
1238      not be visible to the user.  */
1239   TREE_NO_WARNING (var) = 1;
1240
1241   /* Build the use expr.  If the return type of the function was
1242      promoted, convert it back to the expected type.  */
1243   use = var;
1244   if (!lang_hooks.types_compatible_p (TREE_TYPE (var), caller_type))
1245     use = fold_convert (caller_type, var);
1246
1247  done:
1248   /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
1249      way, when the RESULT_DECL is encountered, it will be
1250      automatically replaced by the VAR_DECL.  */
1251   insert_decl_map (id, result, var);
1252
1253   /* Remember this so we can ignore it in remap_decls.  */
1254   id->retvar = var;
1255
1256   *use_p = use;
1257   return var;
1258 }
1259
1260 /* Returns nonzero if a function can be inlined as a tree.  */
1261
1262 bool
1263 tree_inlinable_function_p (tree fn)
1264 {
1265   return inlinable_function_p (fn);
1266 }
1267
1268 static const char *inline_forbidden_reason;
1269
1270 static tree
1271 inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED,
1272                       void *fnp)
1273 {
1274   tree node = *nodep;
1275   tree fn = (tree) fnp;
1276   tree t;
1277
1278   switch (TREE_CODE (node))
1279     {
1280     case CALL_EXPR:
1281       /* Refuse to inline alloca call unless user explicitly forced so as
1282          this may change program's memory overhead drastically when the
1283          function using alloca is called in loop.  In GCC present in
1284          SPEC2000 inlining into schedule_block cause it to require 2GB of
1285          RAM instead of 256MB.  */
1286       if (alloca_call_p (node)
1287           && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
1288         {
1289           inline_forbidden_reason
1290             = N_("%Jfunction %qF can never be inlined because it uses "
1291                  "alloca (override using the always_inline attribute)");
1292           return node;
1293         }
1294       t = get_callee_fndecl (node);
1295       if (! t)
1296         break;
1297
1298       /* We cannot inline functions that call setjmp.  */
1299       if (setjmp_call_p (t))
1300         {
1301           inline_forbidden_reason
1302             = N_("%Jfunction %qF can never be inlined because it uses setjmp");
1303           return node;
1304         }
1305
1306       if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL)
1307         switch (DECL_FUNCTION_CODE (t))
1308           {
1309             /* We cannot inline functions that take a variable number of
1310                arguments.  */
1311           case BUILT_IN_VA_START:
1312           case BUILT_IN_STDARG_START:
1313           case BUILT_IN_NEXT_ARG:
1314           case BUILT_IN_VA_END:
1315             inline_forbidden_reason
1316               = N_("%Jfunction %qF can never be inlined because it "
1317                    "uses variable argument lists");
1318             return node;
1319
1320           case BUILT_IN_LONGJMP:
1321             /* We can't inline functions that call __builtin_longjmp at
1322                all.  The non-local goto machinery really requires the
1323                destination be in a different function.  If we allow the
1324                function calling __builtin_longjmp to be inlined into the
1325                function calling __builtin_setjmp, Things will Go Awry.  */
1326             inline_forbidden_reason
1327               = N_("%Jfunction %qF can never be inlined because "
1328                    "it uses setjmp-longjmp exception handling");
1329             return node;
1330
1331           case BUILT_IN_NONLOCAL_GOTO:
1332             /* Similarly.  */
1333             inline_forbidden_reason
1334               = N_("%Jfunction %qF can never be inlined because "
1335                    "it uses non-local goto");
1336             return node;
1337
1338           case BUILT_IN_RETURN:
1339           case BUILT_IN_APPLY_ARGS:
1340             /* If a __builtin_apply_args caller would be inlined,
1341                it would be saving arguments of the function it has
1342                been inlined into.  Similarly __builtin_return would
1343                return from the function the inline has been inlined into.  */
1344             inline_forbidden_reason
1345               = N_("%Jfunction %qF can never be inlined because "
1346                    "it uses __builtin_return or __builtin_apply_args");
1347             return node;
1348
1349           default:
1350             break;
1351           }
1352       break;
1353
1354     case GOTO_EXPR:
1355       t = TREE_OPERAND (node, 0);
1356
1357       /* We will not inline a function which uses computed goto.  The
1358          addresses of its local labels, which may be tucked into
1359          global storage, are of course not constant across
1360          instantiations, which causes unexpected behavior.  */
1361       if (TREE_CODE (t) != LABEL_DECL)
1362         {
1363           inline_forbidden_reason
1364             = N_("%Jfunction %qF can never be inlined "
1365                  "because it contains a computed goto");
1366           return node;
1367         }
1368       break;
1369
1370     case LABEL_EXPR:
1371       t = TREE_OPERAND (node, 0);
1372       if (DECL_NONLOCAL (t))
1373         {
1374           /* We cannot inline a function that receives a non-local goto
1375              because we cannot remap the destination label used in the
1376              function that is performing the non-local goto.  */
1377           inline_forbidden_reason
1378             = N_("%Jfunction %qF can never be inlined "
1379                  "because it receives a non-local goto");
1380           return node;
1381         }
1382       break;
1383
1384     case RECORD_TYPE:
1385     case UNION_TYPE:
1386       /* We cannot inline a function of the form
1387
1388            void F (int i) { struct S { int ar[i]; } s; }
1389
1390          Attempting to do so produces a catch-22.
1391          If walk_tree examines the TYPE_FIELDS chain of RECORD_TYPE/
1392          UNION_TYPE nodes, then it goes into infinite recursion on a
1393          structure containing a pointer to its own type.  If it doesn't,
1394          then the type node for S doesn't get adjusted properly when
1395          F is inlined.
1396
1397          ??? This is likely no longer true, but it's too late in the 4.0
1398          cycle to try to find out.  This should be checked for 4.1.  */
1399       for (t = TYPE_FIELDS (node); t; t = TREE_CHAIN (t))
1400         if (variably_modified_type_p (TREE_TYPE (t), NULL))
1401           {
1402             inline_forbidden_reason
1403               = N_("%Jfunction %qF can never be inlined "
1404                    "because it uses variable sized variables");
1405             return node;
1406           }
1407
1408     default:
1409       break;
1410     }
1411
1412   return NULL_TREE;
1413 }
1414
1415 /* Return subexpression representing possible alloca call, if any.  */
1416 static tree
1417 inline_forbidden_p (tree fndecl)
1418 {
1419   location_t saved_loc = input_location;
1420   block_stmt_iterator bsi;
1421   basic_block bb;
1422   tree ret = NULL_TREE;
1423
1424   FOR_EACH_BB_FN (bb, DECL_STRUCT_FUNCTION (fndecl))
1425     for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
1426       {
1427         ret = walk_tree_without_duplicates (bsi_stmt_ptr (bsi),
1428                                     inline_forbidden_p_1, fndecl);
1429         if (ret)
1430           goto egress;
1431       }
1432
1433 egress:
1434   input_location = saved_loc;
1435   return ret;
1436 }
1437
1438 /* Returns nonzero if FN is a function that does not have any
1439    fundamental inline blocking properties.  */
1440
1441 static bool
1442 inlinable_function_p (tree fn)
1443 {
1444   bool inlinable = true;
1445
1446   /* If we've already decided this function shouldn't be inlined,
1447      there's no need to check again.  */
1448   if (DECL_UNINLINABLE (fn))
1449     return false;
1450
1451   /* See if there is any language-specific reason it cannot be
1452      inlined.  (It is important that this hook be called early because
1453      in C++ it may result in template instantiation.)
1454      If the function is not inlinable for language-specific reasons,
1455      it is left up to the langhook to explain why.  */
1456   inlinable = !lang_hooks.tree_inlining.cannot_inline_tree_fn (&fn);
1457
1458   /* If we don't have the function body available, we can't inline it.
1459      However, this should not be recorded since we also get here for
1460      forward declared inline functions.  Therefore, return at once.  */
1461   if (!DECL_SAVED_TREE (fn))
1462     return false;
1463
1464   /* If we're not inlining at all, then we cannot inline this function.  */
1465   else if (!flag_inline_trees)
1466     inlinable = false;
1467
1468   /* Only try to inline functions if DECL_INLINE is set.  This should be
1469      true for all functions declared `inline', and for all other functions
1470      as well with -finline-functions.
1471
1472      Don't think of disregarding DECL_INLINE when flag_inline_trees == 2;
1473      it's the front-end that must set DECL_INLINE in this case, because
1474      dwarf2out loses if a function that does not have DECL_INLINE set is
1475      inlined anyway.  That is why we have both DECL_INLINE and
1476      DECL_DECLARED_INLINE_P.  */
1477   /* FIXME: When flag_inline_trees dies, the check for flag_unit_at_a_time
1478             here should be redundant.  */
1479   else if (!DECL_INLINE (fn) && !flag_unit_at_a_time)
1480     inlinable = false;
1481
1482   else if (inline_forbidden_p (fn))
1483     {
1484       /* See if we should warn about uninlinable functions.  Previously,
1485          some of these warnings would be issued while trying to expand
1486          the function inline, but that would cause multiple warnings
1487          about functions that would for example call alloca.  But since
1488          this a property of the function, just one warning is enough.
1489          As a bonus we can now give more details about the reason why a
1490          function is not inlinable.
1491          We only warn for functions declared `inline' by the user.  */
1492       bool do_warning = (warn_inline
1493                          && DECL_INLINE (fn)
1494                          && DECL_DECLARED_INLINE_P (fn)
1495                          && !DECL_IN_SYSTEM_HEADER (fn));
1496
1497       if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
1498         sorry (inline_forbidden_reason, fn, fn);
1499       else if (do_warning)
1500         warning (0, inline_forbidden_reason, fn, fn);
1501
1502       inlinable = false;
1503     }
1504
1505   /* Squirrel away the result so that we don't have to check again.  */
1506   DECL_UNINLINABLE (fn) = !inlinable;
1507
1508   return inlinable;
1509 }
1510
1511 /* Estimate the cost of a memory move.  Use machine dependent
1512    word size and take possible memcpy call into account.  */
1513
1514 int
1515 estimate_move_cost (tree type)
1516 {
1517   HOST_WIDE_INT size;
1518
1519   size = int_size_in_bytes (type);
1520
1521   if (size < 0 || size > MOVE_MAX_PIECES * MOVE_RATIO)
1522     /* Cost of a memcpy call, 3 arguments and the call.  */
1523     return 4;
1524   else
1525     return ((size + MOVE_MAX_PIECES - 1) / MOVE_MAX_PIECES);
1526 }
1527
1528 /* Used by estimate_num_insns.  Estimate number of instructions seen
1529    by given statement.  */
1530
1531 static tree
1532 estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data)
1533 {
1534   int *count = data;
1535   tree x = *tp;
1536
1537   if (IS_TYPE_OR_DECL_P (x))
1538     {
1539       *walk_subtrees = 0;
1540       return NULL;
1541     }
1542   /* Assume that constants and references counts nothing.  These should
1543      be majorized by amount of operations among them we count later
1544      and are common target of CSE and similar optimizations.  */
1545   else if (CONSTANT_CLASS_P (x) || REFERENCE_CLASS_P (x))
1546     return NULL;
1547
1548   switch (TREE_CODE (x))
1549     {
1550     /* Containers have no cost.  */
1551     case TREE_LIST:
1552     case TREE_VEC:
1553     case BLOCK:
1554     case COMPONENT_REF:
1555     case BIT_FIELD_REF:
1556     case INDIRECT_REF:
1557     case ALIGN_INDIRECT_REF:
1558     case MISALIGNED_INDIRECT_REF:
1559     case ARRAY_REF:
1560     case ARRAY_RANGE_REF:
1561     case OBJ_TYPE_REF:
1562     case EXC_PTR_EXPR: /* ??? */
1563     case FILTER_EXPR: /* ??? */
1564     case COMPOUND_EXPR:
1565     case BIND_EXPR:
1566     case WITH_CLEANUP_EXPR:
1567     case NOP_EXPR:
1568     case VIEW_CONVERT_EXPR:
1569     case SAVE_EXPR:
1570     case ADDR_EXPR:
1571     case COMPLEX_EXPR:
1572     case RANGE_EXPR:
1573     case CASE_LABEL_EXPR:
1574     case SSA_NAME:
1575     case CATCH_EXPR:
1576     case EH_FILTER_EXPR:
1577     case STATEMENT_LIST:
1578     case ERROR_MARK:
1579     case NON_LVALUE_EXPR:
1580     case FDESC_EXPR:
1581     case VA_ARG_EXPR:
1582     case TRY_CATCH_EXPR:
1583     case TRY_FINALLY_EXPR:
1584     case LABEL_EXPR:
1585     case GOTO_EXPR:
1586     case RETURN_EXPR:
1587     case EXIT_EXPR:
1588     case LOOP_EXPR:
1589     case PHI_NODE:
1590     case WITH_SIZE_EXPR:
1591       break;
1592
1593     /* We don't account constants for now.  Assume that the cost is amortized
1594        by operations that do use them.  We may re-consider this decision once
1595        we are able to optimize the tree before estimating its size and break
1596        out static initializers.  */
1597     case IDENTIFIER_NODE:
1598     case INTEGER_CST:
1599     case REAL_CST:
1600     case COMPLEX_CST:
1601     case VECTOR_CST:
1602     case STRING_CST:
1603       *walk_subtrees = 0;
1604       return NULL;
1605
1606     /* Try to estimate the cost of assignments.  We have three cases to
1607        deal with:
1608         1) Simple assignments to registers;
1609         2) Stores to things that must live in memory.  This includes
1610            "normal" stores to scalars, but also assignments of large
1611            structures, or constructors of big arrays;
1612         3) TARGET_EXPRs.
1613
1614        Let us look at the first two cases, assuming we have "a = b + C":
1615        <modify_expr <var_decl "a"> <plus_expr <var_decl "b"> <constant C>>
1616        If "a" is a GIMPLE register, the assignment to it is free on almost
1617        any target, because "a" usually ends up in a real register.  Hence
1618        the only cost of this expression comes from the PLUS_EXPR, and we
1619        can ignore the MODIFY_EXPR.
1620        If "a" is not a GIMPLE register, the assignment to "a" will most
1621        likely be a real store, so the cost of the MODIFY_EXPR is the cost
1622        of moving something into "a", which we compute using the function
1623        estimate_move_cost.
1624
1625        The third case deals with TARGET_EXPRs, for which the semantics are
1626        that a temporary is assigned, unless the TARGET_EXPR itself is being
1627        assigned to something else.  In the latter case we do not need the
1628        temporary.  E.g. in <modify_expr <var_decl "a"> <target_expr>>, the
1629        MODIFY_EXPR is free.  */
1630     case INIT_EXPR:
1631     case MODIFY_EXPR:
1632       /* Is the right and side a TARGET_EXPR?  */
1633       if (TREE_CODE (TREE_OPERAND (x, 1)) == TARGET_EXPR)
1634         break;
1635       /* ... fall through ...  */
1636
1637     case TARGET_EXPR:
1638       x = TREE_OPERAND (x, 0);
1639       /* Is this an assignments to a register?  */
1640       if (is_gimple_reg (x))
1641         break;
1642       /* Otherwise it's a store, so fall through to compute the move cost.  */
1643
1644     case CONSTRUCTOR:
1645       *count += estimate_move_cost (TREE_TYPE (x));
1646       break;
1647
1648     /* Assign cost of 1 to usual operations.
1649        ??? We may consider mapping RTL costs to this.  */
1650     case COND_EXPR:
1651     case VEC_COND_EXPR:
1652
1653     case PLUS_EXPR:
1654     case MINUS_EXPR:
1655     case MULT_EXPR:
1656
1657     case FIX_TRUNC_EXPR:
1658     case FIX_CEIL_EXPR:
1659     case FIX_FLOOR_EXPR:
1660     case FIX_ROUND_EXPR:
1661
1662     case NEGATE_EXPR:
1663     case FLOAT_EXPR:
1664     case MIN_EXPR:
1665     case MAX_EXPR:
1666     case ABS_EXPR:
1667
1668     case LSHIFT_EXPR:
1669     case RSHIFT_EXPR:
1670     case LROTATE_EXPR:
1671     case RROTATE_EXPR:
1672
1673     case BIT_IOR_EXPR:
1674     case BIT_XOR_EXPR:
1675     case BIT_AND_EXPR:
1676     case BIT_NOT_EXPR:
1677
1678     case TRUTH_ANDIF_EXPR:
1679     case TRUTH_ORIF_EXPR:
1680     case TRUTH_AND_EXPR:
1681     case TRUTH_OR_EXPR:
1682     case TRUTH_XOR_EXPR:
1683     case TRUTH_NOT_EXPR:
1684
1685     case LT_EXPR:
1686     case LE_EXPR:
1687     case GT_EXPR:
1688     case GE_EXPR:
1689     case EQ_EXPR:
1690     case NE_EXPR:
1691     case ORDERED_EXPR:
1692     case UNORDERED_EXPR:
1693
1694     case UNLT_EXPR:
1695     case UNLE_EXPR:
1696     case UNGT_EXPR:
1697     case UNGE_EXPR:
1698     case UNEQ_EXPR:
1699     case LTGT_EXPR:
1700
1701     case CONVERT_EXPR:
1702
1703     case CONJ_EXPR:
1704
1705     case PREDECREMENT_EXPR:
1706     case PREINCREMENT_EXPR:
1707     case POSTDECREMENT_EXPR:
1708     case POSTINCREMENT_EXPR:
1709
1710     case SWITCH_EXPR:
1711
1712     case ASM_EXPR:
1713
1714     case REALIGN_LOAD_EXPR:
1715
1716     case RESX_EXPR:
1717       *count += 1;
1718       break;
1719
1720     /* Few special cases of expensive operations.  This is useful
1721        to avoid inlining on functions having too many of these.  */
1722     case TRUNC_DIV_EXPR:
1723     case CEIL_DIV_EXPR:
1724     case FLOOR_DIV_EXPR:
1725     case ROUND_DIV_EXPR:
1726     case EXACT_DIV_EXPR:
1727     case TRUNC_MOD_EXPR:
1728     case CEIL_MOD_EXPR:
1729     case FLOOR_MOD_EXPR:
1730     case ROUND_MOD_EXPR:
1731     case RDIV_EXPR:
1732       *count += 10;
1733       break;
1734     case CALL_EXPR:
1735       {
1736         tree decl = get_callee_fndecl (x);
1737         tree arg;
1738
1739         if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
1740           switch (DECL_FUNCTION_CODE (decl))
1741             {
1742             case BUILT_IN_CONSTANT_P:
1743               *walk_subtrees = 0;
1744               return NULL_TREE;
1745             case BUILT_IN_EXPECT:
1746               return NULL_TREE;
1747             default:
1748               break;
1749             }
1750
1751         /* Our cost must be kept in sync with cgraph_estimate_size_after_inlining
1752            that does use function declaration to figure out the arguments.  */
1753         if (!decl)
1754           {
1755             for (arg = TREE_OPERAND (x, 1); arg; arg = TREE_CHAIN (arg))
1756               *count += estimate_move_cost (TREE_TYPE (TREE_VALUE (arg)));
1757           }
1758         else
1759           {
1760             for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg))
1761               *count += estimate_move_cost (TREE_TYPE (arg));
1762           }
1763
1764         *count += PARAM_VALUE (PARAM_INLINE_CALL_COST);
1765         break;
1766       }
1767     default:
1768       gcc_unreachable ();
1769     }
1770   return NULL;
1771 }
1772
1773 /* Estimate number of instructions that will be created by expanding EXPR.  */
1774
1775 int
1776 estimate_num_insns (tree expr)
1777 {
1778   int num = 0;
1779   struct pointer_set_t *visited_nodes;
1780   basic_block bb;
1781   block_stmt_iterator bsi;
1782   struct function *my_function;
1783
1784   /* If we're given an entire function, walk the CFG.  */
1785   if (TREE_CODE (expr) == FUNCTION_DECL)
1786     {
1787       my_function = DECL_STRUCT_FUNCTION (expr);
1788       gcc_assert (my_function && my_function->cfg);
1789       visited_nodes = pointer_set_create ();
1790       FOR_EACH_BB_FN (bb, my_function)
1791         {
1792           for (bsi = bsi_start (bb);
1793                !bsi_end_p (bsi);
1794                bsi_next (&bsi))
1795             {
1796               walk_tree (bsi_stmt_ptr (bsi), estimate_num_insns_1,
1797                          &num, visited_nodes);
1798             }
1799         }
1800       pointer_set_destroy (visited_nodes);
1801     }
1802   else
1803     walk_tree_without_duplicates (&expr, estimate_num_insns_1, &num);
1804
1805   return num;
1806 }
1807
1808 /* Initialized with NOGC, making this poisonous to the garbage collector.  */
1809 static varray_type cfun_stack;
1810
1811 void
1812 push_cfun (struct function *new_cfun)
1813 {
1814   static bool initialized = false;
1815
1816   if (!initialized)
1817     {
1818       VARRAY_GENERIC_PTR_NOGC_INIT (cfun_stack, 20, "cfun_stack");
1819       initialized = true;
1820     }
1821   VARRAY_PUSH_GENERIC_PTR (cfun_stack, cfun);
1822   cfun = new_cfun;
1823 }
1824
1825 void
1826 pop_cfun (void)
1827 {
1828   cfun = (struct function *)VARRAY_TOP_GENERIC_PTR (cfun_stack);
1829   VARRAY_POP (cfun_stack);
1830 }
1831
1832 /* Install new lexical TREE_BLOCK underneath 'current_block'.  */
1833 static void
1834 add_lexical_block (tree current_block, tree new_block)
1835 {
1836   tree *blk_p;
1837
1838   /* Walk to the last sub-block.  */
1839   for (blk_p = &BLOCK_SUBBLOCKS (current_block);
1840        *blk_p;
1841        blk_p = &TREE_CHAIN (*blk_p))
1842     ;
1843   *blk_p = new_block;
1844   BLOCK_SUPERCONTEXT (new_block) = current_block;
1845   BLOCK_SUBBLOCKS (new_block) = NULL_TREE;
1846 }
1847
1848 /* If *TP is a CALL_EXPR, replace it with its inline expansion.  */
1849
1850 static bool
1851 expand_call_inline (basic_block bb, tree stmt, tree *tp, void *data)
1852 {
1853   inline_data *id;
1854   tree t;
1855   tree use_retvar;
1856   tree fn;
1857   splay_tree st;
1858   tree args;
1859   tree return_slot_addr;
1860   tree modify_dest;
1861   location_t saved_location;
1862   struct cgraph_edge *cg_edge;
1863   const char *reason;
1864   basic_block return_block;
1865   edge e;
1866   block_stmt_iterator bsi, stmt_bsi;
1867   bool successfully_inlined = FALSE;
1868   tree t_step;
1869   tree var;
1870   struct cgraph_node *old_node;
1871   tree decl;
1872
1873   /* See what we've got.  */
1874   id = (inline_data *) data;
1875   t = *tp;
1876
1877   /* Set input_location here so we get the right instantiation context
1878      if we call instantiate_decl from inlinable_function_p.  */
1879   saved_location = input_location;
1880   if (EXPR_HAS_LOCATION (t))
1881     input_location = EXPR_LOCATION (t);
1882
1883   /* From here on, we're only interested in CALL_EXPRs.  */
1884   if (TREE_CODE (t) != CALL_EXPR)
1885     goto egress;
1886
1887   /* First, see if we can figure out what function is being called.
1888      If we cannot, then there is no hope of inlining the function.  */
1889   fn = get_callee_fndecl (t);
1890   if (!fn)
1891     goto egress;
1892
1893   /* Turn forward declarations into real ones.  */
1894   fn = cgraph_node (fn)->decl;
1895
1896   /* If fn is a declaration of a function in a nested scope that was
1897      globally declared inline, we don't set its DECL_INITIAL.
1898      However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
1899      C++ front-end uses it for cdtors to refer to their internal
1900      declarations, that are not real functions.  Fortunately those
1901      don't have trees to be saved, so we can tell by checking their
1902      DECL_SAVED_TREE.  */
1903   if (! DECL_INITIAL (fn)
1904       && DECL_ABSTRACT_ORIGIN (fn)
1905       && DECL_SAVED_TREE (DECL_ABSTRACT_ORIGIN (fn)))
1906     fn = DECL_ABSTRACT_ORIGIN (fn);
1907
1908   /* Objective C and fortran still calls tree_rest_of_compilation directly.
1909      Kill this check once this is fixed.  */
1910   if (!id->current_node->analyzed)
1911     goto egress;
1912
1913   cg_edge = cgraph_edge (id->current_node, t);
1914
1915   /* Constant propagation on argument done during previous inlining
1916      may create new direct call.  Produce an edge for it.  */
1917   if (!cg_edge)
1918     {
1919       struct cgraph_node *dest = cgraph_node (fn);
1920
1921       /* We have missing edge in the callgraph.  This can happen in one case
1922          where previous inlining turned indirect call into direct call by
1923          constant propagating arguments.  In all other cases we hit a bug
1924          (incorrect node sharing is most common reason for missing edges.  */
1925       gcc_assert (dest->needed || !flag_unit_at_a_time);
1926       cgraph_create_edge (id->node, dest, t,
1927                           bb->count, bb->loop_depth)->inline_failed
1928         = N_("originally indirect function call not considered for inlining");
1929       goto egress;
1930     }
1931
1932   /* Don't try to inline functions that are not well-suited to
1933      inlining.  */
1934   if (!cgraph_inline_p (cg_edge, &reason))
1935     {
1936       if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
1937         {
1938           sorry ("%Jinlining failed in call to %qF: %s", fn, fn, reason);
1939           sorry ("called from here");
1940         }
1941       else if (warn_inline && DECL_DECLARED_INLINE_P (fn)
1942                && !DECL_IN_SYSTEM_HEADER (fn)
1943                && strlen (reason)
1944                && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn)))
1945         {
1946           warning (0, "%Jinlining failed in call to %qF: %s", fn, fn, reason);
1947           warning (0, "called from here");
1948         }
1949       goto egress;
1950     }
1951
1952 #ifdef ENABLE_CHECKING
1953   if (cg_edge->callee->decl != id->node->decl)
1954     verify_cgraph_node (cg_edge->callee);
1955 #endif
1956
1957   /* We will be inlining this callee.  */
1958
1959   id->eh_region = lookup_stmt_eh_region (stmt);
1960
1961   /* Split the block holding the CALL_EXPR.  */
1962
1963   e = split_block (bb, stmt);
1964   bb = e->src;
1965   return_block = e->dest;
1966   remove_edge (e);
1967
1968   /* split_block splits before the statement, work around this by moving
1969      the call into the first half_bb.  Not pretty, but seems easier than
1970      doing the CFG manipulation by hand when the CALL_EXPR is in the last
1971      statement in BB.  */
1972   stmt_bsi = bsi_last (bb);
1973   bsi = bsi_start (return_block);
1974   if (!bsi_end_p (bsi))
1975     bsi_move_before (&stmt_bsi, &bsi);
1976   else
1977     {
1978       tree stmt = bsi_stmt (stmt_bsi);
1979       bsi_remove (&stmt_bsi);
1980       bsi_insert_after (&bsi, stmt, BSI_NEW_STMT);
1981     }
1982   stmt_bsi = bsi_start (return_block);
1983
1984   /* Build a block containing code to initialize the arguments, the
1985      actual inline expansion of the body, and a label for the return
1986      statements within the function to jump to.  The type of the
1987      statement expression is the return type of the function call.  */
1988   id->block = make_node (BLOCK);
1989   BLOCK_ABSTRACT_ORIGIN (id->block) = fn;
1990   add_lexical_block (TREE_BLOCK (stmt), id->block);
1991
1992
1993   /* Local declarations will be replaced by their equivalents in this
1994      map.  */
1995   st = id->decl_map;
1996   id->decl_map = splay_tree_new (splay_tree_compare_pointers,
1997                                  NULL, NULL);
1998
1999   /* Initialize the parameters.  */
2000   args = TREE_OPERAND (t, 1);
2001   if (CALL_EXPR_HAS_RETURN_SLOT_ADDR (t))
2002     {
2003       return_slot_addr = TREE_VALUE (args);
2004       args = TREE_CHAIN (args);
2005     }
2006   else
2007     return_slot_addr = NULL_TREE;
2008
2009   initialize_inlined_parameters (id, args, TREE_OPERAND (t, 2), fn, bb);
2010
2011   /* Record the function we are about to inline.  */
2012   id->callee = fn;
2013
2014   /* Return statements in the function body will be replaced by jumps
2015      to the RET_LABEL.  */
2016
2017   gcc_assert (DECL_INITIAL (fn));
2018   gcc_assert (TREE_CODE (DECL_INITIAL (fn)) == BLOCK);
2019
2020   /* Find the lhs to which the result of this call is assigned.  */
2021   modify_dest = stmt;
2022   if (TREE_CODE (modify_dest) == MODIFY_EXPR)
2023     {
2024       modify_dest = TREE_OPERAND (modify_dest, 0);
2025
2026       /* The function which we are inlining might not return a value,
2027          in which case we should issue a warning that the function
2028          does not return a value.  In that case the optimizers will
2029          see that the variable to which the value is assigned was not
2030          initialized.  We do not want to issue a warning about that
2031          uninitialized variable.  */
2032       if (DECL_P (modify_dest))
2033         TREE_NO_WARNING (modify_dest) = 1;
2034     }
2035   else
2036     modify_dest = NULL;
2037
2038   /* Declare the return variable for the function.  */
2039   decl = declare_return_variable (id, return_slot_addr,
2040                                   modify_dest, &use_retvar);
2041   /* Do this only if declare_return_variable created a new one.  */
2042   if (decl && !return_slot_addr && decl != modify_dest)
2043     declare_inline_vars (id->block, decl);
2044
2045   /* After we've initialized the parameters, we insert the body of the
2046      function itself.  */
2047   old_node = id->current_node;
2048
2049   /* Anoint the callee-to-be-duplicated as the "current_node."  When
2050      CALL_EXPRs within callee are duplicated, the edges from callee to
2051      callee's callees (caller's grandchildren) will be cloned.  */
2052   id->current_node = cg_edge->callee;
2053
2054   /* This is it.  Duplicate the callee body.  Assume callee is
2055      pre-gimplified.  Note that we must not alter the caller
2056      function in any way before this point, as this CALL_EXPR may be
2057      a self-referential call; if we're calling ourselves, we need to
2058      duplicate our body before altering anything.  */
2059   copy_body (id, bb->count, bb->frequency, bb, return_block);
2060   id->current_node = old_node;
2061
2062   /* Clean up.  */
2063   splay_tree_delete (id->decl_map);
2064   id->decl_map = st;
2065
2066   /* If the inlined function returns a result that we care about,
2067      clobber the CALL_EXPR with a reference to the return variable.  */
2068   if (use_retvar && (TREE_CODE (bsi_stmt (stmt_bsi)) != CALL_EXPR))
2069     {
2070       *tp = use_retvar;
2071       maybe_clean_or_replace_eh_stmt (stmt, stmt);
2072     }
2073   else
2074     /* We're modifying a TSI owned by gimple_expand_calls_inline();
2075        tsi_delink() will leave the iterator in a sane state.  */
2076     bsi_remove (&stmt_bsi);
2077
2078   bsi_next (&bsi);
2079   if (bsi_end_p (bsi))
2080     tree_purge_dead_eh_edges (return_block);
2081
2082   /* If the value of the new expression is ignored, that's OK.  We
2083      don't warn about this for CALL_EXPRs, so we shouldn't warn about
2084      the equivalent inlined version either.  */
2085   TREE_USED (*tp) = 1;
2086
2087   /* Output the inlining info for this abstract function, since it has been
2088      inlined.  If we don't do this now, we can lose the information about the
2089      variables in the function when the blocks get blown away as soon as we
2090      remove the cgraph node.  */
2091   (*debug_hooks->outlining_inline_function) (cg_edge->callee->decl);
2092
2093   /* Update callgraph if needed.  */
2094   cgraph_remove_node (cg_edge->callee);
2095
2096   /* Declare the 'auto' variables added with this inlined body.  */
2097   record_vars (BLOCK_VARS (id->block));
2098   id->block = NULL_TREE;
2099
2100   /* Add local static vars in this inlined callee to caller.  */
2101   for (t_step = id->callee_cfun->unexpanded_var_list;
2102        t_step;
2103        t_step = TREE_CHAIN (t_step))
2104     {
2105       var = TREE_VALUE (t_step);
2106       if (TREE_STATIC (var) && !TREE_ASM_WRITTEN (var))
2107         record_vars (var);
2108     }
2109   successfully_inlined = TRUE;
2110
2111  egress:
2112   input_location = saved_location;
2113   return successfully_inlined;
2114 }
2115
2116 /* Expand call statements reachable from STMT_P.
2117    We can only have CALL_EXPRs as the "toplevel" tree code or nested
2118    in a MODIFY_EXPR.  See tree-gimple.c:get_call_expr_in().  We can
2119    unfortunately not use that function here because we need a pointer
2120    to the CALL_EXPR, not the tree itself.  */
2121
2122 static bool
2123 gimple_expand_calls_inline (basic_block bb, inline_data *id)
2124 {
2125   block_stmt_iterator bsi;
2126
2127   /* Register specific tree functions.  */
2128   tree_register_cfg_hooks ();
2129   for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2130     {
2131       tree *expr_p = bsi_stmt_ptr (bsi);
2132       tree stmt = *expr_p;
2133
2134       if (TREE_CODE (*expr_p) == MODIFY_EXPR)
2135         expr_p = &TREE_OPERAND (*expr_p, 1);
2136       if (TREE_CODE (*expr_p) == WITH_SIZE_EXPR)
2137         expr_p = &TREE_OPERAND (*expr_p, 0);
2138       if (TREE_CODE (*expr_p) == CALL_EXPR)
2139         if (expand_call_inline (bb, stmt, expr_p, id))
2140           return true;
2141     }
2142   return false;
2143 }
2144
2145 /* Expand calls to inline functions in the body of FN.  */
2146
2147 void
2148 optimize_inline_calls (tree fn)
2149 {
2150   inline_data id;
2151   tree prev_fn;
2152   basic_block bb;
2153   /* There is no point in performing inlining if errors have already
2154      occurred -- and we might crash if we try to inline invalid
2155      code.  */
2156   if (errorcount || sorrycount)
2157     return;
2158
2159   /* Clear out ID.  */
2160   memset (&id, 0, sizeof (id));
2161
2162   id.current_node = id.node = cgraph_node (fn);
2163   id.caller = fn;
2164   /* Or any functions that aren't finished yet.  */
2165   prev_fn = NULL_TREE;
2166   if (current_function_decl)
2167     {
2168       id.caller = current_function_decl;
2169       prev_fn = current_function_decl;
2170     }
2171   push_gimplify_context ();
2172
2173   /* Reach the trees by walking over the CFG, and note the
2174      enclosing basic-blocks in the call edges.  */
2175   /* We walk the blocks going forward, because inlined function bodies
2176      will split id->current_basic_block, and the new blocks will
2177      follow it; we'll trudge through them, processing their CALL_EXPRs
2178      along the way.  */
2179   FOR_EACH_BB (bb)
2180     gimple_expand_calls_inline (bb, &id);
2181
2182
2183   pop_gimplify_context (NULL);
2184   /* Renumber the (code) basic_blocks consecutively.  */
2185   compact_blocks ();
2186   /* Renumber the lexical scoping (non-code) blocks consecutively.  */
2187   number_blocks (fn);
2188
2189 #ifdef ENABLE_CHECKING
2190     {
2191       struct cgraph_edge *e;
2192
2193       verify_cgraph_node (id.node);
2194
2195       /* Double check that we inlined everything we are supposed to inline.  */
2196       for (e = id.node->callees; e; e = e->next_callee)
2197         gcc_assert (e->inline_failed);
2198     }
2199 #endif
2200   /* We need to rescale frequencies again to peak at REG_BR_PROB_BASE
2201      as inlining loops might increase the maximum.  */
2202   if (ENTRY_BLOCK_PTR->count)
2203     counts_to_freqs ();
2204   fold_cond_expr_cond ();
2205 }
2206
2207 /* FN is a function that has a complete body, and CLONE is a function whose
2208    body is to be set to a copy of FN, mapping argument declarations according
2209    to the ARG_MAP splay_tree.  */
2210
2211 void
2212 clone_body (tree clone, tree fn, void *arg_map)
2213 {
2214   inline_data id;
2215
2216   /* Clone the body, as if we were making an inline call.  But, remap the
2217      parameters in the callee to the parameters of caller.  */
2218   memset (&id, 0, sizeof (id));
2219   id.caller = clone;
2220   id.callee = fn;
2221   id.callee_cfun = DECL_STRUCT_FUNCTION (fn);
2222   id.decl_map = (splay_tree)arg_map;
2223
2224   /* Cloning is treated slightly differently from inlining.  Set
2225      CLONING_P so that it's clear which operation we're performing.  */
2226   id.cloning_p = true;
2227
2228   /* We're not inside any EH region.  */
2229   id.eh_region = -1;
2230
2231   /* Actually copy the body.  */
2232   append_to_statement_list_force (copy_generic_body (&id), &DECL_SAVED_TREE (clone));
2233 }
2234
2235 /* Save duplicate body in FN.  MAP is used to pass around splay tree
2236    used to update arguments in restore_body.  */
2237
2238 /* Make and return duplicate of body in FN.  Put copies of DECL_ARGUMENTS
2239    in *arg_copy and of the static chain, if any, in *sc_copy.  */
2240
2241 void
2242 save_body (tree fn, tree *arg_copy, tree *sc_copy)
2243 {
2244   inline_data id;
2245   tree newdecl, *parg;
2246   basic_block fn_entry_block;
2247
2248   memset (&id, 0, sizeof (id));
2249   id.callee = fn;
2250   id.callee_cfun = DECL_STRUCT_FUNCTION (fn);
2251   id.caller = fn;
2252   id.node = cgraph_node (fn);
2253   id.saving_p = true;
2254   id.decl_map = splay_tree_new (splay_tree_compare_pointers, NULL, NULL);
2255   *arg_copy = DECL_ARGUMENTS (fn);
2256
2257   for (parg = arg_copy; *parg; parg = &TREE_CHAIN (*parg))
2258     {
2259       tree new = copy_node (*parg);
2260
2261       lang_hooks.dup_lang_specific_decl (new);
2262       DECL_ABSTRACT_ORIGIN (new) = DECL_ORIGIN (*parg);
2263       insert_decl_map (&id, *parg, new);
2264       TREE_CHAIN (new) = TREE_CHAIN (*parg);
2265       *parg = new;
2266     }
2267
2268   *sc_copy = DECL_STRUCT_FUNCTION (fn)->static_chain_decl;
2269   if (*sc_copy)
2270     {
2271       tree new = copy_node (*sc_copy);
2272
2273       lang_hooks.dup_lang_specific_decl (new);
2274       DECL_ABSTRACT_ORIGIN (new) = DECL_ORIGIN (*sc_copy);
2275       insert_decl_map (&id, *sc_copy, new);
2276       TREE_CHAIN (new) = TREE_CHAIN (*sc_copy);
2277       *sc_copy = new;
2278     }
2279
2280   /* We're not inside any EH region.  */
2281   id.eh_region = -1;
2282
2283   insert_decl_map (&id, DECL_RESULT (fn), DECL_RESULT (fn));
2284
2285   /* Actually copy the body, including a new (struct function *) and CFG.
2286      EH info is also duplicated so its labels point into the copied
2287      CFG, not the original.  */
2288   fn_entry_block = ENTRY_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (fn));
2289   newdecl = copy_body (&id, fn_entry_block->count, fn_entry_block->frequency, NULL, NULL);
2290   DECL_STRUCT_FUNCTION (fn)->saved_cfg = DECL_STRUCT_FUNCTION (newdecl)->cfg;
2291   DECL_STRUCT_FUNCTION (fn)->saved_eh = DECL_STRUCT_FUNCTION (newdecl)->eh;
2292
2293   /* Clean up.  */
2294   splay_tree_delete (id.decl_map);
2295 }
2296
2297 /* Passed to walk_tree.  Copies the node pointed to, if appropriate.  */
2298
2299 tree
2300 copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
2301 {
2302   enum tree_code code = TREE_CODE (*tp);
2303
2304   /* We make copies of most nodes.  */
2305   if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code))
2306       || code == TREE_LIST
2307       || code == TREE_VEC
2308       || code == TYPE_DECL)
2309     {
2310       /* Because the chain gets clobbered when we make a copy, we save it
2311          here.  */
2312       tree chain = TREE_CHAIN (*tp);
2313       tree new;
2314
2315       /* Copy the node.  */
2316       new = copy_node (*tp);
2317
2318       /* Propagate mudflap marked-ness.  */
2319       if (flag_mudflap && mf_marked_p (*tp))
2320         mf_mark (new);
2321
2322       *tp = new;
2323
2324       /* Now, restore the chain, if appropriate.  That will cause
2325          walk_tree to walk into the chain as well.  */
2326       if (code == PARM_DECL || code == TREE_LIST)
2327         TREE_CHAIN (*tp) = chain;
2328
2329       /* For now, we don't update BLOCKs when we make copies.  So, we
2330          have to nullify all BIND_EXPRs.  */
2331       if (TREE_CODE (*tp) == BIND_EXPR)
2332         BIND_EXPR_BLOCK (*tp) = NULL_TREE;
2333     }
2334
2335   else if (TREE_CODE_CLASS (code) == tcc_type)
2336     *walk_subtrees = 0;
2337   else if (TREE_CODE_CLASS (code) == tcc_declaration)
2338     *walk_subtrees = 0;
2339   else if (TREE_CODE_CLASS (code) == tcc_constant)
2340     *walk_subtrees = 0;
2341   else
2342     gcc_assert (code != STATEMENT_LIST);
2343   return NULL_TREE;
2344 }
2345
2346 /* The SAVE_EXPR pointed to by TP is being copied.  If ST contains
2347    information indicating to what new SAVE_EXPR this one should be mapped,
2348    use that one.  Otherwise, create a new node and enter it in ST.  FN is
2349    the function into which the copy will be placed.  */
2350
2351 static void
2352 remap_save_expr (tree *tp, void *st_, int *walk_subtrees)
2353 {
2354   splay_tree st = (splay_tree) st_;
2355   splay_tree_node n;
2356   tree t;
2357
2358   /* See if we already encountered this SAVE_EXPR.  */
2359   n = splay_tree_lookup (st, (splay_tree_key) *tp);
2360
2361   /* If we didn't already remap this SAVE_EXPR, do so now.  */
2362   if (!n)
2363     {
2364       t = copy_node (*tp);
2365
2366       /* Remember this SAVE_EXPR.  */
2367       splay_tree_insert (st, (splay_tree_key) *tp, (splay_tree_value) t);
2368       /* Make sure we don't remap an already-remapped SAVE_EXPR.  */
2369       splay_tree_insert (st, (splay_tree_key) t, (splay_tree_value) t);
2370     }
2371   else
2372     {
2373       /* We've already walked into this SAVE_EXPR; don't do it again.  */
2374       *walk_subtrees = 0;
2375       t = (tree) n->value;
2376     }
2377
2378   /* Replace this SAVE_EXPR with the copy.  */
2379   *tp = t;
2380 }
2381
2382 /* Called via walk_tree.  If *TP points to a DECL_STMT for a local label,
2383    copies the declaration and enters it in the splay_tree in DATA (which is
2384    really an `inline_data *').  */
2385
2386 static tree
2387 mark_local_for_remap_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
2388                         void *data)
2389 {
2390   inline_data *id = (inline_data *) data;
2391
2392   /* Don't walk into types.  */
2393   if (TYPE_P (*tp))
2394     *walk_subtrees = 0;
2395
2396   else if (TREE_CODE (*tp) == LABEL_EXPR)
2397     {
2398       tree decl = TREE_OPERAND (*tp, 0);
2399
2400       /* Copy the decl and remember the copy.  */
2401       insert_decl_map (id, decl,
2402                        copy_decl_for_inlining (decl, DECL_CONTEXT (decl),
2403                                                DECL_CONTEXT (decl)));
2404     }
2405
2406   return NULL_TREE;
2407 }
2408
2409 /* Perform any modifications to EXPR required when it is unsaved.  Does
2410    not recurse into EXPR's subtrees.  */
2411
2412 static void
2413 unsave_expr_1 (tree expr)
2414 {
2415   switch (TREE_CODE (expr))
2416     {
2417     case TARGET_EXPR:
2418       /* Don't mess with a TARGET_EXPR that hasn't been expanded.
2419          It's OK for this to happen if it was part of a subtree that
2420          isn't immediately expanded, such as operand 2 of another
2421          TARGET_EXPR.  */
2422       if (TREE_OPERAND (expr, 1))
2423         break;
2424
2425       TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
2426       TREE_OPERAND (expr, 3) = NULL_TREE;
2427       break;
2428
2429     default:
2430       break;
2431     }
2432 }
2433
2434 /* Called via walk_tree when an expression is unsaved.  Using the
2435    splay_tree pointed to by ST (which is really a `splay_tree'),
2436    remaps all local declarations to appropriate replacements.  */
2437
2438 static tree
2439 unsave_r (tree *tp, int *walk_subtrees, void *data)
2440 {
2441   inline_data *id = (inline_data *) data;
2442   splay_tree st = id->decl_map;
2443   splay_tree_node n;
2444
2445   /* Only a local declaration (variable or label).  */
2446   if ((TREE_CODE (*tp) == VAR_DECL && !TREE_STATIC (*tp))
2447       || TREE_CODE (*tp) == LABEL_DECL)
2448     {
2449       /* Lookup the declaration.  */
2450       n = splay_tree_lookup (st, (splay_tree_key) *tp);
2451
2452       /* If it's there, remap it.  */
2453       if (n)
2454         *tp = (tree) n->value;
2455     }
2456
2457   else if (TREE_CODE (*tp) == STATEMENT_LIST)
2458     copy_statement_list (tp);
2459   else if (TREE_CODE (*tp) == BIND_EXPR)
2460     copy_bind_expr (tp, walk_subtrees, id);
2461   else if (TREE_CODE (*tp) == SAVE_EXPR)
2462     remap_save_expr (tp, st, walk_subtrees);
2463   else
2464     {
2465       copy_tree_r (tp, walk_subtrees, NULL);
2466
2467       /* Do whatever unsaving is required.  */
2468       unsave_expr_1 (*tp);
2469     }
2470
2471   /* Keep iterating.  */
2472   return NULL_TREE;
2473 }
2474
2475 /* Copies everything in EXPR and replaces variables, labels
2476    and SAVE_EXPRs local to EXPR.  */
2477
2478 tree
2479 unsave_expr_now (tree expr)
2480 {
2481   inline_data id;
2482
2483   /* There's nothing to do for NULL_TREE.  */
2484   if (expr == 0)
2485     return expr;
2486
2487   /* Set up ID.  */
2488   memset (&id, 0, sizeof (id));
2489   id.callee = current_function_decl;
2490   id.caller = current_function_decl;
2491   id.decl_map = splay_tree_new (splay_tree_compare_pointers, NULL, NULL);
2492
2493   /* Walk the tree once to find local labels.  */
2494   walk_tree_without_duplicates (&expr, mark_local_for_remap_r, &id);
2495
2496   /* Walk the tree again, copying, remapping, and unsaving.  */
2497   walk_tree (&expr, unsave_r, &id, NULL);
2498
2499   /* Clean up.  */
2500   splay_tree_delete (id.decl_map);
2501
2502   return expr;
2503 }
2504
2505 /* Allow someone to determine if SEARCH is a child of TOP from gdb.  */
2506
2507 static tree
2508 debug_find_tree_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
2509 {
2510   if (*tp == data)
2511     return (tree) data;
2512   else
2513     return NULL;
2514 }
2515
2516 bool
2517 debug_find_tree (tree top, tree search)
2518 {
2519   return walk_tree_without_duplicates (&top, debug_find_tree_1, search) != 0;
2520 }
2521
2522
2523 /* Declare the variables created by the inliner.  Add all the variables in
2524    VARS to BIND_EXPR.  */
2525
2526 static void
2527 declare_inline_vars (tree block, tree vars)
2528 {
2529   tree t;
2530   for (t = vars; t; t = TREE_CHAIN (t))
2531     DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
2532
2533   if (block)
2534     BLOCK_VARS (block) = chainon (BLOCK_VARS (block), vars);
2535 }
2536
2537 /* Returns true if we're inlining.  */
2538 static inline bool
2539 inlining_p (inline_data *id)
2540 {
2541   return (!id->saving_p && !id->cloning_p);
2542 }