gcc/tree-inline.c

   1 /* Tree inlining.
   2    Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
   3    Free Software Foundation, Inc.
   4    Contributed by Alexandre Oliva <aoliva@redhat.com>
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  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 "langhooks.h"
  38 #include "basic-block.h"
  39 #include "tree-iterator.h"
  40 #include "cgraph.h"
  41 #include "intl.h"
  42 #include "tree-mudflap.h"
  43 #include "tree-flow.h"
  44 #include "function.h"
  45 #include "ggc.h"
  46 #include "tree-flow.h"
  47 #include "diagnostic.h"
  48 #include "except.h"
  49 #include "debug.h"
  50 #include "pointer-set.h"
  51 #include "ipa-prop.h"
  52 #include "value-prof.h"
  53 #include "tree-pass.h"
  54 #include "target.h"
  55 #include "integrate.h"
  56
  57 /* I'm not real happy about this, but we need to handle gimple and
  58    non-gimple trees.  */
  59 #include "tree-gimple.h"
  60
  61 /* Inlining, Cloning, Versioning, Parallelization
  62
  63    Inlining: a function body is duplicated, but the PARM_DECLs are
  64    remapped into VAR_DECLs, and non-void RETURN_EXPRs become
  65    GIMPLE_MODIFY_STMTs that store to a dedicated returned-value variable.
  66    The duplicated eh_region info of the copy will later be appended
  67    to the info for the caller; the eh_region info in copied throwing
  68    statements and RESX_EXPRs is adjusted accordingly.
  69
  70    Cloning: (only in C++) We have one body for a con/de/structor, and
  71    multiple function decls, each with a unique parameter list.
  72    Duplicate the body, using the given splay tree; some parameters
  73    will become constants (like 0 or 1).
  74
  75    Versioning: a function body is duplicated and the result is a new
  76    function rather than into blocks of an existing function as with
  77    inlining.  Some parameters will become constants.
  78
  79    Parallelization: a region of a function is duplicated resulting in
  80    a new function.  Variables may be replaced with complex expressions
  81    to enable shared variable semantics.
  82
  83    All of these will simultaneously lookup any callgraph edges.  If
  84    we're going to inline the duplicated function body, and the given
  85    function has some cloned callgraph nodes (one for each place this
  86    function will be inlined) those callgraph edges will be duplicated.
  87    If we're cloning the body, those callgraph edges will be
  88    updated to point into the new body.  (Note that the original
  89    callgraph node and edge list will not be altered.)
  90
  91    See the CALL_EXPR handling case in copy_body_r ().  */
  92
  93 /* 0 if we should not perform inlining.
  94    1 if we should expand functions calls inline at the tree level.
  95    2 if we should consider *all* functions to be inline
  96    candidates.  */
  97
  98 int flag_inline_trees = 0;
  99
 100 /* To Do:
 101
 102    o In order to make inlining-on-trees work, we pessimized
 103      function-local static constants.  In particular, they are now
 104      always output, even when not addressed.  Fix this by treating
 105      function-local static constants just like global static
 106      constants; the back-end already knows not to output them if they
 107      are not needed.
 108
 109    o Provide heuristics to clamp inlining of recursive template
 110      calls?  */
 111
 112
 113 /* Weights that estimate_num_insns uses for heuristics in inlining.  */
 114
 115 eni_weights eni_inlining_weights;
 116
 117 /* Weights that estimate_num_insns uses to estimate the size of the
 118    produced code.  */
 119
 120 eni_weights eni_size_weights;
 121
 122 /* Weights that estimate_num_insns uses to estimate the time necessary
 123    to execute the produced code.  */
 124
 125 eni_weights eni_time_weights;
 126
 127 /* Prototypes.  */
 128
 129 static tree declare_return_variable (copy_body_data *, tree, tree, tree *);
 130 static tree copy_generic_body (copy_body_data *);
 131 static bool inlinable_function_p (tree);
 132 static void remap_block (tree *, copy_body_data *);
 133 static tree remap_decls (tree, copy_body_data *);
 134 static void copy_bind_expr (tree *, int *, copy_body_data *);
 135 static tree mark_local_for_remap_r (tree *, int *, void *);
 136 static void unsave_expr_1 (tree);
 137 static tree unsave_r (tree *, int *, void *);
 138 static void declare_inline_vars (tree, tree);
 139 static void remap_save_expr (tree *, void *, int *);
 140 static void add_lexical_block (tree current_block, tree new_block);
 141 static tree copy_decl_to_var (tree, copy_body_data *);
 142 static tree copy_result_decl_to_var (tree, copy_body_data *);
 143 static tree copy_decl_no_change (tree, copy_body_data *);
 144 static tree copy_decl_maybe_to_var (tree, copy_body_data *);
 145
 146 /* Insert a tree->tree mapping for ID.  Despite the name suggests
 147    that the trees should be variables, it is used for more than that.  */
 148
 149 void
 150 insert_decl_map (copy_body_data *id, tree key, tree value)
 151 {
 152   *pointer_map_insert (id->decl_map, key) = value;
 153
 154   /* Always insert an identity map as well.  If we see this same new
 155      node again, we won't want to duplicate it a second time.  */
 156   if (key != value)
 157     *pointer_map_insert (id->decl_map, value) = value;
 158 }
 159
 160 /* Construct new SSA name for old NAME. ID is the inline context.  */
 161
 162 static tree
 163 remap_ssa_name (tree name, copy_body_data *id)
 164 {
 165   tree new;
 166   tree *n;
 167
 168   gcc_assert (TREE_CODE (name) == SSA_NAME);
 169
 170   n = (tree *) pointer_map_contains (id->decl_map, name);
 171   if (n)
 172     return *n;
 173
 174   /* Do not set DEF_STMT yet as statement is not copied yet. We do that
 175      in copy_bb.  */
 176   new = remap_decl (SSA_NAME_VAR (name), id);
 177   /* We might've substituted constant or another SSA_NAME for
 178      the variable.
 179
 180      Replace the SSA name representing RESULT_DECL by variable during
 181      inlining:  this saves us from need to introduce PHI node in a case
 182      return value is just partly initialized.  */
 183   if ((TREE_CODE (new) == VAR_DECL || TREE_CODE (new) == PARM_DECL)
 184       && (TREE_CODE (SSA_NAME_VAR (name)) != RESULT_DECL
 185           || !id->transform_return_to_modify))
 186     {
 187       new = make_ssa_name (new, NULL);
 188       insert_decl_map (id, name, new);
 189       SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new)
 190         = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name);
 191       TREE_TYPE (new) = TREE_TYPE (SSA_NAME_VAR (new));
 192       if (IS_EMPTY_STMT (SSA_NAME_DEF_STMT (name)))
 193         {
 194           /* By inlining function having uninitialized variable, we might
 195              extend the lifetime (variable might get reused).  This cause
 196              ICE in the case we end up extending lifetime of SSA name across
 197              abnormal edge, but also increase register presure.
 198
 199              We simply initialize all uninitialized vars by 0 except for case
 200              we are inlining to very first BB.  We can avoid this for all
 201              BBs that are not withing strongly connected regions of the CFG,
 202              but this is bit expensive to test.
 203            */
 204           if (id->entry_bb && is_gimple_reg (SSA_NAME_VAR (name))
 205               && TREE_CODE (SSA_NAME_VAR (name)) != PARM_DECL
 206               && (id->entry_bb != EDGE_SUCC (ENTRY_BLOCK_PTR, 0)->dest
 207                   || EDGE_COUNT (id->entry_bb->preds) != 1))
 208             {
 209               block_stmt_iterator bsi = bsi_last (id->entry_bb);
 210               tree init_stmt
 211                   = build_gimple_modify_stmt (new,
 212                                               fold_convert (TREE_TYPE (new),
 213                                                             integer_zero_node));
 214               bsi_insert_after (&bsi, init_stmt, BSI_NEW_STMT);
 215               SSA_NAME_DEF_STMT (new) = init_stmt;
 216               SSA_NAME_IS_DEFAULT_DEF (new) = 0;
 217             }
 218           else
 219             {
 220               SSA_NAME_DEF_STMT (new) = build_empty_stmt ();
 221               if (gimple_default_def (id->src_cfun, SSA_NAME_VAR (name)) == name)
 222                 set_default_def (SSA_NAME_VAR (new), new);
 223             }
 224         }
 225     }
 226   else
 227     insert_decl_map (id, name, new);
 228   return new;
 229 }
 230
 231 /* Remap DECL during the copying of the BLOCK tree for the function.  */
 232
 233 tree
 234 remap_decl (tree decl, copy_body_data *id)
 235 {
 236   tree *n;
 237   tree fn;
 238
 239   /* We only remap local variables in the current function.  */
 240   fn = id->src_fn;
 241
 242   /* See if we have remapped this declaration.  */
 243
 244   n = (tree *) pointer_map_contains (id->decl_map, decl);
 245
 246   /* If we didn't already have an equivalent for this declaration,
 247      create one now.  */
 248   if (!n)
 249     {
 250       /* Make a copy of the variable or label.  */
 251       tree t = id->copy_decl (decl, id);
 252
 253       /* Remember it, so that if we encounter this local entity again
 254          we can reuse this copy.  Do this early because remap_type may
 255          need this decl for TYPE_STUB_DECL.  */
 256       insert_decl_map (id, decl, t);
 257
 258       if (!DECL_P (t))
 259         return t;
 260
 261       /* Remap types, if necessary.  */
 262       TREE_TYPE (t) = remap_type (TREE_TYPE (t), id);
 263       if (TREE_CODE (t) == TYPE_DECL)
 264         DECL_ORIGINAL_TYPE (t) = remap_type (DECL_ORIGINAL_TYPE (t), id);
 265
 266       /* Remap sizes as necessary.  */
 267       walk_tree (&DECL_SIZE (t), copy_body_r, id, NULL);
 268       walk_tree (&DECL_SIZE_UNIT (t), copy_body_r, id, NULL);
 269
 270       /* If fields, do likewise for offset and qualifier.  */
 271       if (TREE_CODE (t) == FIELD_DECL)
 272         {
 273           walk_tree (&DECL_FIELD_OFFSET (t), copy_body_r, id, NULL);
 274           if (TREE_CODE (DECL_CONTEXT (t)) == QUAL_UNION_TYPE)
 275             walk_tree (&DECL_QUALIFIER (t), copy_body_r, id, NULL);
 276         }
 277
 278       if (cfun && gimple_in_ssa_p (cfun)
 279           && (TREE_CODE (t) == VAR_DECL
 280               || TREE_CODE (t) == RESULT_DECL || TREE_CODE (t) == PARM_DECL))
 281         {
 282           tree def = gimple_default_def (id->src_cfun, decl);
 283           get_var_ann (t);
 284           if (TREE_CODE (decl) != PARM_DECL && def)
 285             {
 286               tree map = remap_ssa_name (def, id);
 287               /* Watch out RESULT_DECLs whose SSA names map directly
 288                  to them.  */
 289               if (TREE_CODE (map) == SSA_NAME
 290                   && IS_EMPTY_STMT (SSA_NAME_DEF_STMT (map)))
 291                 set_default_def (t, map);
 292             }
 293           add_referenced_var (t);
 294         }
 295       return t;
 296     }
 297
 298   return unshare_expr (*n);
 299 }
 300
 301 static tree
 302 remap_type_1 (tree type, copy_body_data *id)
 303 {
 304   tree new, t;
 305
 306   /* We do need a copy.  build and register it now.  If this is a pointer or
 307      reference type, remap the designated type and make a new pointer or
 308      reference type.  */
 309   if (TREE_CODE (type) == POINTER_TYPE)
 310     {
 311       new = build_pointer_type_for_mode (remap_type (TREE_TYPE (type), id),
 312                                          TYPE_MODE (type),
 313                                          TYPE_REF_CAN_ALIAS_ALL (type));
 314       insert_decl_map (id, type, new);
 315       return new;
 316     }
 317   else if (TREE_CODE (type) == REFERENCE_TYPE)
 318     {
 319       new = build_reference_type_for_mode (remap_type (TREE_TYPE (type), id),
 320                                             TYPE_MODE (type),
 321                                             TYPE_REF_CAN_ALIAS_ALL (type));
 322       insert_decl_map (id, type, new);
 323       return new;
 324     }
 325   else
 326     new = copy_node (type);
 327
 328   insert_decl_map (id, type, new);
 329
 330   /* This is a new type, not a copy of an old type.  Need to reassociate
 331      variants.  We can handle everything except the main variant lazily.  */
 332   t = TYPE_MAIN_VARIANT (type);
 333   if (type != t)
 334     {
 335       t = remap_type (t, id);
 336       TYPE_MAIN_VARIANT (new) = t;
 337       TYPE_NEXT_VARIANT (new) = TYPE_NEXT_VARIANT (t);
 338       TYPE_NEXT_VARIANT (t) = new;
 339     }
 340   else
 341     {
 342       TYPE_MAIN_VARIANT (new) = new;
 343       TYPE_NEXT_VARIANT (new) = NULL;
 344     }
 345
 346   if (TYPE_STUB_DECL (type))
 347     TYPE_STUB_DECL (new) = remap_decl (TYPE_STUB_DECL (type), id);
 348
 349   /* Lazily create pointer and reference types.  */
 350   TYPE_POINTER_TO (new) = NULL;
 351   TYPE_REFERENCE_TO (new) = NULL;
 352
 353   switch (TREE_CODE (new))
 354     {
 355     case INTEGER_TYPE:
 356     case REAL_TYPE:
 357     case FIXED_POINT_TYPE:
 358     case ENUMERAL_TYPE:
 359     case BOOLEAN_TYPE:
 360       t = TYPE_MIN_VALUE (new);
 361       if (t && TREE_CODE (t) != INTEGER_CST)
 362         walk_tree (&TYPE_MIN_VALUE (new), copy_body_r, id, NULL);
 363
 364       t = TYPE_MAX_VALUE (new);
 365       if (t && TREE_CODE (t) != INTEGER_CST)
 366         walk_tree (&TYPE_MAX_VALUE (new), copy_body_r, id, NULL);
 367       return new;
 368
 369     case FUNCTION_TYPE:
 370       TREE_TYPE (new) = remap_type (TREE_TYPE (new), id);
 371       walk_tree (&TYPE_ARG_TYPES (new), copy_body_r, id, NULL);
 372       return new;
 373
 374     case ARRAY_TYPE:
 375       TREE_TYPE (new) = remap_type (TREE_TYPE (new), id);
 376       TYPE_DOMAIN (new) = remap_type (TYPE_DOMAIN (new), id);
 377       break;
 378
 379     case RECORD_TYPE:
 380     case UNION_TYPE:
 381     case QUAL_UNION_TYPE:
 382       {
 383         tree f, nf = NULL;
 384
 385         for (f = TYPE_FIELDS (new); f ; f = TREE_CHAIN (f))
 386           {
 387             t = remap_decl (f, id);
 388             DECL_CONTEXT (t) = new;
 389             TREE_CHAIN (t) = nf;
 390             nf = t;
 391           }
 392         TYPE_FIELDS (new) = nreverse (nf);
 393       }
 394       break;
 395
 396     case OFFSET_TYPE:
 397     default:
 398       /* Shouldn't have been thought variable sized.  */
 399       gcc_unreachable ();
 400     }
 401
 402   walk_tree (&TYPE_SIZE (new), copy_body_r, id, NULL);
 403   walk_tree (&TYPE_SIZE_UNIT (new), copy_body_r, id, NULL);
 404
 405   return new;
 406 }
 407
 408 tree
 409 remap_type (tree type, copy_body_data *id)
 410 {
 411   tree *node;
 412   tree tmp;
 413
 414   if (type == NULL)
 415     return type;
 416
 417   /* See if we have remapped this type.  */
 418   node = (tree *) pointer_map_contains (id->decl_map, type);
 419   if (node)
 420     return *node;
 421
 422   /* The type only needs remapping if it's variably modified.  */
 423   if (! variably_modified_type_p (type, id->src_fn))
 424     {
 425       insert_decl_map (id, type, type);
 426       return type;
 427     }
 428
 429   id->remapping_type_depth++;
 430   tmp = remap_type_1 (type, id);
 431   id->remapping_type_depth--;
 432
 433   return tmp;
 434 }
 435
 436 static tree
 437 remap_decls (tree decls, copy_body_data *id)
 438 {
 439   tree old_var;
 440   tree new_decls = NULL_TREE;
 441
 442   /* Remap its variables.  */
 443   for (old_var = decls; old_var; old_var = TREE_CHAIN (old_var))
 444     {
 445       tree new_var;
 446
 447       /* We can not chain the local static declarations into the unexpanded_var_list
 448          as we can't duplicate them or break one decl rule.  Go ahead and link
 449          them into unexpanded_var_list.  */
 450       if (!auto_var_in_fn_p (old_var, id->src_fn)
 451           && !DECL_EXTERNAL (old_var))
 452         {
 453           cfun->unexpanded_var_list = tree_cons (NULL_TREE, old_var,
 454                                                  cfun->unexpanded_var_list);
 455           continue;
 456         }
 457
 458       /* Remap the variable.  */
 459       new_var = remap_decl (old_var, id);
 460
 461       /* If we didn't remap this variable, so we can't mess with its
 462          TREE_CHAIN.  If we remapped this variable to the return slot, it's
 463          already declared somewhere else, so don't declare it here.  */
 464       if (!new_var || new_var == id->retvar)
 465         ;
 466       else
 467         {
 468           gcc_assert (DECL_P (new_var));
 469           TREE_CHAIN (new_var) = new_decls;
 470           new_decls = new_var;
 471         }
 472     }
 473
 474   return nreverse (new_decls);
 475 }
 476
 477 /* Copy the BLOCK to contain remapped versions of the variables
 478    therein.  And hook the new block into the block-tree.  */
 479
 480 static void
 481 remap_block (tree *block, copy_body_data *id)
 482 {
 483   tree old_block;
 484   tree new_block;
 485   tree fn;
 486
 487   /* Make the new block.  */
 488   old_block = *block;
 489   new_block = make_node (BLOCK);
 490   TREE_USED (new_block) = TREE_USED (old_block);
 491   BLOCK_ABSTRACT_ORIGIN (new_block) = old_block;
 492   BLOCK_SOURCE_LOCATION (new_block) = BLOCK_SOURCE_LOCATION (old_block);
 493   *block = new_block;
 494
 495   /* Remap its variables.  */
 496   BLOCK_VARS (new_block) = remap_decls (BLOCK_VARS (old_block), id);
 497
 498   fn = id->dst_fn;
 499
 500   if (id->transform_lang_insert_block)
 501     lang_hooks.decls.insert_block (new_block);
 502
 503   /* Remember the remapped block.  */
 504   insert_decl_map (id, old_block, new_block);
 505 }
 506
 507 /* Copy the whole block tree and root it in id->block.  */
 508 static tree
 509 remap_blocks (tree block, copy_body_data *id)
 510 {
 511   tree t;
 512   tree new = block;
 513
 514   if (!block)
 515     return NULL;
 516
 517   remap_block (&new, id);
 518   gcc_assert (new != block);
 519   for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
 520     add_lexical_block (new, remap_blocks (t, id));
 521   return new;
 522 }
 523
 524 static void
 525 copy_statement_list (tree *tp)
 526 {
 527   tree_stmt_iterator oi, ni;
 528   tree new;
 529
 530   new = alloc_stmt_list ();
 531   ni = tsi_start (new);
 532   oi = tsi_start (*tp);
 533   *tp = new;
 534
 535   for (; !tsi_end_p (oi); tsi_next (&oi))
 536     tsi_link_after (&ni, tsi_stmt (oi), TSI_NEW_STMT);
 537 }
 538
 539 static void
 540 copy_bind_expr (tree *tp, int *walk_subtrees, copy_body_data *id)
 541 {
 542   tree block = BIND_EXPR_BLOCK (*tp);
 543   /* Copy (and replace) the statement.  */
 544   copy_tree_r (tp, walk_subtrees, NULL);
 545   if (block)
 546     {
 547       remap_block (&block, id);
 548       BIND_EXPR_BLOCK (*tp) = block;
 549     }
 550
 551   if (BIND_EXPR_VARS (*tp))
 552     /* This will remap a lot of the same decls again, but this should be
 553        harmless.  */
 554     BIND_EXPR_VARS (*tp) = remap_decls (BIND_EXPR_VARS (*tp), id);
 555 }
 556
 557 /* Called from copy_body_id via walk_tree.  DATA is really an
 558    `copy_body_data *'.  */
 559
 560 tree
 561 copy_body_r (tree *tp, int *walk_subtrees, void *data)
 562 {
 563   copy_body_data *id = (copy_body_data *) data;
 564   tree fn = id->src_fn;
 565   tree new_block;
 566
 567   /* Begin by recognizing trees that we'll completely rewrite for the
 568      inlining context.  Our output for these trees is completely
 569      different from out input (e.g. RETURN_EXPR is deleted, and morphs
 570      into an edge).  Further down, we'll handle trees that get
 571      duplicated and/or tweaked.  */
 572
 573   /* When requested, RETURN_EXPRs should be transformed to just the
 574      contained GIMPLE_MODIFY_STMT.  The branch semantics of the return will
 575      be handled elsewhere by manipulating the CFG rather than a statement.  */
 576   if (TREE_CODE (*tp) == RETURN_EXPR && id->transform_return_to_modify)
 577     {
 578       tree assignment = TREE_OPERAND (*tp, 0);
 579
 580       /* If we're returning something, just turn that into an
 581          assignment into the equivalent of the original RESULT_DECL.
 582          If the "assignment" is just the result decl, the result
 583          decl has already been set (e.g. a recent "foo (&result_decl,
 584          ...)"); just toss the entire RETURN_EXPR.  */
 585       if (assignment && TREE_CODE (assignment) == GIMPLE_MODIFY_STMT)
 586         {
 587           /* Replace the RETURN_EXPR with (a copy of) the
 588              GIMPLE_MODIFY_STMT hanging underneath.  */
 589           *tp = copy_node (assignment);
 590         }
 591       else /* Else the RETURN_EXPR returns no value.  */
 592         {
 593           *tp = NULL;
 594           return (tree) (void *)1;
 595         }
 596     }
 597   else if (TREE_CODE (*tp) == SSA_NAME)
 598     {
 599       *tp = remap_ssa_name (*tp, id);
 600       *walk_subtrees = 0;
 601       return NULL;
 602     }
 603
 604   /* Local variables and labels need to be replaced by equivalent
 605      variables.  We don't want to copy static variables; there's only
 606      one of those, no matter how many times we inline the containing
 607      function.  Similarly for globals from an outer function.  */
 608   else if (auto_var_in_fn_p (*tp, fn))
 609     {
 610       tree new_decl;
 611
 612       /* Remap the declaration.  */
 613       new_decl = remap_decl (*tp, id);
 614       gcc_assert (new_decl);
 615       /* Replace this variable with the copy.  */
 616       STRIP_TYPE_NOPS (new_decl);
 617       *tp = new_decl;
 618       *walk_subtrees = 0;
 619     }
 620   else if (TREE_CODE (*tp) == STATEMENT_LIST)
 621     copy_statement_list (tp);
 622   else if (TREE_CODE (*tp) == SAVE_EXPR)
 623     remap_save_expr (tp, id->decl_map, walk_subtrees);
 624   else if (TREE_CODE (*tp) == LABEL_DECL
 625            && (! DECL_CONTEXT (*tp)
 626                || decl_function_context (*tp) == id->src_fn))
 627     /* These may need to be remapped for EH handling.  */
 628     *tp = remap_decl (*tp, id);
 629   else if (TREE_CODE (*tp) == BIND_EXPR)
 630     copy_bind_expr (tp, walk_subtrees, id);
 631   /* Types may need remapping as well.  */
 632   else if (TYPE_P (*tp))
 633     *tp = remap_type (*tp, id);
 634
 635   /* If this is a constant, we have to copy the node iff the type will be
 636      remapped.  copy_tree_r will not copy a constant.  */
 637   else if (CONSTANT_CLASS_P (*tp))
 638     {
 639       tree new_type = remap_type (TREE_TYPE (*tp), id);
 640
 641       if (new_type == TREE_TYPE (*tp))
 642         *walk_subtrees = 0;
 643
 644       else if (TREE_CODE (*tp) == INTEGER_CST)
 645         *tp = build_int_cst_wide (new_type, TREE_INT_CST_LOW (*tp),
 646                                   TREE_INT_CST_HIGH (*tp));
 647       else
 648         {
 649           *tp = copy_node (*tp);
 650           TREE_TYPE (*tp) = new_type;
 651         }
 652     }
 653
 654   /* Otherwise, just copy the node.  Note that copy_tree_r already
 655      knows not to copy VAR_DECLs, etc., so this is safe.  */
 656   else
 657     {
 658       /* Here we handle trees that are not completely rewritten.
 659          First we detect some inlining-induced bogosities for
 660          discarding.  */
 661       if (TREE_CODE (*tp) == GIMPLE_MODIFY_STMT
 662           && GIMPLE_STMT_OPERAND (*tp, 0) == GIMPLE_STMT_OPERAND (*tp, 1)
 663           && (auto_var_in_fn_p (GIMPLE_STMT_OPERAND (*tp, 0), fn)))
 664         {
 665           /* Some assignments VAR = VAR; don't generate any rtl code
 666              and thus don't count as variable modification.  Avoid
 667              keeping bogosities like 0 = 0.  */
 668           tree decl = GIMPLE_STMT_OPERAND (*tp, 0), value;
 669           tree *n;
 670
 671           n = (tree *) pointer_map_contains (id->decl_map, decl);
 672           if (n)
 673             {
 674               value = *n;
 675               STRIP_TYPE_NOPS (value);
 676               if (TREE_CONSTANT (value) || TREE_READONLY_DECL_P (value))
 677                 {
 678                   *tp = build_empty_stmt ();
 679                   return copy_body_r (tp, walk_subtrees, data);
 680                 }
 681             }
 682         }
 683       else if (TREE_CODE (*tp) == INDIRECT_REF)
 684         {
 685           /* Get rid of *& from inline substitutions that can happen when a
 686              pointer argument is an ADDR_EXPR.  */
 687           tree decl = TREE_OPERAND (*tp, 0);
 688           tree *n;
 689
 690           n = (tree *) pointer_map_contains (id->decl_map, decl);
 691           if (n)
 692             {
 693               tree new;
 694               tree old;
 695               /* If we happen to get an ADDR_EXPR in n->value, strip
 696                  it manually here as we'll eventually get ADDR_EXPRs
 697                  which lie about their types pointed to.  In this case
 698                  build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
 699                  but we absolutely rely on that.  As fold_indirect_ref
 700                  does other useful transformations, try that first, though.  */
 701               tree type = TREE_TYPE (TREE_TYPE (*n));
 702               new = unshare_expr (*n);
 703               old = *tp;
 704               *tp = gimple_fold_indirect_ref (new);
 705               if (! *tp)
 706                 {
 707                   if (TREE_CODE (new) == ADDR_EXPR)
 708                     {
 709                       *tp = fold_indirect_ref_1 (type, new);
 710                       /* ???  We should either assert here or build
 711                          a VIEW_CONVERT_EXPR instead of blindly leaking
 712                          incompatible types to our IL.  */
 713                       if (! *tp)
 714                         *tp = TREE_OPERAND (new, 0);
 715                     }
 716                   else
 717                     {
 718                       *tp = build1 (INDIRECT_REF, type, new);
 719                       TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old);
 720                     }
 721                 }
 722               *walk_subtrees = 0;
 723               return NULL;
 724             }
 725         }
 726
 727       /* Here is the "usual case".  Copy this tree node, and then
 728          tweak some special cases.  */
 729       copy_tree_r (tp, walk_subtrees, NULL);
 730
 731       /* Global variables we haven't seen yet needs to go into referenced
 732          vars.  If not referenced from types only.  */
 733       if (gimple_in_ssa_p (cfun) && TREE_CODE (*tp) == VAR_DECL
 734           && id->remapping_type_depth == 0)
 735         add_referenced_var (*tp);
 736
 737       /* If EXPR has block defined, map it to newly constructed block.
 738          When inlining we want EXPRs without block appear in the block
 739          of function call.  */
 740       if (EXPR_P (*tp) || GIMPLE_STMT_P (*tp))
 741         {
 742           new_block = id->block;
 743           if (TREE_BLOCK (*tp))
 744             {
 745               tree *n;
 746               n = (tree *) pointer_map_contains (id->decl_map,
 747                                                  TREE_BLOCK (*tp));
 748               gcc_assert (n);
 749               new_block = *n;
 750             }
 751           TREE_BLOCK (*tp) = new_block;
 752         }
 753
 754       if (TREE_CODE (*tp) == RESX_EXPR && id->eh_region_offset)
 755         TREE_OPERAND (*tp, 0) =
 756           build_int_cst
 757             (NULL_TREE,
 758              id->eh_region_offset + TREE_INT_CST_LOW (TREE_OPERAND (*tp, 0)));
 759
 760       if (!GIMPLE_TUPLE_P (*tp) && TREE_CODE (*tp) != OMP_CLAUSE)
 761         TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id);
 762
 763       /* The copied TARGET_EXPR has never been expanded, even if the
 764          original node was expanded already.  */
 765       if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3))
 766         {
 767           TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
 768           TREE_OPERAND (*tp, 3) = NULL_TREE;
 769         }
 770
 771       /* Variable substitution need not be simple.  In particular, the
 772          INDIRECT_REF substitution above.  Make sure that TREE_CONSTANT
 773          and friends are up-to-date.  */
 774       else if (TREE_CODE (*tp) == ADDR_EXPR)
 775         {
 776           int invariant = is_gimple_min_invariant (*tp);
 777           walk_tree (&TREE_OPERAND (*tp, 0), copy_body_r, id, NULL);
 778           /* Handle the case where we substituted an INDIRECT_REF
 779              into the operand of the ADDR_EXPR.  */
 780           if (TREE_CODE (TREE_OPERAND (*tp, 0)) == INDIRECT_REF)
 781             *tp = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0);
 782           else
 783             recompute_tree_invariant_for_addr_expr (*tp);
 784           /* If this used to be invariant, but is not any longer,
 785              then regimplification is probably needed.  */
 786           if (invariant && !is_gimple_min_invariant (*tp))
 787             id->regimplify = true;
 788           *walk_subtrees = 0;
 789         }
 790     }
 791
 792   /* Keep iterating.  */
 793   return NULL_TREE;
 794 }
 795
 796 /* Copy basic block, scale profile accordingly.  Edges will be taken care of
 797    later  */
 798
 799 static basic_block
 800 copy_bb (copy_body_data *id, basic_block bb, int frequency_scale, int count_scale)
 801 {
 802   block_stmt_iterator bsi, copy_bsi;
 803   basic_block copy_basic_block;
 804
 805   /* create_basic_block() will append every new block to
 806      basic_block_info automatically.  */
 807   copy_basic_block = create_basic_block (NULL, (void *) 0,
 808                                          (basic_block) bb->prev_bb->aux);
 809   copy_basic_block->count = bb->count * count_scale / REG_BR_PROB_BASE;
 810
 811   /* We are going to rebuild frequencies from scratch.  These values have just
 812      small importance to drive canonicalize_loop_headers.  */
 813   copy_basic_block->frequency = ((gcov_type)bb->frequency
 814                                      * frequency_scale / REG_BR_PROB_BASE);
 815   if (copy_basic_block->frequency > BB_FREQ_MAX)
 816     copy_basic_block->frequency = BB_FREQ_MAX;
 817   copy_bsi = bsi_start (copy_basic_block);
 818
 819   for (bsi = bsi_start (bb);
 820        !bsi_end_p (bsi); bsi_next (&bsi))
 821     {
 822       tree stmt = bsi_stmt (bsi);
 823       tree orig_stmt = stmt;
 824
 825       id->regimplify = false;
 826       walk_tree (&stmt, copy_body_r, id, NULL);
 827
 828       /* RETURN_EXPR might be removed,
 829          this is signalled by making stmt pointer NULL.  */
 830       if (stmt)
 831         {
 832           tree call, decl;
 833
 834           gimple_duplicate_stmt_histograms (cfun, stmt, id->src_cfun, orig_stmt);
 835
 836           /* With return slot optimization we can end up with
 837              non-gimple (foo *)&this->m, fix that here.  */
 838           if ((TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
 839                && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) == NOP_EXPR
 840                && !is_gimple_val (TREE_OPERAND (GIMPLE_STMT_OPERAND (stmt, 1), 0)))
 841               || id->regimplify)
 842             gimplify_stmt (&stmt);
 843
 844           bsi_insert_after (&copy_bsi, stmt, BSI_NEW_STMT);
 845
 846           /* Process new statement.  gimplify_stmt possibly turned statement
 847              into multiple statements, we need to process all of them.  */
 848           while (!bsi_end_p (copy_bsi))
 849             {
 850               tree *stmtp = bsi_stmt_ptr (copy_bsi);
 851               tree stmt = *stmtp;
 852               call = get_call_expr_in (stmt);
 853
 854               if (call && CALL_EXPR_VA_ARG_PACK (call) && id->call_expr)
 855                 {
 856                   /* __builtin_va_arg_pack () should be replaced by
 857                      all arguments corresponding to ... in the caller.  */
 858                   tree p, *argarray, new_call, *call_ptr;
 859                   int nargs = call_expr_nargs (id->call_expr);
 860
 861                   for (p = DECL_ARGUMENTS (id->src_fn); p; p = TREE_CHAIN (p))
 862                     nargs--;
 863
 864                   argarray = (tree *) alloca ((nargs + call_expr_nargs (call))
 865                                               * sizeof (tree));
 866
 867                   memcpy (argarray, CALL_EXPR_ARGP (call),
 868                           call_expr_nargs (call) * sizeof (*argarray));
 869                   memcpy (argarray + call_expr_nargs (call),
 870                           CALL_EXPR_ARGP (id->call_expr)
 871                           + (call_expr_nargs (id->call_expr) - nargs),
 872                           nargs * sizeof (*argarray));
 873
 874                   new_call = build_call_array (TREE_TYPE (call),
 875                                                CALL_EXPR_FN (call),
 876                                                nargs + call_expr_nargs (call),
 877                                                argarray);
 878                   /* Copy all CALL_EXPR flags, locus and block, except
 879                      CALL_EXPR_VA_ARG_PACK flag.  */
 880                   CALL_EXPR_STATIC_CHAIN (new_call)
 881                     = CALL_EXPR_STATIC_CHAIN (call);
 882                   CALL_EXPR_TAILCALL (new_call) = CALL_EXPR_TAILCALL (call);
 883                   CALL_EXPR_RETURN_SLOT_OPT (new_call)
 884                     = CALL_EXPR_RETURN_SLOT_OPT (call);
 885                   CALL_FROM_THUNK_P (new_call) = CALL_FROM_THUNK_P (call);
 886                   CALL_CANNOT_INLINE_P (new_call)
 887                     = CALL_CANNOT_INLINE_P (call);
 888                   TREE_NOTHROW (new_call) = TREE_NOTHROW (call);
 889                   SET_EXPR_LOCUS (new_call, EXPR_LOCUS (call));
 890                   TREE_BLOCK (new_call) = TREE_BLOCK (call);
 891
 892                   call_ptr = stmtp;
 893                   if (TREE_CODE (*call_ptr) == GIMPLE_MODIFY_STMT)
 894                     call_ptr = &GIMPLE_STMT_OPERAND (*call_ptr, 1);
 895                   if (TREE_CODE (*call_ptr) == WITH_SIZE_EXPR)
 896                     call_ptr = &TREE_OPERAND (*call_ptr, 0);
 897                   gcc_assert (*call_ptr == call);
 898                   if (call_ptr == stmtp)
 899                     {
 900                       bsi_replace (&copy_bsi, new_call, true);
 901                       stmtp = bsi_stmt_ptr (copy_bsi);
 902                       stmt = *stmtp;
 903                     }
 904                   else
 905                     {
 906                       *call_ptr = new_call;
 907                       stmt = *stmtp;
 908                       update_stmt (stmt);
 909                     }
 910                 }
 911               else if (call
 912                        && id->call_expr
 913                        && (decl = get_callee_fndecl (call))
 914                        && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
 915                        && DECL_FUNCTION_CODE (decl)
 916                           == BUILT_IN_VA_ARG_PACK_LEN)
 917                 {
 918                   /* __builtin_va_arg_pack_len () should be replaced by
 919                      the number of anonymous arguments.  */
 920                   int nargs = call_expr_nargs (id->call_expr);
 921                   tree count, *call_ptr, p;
 922
 923                   for (p = DECL_ARGUMENTS (id->src_fn); p; p = TREE_CHAIN (p))
 924                     nargs--;
 925
 926                   count = build_int_cst (integer_type_node, nargs);
 927                   call_ptr = stmtp;
 928                   if (TREE_CODE (*call_ptr) == GIMPLE_MODIFY_STMT)
 929                     call_ptr = &GIMPLE_STMT_OPERAND (*call_ptr, 1);
 930                   if (TREE_CODE (*call_ptr) == WITH_SIZE_EXPR)
 931                     call_ptr = &TREE_OPERAND (*call_ptr, 0);
 932                   gcc_assert (*call_ptr == call && call_ptr != stmtp);
 933                   *call_ptr = count;
 934                   stmt = *stmtp;
 935                   update_stmt (stmt);
 936                   call = NULL_TREE;
 937                 }
 938
 939               /* Statements produced by inlining can be unfolded, especially
 940                  when we constant propagated some operands.  We can't fold
 941                  them right now for two reasons:
 942                  1) folding require SSA_NAME_DEF_STMTs to be correct
 943                  2) we can't change function calls to builtins.
 944                  So we just mark statement for later folding.  We mark
 945                  all new statements, instead just statements that has changed
 946                  by some nontrivial substitution so even statements made
 947                  foldable indirectly are updated.  If this turns out to be
 948                  expensive, copy_body can be told to watch for nontrivial
 949                  changes.  */
 950               if (id->statements_to_fold)
 951                 pointer_set_insert (id->statements_to_fold, stmt);
 952               /* We're duplicating a CALL_EXPR.  Find any corresponding
 953                  callgraph edges and update or duplicate them.  */
 954               if (call && (decl = get_callee_fndecl (call)))
 955                 {
 956                   struct cgraph_node *node;
 957                   struct cgraph_edge *edge;
 958
 959                   switch (id->transform_call_graph_edges)
 960                     {
 961                     case CB_CGE_DUPLICATE:
 962                       edge = cgraph_edge (id->src_node, orig_stmt);
 963                       if (edge)
 964                         cgraph_clone_edge (edge, id->dst_node, stmt,
 965                                            REG_BR_PROB_BASE, 1, edge->frequency, true);
 966                       break;
 967
 968                     case CB_CGE_MOVE_CLONES:
 969                       for (node = id->dst_node->next_clone;
 970                            node;
 971                            node = node->next_clone)
 972                         {
 973                           edge = cgraph_edge (node, orig_stmt);
 974                           gcc_assert (edge);
 975                           cgraph_set_call_stmt (edge, stmt);
 976                         }
 977                       /* FALLTHRU */
 978
 979                     case CB_CGE_MOVE:
 980                       edge = cgraph_edge (id->dst_node, orig_stmt);
 981                       if (edge)
 982                         cgraph_set_call_stmt (edge, stmt);
 983                       break;
 984
 985                     default:
 986                       gcc_unreachable ();
 987                     }
 988                 }
 989               /* If you think we can abort here, you are wrong.
 990                  There is no region 0 in tree land.  */
 991               gcc_assert (lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt)
 992                           != 0);
 993
 994               if (tree_could_throw_p (stmt)
 995                   /* When we are cloning for inlining, we are supposed to
 996                      construct a clone that calls precisely the same functions
 997                      as original.  However IPA optimizers might've proved
 998                      earlier some function calls as non-trapping that might
 999                      render some basic blocks dead that might become
1000                      unreachable.
1001
1002                      We can't update SSA with unreachable blocks in CFG and thus
1003                      we prevent the scenario by preserving even the "dead" eh
1004                      edges until the point they are later removed by
1005                      fixup_cfg pass.  */
1006                   || (id->transform_call_graph_edges == CB_CGE_MOVE_CLONES
1007                       && lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt) > 0))
1008                 {
1009                   int region = lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt);
1010                   /* Add an entry for the copied tree in the EH hashtable.
1011                      When cloning or versioning, use the hashtable in
1012                      cfun, and just copy the EH number.  When inlining, use the
1013                      hashtable in the caller, and adjust the region number.  */
1014                   if (region > 0)
1015                     add_stmt_to_eh_region (stmt, region + id->eh_region_offset);
1016
1017                   /* If this tree doesn't have a region associated with it,
1018                      and there is a "current region,"
1019                      then associate this tree with the current region
1020                      and add edges associated with this region.  */
1021                   if ((lookup_stmt_eh_region_fn (id->src_cfun,
1022                                                  orig_stmt) <= 0
1023                        && id->eh_region > 0)
1024                       && tree_could_throw_p (stmt))
1025                     add_stmt_to_eh_region (stmt, id->eh_region);
1026                 }
1027               if (gimple_in_ssa_p (cfun))
1028                 {
1029                    ssa_op_iter i;
1030                    tree def;
1031
1032                    find_new_referenced_vars (bsi_stmt_ptr (copy_bsi));
1033                    FOR_EACH_SSA_TREE_OPERAND (def, stmt, i, SSA_OP_DEF)
1034                     if (TREE_CODE (def) == SSA_NAME)
1035                       SSA_NAME_DEF_STMT (def) = stmt;
1036                 }
1037               bsi_next (&copy_bsi);
1038             }
1039           copy_bsi = bsi_last (copy_basic_block);
1040         }
1041     }
1042   return copy_basic_block;
1043 }
1044
1045 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
1046    form is quite easy, since dominator relationship for old basic blocks does
1047    not change.
1048
1049    There is however exception where inlining might change dominator relation
1050    across EH edges from basic block within inlined functions destinating
1051    to landing pads in function we inline into.
1052
1053    The function fills in PHI_RESULTs of such PHI nodes if they refer
1054    to gimple regs.  Otherwise, the function mark PHI_RESULT of such
1055    PHI nodes for renaming.  For non-gimple regs, renaming is safe: the
1056    EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
1057    set, and this means that there will be no overlapping live ranges
1058    for the underlying symbol.
1059
1060    This might change in future if we allow redirecting of EH edges and
1061    we might want to change way build CFG pre-inlining to include
1062    all the possible edges then.  */
1063 static void
1064 update_ssa_across_abnormal_edges (basic_block bb, basic_block ret_bb,
1065                                   bool can_throw, bool nonlocal_goto)
1066 {
1067   edge e;
1068   edge_iterator ei;
1069
1070   FOR_EACH_EDGE (e, ei, bb->succs)
1071     if (!e->dest->aux
1072         || ((basic_block)e->dest->aux)->index == ENTRY_BLOCK)
1073       {
1074         tree phi;
1075
1076         gcc_assert (e->flags & EDGE_ABNORMAL);
1077         if (!nonlocal_goto)
1078           gcc_assert (e->flags & EDGE_EH);
1079         if (!can_throw)
1080           gcc_assert (!(e->flags & EDGE_EH));
1081         for (phi = phi_nodes (e->dest); phi; phi = PHI_CHAIN (phi))
1082           {
1083             edge re;
1084
1085             /* There shouldn't be any PHI nodes in the ENTRY_BLOCK.  */
1086             gcc_assert (!e->dest->aux);
1087
1088             gcc_assert (SSA_NAME_OCCURS_IN_ABNORMAL_PHI
1089                         (PHI_RESULT (phi)));
1090
1091             if (!is_gimple_reg (PHI_RESULT (phi)))
1092               {
1093                 mark_sym_for_renaming
1094                   (SSA_NAME_VAR (PHI_RESULT (phi)));
1095                 continue;
1096               }
1097
1098             re = find_edge (ret_bb, e->dest);
1099             gcc_assert (re);
1100             gcc_assert ((re->flags & (EDGE_EH | EDGE_ABNORMAL))
1101                         == (e->flags & (EDGE_EH | EDGE_ABNORMAL)));
1102
1103             SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi, e),
1104                      USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi, re)));
1105           }
1106       }
1107 }
1108
1109 /* Copy edges from BB into its copy constructed earlier, scale profile
1110    accordingly.  Edges will be taken care of later.  Assume aux
1111    pointers to point to the copies of each BB.  */
1112 static void
1113 copy_edges_for_bb (basic_block bb, int count_scale, basic_block ret_bb)
1114 {
1115   basic_block new_bb = (basic_block) bb->aux;
1116   edge_iterator ei;
1117   edge old_edge;
1118   block_stmt_iterator bsi;
1119   int flags;
1120
1121   /* Use the indices from the original blocks to create edges for the
1122      new ones.  */
1123   FOR_EACH_EDGE (old_edge, ei, bb->succs)
1124     if (!(old_edge->flags & EDGE_EH))
1125       {
1126         edge new;
1127
1128         flags = old_edge->flags;
1129
1130         /* Return edges do get a FALLTHRU flag when the get inlined.  */
1131         if (old_edge->dest->index == EXIT_BLOCK && !old_edge->flags
1132             && old_edge->dest->aux != EXIT_BLOCK_PTR)
1133           flags |= EDGE_FALLTHRU;
1134         new = make_edge (new_bb, (basic_block) old_edge->dest->aux, flags);
1135         new->count = old_edge->count * count_scale / REG_BR_PROB_BASE;
1136         new->probability = old_edge->probability;
1137       }
1138
1139   if (bb->index == ENTRY_BLOCK || bb->index == EXIT_BLOCK)
1140     return;
1141
1142   for (bsi = bsi_start (new_bb); !bsi_end_p (bsi);)
1143     {
1144       tree copy_stmt;
1145       bool can_throw, nonlocal_goto;
1146
1147       copy_stmt = bsi_stmt (bsi);
1148       update_stmt (copy_stmt);
1149       if (gimple_in_ssa_p (cfun))
1150         mark_symbols_for_renaming (copy_stmt);
1151       /* Do this before the possible split_block.  */
1152       bsi_next (&bsi);
1153
1154       /* If this tree could throw an exception, there are two
1155          cases where we need to add abnormal edge(s): the
1156          tree wasn't in a region and there is a "current
1157          region" in the caller; or the original tree had
1158          EH edges.  In both cases split the block after the tree,
1159          and add abnormal edge(s) as needed; we need both
1160          those from the callee and the caller.
1161          We check whether the copy can throw, because the const
1162          propagation can change an INDIRECT_REF which throws
1163          into a COMPONENT_REF which doesn't.  If the copy
1164          can throw, the original could also throw.  */
1165
1166       can_throw = tree_can_throw_internal (copy_stmt);
1167       nonlocal_goto = tree_can_make_abnormal_goto (copy_stmt);
1168
1169       if (can_throw || nonlocal_goto)
1170         {
1171           if (!bsi_end_p (bsi))
1172             /* Note that bb's predecessor edges aren't necessarily
1173                right at this point; split_block doesn't care.  */
1174             {
1175               edge e = split_block (new_bb, copy_stmt);
1176
1177               new_bb = e->dest;
1178               new_bb->aux = e->src->aux;
1179               bsi = bsi_start (new_bb);
1180             }
1181         }
1182
1183       if (can_throw)
1184         make_eh_edges (copy_stmt);
1185
1186       if (nonlocal_goto)
1187         make_abnormal_goto_edges (bb_for_stmt (copy_stmt), true);
1188
1189       if ((can_throw || nonlocal_goto)
1190           && gimple_in_ssa_p (cfun))
1191         update_ssa_across_abnormal_edges (bb_for_stmt (copy_stmt), ret_bb,
1192                                           can_throw, nonlocal_goto);
1193     }
1194 }
1195
1196 /* Copy the PHIs.  All blocks and edges are copied, some blocks
1197    was possibly split and new outgoing EH edges inserted.
1198    BB points to the block of original function and AUX pointers links
1199    the original and newly copied blocks.  */
1200
1201 static void
1202 copy_phis_for_bb (basic_block bb, copy_body_data *id)
1203 {
1204   basic_block new_bb = bb->aux;
1205   edge_iterator ei;
1206   tree phi;
1207
1208   for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
1209     {
1210       tree res = PHI_RESULT (phi);
1211       tree new_res = res;
1212       tree new_phi;
1213       edge new_edge;
1214
1215       if (is_gimple_reg (res))
1216         {
1217           walk_tree (&new_res, copy_body_r, id, NULL);
1218           SSA_NAME_DEF_STMT (new_res)
1219             = new_phi = create_phi_node (new_res, new_bb);
1220           FOR_EACH_EDGE (new_edge, ei, new_bb->preds)
1221             {
1222               edge old_edge = find_edge (new_edge->src->aux, bb);
1223               tree arg = PHI_ARG_DEF_FROM_EDGE (phi, old_edge);
1224               tree new_arg = arg;
1225
1226               walk_tree (&new_arg, copy_body_r, id, NULL);
1227               gcc_assert (new_arg);
1228               /* With return slot optimization we can end up with
1229                  non-gimple (foo *)&this->m, fix that here.  */
1230               if (TREE_CODE (new_arg) != SSA_NAME
1231                   && TREE_CODE (new_arg) != FUNCTION_DECL
1232                   && !is_gimple_val (new_arg))
1233                 {
1234                   tree stmts = NULL_TREE;
1235                   new_arg = force_gimple_operand (new_arg, &stmts,
1236                                                   true, NULL);
1237                   bsi_insert_on_edge_immediate (new_edge, stmts);
1238                 }
1239               add_phi_arg (new_phi, new_arg, new_edge);
1240             }
1241         }
1242     }
1243 }
1244
1245 /* Wrapper for remap_decl so it can be used as a callback.  */
1246 static tree
1247 remap_decl_1 (tree decl, void *data)
1248 {
1249   return remap_decl (decl, (copy_body_data *) data);
1250 }
1251
1252 /* Build struct function and associated datastructures for the new clone
1253    NEW_FNDECL to be build.  CALLEE_FNDECL is the original */
1254
1255 static void
1256 initialize_cfun (tree new_fndecl, tree callee_fndecl, gcov_type count,
1257                  int frequency)
1258 {
1259   struct function *new_cfun
1260      = (struct function *) ggc_alloc_cleared (sizeof (struct function));
1261   struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
1262   int count_scale, frequency_scale;
1263
1264   if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count)
1265     count_scale = (REG_BR_PROB_BASE * count
1266                    / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count);
1267   else
1268     count_scale = 1;
1269
1270   if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency)
1271     frequency_scale = (REG_BR_PROB_BASE * frequency
1272                        /
1273                        ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency);
1274   else
1275     frequency_scale = count_scale;
1276
1277   /* Register specific tree functions.  */
1278   tree_register_cfg_hooks ();
1279   *new_cfun = *DECL_STRUCT_FUNCTION (callee_fndecl);
1280   new_cfun->funcdef_no = get_next_funcdef_no ();
1281   VALUE_HISTOGRAMS (new_cfun) = NULL;
1282   new_cfun->unexpanded_var_list = NULL;
1283   new_cfun->cfg = NULL;
1284   new_cfun->decl = new_fndecl /*= copy_node (callee_fndecl)*/;
1285   DECL_STRUCT_FUNCTION (new_fndecl) = new_cfun;
1286   push_cfun (new_cfun);
1287   init_empty_tree_cfg ();
1288
1289   ENTRY_BLOCK_PTR->count =
1290     (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count * count_scale /
1291      REG_BR_PROB_BASE);
1292   ENTRY_BLOCK_PTR->frequency =
1293     (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency *
1294      frequency_scale / REG_BR_PROB_BASE);
1295   EXIT_BLOCK_PTR->count =
1296     (EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count * count_scale /
1297      REG_BR_PROB_BASE);
1298   EXIT_BLOCK_PTR->frequency =
1299     (EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency *
1300      frequency_scale / REG_BR_PROB_BASE);
1301   if (src_cfun->eh)
1302     init_eh_for_function ();
1303
1304   if (src_cfun->gimple_df)
1305     {
1306       init_tree_ssa ();
1307       cfun->gimple_df->in_ssa_p = true;
1308       init_ssa_operands ();
1309     }
1310   pop_cfun ();
1311 }
1312
1313 /* Make a copy of the body of FN so that it can be inserted inline in
1314    another function.  Walks FN via CFG, returns new fndecl.  */
1315
1316 static tree
1317 copy_cfg_body (copy_body_data * id, gcov_type count, int frequency,
1318                basic_block entry_block_map, basic_block exit_block_map)
1319 {
1320   tree callee_fndecl = id->src_fn;
1321   /* Original cfun for the callee, doesn't change.  */
1322   struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
1323   struct function *cfun_to_copy;
1324   basic_block bb;
1325   tree new_fndecl = NULL;
1326   int count_scale, frequency_scale;
1327   int last;
1328
1329   if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count)
1330     count_scale = (REG_BR_PROB_BASE * count
1331                    / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count);
1332   else
1333     count_scale = 1;
1334
1335   if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency)
1336     frequency_scale = (REG_BR_PROB_BASE * frequency
1337                        /
1338                        ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency);
1339   else
1340     frequency_scale = count_scale;
1341
1342   /* Register specific tree functions.  */
1343   tree_register_cfg_hooks ();
1344
1345   /* Must have a CFG here at this point.  */
1346   gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION
1347               (DECL_STRUCT_FUNCTION (callee_fndecl)));
1348
1349   cfun_to_copy = id->src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
1350
1351
1352   ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy)->aux = entry_block_map;
1353   EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy)->aux = exit_block_map;
1354   entry_block_map->aux = ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy);
1355   exit_block_map->aux = EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy);
1356
1357   /* Duplicate any exception-handling regions.  */
1358   if (cfun->eh)
1359     {
1360       id->eh_region_offset
1361         = duplicate_eh_regions (cfun_to_copy, remap_decl_1, id,
1362                                 0, id->eh_region);
1363     }
1364   /* Use aux pointers to map the original blocks to copy.  */
1365   FOR_EACH_BB_FN (bb, cfun_to_copy)
1366     {
1367       basic_block new = copy_bb (id, bb, frequency_scale, count_scale);
1368       bb->aux = new;
1369       new->aux = bb;
1370     }
1371
1372   last = last_basic_block;
1373   /* Now that we've duplicated the blocks, duplicate their edges.  */
1374   FOR_ALL_BB_FN (bb, cfun_to_copy)
1375     copy_edges_for_bb (bb, count_scale, exit_block_map);
1376   if (gimple_in_ssa_p (cfun))
1377     FOR_ALL_BB_FN (bb, cfun_to_copy)
1378       copy_phis_for_bb (bb, id);
1379   FOR_ALL_BB_FN (bb, cfun_to_copy)
1380     {
1381       ((basic_block)bb->aux)->aux = NULL;
1382       bb->aux = NULL;
1383     }
1384   /* Zero out AUX fields of newly created block during EH edge
1385      insertion. */
1386   for (; last < last_basic_block; last++)
1387     BASIC_BLOCK (last)->aux = NULL;
1388   entry_block_map->aux = NULL;
1389   exit_block_map->aux = NULL;
1390
1391   return new_fndecl;
1392 }
1393
1394 /* Make a copy of the body of FN so that it can be inserted inline in
1395    another function.  */
1396
1397 static tree
1398 copy_generic_body (copy_body_data *id)
1399 {
1400   tree body;
1401   tree fndecl = id->src_fn;
1402
1403   body = DECL_SAVED_TREE (fndecl);
1404   walk_tree (&body, copy_body_r, id, NULL);
1405
1406   return body;
1407 }
1408
1409 static tree
1410 copy_body (copy_body_data *id, gcov_type count, int frequency,
1411            basic_block entry_block_map, basic_block exit_block_map)
1412 {
1413   tree fndecl = id->src_fn;
1414   tree body;
1415
1416   /* If this body has a CFG, walk CFG and copy.  */
1417   gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (fndecl)));
1418   body = copy_cfg_body (id, count, frequency, entry_block_map, exit_block_map);
1419
1420   return body;
1421 }
1422
1423 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
1424    defined in function FN, or of a data member thereof.  */
1425
1426 static bool
1427 self_inlining_addr_expr (tree value, tree fn)
1428 {
1429   tree var;
1430
1431   if (TREE_CODE (value) != ADDR_EXPR)
1432     return false;
1433
1434   var = get_base_address (TREE_OPERAND (value, 0));
1435
1436   return var && auto_var_in_fn_p (var, fn);
1437 }
1438
1439 static void
1440 setup_one_parameter (copy_body_data *id, tree p, tree value, tree fn,
1441                      basic_block bb, tree *vars)
1442 {
1443   tree init_stmt;
1444   tree var;
1445   tree var_sub;
1446   tree rhs = value;
1447   tree def = (gimple_in_ssa_p (cfun)
1448               ? gimple_default_def (id->src_cfun, p) : NULL);
1449
1450   if (value
1451       && value != error_mark_node
1452       && !useless_type_conversion_p (TREE_TYPE (p), TREE_TYPE (value)))
1453     {
1454       if (fold_convertible_p (TREE_TYPE (p), value))
1455         rhs = fold_build1 (NOP_EXPR, TREE_TYPE (p), value);
1456       else
1457         /* ???  For valid (GIMPLE) programs we should not end up here.
1458            Still if something has gone wrong and we end up with truly
1459            mismatched types here, fall back to using a VIEW_CONVERT_EXPR
1460            to not leak invalid GIMPLE to the following passes.  */
1461         rhs = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (p), value);
1462     }
1463
1464   /* If the parameter is never assigned to, has no SSA_NAMEs created,
1465      we may not need to create a new variable here at all.  Instead, we may
1466      be able to just use the argument value.  */
1467   if (TREE_READONLY (p)
1468       && !TREE_ADDRESSABLE (p)
1469       && value && !TREE_SIDE_EFFECTS (value)
1470       && !def)
1471     {
1472       /* We may produce non-gimple trees by adding NOPs or introduce
1473          invalid sharing when operand is not really constant.
1474          It is not big deal to prohibit constant propagation here as
1475          we will constant propagate in DOM1 pass anyway.  */
1476       if (is_gimple_min_invariant (value)
1477           && useless_type_conversion_p (TREE_TYPE (p),
1478                                                  TREE_TYPE (value))
1479           /* We have to be very careful about ADDR_EXPR.  Make sure
1480              the base variable isn't a local variable of the inlined
1481              function, e.g., when doing recursive inlining, direct or
1482              mutually-recursive or whatever, which is why we don't
1483              just test whether fn == current_function_decl.  */
1484           && ! self_inlining_addr_expr (value, fn))
1485         {
1486           insert_decl_map (id, p, value);
1487           return;
1488         }
1489     }
1490
1491   /* Make an equivalent VAR_DECL.  Note that we must NOT remap the type
1492      here since the type of this decl must be visible to the calling
1493      function.  */
1494   var = copy_decl_to_var (p, id);
1495   if (gimple_in_ssa_p (cfun) && TREE_CODE (var) == VAR_DECL)
1496     {
1497       get_var_ann (var);
1498       add_referenced_var (var);
1499     }
1500
1501   /* See if the frontend wants to pass this by invisible reference.  If
1502      so, our new VAR_DECL will have REFERENCE_TYPE, and we need to
1503      replace uses of the PARM_DECL with dereferences.  */
1504   if (TREE_TYPE (var) != TREE_TYPE (p)
1505       && POINTER_TYPE_P (TREE_TYPE (var))
1506       && TREE_TYPE (TREE_TYPE (var)) == TREE_TYPE (p))
1507     {
1508       insert_decl_map (id, var, var);
1509       var_sub = build_fold_indirect_ref (var);
1510     }
1511   else
1512     var_sub = var;
1513
1514   /* Register the VAR_DECL as the equivalent for the PARM_DECL;
1515      that way, when the PARM_DECL is encountered, it will be
1516      automatically replaced by the VAR_DECL.  */
1517   insert_decl_map (id, p, var_sub);
1518
1519   /* Declare this new variable.  */
1520   TREE_CHAIN (var) = *vars;
1521   *vars = var;
1522
1523   /* Make gimplifier happy about this variable.  */
1524   DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
1525
1526   /* Even if P was TREE_READONLY, the new VAR should not be.
1527      In the original code, we would have constructed a
1528      temporary, and then the function body would have never
1529      changed the value of P.  However, now, we will be
1530      constructing VAR directly.  The constructor body may
1531      change its value multiple times as it is being
1532      constructed.  Therefore, it must not be TREE_READONLY;
1533      the back-end assumes that TREE_READONLY variable is
1534      assigned to only once.  */
1535   if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p)))
1536     TREE_READONLY (var) = 0;
1537
1538   /* If there is no setup required and we are in SSA, take the easy route
1539      replacing all SSA names representing the function parameter by the
1540      SSA name passed to function.
1541
1542      We need to construct map for the variable anyway as it might be used
1543      in different SSA names when parameter is set in function.
1544
1545      FIXME: This usually kills the last connection in between inlined
1546      function parameter and the actual value in debug info.  Can we do
1547      better here?  If we just inserted the statement, copy propagation
1548      would kill it anyway as it always did in older versions of GCC.
1549
1550      We might want to introduce a notion that single SSA_NAME might
1551      represent multiple variables for purposes of debugging. */
1552   if (gimple_in_ssa_p (cfun) && rhs && def && is_gimple_reg (p)
1553       && (TREE_CODE (rhs) == SSA_NAME
1554           || is_gimple_min_invariant (rhs))
1555       && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def))
1556     {
1557       insert_decl_map (id, def, rhs);
1558       return;
1559     }
1560
1561   /* If the value of argument is never used, don't care about initializing
1562      it.  */
1563   if (gimple_in_ssa_p (cfun) && !def && is_gimple_reg (p))
1564     {
1565       gcc_assert (!value || !TREE_SIDE_EFFECTS (value));
1566       return;
1567     }
1568
1569   /* Initialize this VAR_DECL from the equivalent argument.  Convert
1570      the argument to the proper type in case it was promoted.  */
1571   if (value)
1572     {
1573       block_stmt_iterator bsi = bsi_last (bb);
1574
1575       if (rhs == error_mark_node)
1576         {
1577           insert_decl_map (id, p, var_sub);
1578           return;
1579         }
1580
1581       STRIP_USELESS_TYPE_CONVERSION (rhs);
1582
1583       /* We want to use GIMPLE_MODIFY_STMT, not INIT_EXPR here so that we
1584          keep our trees in gimple form.  */
1585       if (def && gimple_in_ssa_p (cfun) && is_gimple_reg (p))
1586         {
1587           def = remap_ssa_name (def, id);
1588           init_stmt = build_gimple_modify_stmt (def, rhs);
1589           SSA_NAME_DEF_STMT (def) = init_stmt;
1590           SSA_NAME_IS_DEFAULT_DEF (def) = 0;
1591           set_default_def (var, NULL);
1592         }
1593       else
1594         init_stmt = build_gimple_modify_stmt (var, rhs);
1595
1596       /* If we did not create a gimple value and we did not create a gimple
1597          cast of a gimple value, then we will need to gimplify INIT_STMTS
1598          at the end.  Note that is_gimple_cast only checks the outer
1599          tree code, not its operand.  Thus the explicit check that its
1600          operand is a gimple value.  */
1601       if ((!is_gimple_val (rhs)
1602           && (!is_gimple_cast (rhs)
1603               || !is_gimple_val (TREE_OPERAND (rhs, 0))))
1604           || !is_gimple_reg (var))
1605         {
1606           tree_stmt_iterator i;
1607
1608           push_gimplify_context ();
1609           gimplify_stmt (&init_stmt);
1610           if (gimple_in_ssa_p (cfun)
1611               && init_stmt && TREE_CODE (init_stmt) == STATEMENT_LIST)
1612             {
1613               /* The replacement can expose previously unreferenced
1614                  variables.  */
1615               for (i = tsi_start (init_stmt); !tsi_end_p (i); tsi_next (&i))
1616                 find_new_referenced_vars (tsi_stmt_ptr (i));
1617              }
1618           pop_gimplify_context (NULL);
1619         }
1620
1621       /* If VAR represents a zero-sized variable, it's possible that the
1622          assignment statment may result in no gimple statements.  */
1623       if (init_stmt)
1624         bsi_insert_after (&bsi, init_stmt, BSI_NEW_STMT);
1625       if (gimple_in_ssa_p (cfun))
1626         for (;!bsi_end_p (bsi); bsi_next (&bsi))
1627           mark_symbols_for_renaming (bsi_stmt (bsi));
1628     }
1629 }
1630
1631 /* Generate code to initialize the parameters of the function at the
1632    top of the stack in ID from the CALL_EXPR EXP.  */
1633
1634 static void
1635 initialize_inlined_parameters (copy_body_data *id, tree exp,
1636                                tree fn, basic_block bb)
1637 {
1638   tree parms;
1639   tree a;
1640   tree p;
1641   tree vars = NULL_TREE;
1642   call_expr_arg_iterator iter;
1643   tree static_chain = CALL_EXPR_STATIC_CHAIN (exp);
1644
1645   /* Figure out what the parameters are.  */
1646   parms = DECL_ARGUMENTS (fn);
1647
1648   /* Loop through the parameter declarations, replacing each with an
1649      equivalent VAR_DECL, appropriately initialized.  */
1650   for (p = parms, a = first_call_expr_arg (exp, &iter); p;
1651        a = next_call_expr_arg (&iter), p = TREE_CHAIN (p))
1652     setup_one_parameter (id, p, a, fn, bb, &vars);
1653
1654   /* Initialize the static chain.  */
1655   p = DECL_STRUCT_FUNCTION (fn)->static_chain_decl;
1656   gcc_assert (fn != current_function_decl);
1657   if (p)
1658     {
1659       /* No static chain?  Seems like a bug in tree-nested.c.  */
1660       gcc_assert (static_chain);
1661
1662       setup_one_parameter (id, p, static_chain, fn, bb, &vars);
1663     }
1664
1665   declare_inline_vars (id->block, vars);
1666 }
1667
1668 /* Declare a return variable to replace the RESULT_DECL for the
1669    function we are calling.  An appropriate DECL_STMT is returned.
1670    The USE_STMT is filled to contain a use of the declaration to
1671    indicate the return value of the function.
1672
1673    RETURN_SLOT, if non-null is place where to store the result.  It
1674    is set only for CALL_EXPR_RETURN_SLOT_OPT.  MODIFY_DEST, if non-null,
1675    was the LHS of the GIMPLE_MODIFY_STMT to which this call is the RHS.
1676
1677    The return value is a (possibly null) value that is the result of the
1678    function as seen by the callee.  *USE_P is a (possibly null) value that
1679    holds the result as seen by the caller.  */
1680
1681 static tree
1682 declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest,
1683                          tree *use_p)
1684 {
1685   tree callee = id->src_fn;
1686   tree caller = id->dst_fn;
1687   tree result = DECL_RESULT (callee);
1688   tree callee_type = TREE_TYPE (result);
1689   tree caller_type = TREE_TYPE (TREE_TYPE (callee));
1690   tree var, use;
1691
1692   /* We don't need to do anything for functions that don't return
1693      anything.  */
1694   if (!result || VOID_TYPE_P (callee_type))
1695     {
1696       *use_p = NULL_TREE;
1697       return NULL_TREE;
1698     }
1699
1700   /* If there was a return slot, then the return value is the
1701      dereferenced address of that object.  */
1702   if (return_slot)
1703     {
1704       /* The front end shouldn't have used both return_slot and
1705          a modify expression.  */
1706       gcc_assert (!modify_dest);
1707       if (DECL_BY_REFERENCE (result))
1708         {
1709           tree return_slot_addr = build_fold_addr_expr (return_slot);
1710           STRIP_USELESS_TYPE_CONVERSION (return_slot_addr);
1711
1712           /* We are going to construct *&return_slot and we can't do that
1713              for variables believed to be not addressable.
1714
1715              FIXME: This check possibly can match, because values returned
1716              via return slot optimization are not believed to have address
1717              taken by alias analysis.  */
1718           gcc_assert (TREE_CODE (return_slot) != SSA_NAME);
1719           if (gimple_in_ssa_p (cfun))
1720             {
1721               HOST_WIDE_INT bitsize;
1722               HOST_WIDE_INT bitpos;
1723               tree offset;
1724               enum machine_mode mode;
1725               int unsignedp;
1726               int volatilep;
1727               tree base;
1728               base = get_inner_reference (return_slot, &bitsize, &bitpos,
1729                                           &offset,
1730                                           &mode, &unsignedp, &volatilep,
1731                                           false);
1732               if (TREE_CODE (base) == INDIRECT_REF)
1733                 base = TREE_OPERAND (base, 0);
1734               if (TREE_CODE (base) == SSA_NAME)
1735                 base = SSA_NAME_VAR (base);
1736               mark_sym_for_renaming (base);
1737             }
1738           var = return_slot_addr;
1739         }
1740       else
1741         {
1742           var = return_slot;
1743           gcc_assert (TREE_CODE (var) != SSA_NAME);
1744           TREE_ADDRESSABLE (var) |= TREE_ADDRESSABLE (result);
1745         }
1746       if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
1747            || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
1748           && !DECL_GIMPLE_REG_P (result)
1749           && DECL_P (var))
1750         DECL_GIMPLE_REG_P (var) = 0;
1751       use = NULL;
1752       goto done;
1753     }
1754
1755   /* All types requiring non-trivial constructors should have been handled.  */
1756   gcc_assert (!TREE_ADDRESSABLE (callee_type));
1757
1758   /* Attempt to avoid creating a new temporary variable.  */
1759   if (modify_dest
1760       && TREE_CODE (modify_dest) != SSA_NAME)
1761     {
1762       bool use_it = false;
1763
1764       /* We can't use MODIFY_DEST if there's type promotion involved.  */
1765       if (!useless_type_conversion_p (callee_type, caller_type))
1766         use_it = false;
1767
1768       /* ??? If we're assigning to a variable sized type, then we must
1769          reuse the destination variable, because we've no good way to
1770          create variable sized temporaries at this point.  */
1771       else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type)) != INTEGER_CST)
1772         use_it = true;
1773
1774       /* If the callee cannot possibly modify MODIFY_DEST, then we can
1775          reuse it as the result of the call directly.  Don't do this if
1776          it would promote MODIFY_DEST to addressable.  */
1777       else if (TREE_ADDRESSABLE (result))
1778         use_it = false;
1779       else
1780         {
1781           tree base_m = get_base_address (modify_dest);
1782
1783           /* If the base isn't a decl, then it's a pointer, and we don't
1784              know where that's going to go.  */
1785           if (!DECL_P (base_m))
1786             use_it = false;
1787           else if (is_global_var (base_m))
1788             use_it = false;
1789           else if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
1790                     || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
1791                    && !DECL_GIMPLE_REG_P (result)
1792                    && DECL_GIMPLE_REG_P (base_m))
1793             use_it = false;
1794           else if (!TREE_ADDRESSABLE (base_m))
1795             use_it = true;
1796         }
1797
1798       if (use_it)
1799         {
1800           var = modify_dest;
1801           use = NULL;
1802           goto done;
1803         }
1804     }
1805
1806   gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type)) == INTEGER_CST);
1807
1808   var = copy_result_decl_to_var (result, id);
1809   if (gimple_in_ssa_p (cfun))
1810     {
1811       get_var_ann (var);
1812       add_referenced_var (var);
1813     }
1814
1815   DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
1816   DECL_STRUCT_FUNCTION (caller)->unexpanded_var_list
1817     = tree_cons (NULL_TREE, var,
1818                  DECL_STRUCT_FUNCTION (caller)->unexpanded_var_list);
1819
1820   /* Do not have the rest of GCC warn about this variable as it should
1821      not be visible to the user.  */
1822   TREE_NO_WARNING (var) = 1;
1823
1824   declare_inline_vars (id->block, var);
1825
1826   /* Build the use expr.  If the return type of the function was
1827      promoted, convert it back to the expected type.  */
1828   use = var;
1829   if (!useless_type_conversion_p (caller_type, TREE_TYPE (var)))
1830     use = fold_convert (caller_type, var);
1831
1832   STRIP_USELESS_TYPE_CONVERSION (use);
1833
1834   if (DECL_BY_REFERENCE (result))
1835     var = build_fold_addr_expr (var);
1836
1837  done:
1838   /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
1839      way, when the RESULT_DECL is encountered, it will be
1840      automatically replaced by the VAR_DECL.  */
1841   insert_decl_map (id, result, var);
1842
1843   /* Remember this so we can ignore it in remap_decls.  */
1844   id->retvar = var;
1845
1846   *use_p = use;
1847   return var;
1848 }
1849
1850 /* Returns nonzero if a function can be inlined as a tree.  */
1851
1852 bool
1853 tree_inlinable_function_p (tree fn)
1854 {
1855   return inlinable_function_p (fn);
1856 }
1857
1858 static const char *inline_forbidden_reason;
1859
1860 static tree
1861 inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED,
1862                       void *fnp)
1863 {
1864   tree node = *nodep;
1865   tree fn = (tree) fnp;
1866   tree t;
1867
1868   switch (TREE_CODE (node))
1869     {
1870     case CALL_EXPR:
1871       /* Refuse to inline alloca call unless user explicitly forced so as
1872          this may change program's memory overhead drastically when the
1873          function using alloca is called in loop.  In GCC present in
1874          SPEC2000 inlining into schedule_block cause it to require 2GB of
1875          RAM instead of 256MB.  */
1876       if (alloca_call_p (node)
1877           && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
1878         {
1879           inline_forbidden_reason
1880             = G_("function %q+F can never be inlined because it uses "
1881                  "alloca (override using the always_inline attribute)");
1882           return node;
1883         }
1884       t = get_callee_fndecl (node);
1885       if (! t)
1886         break;
1887
1888       /* We cannot inline functions that call setjmp.  */
1889       if (setjmp_call_p (t))
1890         {
1891           inline_forbidden_reason
1892             = G_("function %q+F can never be inlined because it uses setjmp");
1893           return node;
1894         }
1895
1896       if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL)
1897         switch (DECL_FUNCTION_CODE (t))
1898           {
1899             /* We cannot inline functions that take a variable number of
1900                arguments.  */
1901           case BUILT_IN_VA_START:
1902           case BUILT_IN_NEXT_ARG:
1903           case BUILT_IN_VA_END:
1904             inline_forbidden_reason
1905               = G_("function %q+F can never be inlined because it "
1906                    "uses variable argument lists");
1907             return node;
1908
1909           case BUILT_IN_LONGJMP:
1910             /* We can't inline functions that call __builtin_longjmp at
1911                all.  The non-local goto machinery really requires the
1912                destination be in a different function.  If we allow the
1913                function calling __builtin_longjmp to be inlined into the
1914                function calling __builtin_setjmp, Things will Go Awry.  */
1915             inline_forbidden_reason
1916               = G_("function %q+F can never be inlined because "
1917                    "it uses setjmp-longjmp exception handling");
1918             return node;
1919
1920           case BUILT_IN_NONLOCAL_GOTO:
1921             /* Similarly.  */
1922             inline_forbidden_reason
1923               = G_("function %q+F can never be inlined because "
1924                    "it uses non-local goto");
1925             return node;
1926
1927           case BUILT_IN_RETURN:
1928           case BUILT_IN_APPLY_ARGS:
1929             /* If a __builtin_apply_args caller would be inlined,
1930                it would be saving arguments of the function it has
1931                been inlined into.  Similarly __builtin_return would
1932                return from the function the inline has been inlined into.  */
1933             inline_forbidden_reason
1934               = G_("function %q+F can never be inlined because "
1935                    "it uses __builtin_return or __builtin_apply_args");
1936             return node;
1937
1938           default:
1939             break;
1940           }
1941       break;
1942
1943     case GOTO_EXPR:
1944       t = TREE_OPERAND (node, 0);
1945
1946       /* We will not inline a function which uses computed goto.  The
1947          addresses of its local labels, which may be tucked into
1948          global storage, are of course not constant across
1949          instantiations, which causes unexpected behavior.  */
1950       if (TREE_CODE (t) != LABEL_DECL)
1951         {
1952           inline_forbidden_reason
1953             = G_("function %q+F can never be inlined "
1954                  "because it contains a computed goto");
1955           return node;
1956         }
1957       break;
1958
1959     case LABEL_EXPR:
1960       t = TREE_OPERAND (node, 0);
1961       if (DECL_NONLOCAL (t))
1962         {
1963           /* We cannot inline a function that receives a non-local goto
1964              because we cannot remap the destination label used in the
1965              function that is performing the non-local goto.  */
1966           inline_forbidden_reason
1967             = G_("function %q+F can never be inlined "
1968                  "because it receives a non-local goto");
1969           return node;
1970         }
1971       break;
1972
1973     case RECORD_TYPE:
1974     case UNION_TYPE:
1975       /* We cannot inline a function of the form
1976
1977            void F (int i) { struct S { int ar[i]; } s; }
1978
1979          Attempting to do so produces a catch-22.
1980          If walk_tree examines the TYPE_FIELDS chain of RECORD_TYPE/
1981          UNION_TYPE nodes, then it goes into infinite recursion on a
1982          structure containing a pointer to its own type.  If it doesn't,
1983          then the type node for S doesn't get adjusted properly when
1984          F is inlined.
1985
1986          ??? This is likely no longer true, but it's too late in the 4.0
1987          cycle to try to find out.  This should be checked for 4.1.  */
1988       for (t = TYPE_FIELDS (node); t; t = TREE_CHAIN (t))
1989         if (variably_modified_type_p (TREE_TYPE (t), NULL))
1990           {
1991             inline_forbidden_reason
1992               = G_("function %q+F can never be inlined "
1993                    "because it uses variable sized variables");
1994             return node;
1995           }
1996
1997     default:
1998       break;
1999     }
2000
2001   return NULL_TREE;
2002 }
2003
2004 static tree
2005 inline_forbidden_p_2 (tree *nodep, int *walk_subtrees,
2006                       void *fnp)
2007 {
2008   tree node = *nodep;
2009   tree fn = (tree) fnp;
2010
2011   if (TREE_CODE (node) == LABEL_DECL && DECL_CONTEXT (node) == fn)
2012     {
2013       inline_forbidden_reason
2014         = G_("function %q+F can never be inlined "
2015              "because it saves address of local label in a static variable");
2016       return node;
2017     }
2018
2019   if (TYPE_P (node))
2020     *walk_subtrees = 0;
2021
2022   return NULL_TREE;
2023 }
2024
2025 /* Return subexpression representing possible alloca call, if any.  */
2026 static tree
2027 inline_forbidden_p (tree fndecl)
2028 {
2029   location_t saved_loc = input_location;
2030   block_stmt_iterator bsi;
2031   basic_block bb;
2032   tree ret = NULL_TREE;
2033   struct function *fun = DECL_STRUCT_FUNCTION (fndecl);
2034   tree step;
2035
2036   FOR_EACH_BB_FN (bb, fun)
2037     for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2038       {
2039         ret = walk_tree_without_duplicates (bsi_stmt_ptr (bsi),
2040                                             inline_forbidden_p_1, fndecl);
2041         if (ret)
2042           goto egress;
2043       }
2044
2045   for (step = fun->unexpanded_var_list; step; step = TREE_CHAIN (step))
2046     {
2047       tree decl = TREE_VALUE (step);
2048       if (TREE_CODE (decl) == VAR_DECL
2049           && TREE_STATIC (decl)
2050           && !DECL_EXTERNAL (decl)
2051           && DECL_INITIAL (decl))
2052         ret = walk_tree_without_duplicates (&DECL_INITIAL (decl),
2053                                             inline_forbidden_p_2, fndecl);
2054         if (ret)
2055           goto egress;
2056     }
2057
2058 egress:
2059   input_location = saved_loc;
2060   return ret;
2061 }
2062
2063 /* Returns nonzero if FN is a function that does not have any
2064    fundamental inline blocking properties.  */
2065
2066 static bool
2067 inlinable_function_p (tree fn)
2068 {
2069   bool inlinable = true;
2070   bool do_warning;
2071   tree always_inline;
2072
2073   /* If we've already decided this function shouldn't be inlined,
2074      there's no need to check again.  */
2075   if (DECL_UNINLINABLE (fn))
2076     return false;
2077
2078   /* We only warn for functions declared `inline' by the user.  */
2079   do_warning = (warn_inline
2080                 && DECL_INLINE (fn)
2081                 && DECL_DECLARED_INLINE_P (fn)
2082                 && !DECL_IN_SYSTEM_HEADER (fn));
2083
2084   always_inline = lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn));
2085
2086   if (flag_really_no_inline
2087       && always_inline == NULL)
2088     {
2089       if (do_warning)
2090         warning (OPT_Winline, "function %q+F can never be inlined because it "
2091                  "is suppressed using -fno-inline", fn);
2092       inlinable = false;
2093     }
2094
2095   /* Don't auto-inline anything that might not be bound within
2096      this unit of translation.  */
2097   else if (!DECL_DECLARED_INLINE_P (fn)
2098            && DECL_REPLACEABLE_P (fn))
2099     inlinable = false;
2100
2101   else if (!function_attribute_inlinable_p (fn))
2102     {
2103       if (do_warning)
2104         warning (OPT_Winline, "function %q+F can never be inlined because it "
2105                  "uses attributes conflicting with inlining", fn);
2106       inlinable = false;
2107     }
2108
2109   /* If we don't have the function body available, we can't inline it.
2110      However, this should not be recorded since we also get here for
2111      forward declared inline functions.  Therefore, return at once.  */
2112   if (!DECL_SAVED_TREE (fn))
2113     return false;
2114
2115   /* If we're not inlining at all, then we cannot inline this function.  */
2116   else if (!flag_inline_trees)
2117     inlinable = false;
2118
2119   /* Only try to inline functions if DECL_INLINE is set.  This should be
2120      true for all functions declared `inline', and for all other functions
2121      as well with -finline-functions.
2122
2123      Don't think of disregarding DECL_INLINE when flag_inline_trees == 2;
2124      it's the front-end that must set DECL_INLINE in this case, because
2125      dwarf2out loses if a function that does not have DECL_INLINE set is
2126      inlined anyway.  That is why we have both DECL_INLINE and
2127      DECL_DECLARED_INLINE_P.  */
2128   /* FIXME: When flag_inline_trees dies, the check for flag_unit_at_a_time
2129             here should be redundant.  */
2130   else if (!DECL_INLINE (fn) && !flag_unit_at_a_time)
2131     inlinable = false;
2132
2133   else if (inline_forbidden_p (fn))
2134     {
2135       /* See if we should warn about uninlinable functions.  Previously,
2136          some of these warnings would be issued while trying to expand
2137          the function inline, but that would cause multiple warnings
2138          about functions that would for example call alloca.  But since
2139          this a property of the function, just one warning is enough.
2140          As a bonus we can now give more details about the reason why a
2141          function is not inlinable.  */
2142       if (always_inline)
2143         sorry (inline_forbidden_reason, fn);
2144       else if (do_warning)
2145         warning (OPT_Winline, inline_forbidden_reason, fn);
2146
2147       inlinable = false;
2148     }
2149
2150   /* Squirrel away the result so that we don't have to check again.  */
2151   DECL_UNINLINABLE (fn) = !inlinable;
2152
2153   return inlinable;
2154 }
2155
2156 /* Estimate the cost of a memory move.  Use machine dependent
2157    word size and take possible memcpy call into account.  */
2158
2159 int
2160 estimate_move_cost (tree type)
2161 {
2162   HOST_WIDE_INT size;
2163
2164   size = int_size_in_bytes (type);
2165
2166   if (size < 0 || size > MOVE_MAX_PIECES * MOVE_RATIO)
2167     /* Cost of a memcpy call, 3 arguments and the call.  */
2168     return 4;
2169   else
2170     return ((size + MOVE_MAX_PIECES - 1) / MOVE_MAX_PIECES);
2171 }
2172
2173 /* Arguments for estimate_num_insns_1.  */
2174
2175 struct eni_data
2176 {
2177   /* Used to return the number of insns.  */
2178   int count;
2179
2180   /* Weights of various constructs.  */
2181   eni_weights *weights;
2182 };
2183
2184 /* Used by estimate_num_insns.  Estimate number of instructions seen
2185    by given statement.  */
2186
2187 static tree
2188 estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data)
2189 {
2190   struct eni_data *d = data;
2191   tree x = *tp;
2192   unsigned cost;
2193
2194   if (IS_TYPE_OR_DECL_P (x))
2195     {
2196       *walk_subtrees = 0;
2197       return NULL;
2198     }
2199   /* Assume that constants and references counts nothing.  These should
2200      be majorized by amount of operations among them we count later
2201      and are common target of CSE and similar optimizations.  */
2202   else if (CONSTANT_CLASS_P (x) || REFERENCE_CLASS_P (x))
2203     return NULL;
2204
2205   switch (TREE_CODE (x))
2206     {
2207     /* Containers have no cost.  */
2208     case TREE_LIST:
2209     case TREE_VEC:
2210     case BLOCK:
2211     case COMPONENT_REF:
2212     case BIT_FIELD_REF:
2213     case INDIRECT_REF:
2214     case ALIGN_INDIRECT_REF:
2215     case MISALIGNED_INDIRECT_REF:
2216     case ARRAY_REF:
2217     case ARRAY_RANGE_REF:
2218     case OBJ_TYPE_REF:
2219     case EXC_PTR_EXPR: /* ??? */
2220     case FILTER_EXPR: /* ??? */
2221     case COMPOUND_EXPR:
2222     case BIND_EXPR:
2223     case WITH_CLEANUP_EXPR:
2224     case PAREN_EXPR:
2225     case NOP_EXPR:
2226     case CONVERT_EXPR:
2227     case VIEW_CONVERT_EXPR:
2228     case SAVE_EXPR:
2229     case ADDR_EXPR:
2230     case COMPLEX_EXPR:
2231     case RANGE_EXPR:
2232     case CASE_LABEL_EXPR:
2233     case SSA_NAME:
2234     case CATCH_EXPR:
2235     case EH_FILTER_EXPR:
2236     case STATEMENT_LIST:
2237     case ERROR_MARK:
2238     case NON_LVALUE_EXPR:
2239     case FDESC_EXPR:
2240     case VA_ARG_EXPR:
2241     case TRY_CATCH_EXPR:
2242     case TRY_FINALLY_EXPR:
2243     case LABEL_EXPR:
2244     case GOTO_EXPR:
2245     case RETURN_EXPR:
2246     case EXIT_EXPR:
2247     case LOOP_EXPR:
2248     case PHI_NODE:
2249     case WITH_SIZE_EXPR:
2250     case OMP_CLAUSE:
2251     case OMP_RETURN:
2252     case OMP_CONTINUE:
2253     case OMP_SECTIONS_SWITCH:
2254     case OMP_ATOMIC_STORE:
2255       break;
2256
2257     /* We don't account constants for now.  Assume that the cost is amortized
2258        by operations that do use them.  We may re-consider this decision once
2259        we are able to optimize the tree before estimating its size and break
2260        out static initializers.  */
2261     case IDENTIFIER_NODE:
2262     case INTEGER_CST:
2263     case REAL_CST:
2264     case FIXED_CST:
2265     case COMPLEX_CST:
2266     case VECTOR_CST:
2267     case STRING_CST:
2268     case PREDICT_EXPR:
2269       *walk_subtrees = 0;
2270       return NULL;
2271
2272       /* CHANGE_DYNAMIC_TYPE_EXPR explicitly expands to nothing.  */
2273     case CHANGE_DYNAMIC_TYPE_EXPR:
2274       *walk_subtrees = 0;
2275       return NULL;
2276
2277     /* Try to estimate the cost of assignments.  We have three cases to
2278        deal with:
2279         1) Simple assignments to registers;
2280         2) Stores to things that must live in memory.  This includes
2281            "normal" stores to scalars, but also assignments of large
2282            structures, or constructors of big arrays;
2283         3) TARGET_EXPRs.
2284
2285        Let us look at the first two cases, assuming we have "a = b + C":
2286        <GIMPLE_MODIFY_STMT <var_decl "a">
2287                            <plus_expr <var_decl "b"> <constant C>>
2288        If "a" is a GIMPLE register, the assignment to it is free on almost
2289        any target, because "a" usually ends up in a real register.  Hence
2290        the only cost of this expression comes from the PLUS_EXPR, and we
2291        can ignore the GIMPLE_MODIFY_STMT.
2292        If "a" is not a GIMPLE register, the assignment to "a" will most
2293        likely be a real store, so the cost of the GIMPLE_MODIFY_STMT is the cost
2294        of moving something into "a", which we compute using the function
2295        estimate_move_cost.
2296
2297        The third case deals with TARGET_EXPRs, for which the semantics are
2298        that a temporary is assigned, unless the TARGET_EXPR itself is being
2299        assigned to something else.  In the latter case we do not need the
2300        temporary.  E.g. in:
2301                 <GIMPLE_MODIFY_STMT <var_decl "a"> <target_expr>>, the
2302        GIMPLE_MODIFY_STMT is free.  */
2303     case INIT_EXPR:
2304     case GIMPLE_MODIFY_STMT:
2305       /* Is the right and side a TARGET_EXPR?  */
2306       if (TREE_CODE (GENERIC_TREE_OPERAND (x, 1)) == TARGET_EXPR)
2307         break;
2308       /* ... fall through ...  */
2309
2310     case TARGET_EXPR:
2311       x = GENERIC_TREE_OPERAND (x, 0);
2312       /* Is this an assignments to a register?  */
2313       if (is_gimple_reg (x))
2314         break;
2315       /* Otherwise it's a store, so fall through to compute the move cost.  */
2316
2317     case CONSTRUCTOR:
2318       d->count += estimate_move_cost (TREE_TYPE (x));
2319       break;
2320
2321     /* Assign cost of 1 to usual operations.
2322        ??? We may consider mapping RTL costs to this.  */
2323     case COND_EXPR:
2324     case VEC_COND_EXPR:
2325
2326     case PLUS_EXPR:
2327     case POINTER_PLUS_EXPR:
2328     case MINUS_EXPR:
2329     case MULT_EXPR:
2330
2331     case FIXED_CONVERT_EXPR:
2332     case FIX_TRUNC_EXPR:
2333
2334     case NEGATE_EXPR:
2335     case FLOAT_EXPR:
2336     case MIN_EXPR:
2337     case MAX_EXPR:
2338     case ABS_EXPR:
2339
2340     case LSHIFT_EXPR:
2341     case RSHIFT_EXPR:
2342     case LROTATE_EXPR:
2343     case RROTATE_EXPR:
2344     case VEC_LSHIFT_EXPR:
2345     case VEC_RSHIFT_EXPR:
2346
2347     case BIT_IOR_EXPR:
2348     case BIT_XOR_EXPR:
2349     case BIT_AND_EXPR:
2350     case BIT_NOT_EXPR:
2351
2352     case TRUTH_ANDIF_EXPR:
2353     case TRUTH_ORIF_EXPR:
2354     case TRUTH_AND_EXPR:
2355     case TRUTH_OR_EXPR:
2356     case TRUTH_XOR_EXPR:
2357     case TRUTH_NOT_EXPR:
2358
2359     case LT_EXPR:
2360     case LE_EXPR:
2361     case GT_EXPR:
2362     case GE_EXPR:
2363     case EQ_EXPR:
2364     case NE_EXPR:
2365     case ORDERED_EXPR:
2366     case UNORDERED_EXPR:
2367
2368     case UNLT_EXPR:
2369     case UNLE_EXPR:
2370     case UNGT_EXPR:
2371     case UNGE_EXPR:
2372     case UNEQ_EXPR:
2373     case LTGT_EXPR:
2374
2375     case CONJ_EXPR:
2376
2377     case PREDECREMENT_EXPR:
2378     case PREINCREMENT_EXPR:
2379     case POSTDECREMENT_EXPR:
2380     case POSTINCREMENT_EXPR:
2381
2382     case ASM_EXPR:
2383
2384     case REALIGN_LOAD_EXPR:
2385
2386     case REDUC_MAX_EXPR:
2387     case REDUC_MIN_EXPR:
2388     case REDUC_PLUS_EXPR:
2389     case WIDEN_SUM_EXPR:
2390     case DOT_PROD_EXPR:
2391     case VEC_WIDEN_MULT_HI_EXPR:
2392     case VEC_WIDEN_MULT_LO_EXPR:
2393     case VEC_UNPACK_HI_EXPR:
2394     case VEC_UNPACK_LO_EXPR:
2395     case VEC_UNPACK_FLOAT_HI_EXPR:
2396     case VEC_UNPACK_FLOAT_LO_EXPR:
2397     case VEC_PACK_TRUNC_EXPR:
2398     case VEC_PACK_SAT_EXPR:
2399     case VEC_PACK_FIX_TRUNC_EXPR:
2400
2401     case WIDEN_MULT_EXPR:
2402
2403     case VEC_EXTRACT_EVEN_EXPR:
2404     case VEC_EXTRACT_ODD_EXPR:
2405     case VEC_INTERLEAVE_HIGH_EXPR:
2406     case VEC_INTERLEAVE_LOW_EXPR:
2407
2408     case RESX_EXPR:
2409       d->count += 1;
2410       break;
2411
2412     case SWITCH_EXPR:
2413       /* Take into account cost of the switch + guess 2 conditional jumps for
2414          each case label.
2415
2416          TODO: once the switch expansion logic is sufficiently separated, we can
2417          do better job on estimating cost of the switch.  */
2418       d->count += TREE_VEC_LENGTH (SWITCH_LABELS (x)) * 2;
2419       break;
2420
2421     /* Few special cases of expensive operations.  This is useful
2422        to avoid inlining on functions having too many of these.  */
2423     case TRUNC_DIV_EXPR:
2424     case CEIL_DIV_EXPR:
2425     case FLOOR_DIV_EXPR:
2426     case ROUND_DIV_EXPR:
2427     case EXACT_DIV_EXPR:
2428     case TRUNC_MOD_EXPR:
2429     case CEIL_MOD_EXPR:
2430     case FLOOR_MOD_EXPR:
2431     case ROUND_MOD_EXPR:
2432     case RDIV_EXPR:
2433       d->count += d->weights->div_mod_cost;
2434       break;
2435     case CALL_EXPR:
2436       {
2437         tree decl = get_callee_fndecl (x);
2438         tree addr = CALL_EXPR_FN (x);
2439         tree funtype = TREE_TYPE (addr);
2440
2441         gcc_assert (POINTER_TYPE_P (funtype));
2442         funtype = TREE_TYPE (funtype);
2443
2444         if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD)
2445           cost = d->weights->target_builtin_call_cost;
2446         else
2447           cost = d->weights->call_cost;
2448
2449         if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
2450           switch (DECL_FUNCTION_CODE (decl))
2451             {
2452             case BUILT_IN_CONSTANT_P:
2453               *walk_subtrees = 0;
2454               return NULL_TREE;
2455             case BUILT_IN_EXPECT:
2456               return NULL_TREE;
2457             /* Prefetch instruction is not expensive.  */
2458             case BUILT_IN_PREFETCH:
2459               cost = 1;
2460               break;
2461             default:
2462               break;
2463             }
2464
2465         if (decl)
2466           funtype = TREE_TYPE (decl);
2467
2468         /* Our cost must be kept in sync with cgraph_estimate_size_after_inlining
2469            that does use function declaration to figure out the arguments.
2470
2471            When we deal with function with no body nor prototype, base estimates on
2472            actual parameters of the call expression.  Otherwise use either the actual
2473            arguments types or function declaration for more precise answer.  */
2474         if (decl && DECL_ARGUMENTS (decl))
2475           {
2476             tree arg;
2477             for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg))
2478               d->count += estimate_move_cost (TREE_TYPE (arg));
2479           }
2480         else if (funtype && prototype_p (funtype))
2481           {
2482             tree t;
2483             for (t = TYPE_ARG_TYPES (funtype); t; t = TREE_CHAIN (t))
2484               d->count += estimate_move_cost (TREE_VALUE (t));
2485           }
2486         else
2487           {
2488             tree a;
2489             call_expr_arg_iterator iter;
2490             FOR_EACH_CALL_EXPR_ARG (a, iter, x)
2491               d->count += estimate_move_cost (TREE_TYPE (a));
2492           }
2493
2494         d->count += cost;
2495         break;
2496       }
2497
2498     case OMP_PARALLEL:
2499     case OMP_FOR:
2500     case OMP_SECTIONS:
2501     case OMP_SINGLE:
2502     case OMP_SECTION:
2503     case OMP_MASTER:
2504     case OMP_ORDERED:
2505     case OMP_CRITICAL:
2506     case OMP_ATOMIC:
2507     case OMP_ATOMIC_LOAD:
2508       /* OpenMP directives are generally very expensive.  */
2509       d->count += d->weights->omp_cost;
2510       break;
2511
2512     default:
2513       gcc_unreachable ();
2514     }
2515   return NULL;
2516 }
2517
2518 /* Estimate number of instructions that will be created by expanding EXPR.
2519    WEIGHTS contains weights attributed to various constructs.  */
2520
2521 int
2522 estimate_num_insns (tree expr, eni_weights *weights)
2523 {
2524   struct pointer_set_t *visited_nodes;
2525   basic_block bb;
2526   block_stmt_iterator bsi;
2527   struct function *my_function;
2528   struct eni_data data;
2529
2530   data.count = 0;
2531   data.weights = weights;
2532
2533   /* If we're given an entire function, walk the CFG.  */
2534   if (TREE_CODE (expr) == FUNCTION_DECL)
2535     {
2536       my_function = DECL_STRUCT_FUNCTION (expr);
2537       gcc_assert (my_function && my_function->cfg);
2538       visited_nodes = pointer_set_create ();
2539       FOR_EACH_BB_FN (bb, my_function)
2540         {
2541           for (bsi = bsi_start (bb);
2542                !bsi_end_p (bsi);
2543                bsi_next (&bsi))
2544             {
2545               walk_tree (bsi_stmt_ptr (bsi), estimate_num_insns_1,
2546                          &data, visited_nodes);
2547             }
2548         }
2549       pointer_set_destroy (visited_nodes);
2550     }
2551   else
2552     walk_tree_without_duplicates (&expr, estimate_num_insns_1, &data);
2553
2554   return data.count;
2555 }
2556
2557 /* Initializes weights used by estimate_num_insns.  */
2558
2559 void
2560 init_inline_once (void)
2561 {
2562   eni_inlining_weights.call_cost = PARAM_VALUE (PARAM_INLINE_CALL_COST);
2563   eni_inlining_weights.target_builtin_call_cost = 1;
2564   eni_inlining_weights.div_mod_cost = 10;
2565   eni_inlining_weights.omp_cost = 40;
2566
2567   eni_size_weights.call_cost = 1;
2568   eni_size_weights.target_builtin_call_cost = 1;
2569   eni_size_weights.div_mod_cost = 1;
2570   eni_size_weights.omp_cost = 40;
2571
2572   /* Estimating time for call is difficult, since we have no idea what the
2573      called function does.  In the current uses of eni_time_weights,
2574      underestimating the cost does less harm than overestimating it, so
2575      we choose a rather small value here.  */
2576   eni_time_weights.call_cost = 10;
2577   eni_time_weights.target_builtin_call_cost = 10;
2578   eni_time_weights.div_mod_cost = 10;
2579   eni_time_weights.omp_cost = 40;
2580 }
2581
2582 /* Install new lexical TREE_BLOCK underneath 'current_block'.  */
2583 static void
2584 add_lexical_block (tree current_block, tree new_block)
2585 {
2586   tree *blk_p;
2587
2588   /* Walk to the last sub-block.  */
2589   for (blk_p = &BLOCK_SUBBLOCKS (current_block);
2590        *blk_p;
2591        blk_p = &BLOCK_CHAIN (*blk_p))
2592     ;
2593   *blk_p = new_block;
2594   BLOCK_SUPERCONTEXT (new_block) = current_block;
2595 }
2596
2597 /* If *TP is a CALL_EXPR, replace it with its inline expansion.  */
2598
2599 static bool
2600 expand_call_inline (basic_block bb, tree stmt, tree *tp, void *data)
2601 {
2602   copy_body_data *id;
2603   tree t;
2604   tree retvar, use_retvar;
2605   tree fn;
2606   struct pointer_map_t *st;
2607   tree return_slot;
2608   tree modify_dest;
2609   location_t saved_location;
2610   struct cgraph_edge *cg_edge;
2611   const char *reason;
2612   basic_block return_block;
2613   edge e;
2614   block_stmt_iterator bsi, stmt_bsi;
2615   bool successfully_inlined = FALSE;
2616   bool purge_dead_abnormal_edges;
2617   tree t_step;
2618   tree var;
2619
2620   /* See what we've got.  */
2621   id = (copy_body_data *) data;
2622   t = *tp;
2623
2624   /* Set input_location here so we get the right instantiation context
2625      if we call instantiate_decl from inlinable_function_p.  */
2626   saved_location = input_location;
2627   if (EXPR_HAS_LOCATION (t))
2628     input_location = EXPR_LOCATION (t);
2629
2630   /* From here on, we're only interested in CALL_EXPRs.  */
2631   if (TREE_CODE (t) != CALL_EXPR)
2632     goto egress;
2633
2634   /* First, see if we can figure out what function is being called.
2635      If we cannot, then there is no hope of inlining the function.  */
2636   fn = get_callee_fndecl (t);
2637   if (!fn)
2638     goto egress;
2639
2640   /* Turn forward declarations into real ones.  */
2641   fn = cgraph_node (fn)->decl;
2642
2643   /* If fn is a declaration of a function in a nested scope that was
2644      globally declared inline, we don't set its DECL_INITIAL.
2645      However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
2646      C++ front-end uses it for cdtors to refer to their internal
2647      declarations, that are not real functions.  Fortunately those
2648      don't have trees to be saved, so we can tell by checking their
2649      DECL_SAVED_TREE.  */
2650   if (! DECL_INITIAL (fn)
2651       && DECL_ABSTRACT_ORIGIN (fn)
2652       && DECL_SAVED_TREE (DECL_ABSTRACT_ORIGIN (fn)))
2653     fn = DECL_ABSTRACT_ORIGIN (fn);
2654
2655   /* Objective C and fortran still calls tree_rest_of_compilation directly.
2656      Kill this check once this is fixed.  */
2657   if (!id->dst_node->analyzed)
2658     goto egress;
2659
2660   cg_edge = cgraph_edge (id->dst_node, stmt);
2661
2662   /* Constant propagation on argument done during previous inlining
2663      may create new direct call.  Produce an edge for it.  */
2664   if (!cg_edge)
2665     {
2666       struct cgraph_node *dest = cgraph_node (fn);
2667
2668       /* We have missing edge in the callgraph.  This can happen in one case
2669          where previous inlining turned indirect call into direct call by
2670          constant propagating arguments.  In all other cases we hit a bug
2671          (incorrect node sharing is most common reason for missing edges.  */
2672       gcc_assert (dest->needed || !flag_unit_at_a_time);
2673       cgraph_create_edge (id->dst_node, dest, stmt,
2674                           bb->count, CGRAPH_FREQ_BASE,
2675                           bb->loop_depth)->inline_failed
2676         = N_("originally indirect function call not considered for inlining");
2677       if (dump_file)
2678         {
2679            fprintf (dump_file, "Created new direct edge to %s",
2680                     cgraph_node_name (dest));
2681         }
2682       goto egress;
2683     }
2684
2685   /* Don't try to inline functions that are not well-suited to
2686      inlining.  */
2687   if (!cgraph_inline_p (cg_edge, &reason))
2688     {
2689       if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn))
2690           /* Avoid warnings during early inline pass. */
2691           && (!flag_unit_at_a_time || cgraph_global_info_ready))
2692         {
2693           sorry ("inlining failed in call to %q+F: %s", fn, reason);
2694           sorry ("called from here");
2695         }
2696       else if (warn_inline && DECL_DECLARED_INLINE_P (fn)
2697                && !DECL_IN_SYSTEM_HEADER (fn)
2698                && strlen (reason)
2699                && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn))
2700                /* Avoid warnings during early inline pass. */
2701                && (!flag_unit_at_a_time || cgraph_global_info_ready))
2702         {
2703           warning (OPT_Winline, "inlining failed in call to %q+F: %s",
2704                    fn, reason);
2705           warning (OPT_Winline, "called from here");
2706         }
2707       goto egress;
2708     }
2709   fn = cg_edge->callee->decl;
2710
2711 #ifdef ENABLE_CHECKING
2712   if (cg_edge->callee->decl != id->dst_node->decl)
2713     verify_cgraph_node (cg_edge->callee);
2714 #endif
2715
2716   /* We will be inlining this callee.  */
2717   id->eh_region = lookup_stmt_eh_region (stmt);
2718
2719   /* Split the block holding the CALL_EXPR.  */
2720   e = split_block (bb, stmt);
2721   bb = e->src;
2722   return_block = e->dest;
2723   remove_edge (e);
2724
2725   /* split_block splits after the statement; work around this by
2726      moving the call into the second block manually.  Not pretty,
2727      but seems easier than doing the CFG manipulation by hand
2728      when the CALL_EXPR is in the last statement of BB.  */
2729   stmt_bsi = bsi_last (bb);
2730   bsi_remove (&stmt_bsi, false);
2731
2732   /* If the CALL_EXPR was in the last statement of BB, it may have
2733      been the source of abnormal edges.  In this case, schedule
2734      the removal of dead abnormal edges.  */
2735   bsi = bsi_start (return_block);
2736   if (bsi_end_p (bsi))
2737     {
2738       bsi_insert_after (&bsi, stmt, BSI_NEW_STMT);
2739       purge_dead_abnormal_edges = true;
2740     }
2741   else
2742     {
2743       bsi_insert_before (&bsi, stmt, BSI_NEW_STMT);
2744       purge_dead_abnormal_edges = false;
2745     }
2746
2747   stmt_bsi = bsi_start (return_block);
2748
2749   /* Build a block containing code to initialize the arguments, the
2750      actual inline expansion of the body, and a label for the return
2751      statements within the function to jump to.  The type of the
2752      statement expression is the return type of the function call.  */
2753   id->block = make_node (BLOCK);
2754   BLOCK_ABSTRACT_ORIGIN (id->block) = fn;
2755   BLOCK_SOURCE_LOCATION (id->block) = input_location;
2756   add_lexical_block (TREE_BLOCK (stmt), id->block);
2757
2758   /* Local declarations will be replaced by their equivalents in this
2759      map.  */
2760   st = id->decl_map;
2761   id->decl_map = pointer_map_create ();
2762
2763   /* Record the function we are about to inline.  */
2764   id->src_fn = fn;
2765   id->src_node = cg_edge->callee;
2766   id->src_cfun = DECL_STRUCT_FUNCTION (fn);
2767   id->call_expr = t;
2768
2769   gcc_assert (!id->src_cfun->after_inlining);
2770
2771   id->entry_bb = bb;
2772   initialize_inlined_parameters (id, t, fn, bb);
2773
2774   if (DECL_INITIAL (fn))
2775     add_lexical_block (id->block, remap_blocks (DECL_INITIAL (fn), id));
2776
2777   /* Return statements in the function body will be replaced by jumps
2778      to the RET_LABEL.  */
2779
2780   gcc_assert (DECL_INITIAL (fn));
2781   gcc_assert (TREE_CODE (DECL_INITIAL (fn)) == BLOCK);
2782
2783   /* Find the lhs to which the result of this call is assigned.  */
2784   return_slot = NULL;
2785   if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
2786     {
2787       modify_dest = GIMPLE_STMT_OPERAND (stmt, 0);
2788
2789       /* The function which we are inlining might not return a value,
2790          in which case we should issue a warning that the function
2791          does not return a value.  In that case the optimizers will
2792          see that the variable to which the value is assigned was not
2793          initialized.  We do not want to issue a warning about that
2794          uninitialized variable.  */
2795       if (DECL_P (modify_dest))
2796         TREE_NO_WARNING (modify_dest) = 1;
2797       if (CALL_EXPR_RETURN_SLOT_OPT (t))
2798         {
2799           return_slot = modify_dest;
2800           modify_dest = NULL;
2801         }
2802     }
2803   else
2804     modify_dest = NULL;
2805
2806   /* If we are inlining a call to the C++ operator new, we don't want
2807      to use type based alias analysis on the return value.  Otherwise
2808      we may get confused if the compiler sees that the inlined new
2809      function returns a pointer which was just deleted.  See bug
2810      33407.  */
2811   if (DECL_IS_OPERATOR_NEW (fn))
2812     {
2813       return_slot = NULL;
2814       modify_dest = NULL;
2815     }
2816
2817   /* Declare the return variable for the function.  */
2818   retvar = declare_return_variable (id, return_slot,
2819                                     modify_dest, &use_retvar);
2820
2821   if (DECL_IS_OPERATOR_NEW (fn))
2822     {
2823       gcc_assert (TREE_CODE (retvar) == VAR_DECL
2824                   && POINTER_TYPE_P (TREE_TYPE (retvar)));
2825       DECL_NO_TBAA_P (retvar) = 1;
2826     }
2827
2828   /* This is it.  Duplicate the callee body.  Assume callee is
2829      pre-gimplified.  Note that we must not alter the caller
2830      function in any way before this point, as this CALL_EXPR may be
2831      a self-referential call; if we're calling ourselves, we need to
2832      duplicate our body before altering anything.  */
2833   copy_body (id, bb->count, bb->frequency, bb, return_block);
2834
2835   /* Add local vars in this inlined callee to caller.  */
2836   t_step = id->src_cfun->unexpanded_var_list;
2837   for (; t_step; t_step = TREE_CHAIN (t_step))
2838     {
2839       var = TREE_VALUE (t_step);
2840       if (TREE_STATIC (var) && !TREE_ASM_WRITTEN (var))
2841         cfun->unexpanded_var_list = tree_cons (NULL_TREE, var,
2842                                                cfun->unexpanded_var_list);
2843       else
2844         cfun->unexpanded_var_list = tree_cons (NULL_TREE, remap_decl (var, id),
2845                                                cfun->unexpanded_var_list);
2846     }
2847
2848   /* Clean up.  */
2849   pointer_map_destroy (id->decl_map);
2850   id->decl_map = st;
2851
2852   /* If the inlined function returns a result that we care about,
2853      clobber the CALL_EXPR with a reference to the return variable.  */
2854   if (use_retvar && (TREE_CODE (bsi_stmt (stmt_bsi)) != CALL_EXPR))
2855     {
2856       *tp = use_retvar;
2857       if (gimple_in_ssa_p (cfun))
2858         {
2859           update_stmt (stmt);
2860           mark_symbols_for_renaming (stmt);
2861         }
2862       maybe_clean_or_replace_eh_stmt (stmt, stmt);
2863     }
2864   else
2865     /* We're modifying a TSI owned by gimple_expand_calls_inline();
2866        tsi_delink() will leave the iterator in a sane state.  */
2867     {
2868       /* Handle case of inlining function that miss return statement so
2869          return value becomes undefined.  */
2870       if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
2871           && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) == SSA_NAME)
2872         {
2873           tree name = TREE_OPERAND (stmt, 0);
2874           tree var = SSA_NAME_VAR (TREE_OPERAND (stmt, 0));
2875           tree def = gimple_default_def (cfun, var);
2876
2877           /* If the variable is used undefined, make this name undefined via
2878              move.  */
2879           if (def)
2880             {
2881               TREE_OPERAND (stmt, 1) = def;
2882               update_stmt (stmt);
2883             }
2884           /* Otherwise make this variable undefined.  */
2885           else
2886             {
2887               bsi_remove (&stmt_bsi, true);
2888               set_default_def (var, name);
2889               SSA_NAME_DEF_STMT (name) = build_empty_stmt ();
2890             }
2891         }
2892       else
2893         bsi_remove (&stmt_bsi, true);
2894     }
2895
2896   if (purge_dead_abnormal_edges)
2897     tree_purge_dead_abnormal_call_edges (return_block);
2898
2899   /* If the value of the new expression is ignored, that's OK.  We
2900      don't warn about this for CALL_EXPRs, so we shouldn't warn about
2901      the equivalent inlined version either.  */
2902   TREE_USED (*tp) = 1;
2903
2904   /* Output the inlining info for this abstract function, since it has been
2905      inlined.  If we don't do this now, we can lose the information about the
2906      variables in the function when the blocks get blown away as soon as we
2907      remove the cgraph node.  */
2908   (*debug_hooks->outlining_inline_function) (cg_edge->callee->decl);
2909
2910   /* Update callgraph if needed.  */
2911   cgraph_remove_node (cg_edge->callee);
2912
2913   id->block = NULL_TREE;
2914   successfully_inlined = TRUE;
2915
2916  egress:
2917   input_location = saved_location;
2918   return successfully_inlined;
2919 }
2920
2921 /* Expand call statements reachable from STMT_P.
2922    We can only have CALL_EXPRs as the "toplevel" tree code or nested
2923    in a GIMPLE_MODIFY_STMT.  See tree-gimple.c:get_call_expr_in().  We can
2924    unfortunately not use that function here because we need a pointer
2925    to the CALL_EXPR, not the tree itself.  */
2926
2927 static bool
2928 gimple_expand_calls_inline (basic_block bb, copy_body_data *id)
2929 {
2930   block_stmt_iterator bsi;
2931
2932   /* Register specific tree functions.  */
2933   tree_register_cfg_hooks ();
2934   for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2935     {
2936       tree *expr_p = bsi_stmt_ptr (bsi);
2937       tree stmt = *expr_p;
2938
2939       if (TREE_CODE (*expr_p) == GIMPLE_MODIFY_STMT)
2940         expr_p = &GIMPLE_STMT_OPERAND (*expr_p, 1);
2941       if (TREE_CODE (*expr_p) == WITH_SIZE_EXPR)
2942         expr_p = &TREE_OPERAND (*expr_p, 0);
2943       if (TREE_CODE (*expr_p) == CALL_EXPR)
2944         if (expand_call_inline (bb, stmt, expr_p, id))
2945           return true;
2946     }
2947   return false;
2948 }
2949
2950 /* Walk all basic blocks created after FIRST and try to fold every statement
2951    in the STATEMENTS pointer set.  */
2952 static void
2953 fold_marked_statements (int first, struct pointer_set_t *statements)
2954 {
2955   for (;first < n_basic_blocks;first++)
2956     if (BASIC_BLOCK (first))
2957       {
2958         block_stmt_iterator bsi;
2959         for (bsi = bsi_start (BASIC_BLOCK (first));
2960              !bsi_end_p (bsi); bsi_next (&bsi))
2961           if (pointer_set_contains (statements, bsi_stmt (bsi)))
2962             {
2963               tree old_stmt = bsi_stmt (bsi);
2964               tree old_call = get_call_expr_in (old_stmt);
2965
2966               if (fold_stmt (bsi_stmt_ptr (bsi)))
2967                 {
2968                   update_stmt (bsi_stmt (bsi));
2969                   if (old_call)
2970                     cgraph_update_edges_for_call_stmt (old_stmt, old_call,
2971                                                        bsi_stmt (bsi));
2972                   if (maybe_clean_or_replace_eh_stmt (old_stmt,
2973                                                       bsi_stmt (bsi)))
2974                     tree_purge_dead_eh_edges (BASIC_BLOCK (first));
2975                 }
2976             }
2977       }
2978 }
2979
2980 /* Return true if BB has at least one abnormal outgoing edge.  */
2981
2982 static inline bool
2983 has_abnormal_outgoing_edge_p (basic_block bb)
2984 {
2985   edge e;
2986   edge_iterator ei;
2987
2988   FOR_EACH_EDGE (e, ei, bb->succs)
2989     if (e->flags & EDGE_ABNORMAL)
2990       return true;
2991
2992   return false;
2993 }
2994
2995 /* Expand calls to inline functions in the body of FN.  */
2996
2997 unsigned int
2998 optimize_inline_calls (tree fn)
2999 {
3000   copy_body_data id;
3001   tree prev_fn;
3002   basic_block bb;
3003   int last = n_basic_blocks;
3004   /* There is no point in performing inlining if errors have already
3005      occurred -- and we might crash if we try to inline invalid
3006      code.  */
3007   if (errorcount || sorrycount)
3008     return 0;
3009
3010   /* Clear out ID.  */
3011   memset (&id, 0, sizeof (id));
3012
3013   id.src_node = id.dst_node = cgraph_node (fn);
3014   id.dst_fn = fn;
3015   /* Or any functions that aren't finished yet.  */
3016   prev_fn = NULL_TREE;
3017   if (current_function_decl)
3018     {
3019       id.dst_fn = current_function_decl;
3020       prev_fn = current_function_decl;
3021     }
3022
3023   id.copy_decl = copy_decl_maybe_to_var;
3024   id.transform_call_graph_edges = CB_CGE_DUPLICATE;
3025   id.transform_new_cfg = false;
3026   id.transform_return_to_modify = true;
3027   id.transform_lang_insert_block = false;
3028   id.statements_to_fold = pointer_set_create ();
3029
3030   push_gimplify_context ();
3031
3032   /* We make no attempts to keep dominance info up-to-date.  */
3033   free_dominance_info (CDI_DOMINATORS);
3034   free_dominance_info (CDI_POST_DOMINATORS);
3035
3036   /* Reach the trees by walking over the CFG, and note the
3037      enclosing basic-blocks in the call edges.  */
3038   /* We walk the blocks going forward, because inlined function bodies
3039      will split id->current_basic_block, and the new blocks will
3040      follow it; we'll trudge through them, processing their CALL_EXPRs
3041      along the way.  */
3042   FOR_EACH_BB (bb)
3043     gimple_expand_calls_inline (bb, &id);
3044
3045   pop_gimplify_context (NULL);
3046
3047 #ifdef ENABLE_CHECKING
3048     {
3049       struct cgraph_edge *e;
3050
3051       verify_cgraph_node (id.dst_node);
3052
3053       /* Double check that we inlined everything we are supposed to inline.  */
3054       for (e = id.dst_node->callees; e; e = e->next_callee)
3055         gcc_assert (e->inline_failed);
3056     }
3057 #endif
3058
3059   /* Fold the statements before compacting/renumbering the basic blocks.  */
3060   fold_marked_statements (last, id.statements_to_fold);
3061   pointer_set_destroy (id.statements_to_fold);
3062
3063   /* Renumber the (code) basic_blocks consecutively.  */
3064   compact_blocks ();
3065   /* Renumber the lexical scoping (non-code) blocks consecutively.  */
3066   number_blocks (fn);
3067
3068   /* We are not going to maintain the cgraph edges up to date.
3069      Kill it so it won't confuse us.  */
3070   cgraph_node_remove_callees (id.dst_node);
3071
3072   fold_cond_expr_cond ();
3073   /* It would be nice to check SSA/CFG/statement consistency here, but it is
3074      not possible yet - the IPA passes might make various functions to not
3075      throw and they don't care to proactively update local EH info.  This is
3076      done later in fixup_cfg pass that also execute the verification.  */
3077   return (TODO_update_ssa | TODO_cleanup_cfg
3078           | (gimple_in_ssa_p (cfun) ? TODO_remove_unused_locals : 0)
3079           | (profile_status != PROFILE_ABSENT ? TODO_rebuild_frequencies : 0));
3080 }
3081
3082 /* FN is a function that has a complete body, and CLONE is a function whose
3083    body is to be set to a copy of FN, mapping argument declarations according
3084    to the ARG_MAP splay_tree.  */
3085
3086 void
3087 clone_body (tree clone, tree fn, void *arg_map)
3088 {
3089   copy_body_data id;
3090
3091   /* Clone the body, as if we were making an inline call.  But, remap the
3092      parameters in the callee to the parameters of caller.  */
3093   memset (&id, 0, sizeof (id));
3094   id.src_fn = fn;
3095   id.dst_fn = clone;
3096   id.src_cfun = DECL_STRUCT_FUNCTION (fn);
3097   id.decl_map = (struct pointer_map_t *)arg_map;
3098
3099   id.copy_decl = copy_decl_no_change;
3100   id.transform_call_graph_edges = CB_CGE_DUPLICATE;
3101   id.transform_new_cfg = true;
3102   id.transform_return_to_modify = false;
3103   id.transform_lang_insert_block = true;
3104
3105   /* We're not inside any EH region.  */
3106   id.eh_region = -1;
3107
3108   /* Actually copy the body.  */
3109   append_to_statement_list_force (copy_generic_body (&id), &DECL_SAVED_TREE (clone));
3110 }
3111
3112 /* Passed to walk_tree.  Copies the node pointed to, if appropriate.  */
3113
3114 tree
3115 copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
3116 {
3117   enum tree_code code = TREE_CODE (*tp);
3118   enum tree_code_class cl = TREE_CODE_CLASS (code);
3119
3120   /* We make copies of most nodes.  */
3121   if (IS_EXPR_CODE_CLASS (cl)
3122       || IS_GIMPLE_STMT_CODE_CLASS (cl)
3123       || code == TREE_LIST
3124       || code == TREE_VEC
3125       || code == TYPE_DECL
3126       || code == OMP_CLAUSE)
3127     {
3128       /* Because the chain gets clobbered when we make a copy, we save it
3129          here.  */
3130       tree chain = NULL_TREE, new;
3131
3132       if (!GIMPLE_TUPLE_P (*tp))
3133         chain = TREE_CHAIN (*tp);
3134
3135       /* Copy the node.  */
3136       new = copy_node (*tp);
3137
3138       /* Propagate mudflap marked-ness.  */
3139       if (flag_mudflap && mf_marked_p (*tp))
3140         mf_mark (new);
3141
3142       *tp = new;
3143
3144       /* Now, restore the chain, if appropriate.  That will cause
3145          walk_tree to walk into the chain as well.  */
3146       if (code == PARM_DECL
3147           || code == TREE_LIST
3148           || code == OMP_CLAUSE)
3149         TREE_CHAIN (*tp) = chain;
3150
3151       /* For now, we don't update BLOCKs when we make copies.  So, we
3152          have to nullify all BIND_EXPRs.  */
3153       if (TREE_CODE (*tp) == BIND_EXPR)
3154         BIND_EXPR_BLOCK (*tp) = NULL_TREE;
3155     }
3156   else if (code == CONSTRUCTOR)
3157     {
3158       /* CONSTRUCTOR nodes need special handling because
3159          we need to duplicate the vector of elements.  */
3160       tree new;
3161
3162       new = copy_node (*tp);
3163
3164       /* Propagate mudflap marked-ness.  */
3165       if (flag_mudflap && mf_marked_p (*tp))
3166         mf_mark (new);
3167
3168       CONSTRUCTOR_ELTS (new) = VEC_copy (constructor_elt, gc,
3169                                          CONSTRUCTOR_ELTS (*tp));
3170       *tp = new;
3171     }
3172   else if (TREE_CODE_CLASS (code) == tcc_type)
3173     *walk_subtrees = 0;
3174   else if (TREE_CODE_CLASS (code) == tcc_declaration)
3175     *walk_subtrees = 0;
3176   else if (TREE_CODE_CLASS (code) == tcc_constant)
3177     *walk_subtrees = 0;
3178   else
3179     gcc_assert (code != STATEMENT_LIST);
3180   return NULL_TREE;
3181 }
3182
3183 /* The SAVE_EXPR pointed to by TP is being copied.  If ST contains
3184    information indicating to what new SAVE_EXPR this one should be mapped,
3185    use that one.  Otherwise, create a new node and enter it in ST.  FN is
3186    the function into which the copy will be placed.  */
3187
3188 static void
3189 remap_save_expr (tree *tp, void *st_, int *walk_subtrees)
3190 {
3191   struct pointer_map_t *st = (struct pointer_map_t *) st_;
3192   tree *n;
3193   tree t;
3194
3195   /* See if we already encountered this SAVE_EXPR.  */
3196   n = (tree *) pointer_map_contains (st, *tp);
3197
3198   /* If we didn't already remap this SAVE_EXPR, do so now.  */
3199   if (!n)
3200     {
3201       t = copy_node (*tp);
3202
3203       /* Remember this SAVE_EXPR.  */
3204       *pointer_map_insert (st, *tp) = t;
3205       /* Make sure we don't remap an already-remapped SAVE_EXPR.  */
3206       *pointer_map_insert (st, t) = t;
3207     }
3208   else
3209     {
3210       /* We've already walked into this SAVE_EXPR; don't do it again.  */
3211       *walk_subtrees = 0;
3212       t = *n;
3213     }
3214
3215   /* Replace this SAVE_EXPR with the copy.  */
3216   *tp = t;
3217 }
3218
3219 /* Called via walk_tree.  If *TP points to a DECL_STMT for a local label,
3220    copies the declaration and enters it in the splay_tree in DATA (which is
3221    really an `copy_body_data *').  */
3222
3223 static tree
3224 mark_local_for_remap_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
3225                         void *data)
3226 {
3227   copy_body_data *id = (copy_body_data *) data;
3228
3229   /* Don't walk into types.  */
3230   if (TYPE_P (*tp))
3231     *walk_subtrees = 0;
3232
3233   else if (TREE_CODE (*tp) == LABEL_EXPR)
3234     {
3235       tree decl = TREE_OPERAND (*tp, 0);
3236
3237       /* Copy the decl and remember the copy.  */
3238       insert_decl_map (id, decl, id->copy_decl (decl, id));
3239     }
3240
3241   return NULL_TREE;
3242 }
3243
3244 /* Perform any modifications to EXPR required when it is unsaved.  Does
3245    not recurse into EXPR's subtrees.  */
3246
3247 static void
3248 unsave_expr_1 (tree expr)
3249 {
3250   switch (TREE_CODE (expr))
3251     {
3252     case TARGET_EXPR:
3253       /* Don't mess with a TARGET_EXPR that hasn't been expanded.
3254          It's OK for this to happen if it was part of a subtree that
3255          isn't immediately expanded, such as operand 2 of another
3256          TARGET_EXPR.  */
3257       if (TREE_OPERAND (expr, 1))
3258         break;
3259
3260       TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
3261       TREE_OPERAND (expr, 3) = NULL_TREE;
3262       break;
3263
3264     default:
3265       break;
3266     }
3267 }
3268
3269 /* Called via walk_tree when an expression is unsaved.  Using the
3270    splay_tree pointed to by ST (which is really a `splay_tree'),
3271    remaps all local declarations to appropriate replacements.  */
3272
3273 static tree
3274 unsave_r (tree *tp, int *walk_subtrees, void *data)
3275 {
3276   copy_body_data *id = (copy_body_data *) data;
3277   struct pointer_map_t *st = id->decl_map;
3278   tree *n;
3279
3280   /* Only a local declaration (variable or label).  */
3281   if ((TREE_CODE (*tp) == VAR_DECL && !TREE_STATIC (*tp))
3282       || TREE_CODE (*tp) == LABEL_DECL)
3283     {
3284       /* Lookup the declaration.  */
3285       n = (tree *) pointer_map_contains (st, *tp);
3286
3287       /* If it's there, remap it.  */
3288       if (n)
3289         *tp = *n;
3290     }
3291
3292   else if (TREE_CODE (*tp) == STATEMENT_LIST)
3293     copy_statement_list (tp);
3294   else if (TREE_CODE (*tp) == BIND_EXPR)
3295     copy_bind_expr (tp, walk_subtrees, id);
3296   else if (TREE_CODE (*tp) == SAVE_EXPR)
3297     remap_save_expr (tp, st, walk_subtrees);
3298   else
3299     {
3300       copy_tree_r (tp, walk_subtrees, NULL);
3301
3302       /* Do whatever unsaving is required.  */
3303       unsave_expr_1 (*tp);
3304     }
3305
3306   /* Keep iterating.  */
3307   return NULL_TREE;
3308 }
3309
3310 /* Copies everything in EXPR and replaces variables, labels
3311    and SAVE_EXPRs local to EXPR.  */
3312
3313 tree
3314 unsave_expr_now (tree expr)
3315 {
3316   copy_body_data id;
3317
3318   /* There's nothing to do for NULL_TREE.  */
3319   if (expr == 0)
3320     return expr;
3321
3322   /* Set up ID.  */
3323   memset (&id, 0, sizeof (id));
3324   id.src_fn = current_function_decl;
3325   id.dst_fn = current_function_decl;
3326   id.decl_map = pointer_map_create ();
3327
3328   id.copy_decl = copy_decl_no_change;
3329   id.transform_call_graph_edges = CB_CGE_DUPLICATE;
3330   id.transform_new_cfg = false;
3331   id.transform_return_to_modify = false;
3332   id.transform_lang_insert_block = false;
3333
3334   /* Walk the tree once to find local labels.  */
3335   walk_tree_without_duplicates (&expr, mark_local_for_remap_r, &id);
3336
3337   /* Walk the tree again, copying, remapping, and unsaving.  */
3338   walk_tree (&expr, unsave_r, &id, NULL);
3339
3340   /* Clean up.  */
3341   pointer_map_destroy (id.decl_map);
3342
3343   return expr;
3344 }
3345
3346 /* Allow someone to determine if SEARCH is a child of TOP from gdb.  */
3347
3348 static tree
3349 debug_find_tree_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
3350 {
3351   if (*tp == data)
3352     return (tree) data;
3353   else
3354     return NULL;
3355 }
3356
3357 bool
3358 debug_find_tree (tree top, tree search)
3359 {
3360   return walk_tree_without_duplicates (&top, debug_find_tree_1, search) != 0;
3361 }
3362
3363
3364 /* Declare the variables created by the inliner.  Add all the variables in
3365    VARS to BIND_EXPR.  */
3366
3367 static void
3368 declare_inline_vars (tree block, tree vars)
3369 {
3370   tree t;
3371   for (t = vars; t; t = TREE_CHAIN (t))
3372     {
3373       DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
3374       gcc_assert (!TREE_STATIC (t) && !TREE_ASM_WRITTEN (t));
3375       cfun->unexpanded_var_list =
3376         tree_cons (NULL_TREE, t,
3377                    cfun->unexpanded_var_list);
3378     }
3379
3380   if (block)
3381     BLOCK_VARS (block) = chainon (BLOCK_VARS (block), vars);
3382 }
3383
3384
3385 /* Copy NODE (which must be a DECL).  The DECL originally was in the FROM_FN,
3386    but now it will be in the TO_FN.  PARM_TO_VAR means enable PARM_DECL to
3387    VAR_DECL translation.  */
3388
3389 static tree
3390 copy_decl_for_dup_finish (copy_body_data *id, tree decl, tree copy)
3391 {
3392   /* Don't generate debug information for the copy if we wouldn't have
3393      generated it for the copy either.  */
3394   DECL_ARTIFICIAL (copy) = DECL_ARTIFICIAL (decl);
3395   DECL_IGNORED_P (copy) = DECL_IGNORED_P (decl);
3396
3397   /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
3398      declaration inspired this copy.  */
3399   DECL_ABSTRACT_ORIGIN (copy) = DECL_ORIGIN (decl);
3400
3401   /* The new variable/label has no RTL, yet.  */
3402   if (CODE_CONTAINS_STRUCT (TREE_CODE (copy), TS_DECL_WRTL)
3403       && !TREE_STATIC (copy) && !DECL_EXTERNAL (copy))
3404     SET_DECL_RTL (copy, NULL_RTX);
3405
3406   /* These args would always appear unused, if not for this.  */
3407   TREE_USED (copy) = 1;
3408
3409   /* Set the context for the new declaration.  */
3410   if (!DECL_CONTEXT (decl))
3411     /* Globals stay global.  */
3412     ;
3413   else if (DECL_CONTEXT (decl) != id->src_fn)
3414     /* Things that weren't in the scope of the function we're inlining
3415        from aren't in the scope we're inlining to, either.  */
3416     ;
3417   else if (TREE_STATIC (decl))
3418     /* Function-scoped static variables should stay in the original
3419        function.  */
3420     ;
3421   else
3422     /* Ordinary automatic local variables are now in the scope of the
3423        new function.  */
3424     DECL_CONTEXT (copy) = id->dst_fn;
3425
3426   return copy;
3427 }
3428
3429 static tree
3430 copy_decl_to_var (tree decl, copy_body_data *id)
3431 {
3432   tree copy, type;
3433
3434   gcc_assert (TREE_CODE (decl) == PARM_DECL
3435               || TREE_CODE (decl) == RESULT_DECL);
3436
3437   type = TREE_TYPE (decl);
3438
3439   copy = build_decl (VAR_DECL, DECL_NAME (decl), type);
3440   TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl);
3441   TREE_READONLY (copy) = TREE_READONLY (decl);
3442   TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl);
3443   DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl);
3444   DECL_NO_TBAA_P (copy) = DECL_NO_TBAA_P (decl);
3445
3446   return copy_decl_for_dup_finish (id, decl, copy);
3447 }
3448
3449 /* Like copy_decl_to_var, but create a return slot object instead of a
3450    pointer variable for return by invisible reference.  */
3451
3452 static tree
3453 copy_result_decl_to_var (tree decl, copy_body_data *id)
3454 {
3455   tree copy, type;
3456
3457   gcc_assert (TREE_CODE (decl) == PARM_DECL
3458               || TREE_CODE (decl) == RESULT_DECL);
3459
3460   type = TREE_TYPE (decl);
3461   if (DECL_BY_REFERENCE (decl))
3462     type = TREE_TYPE (type);
3463
3464   copy = build_decl (VAR_DECL, DECL_NAME (decl), type);
3465   TREE_READONLY (copy) = TREE_READONLY (decl);
3466   TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl);
3467   if (!DECL_BY_REFERENCE (decl))
3468     {
3469       TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl);
3470       DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl);
3471       DECL_NO_TBAA_P (copy) = DECL_NO_TBAA_P (decl);
3472     }
3473
3474   return copy_decl_for_dup_finish (id, decl, copy);
3475 }
3476
3477
3478 static tree
3479 copy_decl_no_change (tree decl, copy_body_data *id)
3480 {
3481   tree copy;
3482
3483   copy = copy_node (decl);
3484
3485   /* The COPY is not abstract; it will be generated in DST_FN.  */
3486   DECL_ABSTRACT (copy) = 0;
3487   lang_hooks.dup_lang_specific_decl (copy);
3488
3489   /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
3490      been taken; it's for internal bookkeeping in expand_goto_internal.  */
3491   if (TREE_CODE (copy) == LABEL_DECL)
3492     {
3493       TREE_ADDRESSABLE (copy) = 0;
3494       LABEL_DECL_UID (copy) = -1;
3495     }
3496
3497   return copy_decl_for_dup_finish (id, decl, copy);
3498 }
3499
3500 static tree
3501 copy_decl_maybe_to_var (tree decl, copy_body_data *id)
3502 {
3503   if (TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL)
3504     return copy_decl_to_var (decl, id);
3505   else
3506     return copy_decl_no_change (decl, id);
3507 }
3508
3509 /* Return a copy of the function's argument tree.  */
3510 static tree
3511 copy_arguments_for_versioning (tree orig_parm, copy_body_data * id)
3512 {
3513   tree *arg_copy, *parg;
3514
3515   arg_copy = &orig_parm;
3516   for (parg = arg_copy; *parg; parg = &TREE_CHAIN (*parg))
3517     {
3518       tree new = remap_decl (*parg, id);
3519       lang_hooks.dup_lang_specific_decl (new);
3520       TREE_CHAIN (new) = TREE_CHAIN (*parg);
3521       *parg = new;
3522     }
3523   return orig_parm;
3524 }
3525
3526 /* Return a copy of the function's static chain.  */
3527 static tree
3528 copy_static_chain (tree static_chain, copy_body_data * id)
3529 {
3530   tree *chain_copy, *pvar;
3531
3532   chain_copy = &static_chain;
3533   for (pvar = chain_copy; *pvar; pvar = &TREE_CHAIN (*pvar))
3534     {
3535       tree new = remap_decl (*pvar, id);
3536       lang_hooks.dup_lang_specific_decl (new);
3537       TREE_CHAIN (new) = TREE_CHAIN (*pvar);
3538       *pvar = new;
3539     }
3540   return static_chain;
3541 }
3542
3543 /* Return true if the function is allowed to be versioned.
3544    This is a guard for the versioning functionality.  */
3545 bool
3546 tree_versionable_function_p (tree fndecl)
3547 {
3548   if (fndecl == NULL_TREE)
3549     return false;
3550   /* ??? There are cases where a function is
3551      uninlinable but can be versioned.  */
3552   if (!tree_inlinable_function_p (fndecl))
3553     return false;
3554
3555   return true;
3556 }
3557
3558 /* Create a copy of a function's tree.
3559    OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
3560    of the original function and the new copied function
3561    respectively.  In case we want to replace a DECL
3562    tree with another tree while duplicating the function's
3563    body, TREE_MAP represents the mapping between these
3564    trees. If UPDATE_CLONES is set, the call_stmt fields
3565    of edges of clones of the function will be updated.  */
3566 void
3567 tree_function_versioning (tree old_decl, tree new_decl, varray_type tree_map,
3568                           bool update_clones)
3569 {
3570   struct cgraph_node *old_version_node;
3571   struct cgraph_node *new_version_node;
3572   copy_body_data id;
3573   tree p;
3574   unsigned i;
3575   struct ipa_replace_map *replace_info;
3576   basic_block old_entry_block;
3577   tree t_step;
3578   tree old_current_function_decl = current_function_decl;
3579
3580   gcc_assert (TREE_CODE (old_decl) == FUNCTION_DECL
3581               && TREE_CODE (new_decl) == FUNCTION_DECL);
3582   DECL_POSSIBLY_INLINED (old_decl) = 1;
3583
3584   old_version_node = cgraph_node (old_decl);
3585   new_version_node = cgraph_node (new_decl);
3586
3587   DECL_ARTIFICIAL (new_decl) = 1;
3588   DECL_ABSTRACT_ORIGIN (new_decl) = DECL_ORIGIN (old_decl);
3589
3590   /* Prepare the data structures for the tree copy.  */
3591   memset (&id, 0, sizeof (id));
3592
3593   /* Generate a new name for the new version. */
3594   if (!update_clones)
3595     {
3596       DECL_NAME (new_decl) =  create_tmp_var_name (NULL);
3597       SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
3598       SET_DECL_RTL (new_decl, NULL_RTX);
3599       id.statements_to_fold = pointer_set_create ();
3600     }
3601
3602   id.decl_map = pointer_map_create ();
3603   id.src_fn = old_decl;
3604   id.dst_fn = new_decl;
3605   id.src_node = old_version_node;
3606   id.dst_node = new_version_node;
3607   id.src_cfun = DECL_STRUCT_FUNCTION (old_decl);
3608
3609   id.copy_decl = copy_decl_no_change;
3610   id.transform_call_graph_edges
3611     = update_clones ? CB_CGE_MOVE_CLONES : CB_CGE_MOVE;
3612   id.transform_new_cfg = true;
3613   id.transform_return_to_modify = false;
3614   id.transform_lang_insert_block = false;
3615
3616   current_function_decl = new_decl;
3617   old_entry_block = ENTRY_BLOCK_PTR_FOR_FUNCTION
3618     (DECL_STRUCT_FUNCTION (old_decl));
3619   initialize_cfun (new_decl, old_decl,
3620                    old_entry_block->count,
3621                    old_entry_block->frequency);
3622   push_cfun (DECL_STRUCT_FUNCTION (new_decl));
3623
3624   /* Copy the function's static chain.  */
3625   p = DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl;
3626   if (p)
3627     DECL_STRUCT_FUNCTION (new_decl)->static_chain_decl =
3628       copy_static_chain (DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl,
3629                          &id);
3630   /* Copy the function's arguments.  */
3631   if (DECL_ARGUMENTS (old_decl) != NULL_TREE)
3632     DECL_ARGUMENTS (new_decl) =
3633       copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl), &id);
3634
3635   /* If there's a tree_map, prepare for substitution.  */
3636   if (tree_map)
3637     for (i = 0; i < VARRAY_ACTIVE_SIZE (tree_map); i++)
3638       {
3639         replace_info = VARRAY_GENERIC_PTR (tree_map, i);
3640         if (replace_info->replace_p)
3641           insert_decl_map (&id, replace_info->old_tree,
3642                            replace_info->new_tree);
3643       }
3644
3645   DECL_INITIAL (new_decl) = remap_blocks (DECL_INITIAL (id.src_fn), &id);
3646
3647   /* Renumber the lexical scoping (non-code) blocks consecutively.  */
3648   number_blocks (id.dst_fn);
3649
3650   if (DECL_STRUCT_FUNCTION (old_decl)->unexpanded_var_list != NULL_TREE)
3651     /* Add local vars.  */
3652     for (t_step = DECL_STRUCT_FUNCTION (old_decl)->unexpanded_var_list;
3653          t_step; t_step = TREE_CHAIN (t_step))
3654       {
3655         tree var = TREE_VALUE (t_step);
3656         if (TREE_STATIC (var) && !TREE_ASM_WRITTEN (var))
3657           cfun->unexpanded_var_list = tree_cons (NULL_TREE, var,
3658                                                  cfun->unexpanded_var_list);
3659         else
3660           cfun->unexpanded_var_list =
3661             tree_cons (NULL_TREE, remap_decl (var, &id),
3662                        cfun->unexpanded_var_list);
3663       }
3664
3665   /* Copy the Function's body.  */
3666   copy_body (&id, old_entry_block->count, old_entry_block->frequency, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR);
3667
3668   if (DECL_RESULT (old_decl) != NULL_TREE)
3669     {
3670       tree *res_decl = &DECL_RESULT (old_decl);
3671       DECL_RESULT (new_decl) = remap_decl (*res_decl, &id);
3672       lang_hooks.dup_lang_specific_decl (DECL_RESULT (new_decl));
3673     }
3674
3675   /* Renumber the lexical scoping (non-code) blocks consecutively.  */
3676   number_blocks (new_decl);
3677
3678   /* Clean up.  */
3679   pointer_map_destroy (id.decl_map);
3680   if (!update_clones)
3681     {
3682       fold_marked_statements (0, id.statements_to_fold);
3683       pointer_set_destroy (id.statements_to_fold);
3684       fold_cond_expr_cond ();
3685     }
3686   if (gimple_in_ssa_p (cfun))
3687     {
3688       free_dominance_info (CDI_DOMINATORS);
3689       free_dominance_info (CDI_POST_DOMINATORS);
3690       if (!update_clones)
3691         delete_unreachable_blocks ();
3692       update_ssa (TODO_update_ssa);
3693       if (!update_clones)
3694         {
3695           fold_cond_expr_cond ();
3696           if (need_ssa_update_p ())
3697             update_ssa (TODO_update_ssa);
3698         }
3699     }
3700   free_dominance_info (CDI_DOMINATORS);
3701   free_dominance_info (CDI_POST_DOMINATORS);
3702   pop_cfun ();
3703   current_function_decl = old_current_function_decl;
3704   gcc_assert (!current_function_decl
3705               || DECL_STRUCT_FUNCTION (current_function_decl) == cfun);
3706   return;
3707 }
3708
3709 /* Duplicate a type, fields and all.  */
3710
3711 tree
3712 build_duplicate_type (tree type)
3713 {
3714   struct copy_body_data id;
3715
3716   memset (&id, 0, sizeof (id));
3717   id.src_fn = current_function_decl;
3718   id.dst_fn = current_function_decl;
3719   id.src_cfun = cfun;
3720   id.decl_map = pointer_map_create ();
3721   id.copy_decl = copy_decl_no_change;
3722
3723   type = remap_type_1 (type, &id);
3724
3725   pointer_map_destroy (id.decl_map);
3726
3727   TYPE_CANONICAL (type) = type;
3728
3729   return type;
3730 }