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 = TREE_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 && !TREE_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       *walk_subtrees = 0;
2269       return NULL;
2270
2271       /* CHANGE_DYNAMIC_TYPE_EXPR explicitly expands to nothing.  */
2272     case CHANGE_DYNAMIC_TYPE_EXPR:
2273       *walk_subtrees = 0;
2274       return NULL;
2275
2276     /* Try to estimate the cost of assignments.  We have three cases to
2277        deal with:
2278         1) Simple assignments to registers;
2279         2) Stores to things that must live in memory.  This includes
2280            "normal" stores to scalars, but also assignments of large
2281            structures, or constructors of big arrays;
2282         3) TARGET_EXPRs.
2283
2284        Let us look at the first two cases, assuming we have "a = b + C":
2285        <GIMPLE_MODIFY_STMT <var_decl "a">
2286                            <plus_expr <var_decl "b"> <constant C>>
2287        If "a" is a GIMPLE register, the assignment to it is free on almost
2288        any target, because "a" usually ends up in a real register.  Hence
2289        the only cost of this expression comes from the PLUS_EXPR, and we
2290        can ignore the GIMPLE_MODIFY_STMT.
2291        If "a" is not a GIMPLE register, the assignment to "a" will most
2292        likely be a real store, so the cost of the GIMPLE_MODIFY_STMT is the cost
2293        of moving something into "a", which we compute using the function
2294        estimate_move_cost.
2295
2296        The third case deals with TARGET_EXPRs, for which the semantics are
2297        that a temporary is assigned, unless the TARGET_EXPR itself is being
2298        assigned to something else.  In the latter case we do not need the
2299        temporary.  E.g. in:
2300                 <GIMPLE_MODIFY_STMT <var_decl "a"> <target_expr>>, the
2301        GIMPLE_MODIFY_STMT is free.  */
2302     case INIT_EXPR:
2303     case GIMPLE_MODIFY_STMT:
2304       /* Is the right and side a TARGET_EXPR?  */
2305       if (TREE_CODE (GENERIC_TREE_OPERAND (x, 1)) == TARGET_EXPR)
2306         break;
2307       /* ... fall through ...  */
2308
2309     case TARGET_EXPR:
2310       x = GENERIC_TREE_OPERAND (x, 0);
2311       /* Is this an assignments to a register?  */
2312       if (is_gimple_reg (x))
2313         break;
2314       /* Otherwise it's a store, so fall through to compute the move cost.  */
2315
2316     case CONSTRUCTOR:
2317       d->count += estimate_move_cost (TREE_TYPE (x));
2318       break;
2319
2320     /* Assign cost of 1 to usual operations.
2321        ??? We may consider mapping RTL costs to this.  */
2322     case COND_EXPR:
2323     case VEC_COND_EXPR:
2324
2325     case PLUS_EXPR:
2326     case POINTER_PLUS_EXPR:
2327     case MINUS_EXPR:
2328     case MULT_EXPR:
2329
2330     case FIXED_CONVERT_EXPR:
2331     case FIX_TRUNC_EXPR:
2332
2333     case NEGATE_EXPR:
2334     case FLOAT_EXPR:
2335     case MIN_EXPR:
2336     case MAX_EXPR:
2337     case ABS_EXPR:
2338
2339     case LSHIFT_EXPR:
2340     case RSHIFT_EXPR:
2341     case LROTATE_EXPR:
2342     case RROTATE_EXPR:
2343     case VEC_LSHIFT_EXPR:
2344     case VEC_RSHIFT_EXPR:
2345
2346     case BIT_IOR_EXPR:
2347     case BIT_XOR_EXPR:
2348     case BIT_AND_EXPR:
2349     case BIT_NOT_EXPR:
2350
2351     case TRUTH_ANDIF_EXPR:
2352     case TRUTH_ORIF_EXPR:
2353     case TRUTH_AND_EXPR:
2354     case TRUTH_OR_EXPR:
2355     case TRUTH_XOR_EXPR:
2356     case TRUTH_NOT_EXPR:
2357
2358     case LT_EXPR:
2359     case LE_EXPR:
2360     case GT_EXPR:
2361     case GE_EXPR:
2362     case EQ_EXPR:
2363     case NE_EXPR:
2364     case ORDERED_EXPR:
2365     case UNORDERED_EXPR:
2366
2367     case UNLT_EXPR:
2368     case UNLE_EXPR:
2369     case UNGT_EXPR:
2370     case UNGE_EXPR:
2371     case UNEQ_EXPR:
2372     case LTGT_EXPR:
2373
2374     case CONJ_EXPR:
2375
2376     case PREDECREMENT_EXPR:
2377     case PREINCREMENT_EXPR:
2378     case POSTDECREMENT_EXPR:
2379     case POSTINCREMENT_EXPR:
2380
2381     case ASM_EXPR:
2382
2383     case REALIGN_LOAD_EXPR:
2384
2385     case REDUC_MAX_EXPR:
2386     case REDUC_MIN_EXPR:
2387     case REDUC_PLUS_EXPR:
2388     case WIDEN_SUM_EXPR:
2389     case DOT_PROD_EXPR:
2390     case VEC_WIDEN_MULT_HI_EXPR:
2391     case VEC_WIDEN_MULT_LO_EXPR:
2392     case VEC_UNPACK_HI_EXPR:
2393     case VEC_UNPACK_LO_EXPR:
2394     case VEC_UNPACK_FLOAT_HI_EXPR:
2395     case VEC_UNPACK_FLOAT_LO_EXPR:
2396     case VEC_PACK_TRUNC_EXPR:
2397     case VEC_PACK_SAT_EXPR:
2398     case VEC_PACK_FIX_TRUNC_EXPR:
2399
2400     case WIDEN_MULT_EXPR:
2401
2402     case VEC_EXTRACT_EVEN_EXPR:
2403     case VEC_EXTRACT_ODD_EXPR:
2404     case VEC_INTERLEAVE_HIGH_EXPR:
2405     case VEC_INTERLEAVE_LOW_EXPR:
2406
2407     case RESX_EXPR:
2408       d->count += 1;
2409       break;
2410
2411     case SWITCH_EXPR:
2412       /* Take into account cost of the switch + guess 2 conditional jumps for
2413          each case label.
2414
2415          TODO: once the switch expansion logic is sufficiently separated, we can
2416          do better job on estimating cost of the switch.  */
2417       d->count += TREE_VEC_LENGTH (SWITCH_LABELS (x)) * 2;
2418       break;
2419
2420     /* Few special cases of expensive operations.  This is useful
2421        to avoid inlining on functions having too many of these.  */
2422     case TRUNC_DIV_EXPR:
2423     case CEIL_DIV_EXPR:
2424     case FLOOR_DIV_EXPR:
2425     case ROUND_DIV_EXPR:
2426     case EXACT_DIV_EXPR:
2427     case TRUNC_MOD_EXPR:
2428     case CEIL_MOD_EXPR:
2429     case FLOOR_MOD_EXPR:
2430     case ROUND_MOD_EXPR:
2431     case RDIV_EXPR:
2432       d->count += d->weights->div_mod_cost;
2433       break;
2434     case CALL_EXPR:
2435       {
2436         tree decl = get_callee_fndecl (x);
2437         tree addr = CALL_EXPR_FN (x);
2438         tree funtype = TREE_TYPE (addr);
2439
2440         gcc_assert (POINTER_TYPE_P (funtype));
2441         funtype = TREE_TYPE (funtype);
2442
2443         if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD)
2444           cost = d->weights->target_builtin_call_cost;
2445         else
2446           cost = d->weights->call_cost;
2447
2448         if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
2449           switch (DECL_FUNCTION_CODE (decl))
2450             {
2451             case BUILT_IN_CONSTANT_P:
2452               *walk_subtrees = 0;
2453               return NULL_TREE;
2454             case BUILT_IN_EXPECT:
2455               return NULL_TREE;
2456             /* Prefetch instruction is not expensive.  */
2457             case BUILT_IN_PREFETCH:
2458               cost = 1;
2459               break;
2460             default:
2461               break;
2462             }
2463
2464         if (decl)
2465           funtype = TREE_TYPE (decl);
2466
2467         /* Our cost must be kept in sync with cgraph_estimate_size_after_inlining
2468            that does use function declaration to figure out the arguments.
2469
2470            When we deal with function with no body nor prototype, base estimates on
2471            actual parameters of the call expression.  Otherwise use either the actual
2472            arguments types or function declaration for more precise answer.  */
2473         if (decl && DECL_ARGUMENTS (decl))
2474           {
2475             tree arg;
2476             for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg))
2477               d->count += estimate_move_cost (TREE_TYPE (arg));
2478           }
2479         else if (funtype && prototype_p (funtype))
2480           {
2481             tree t;
2482             for (t = TYPE_ARG_TYPES (funtype); t; t = TREE_CHAIN (t))
2483               d->count += estimate_move_cost (TREE_VALUE (t));
2484           }
2485         else
2486           {
2487             tree a;
2488             call_expr_arg_iterator iter;
2489             FOR_EACH_CALL_EXPR_ARG (a, iter, x)
2490               d->count += estimate_move_cost (TREE_TYPE (a));
2491           }
2492
2493         d->count += cost;
2494         break;
2495       }
2496
2497     case OMP_PARALLEL:
2498     case OMP_FOR:
2499     case OMP_SECTIONS:
2500     case OMP_SINGLE:
2501     case OMP_SECTION:
2502     case OMP_MASTER:
2503     case OMP_ORDERED:
2504     case OMP_CRITICAL:
2505     case OMP_ATOMIC:
2506     case OMP_ATOMIC_LOAD:
2507       /* OpenMP directives are generally very expensive.  */
2508       d->count += d->weights->omp_cost;
2509       break;
2510
2511     default:
2512       gcc_unreachable ();
2513     }
2514   return NULL;
2515 }
2516
2517 /* Estimate number of instructions that will be created by expanding EXPR.
2518    WEIGHTS contains weights attributed to various constructs.  */
2519
2520 int
2521 estimate_num_insns (tree expr, eni_weights *weights)
2522 {
2523   struct pointer_set_t *visited_nodes;
2524   basic_block bb;
2525   block_stmt_iterator bsi;
2526   struct function *my_function;
2527   struct eni_data data;
2528
2529   data.count = 0;
2530   data.weights = weights;
2531
2532   /* If we're given an entire function, walk the CFG.  */
2533   if (TREE_CODE (expr) == FUNCTION_DECL)
2534     {
2535       my_function = DECL_STRUCT_FUNCTION (expr);
2536       gcc_assert (my_function && my_function->cfg);
2537       visited_nodes = pointer_set_create ();
2538       FOR_EACH_BB_FN (bb, my_function)
2539         {
2540           for (bsi = bsi_start (bb);
2541                !bsi_end_p (bsi);
2542                bsi_next (&bsi))
2543             {
2544               walk_tree (bsi_stmt_ptr (bsi), estimate_num_insns_1,
2545                          &data, visited_nodes);
2546             }
2547         }
2548       pointer_set_destroy (visited_nodes);
2549     }
2550   else
2551     walk_tree_without_duplicates (&expr, estimate_num_insns_1, &data);
2552
2553   return data.count;
2554 }
2555
2556 /* Initializes weights used by estimate_num_insns.  */
2557
2558 void
2559 init_inline_once (void)
2560 {
2561   eni_inlining_weights.call_cost = PARAM_VALUE (PARAM_INLINE_CALL_COST);
2562   eni_inlining_weights.target_builtin_call_cost = 1;
2563   eni_inlining_weights.div_mod_cost = 10;
2564   eni_inlining_weights.omp_cost = 40;
2565
2566   eni_size_weights.call_cost = 1;
2567   eni_size_weights.target_builtin_call_cost = 1;
2568   eni_size_weights.div_mod_cost = 1;
2569   eni_size_weights.omp_cost = 40;
2570
2571   /* Estimating time for call is difficult, since we have no idea what the
2572      called function does.  In the current uses of eni_time_weights,
2573      underestimating the cost does less harm than overestimating it, so
2574      we choose a rather small value here.  */
2575   eni_time_weights.call_cost = 10;
2576   eni_time_weights.target_builtin_call_cost = 10;
2577   eni_time_weights.div_mod_cost = 10;
2578   eni_time_weights.omp_cost = 40;
2579 }
2580
2581 /* Install new lexical TREE_BLOCK underneath 'current_block'.  */
2582 static void
2583 add_lexical_block (tree current_block, tree new_block)
2584 {
2585   tree *blk_p;
2586
2587   /* Walk to the last sub-block.  */
2588   for (blk_p = &BLOCK_SUBBLOCKS (current_block);
2589        *blk_p;
2590        blk_p = &BLOCK_CHAIN (*blk_p))
2591     ;
2592   *blk_p = new_block;
2593   BLOCK_SUPERCONTEXT (new_block) = current_block;
2594 }
2595
2596 /* If *TP is a CALL_EXPR, replace it with its inline expansion.  */
2597
2598 static bool
2599 expand_call_inline (basic_block bb, tree stmt, tree *tp, void *data)
2600 {
2601   copy_body_data *id;
2602   tree t;
2603   tree retvar, use_retvar;
2604   tree fn;
2605   struct pointer_map_t *st;
2606   tree return_slot;
2607   tree modify_dest;
2608   location_t saved_location;
2609   struct cgraph_edge *cg_edge;
2610   const char *reason;
2611   basic_block return_block;
2612   edge e;
2613   block_stmt_iterator bsi, stmt_bsi;
2614   bool successfully_inlined = FALSE;
2615   bool purge_dead_abnormal_edges;
2616   tree t_step;
2617   tree var;
2618
2619   /* See what we've got.  */
2620   id = (copy_body_data *) data;
2621   t = *tp;
2622
2623   /* Set input_location here so we get the right instantiation context
2624      if we call instantiate_decl from inlinable_function_p.  */
2625   saved_location = input_location;
2626   if (EXPR_HAS_LOCATION (t))
2627     input_location = EXPR_LOCATION (t);
2628
2629   /* From here on, we're only interested in CALL_EXPRs.  */
2630   if (TREE_CODE (t) != CALL_EXPR)
2631     goto egress;
2632
2633   /* First, see if we can figure out what function is being called.
2634      If we cannot, then there is no hope of inlining the function.  */
2635   fn = get_callee_fndecl (t);
2636   if (!fn)
2637     goto egress;
2638
2639   /* Turn forward declarations into real ones.  */
2640   fn = cgraph_node (fn)->decl;
2641
2642   /* If fn is a declaration of a function in a nested scope that was
2643      globally declared inline, we don't set its DECL_INITIAL.
2644      However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
2645      C++ front-end uses it for cdtors to refer to their internal
2646      declarations, that are not real functions.  Fortunately those
2647      don't have trees to be saved, so we can tell by checking their
2648      DECL_SAVED_TREE.  */
2649   if (! DECL_INITIAL (fn)
2650       && DECL_ABSTRACT_ORIGIN (fn)
2651       && DECL_SAVED_TREE (DECL_ABSTRACT_ORIGIN (fn)))
2652     fn = DECL_ABSTRACT_ORIGIN (fn);
2653
2654   /* Objective C and fortran still calls tree_rest_of_compilation directly.
2655      Kill this check once this is fixed.  */
2656   if (!id->dst_node->analyzed)
2657     goto egress;
2658
2659   cg_edge = cgraph_edge (id->dst_node, stmt);
2660
2661   /* Constant propagation on argument done during previous inlining
2662      may create new direct call.  Produce an edge for it.  */
2663   if (!cg_edge)
2664     {
2665       struct cgraph_node *dest = cgraph_node (fn);
2666
2667       /* We have missing edge in the callgraph.  This can happen in one case
2668          where previous inlining turned indirect call into direct call by
2669          constant propagating arguments.  In all other cases we hit a bug
2670          (incorrect node sharing is most common reason for missing edges.  */
2671       gcc_assert (dest->needed || !flag_unit_at_a_time);
2672       cgraph_create_edge (id->dst_node, dest, stmt,
2673                           bb->count, CGRAPH_FREQ_BASE,
2674                           bb->loop_depth)->inline_failed
2675         = N_("originally indirect function call not considered for inlining");
2676       if (dump_file)
2677         {
2678            fprintf (dump_file, "Created new direct edge to %s",
2679                     cgraph_node_name (dest));
2680         }
2681       goto egress;
2682     }
2683
2684   /* Don't try to inline functions that are not well-suited to
2685      inlining.  */
2686   if (!cgraph_inline_p (cg_edge, &reason))
2687     {
2688       if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn))
2689           /* Avoid warnings during early inline pass. */
2690           && (!flag_unit_at_a_time || cgraph_global_info_ready))
2691         {
2692           sorry ("inlining failed in call to %q+F: %s", fn, reason);
2693           sorry ("called from here");
2694         }
2695       else if (warn_inline && DECL_DECLARED_INLINE_P (fn)
2696                && !DECL_IN_SYSTEM_HEADER (fn)
2697                && strlen (reason)
2698                && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn))
2699                /* Avoid warnings during early inline pass. */
2700                && (!flag_unit_at_a_time || cgraph_global_info_ready))
2701         {
2702           warning (OPT_Winline, "inlining failed in call to %q+F: %s",
2703                    fn, reason);
2704           warning (OPT_Winline, "called from here");
2705         }
2706       goto egress;
2707     }
2708   fn = cg_edge->callee->decl;
2709
2710 #ifdef ENABLE_CHECKING
2711   if (cg_edge->callee->decl != id->dst_node->decl)
2712     verify_cgraph_node (cg_edge->callee);
2713 #endif
2714
2715   /* We will be inlining this callee.  */
2716   id->eh_region = lookup_stmt_eh_region (stmt);
2717
2718   /* Split the block holding the CALL_EXPR.  */
2719   e = split_block (bb, stmt);
2720   bb = e->src;
2721   return_block = e->dest;
2722   remove_edge (e);
2723
2724   /* split_block splits after the statement; work around this by
2725      moving the call into the second block manually.  Not pretty,
2726      but seems easier than doing the CFG manipulation by hand
2727      when the CALL_EXPR is in the last statement of BB.  */
2728   stmt_bsi = bsi_last (bb);
2729   bsi_remove (&stmt_bsi, false);
2730
2731   /* If the CALL_EXPR was in the last statement of BB, it may have
2732      been the source of abnormal edges.  In this case, schedule
2733      the removal of dead abnormal edges.  */
2734   bsi = bsi_start (return_block);
2735   if (bsi_end_p (bsi))
2736     {
2737       bsi_insert_after (&bsi, stmt, BSI_NEW_STMT);
2738       purge_dead_abnormal_edges = true;
2739     }
2740   else
2741     {
2742       bsi_insert_before (&bsi, stmt, BSI_NEW_STMT);
2743       purge_dead_abnormal_edges = false;
2744     }
2745
2746   stmt_bsi = bsi_start (return_block);
2747
2748   /* Build a block containing code to initialize the arguments, the
2749      actual inline expansion of the body, and a label for the return
2750      statements within the function to jump to.  The type of the
2751      statement expression is the return type of the function call.  */
2752   id->block = make_node (BLOCK);
2753   BLOCK_ABSTRACT_ORIGIN (id->block) = fn;
2754   BLOCK_SOURCE_LOCATION (id->block) = input_location;
2755   add_lexical_block (TREE_BLOCK (stmt), id->block);
2756
2757   /* Local declarations will be replaced by their equivalents in this
2758      map.  */
2759   st = id->decl_map;
2760   id->decl_map = pointer_map_create ();
2761
2762   /* Record the function we are about to inline.  */
2763   id->src_fn = fn;
2764   id->src_node = cg_edge->callee;
2765   id->src_cfun = DECL_STRUCT_FUNCTION (fn);
2766   id->call_expr = t;
2767
2768   gcc_assert (!id->src_cfun->after_inlining);
2769
2770   id->entry_bb = bb;
2771   initialize_inlined_parameters (id, t, fn, bb);
2772
2773   if (DECL_INITIAL (fn))
2774     add_lexical_block (id->block, remap_blocks (DECL_INITIAL (fn), id));
2775
2776   /* Return statements in the function body will be replaced by jumps
2777      to the RET_LABEL.  */
2778
2779   gcc_assert (DECL_INITIAL (fn));
2780   gcc_assert (TREE_CODE (DECL_INITIAL (fn)) == BLOCK);
2781
2782   /* Find the lhs to which the result of this call is assigned.  */
2783   return_slot = NULL;
2784   if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
2785     {
2786       modify_dest = GIMPLE_STMT_OPERAND (stmt, 0);
2787
2788       /* The function which we are inlining might not return a value,
2789          in which case we should issue a warning that the function
2790          does not return a value.  In that case the optimizers will
2791          see that the variable to which the value is assigned was not
2792          initialized.  We do not want to issue a warning about that
2793          uninitialized variable.  */
2794       if (DECL_P (modify_dest))
2795         TREE_NO_WARNING (modify_dest) = 1;
2796       if (CALL_EXPR_RETURN_SLOT_OPT (t))
2797         {
2798           return_slot = modify_dest;
2799           modify_dest = NULL;
2800         }
2801     }
2802   else
2803     modify_dest = NULL;
2804
2805   /* If we are inlining a call to the C++ operator new, we don't want
2806      to use type based alias analysis on the return value.  Otherwise
2807      we may get confused if the compiler sees that the inlined new
2808      function returns a pointer which was just deleted.  See bug
2809      33407.  */
2810   if (DECL_IS_OPERATOR_NEW (fn))
2811     {
2812       return_slot = NULL;
2813       modify_dest = NULL;
2814     }
2815
2816   /* Declare the return variable for the function.  */
2817   retvar = declare_return_variable (id, return_slot,
2818                                     modify_dest, &use_retvar);
2819
2820   if (DECL_IS_OPERATOR_NEW (fn))
2821     {
2822       gcc_assert (TREE_CODE (retvar) == VAR_DECL
2823                   && POINTER_TYPE_P (TREE_TYPE (retvar)));
2824       DECL_NO_TBAA_P (retvar) = 1;
2825     }
2826
2827   /* This is it.  Duplicate the callee body.  Assume callee is
2828      pre-gimplified.  Note that we must not alter the caller
2829      function in any way before this point, as this CALL_EXPR may be
2830      a self-referential call; if we're calling ourselves, we need to
2831      duplicate our body before altering anything.  */
2832   copy_body (id, bb->count, bb->frequency, bb, return_block);
2833
2834   /* Add local vars in this inlined callee to caller.  */
2835   t_step = id->src_cfun->unexpanded_var_list;
2836   for (; t_step; t_step = TREE_CHAIN (t_step))
2837     {
2838       var = TREE_VALUE (t_step);
2839       if (TREE_STATIC (var) && !TREE_ASM_WRITTEN (var))
2840         cfun->unexpanded_var_list = tree_cons (NULL_TREE, var,
2841                                                cfun->unexpanded_var_list);
2842       else
2843         cfun->unexpanded_var_list = tree_cons (NULL_TREE, remap_decl (var, id),
2844                                                cfun->unexpanded_var_list);
2845     }
2846
2847   /* Clean up.  */
2848   pointer_map_destroy (id->decl_map);
2849   id->decl_map = st;
2850
2851   /* If the inlined function returns a result that we care about,
2852      clobber the CALL_EXPR with a reference to the return variable.  */
2853   if (use_retvar && (TREE_CODE (bsi_stmt (stmt_bsi)) != CALL_EXPR))
2854     {
2855       *tp = use_retvar;
2856       if (gimple_in_ssa_p (cfun))
2857         {
2858           update_stmt (stmt);
2859           mark_symbols_for_renaming (stmt);
2860         }
2861       maybe_clean_or_replace_eh_stmt (stmt, stmt);
2862     }
2863   else
2864     /* We're modifying a TSI owned by gimple_expand_calls_inline();
2865        tsi_delink() will leave the iterator in a sane state.  */
2866     {
2867       /* Handle case of inlining function that miss return statement so
2868          return value becomes undefined.  */
2869       if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
2870           && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) == SSA_NAME)
2871         {
2872           tree name = TREE_OPERAND (stmt, 0);
2873           tree var = SSA_NAME_VAR (TREE_OPERAND (stmt, 0));
2874           tree def = gimple_default_def (cfun, var);
2875
2876           /* If the variable is used undefined, make this name undefined via
2877              move.  */
2878           if (def)
2879             {
2880               TREE_OPERAND (stmt, 1) = def;
2881               update_stmt (stmt);
2882             }
2883           /* Otherwise make this variable undefined.  */
2884           else
2885             {
2886               bsi_remove (&stmt_bsi, true);
2887               set_default_def (var, name);
2888               SSA_NAME_DEF_STMT (name) = build_empty_stmt ();
2889             }
2890         }
2891       else
2892         bsi_remove (&stmt_bsi, true);
2893     }
2894
2895   if (purge_dead_abnormal_edges)
2896     tree_purge_dead_abnormal_call_edges (return_block);
2897
2898   /* If the value of the new expression is ignored, that's OK.  We
2899      don't warn about this for CALL_EXPRs, so we shouldn't warn about
2900      the equivalent inlined version either.  */
2901   TREE_USED (*tp) = 1;
2902
2903   /* Output the inlining info for this abstract function, since it has been
2904      inlined.  If we don't do this now, we can lose the information about the
2905      variables in the function when the blocks get blown away as soon as we
2906      remove the cgraph node.  */
2907   (*debug_hooks->outlining_inline_function) (cg_edge->callee->decl);
2908
2909   /* Update callgraph if needed.  */
2910   cgraph_remove_node (cg_edge->callee);
2911
2912   id->block = NULL_TREE;
2913   successfully_inlined = TRUE;
2914
2915  egress:
2916   input_location = saved_location;
2917   return successfully_inlined;
2918 }
2919
2920 /* Expand call statements reachable from STMT_P.
2921    We can only have CALL_EXPRs as the "toplevel" tree code or nested
2922    in a GIMPLE_MODIFY_STMT.  See tree-gimple.c:get_call_expr_in().  We can
2923    unfortunately not use that function here because we need a pointer
2924    to the CALL_EXPR, not the tree itself.  */
2925
2926 static bool
2927 gimple_expand_calls_inline (basic_block bb, copy_body_data *id)
2928 {
2929   block_stmt_iterator bsi;
2930
2931   /* Register specific tree functions.  */
2932   tree_register_cfg_hooks ();
2933   for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2934     {
2935       tree *expr_p = bsi_stmt_ptr (bsi);
2936       tree stmt = *expr_p;
2937
2938       if (TREE_CODE (*expr_p) == GIMPLE_MODIFY_STMT)
2939         expr_p = &GIMPLE_STMT_OPERAND (*expr_p, 1);
2940       if (TREE_CODE (*expr_p) == WITH_SIZE_EXPR)
2941         expr_p = &TREE_OPERAND (*expr_p, 0);
2942       if (TREE_CODE (*expr_p) == CALL_EXPR)
2943         if (expand_call_inline (bb, stmt, expr_p, id))
2944           return true;
2945     }
2946   return false;
2947 }
2948
2949 /* Walk all basic blocks created after FIRST and try to fold every statement
2950    in the STATEMENTS pointer set.  */
2951 static void
2952 fold_marked_statements (int first, struct pointer_set_t *statements)
2953 {
2954   for (;first < n_basic_blocks;first++)
2955     if (BASIC_BLOCK (first))
2956       {
2957         block_stmt_iterator bsi;
2958         for (bsi = bsi_start (BASIC_BLOCK (first));
2959              !bsi_end_p (bsi); bsi_next (&bsi))
2960           if (pointer_set_contains (statements, bsi_stmt (bsi)))
2961             {
2962               tree old_stmt = bsi_stmt (bsi);
2963               tree old_call = get_call_expr_in (old_stmt);
2964
2965               if (fold_stmt (bsi_stmt_ptr (bsi)))
2966                 {
2967                   update_stmt (bsi_stmt (bsi));
2968                   if (old_call)
2969                     cgraph_update_edges_for_call_stmt (old_stmt, old_call,
2970                                                        bsi_stmt (bsi));
2971                   if (maybe_clean_or_replace_eh_stmt (old_stmt,
2972                                                       bsi_stmt (bsi)))
2973                     tree_purge_dead_eh_edges (BASIC_BLOCK (first));
2974                 }
2975             }
2976       }
2977 }
2978
2979 /* Return true if BB has at least one abnormal outgoing edge.  */
2980
2981 static inline bool
2982 has_abnormal_outgoing_edge_p (basic_block bb)
2983 {
2984   edge e;
2985   edge_iterator ei;
2986
2987   FOR_EACH_EDGE (e, ei, bb->succs)
2988     if (e->flags & EDGE_ABNORMAL)
2989       return true;
2990
2991   return false;
2992 }
2993
2994 /* Expand calls to inline functions in the body of FN.  */
2995
2996 unsigned int
2997 optimize_inline_calls (tree fn)
2998 {
2999   copy_body_data id;
3000   tree prev_fn;
3001   basic_block bb;
3002   int last = n_basic_blocks;
3003   /* There is no point in performing inlining if errors have already
3004      occurred -- and we might crash if we try to inline invalid
3005      code.  */
3006   if (errorcount || sorrycount)
3007     return 0;
3008
3009   /* Clear out ID.  */
3010   memset (&id, 0, sizeof (id));
3011
3012   id.src_node = id.dst_node = cgraph_node (fn);
3013   id.dst_fn = fn;
3014   /* Or any functions that aren't finished yet.  */
3015   prev_fn = NULL_TREE;
3016   if (current_function_decl)
3017     {
3018       id.dst_fn = current_function_decl;
3019       prev_fn = current_function_decl;
3020     }
3021
3022   id.copy_decl = copy_decl_maybe_to_var;
3023   id.transform_call_graph_edges = CB_CGE_DUPLICATE;
3024   id.transform_new_cfg = false;
3025   id.transform_return_to_modify = true;
3026   id.transform_lang_insert_block = false;
3027   id.statements_to_fold = pointer_set_create ();
3028
3029   push_gimplify_context ();
3030
3031   /* We make no attempts to keep dominance info up-to-date.  */
3032   free_dominance_info (CDI_DOMINATORS);
3033   free_dominance_info (CDI_POST_DOMINATORS);
3034
3035   /* Reach the trees by walking over the CFG, and note the
3036      enclosing basic-blocks in the call edges.  */
3037   /* We walk the blocks going forward, because inlined function bodies
3038      will split id->current_basic_block, and the new blocks will
3039      follow it; we'll trudge through them, processing their CALL_EXPRs
3040      along the way.  */
3041   FOR_EACH_BB (bb)
3042     gimple_expand_calls_inline (bb, &id);
3043
3044   pop_gimplify_context (NULL);
3045
3046 #ifdef ENABLE_CHECKING
3047     {
3048       struct cgraph_edge *e;
3049
3050       verify_cgraph_node (id.dst_node);
3051
3052       /* Double check that we inlined everything we are supposed to inline.  */
3053       for (e = id.dst_node->callees; e; e = e->next_callee)
3054         gcc_assert (e->inline_failed);
3055     }
3056 #endif
3057
3058   /* Fold the statements before compacting/renumbering the basic blocks.  */
3059   fold_marked_statements (last, id.statements_to_fold);
3060   pointer_set_destroy (id.statements_to_fold);
3061
3062   /* Renumber the (code) basic_blocks consecutively.  */
3063   compact_blocks ();
3064   /* Renumber the lexical scoping (non-code) blocks consecutively.  */
3065   number_blocks (fn);
3066
3067   /* We are not going to maintain the cgraph edges up to date.
3068      Kill it so it won't confuse us.  */
3069   cgraph_node_remove_callees (id.dst_node);
3070
3071   fold_cond_expr_cond ();
3072   /* It would be nice to check SSA/CFG/statement consistency here, but it is
3073      not possible yet - the IPA passes might make various functions to not
3074      throw and they don't care to proactively update local EH info.  This is
3075      done later in fixup_cfg pass that also execute the verification.  */
3076   return (TODO_update_ssa | TODO_cleanup_cfg
3077           | (gimple_in_ssa_p (cfun) ? TODO_remove_unused_locals : 0)
3078           | (profile_status != PROFILE_ABSENT ? TODO_rebuild_frequencies : 0));
3079 }
3080
3081 /* FN is a function that has a complete body, and CLONE is a function whose
3082    body is to be set to a copy of FN, mapping argument declarations according
3083    to the ARG_MAP splay_tree.  */
3084
3085 void
3086 clone_body (tree clone, tree fn, void *arg_map)
3087 {
3088   copy_body_data id;
3089
3090   /* Clone the body, as if we were making an inline call.  But, remap the
3091      parameters in the callee to the parameters of caller.  */
3092   memset (&id, 0, sizeof (id));
3093   id.src_fn = fn;
3094   id.dst_fn = clone;
3095   id.src_cfun = DECL_STRUCT_FUNCTION (fn);
3096   id.decl_map = (struct pointer_map_t *)arg_map;
3097
3098   id.copy_decl = copy_decl_no_change;
3099   id.transform_call_graph_edges = CB_CGE_DUPLICATE;
3100   id.transform_new_cfg = true;
3101   id.transform_return_to_modify = false;
3102   id.transform_lang_insert_block = true;
3103
3104   /* We're not inside any EH region.  */
3105   id.eh_region = -1;
3106
3107   /* Actually copy the body.  */
3108   append_to_statement_list_force (copy_generic_body (&id), &DECL_SAVED_TREE (clone));
3109 }
3110
3111 /* Passed to walk_tree.  Copies the node pointed to, if appropriate.  */
3112
3113 tree
3114 copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
3115 {
3116   enum tree_code code = TREE_CODE (*tp);
3117   enum tree_code_class cl = TREE_CODE_CLASS (code);
3118
3119   /* We make copies of most nodes.  */
3120   if (IS_EXPR_CODE_CLASS (cl)
3121       || IS_GIMPLE_STMT_CODE_CLASS (cl)
3122       || code == TREE_LIST
3123       || code == TREE_VEC
3124       || code == TYPE_DECL
3125       || code == OMP_CLAUSE)
3126     {
3127       /* Because the chain gets clobbered when we make a copy, we save it
3128          here.  */
3129       tree chain = NULL_TREE, new;
3130
3131       if (!GIMPLE_TUPLE_P (*tp))
3132         chain = TREE_CHAIN (*tp);
3133
3134       /* Copy the node.  */
3135       new = copy_node (*tp);
3136
3137       /* Propagate mudflap marked-ness.  */
3138       if (flag_mudflap && mf_marked_p (*tp))
3139         mf_mark (new);
3140
3141       *tp = new;
3142
3143       /* Now, restore the chain, if appropriate.  That will cause
3144          walk_tree to walk into the chain as well.  */
3145       if (code == PARM_DECL
3146           || code == TREE_LIST
3147           || code == OMP_CLAUSE)
3148         TREE_CHAIN (*tp) = chain;
3149
3150       /* For now, we don't update BLOCKs when we make copies.  So, we
3151          have to nullify all BIND_EXPRs.  */
3152       if (TREE_CODE (*tp) == BIND_EXPR)
3153         BIND_EXPR_BLOCK (*tp) = NULL_TREE;
3154     }
3155   else if (code == CONSTRUCTOR)
3156     {
3157       /* CONSTRUCTOR nodes need special handling because
3158          we need to duplicate the vector of elements.  */
3159       tree new;
3160
3161       new = copy_node (*tp);
3162
3163       /* Propagate mudflap marked-ness.  */
3164       if (flag_mudflap && mf_marked_p (*tp))
3165         mf_mark (new);
3166
3167       CONSTRUCTOR_ELTS (new) = VEC_copy (constructor_elt, gc,
3168                                          CONSTRUCTOR_ELTS (*tp));
3169       *tp = new;
3170     }
3171   else if (TREE_CODE_CLASS (code) == tcc_type)
3172     *walk_subtrees = 0;
3173   else if (TREE_CODE_CLASS (code) == tcc_declaration)
3174     *walk_subtrees = 0;
3175   else if (TREE_CODE_CLASS (code) == tcc_constant)
3176     *walk_subtrees = 0;
3177   else
3178     gcc_assert (code != STATEMENT_LIST);
3179   return NULL_TREE;
3180 }
3181
3182 /* The SAVE_EXPR pointed to by TP is being copied.  If ST contains
3183    information indicating to what new SAVE_EXPR this one should be mapped,
3184    use that one.  Otherwise, create a new node and enter it in ST.  FN is
3185    the function into which the copy will be placed.  */
3186
3187 static void
3188 remap_save_expr (tree *tp, void *st_, int *walk_subtrees)
3189 {
3190   struct pointer_map_t *st = (struct pointer_map_t *) st_;
3191   tree *n;
3192   tree t;
3193
3194   /* See if we already encountered this SAVE_EXPR.  */
3195   n = (tree *) pointer_map_contains (st, *tp);
3196
3197   /* If we didn't already remap this SAVE_EXPR, do so now.  */
3198   if (!n)
3199     {
3200       t = copy_node (*tp);
3201
3202       /* Remember this SAVE_EXPR.  */
3203       *pointer_map_insert (st, *tp) = t;
3204       /* Make sure we don't remap an already-remapped SAVE_EXPR.  */
3205       *pointer_map_insert (st, t) = t;
3206     }
3207   else
3208     {
3209       /* We've already walked into this SAVE_EXPR; don't do it again.  */
3210       *walk_subtrees = 0;
3211       t = *n;
3212     }
3213
3214   /* Replace this SAVE_EXPR with the copy.  */
3215   *tp = t;
3216 }
3217
3218 /* Called via walk_tree.  If *TP points to a DECL_STMT for a local label,
3219    copies the declaration and enters it in the splay_tree in DATA (which is
3220    really an `copy_body_data *').  */
3221
3222 static tree
3223 mark_local_for_remap_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
3224                         void *data)
3225 {
3226   copy_body_data *id = (copy_body_data *) data;
3227
3228   /* Don't walk into types.  */
3229   if (TYPE_P (*tp))
3230     *walk_subtrees = 0;
3231
3232   else if (TREE_CODE (*tp) == LABEL_EXPR)
3233     {
3234       tree decl = TREE_OPERAND (*tp, 0);
3235
3236       /* Copy the decl and remember the copy.  */
3237       insert_decl_map (id, decl, id->copy_decl (decl, id));
3238     }
3239
3240   return NULL_TREE;
3241 }
3242
3243 /* Perform any modifications to EXPR required when it is unsaved.  Does
3244    not recurse into EXPR's subtrees.  */
3245
3246 static void
3247 unsave_expr_1 (tree expr)
3248 {
3249   switch (TREE_CODE (expr))
3250     {
3251     case TARGET_EXPR:
3252       /* Don't mess with a TARGET_EXPR that hasn't been expanded.
3253          It's OK for this to happen if it was part of a subtree that
3254          isn't immediately expanded, such as operand 2 of another
3255          TARGET_EXPR.  */
3256       if (TREE_OPERAND (expr, 1))
3257         break;
3258
3259       TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
3260       TREE_OPERAND (expr, 3) = NULL_TREE;
3261       break;
3262
3263     default:
3264       break;
3265     }
3266 }
3267
3268 /* Called via walk_tree when an expression is unsaved.  Using the
3269    splay_tree pointed to by ST (which is really a `splay_tree'),
3270    remaps all local declarations to appropriate replacements.  */
3271
3272 static tree
3273 unsave_r (tree *tp, int *walk_subtrees, void *data)
3274 {
3275   copy_body_data *id = (copy_body_data *) data;
3276   struct pointer_map_t *st = id->decl_map;
3277   tree *n;
3278
3279   /* Only a local declaration (variable or label).  */
3280   if ((TREE_CODE (*tp) == VAR_DECL && !TREE_STATIC (*tp))
3281       || TREE_CODE (*tp) == LABEL_DECL)
3282     {
3283       /* Lookup the declaration.  */
3284       n = (tree *) pointer_map_contains (st, *tp);
3285
3286       /* If it's there, remap it.  */
3287       if (n)
3288         *tp = *n;
3289     }
3290
3291   else if (TREE_CODE (*tp) == STATEMENT_LIST)
3292     copy_statement_list (tp);
3293   else if (TREE_CODE (*tp) == BIND_EXPR)
3294     copy_bind_expr (tp, walk_subtrees, id);
3295   else if (TREE_CODE (*tp) == SAVE_EXPR)
3296     remap_save_expr (tp, st, walk_subtrees);
3297   else
3298     {
3299       copy_tree_r (tp, walk_subtrees, NULL);
3300
3301       /* Do whatever unsaving is required.  */
3302       unsave_expr_1 (*tp);
3303     }
3304
3305   /* Keep iterating.  */
3306   return NULL_TREE;
3307 }
3308
3309 /* Copies everything in EXPR and replaces variables, labels
3310    and SAVE_EXPRs local to EXPR.  */
3311
3312 tree
3313 unsave_expr_now (tree expr)
3314 {
3315   copy_body_data id;
3316
3317   /* There's nothing to do for NULL_TREE.  */
3318   if (expr == 0)
3319     return expr;
3320
3321   /* Set up ID.  */
3322   memset (&id, 0, sizeof (id));
3323   id.src_fn = current_function_decl;
3324   id.dst_fn = current_function_decl;
3325   id.decl_map = pointer_map_create ();
3326
3327   id.copy_decl = copy_decl_no_change;
3328   id.transform_call_graph_edges = CB_CGE_DUPLICATE;
3329   id.transform_new_cfg = false;
3330   id.transform_return_to_modify = false;
3331   id.transform_lang_insert_block = false;
3332
3333   /* Walk the tree once to find local labels.  */
3334   walk_tree_without_duplicates (&expr, mark_local_for_remap_r, &id);
3335
3336   /* Walk the tree again, copying, remapping, and unsaving.  */
3337   walk_tree (&expr, unsave_r, &id, NULL);
3338
3339   /* Clean up.  */
3340   pointer_map_destroy (id.decl_map);
3341
3342   return expr;
3343 }
3344
3345 /* Allow someone to determine if SEARCH is a child of TOP from gdb.  */
3346
3347 static tree
3348 debug_find_tree_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
3349 {
3350   if (*tp == data)
3351     return (tree) data;
3352   else
3353     return NULL;
3354 }
3355
3356 bool
3357 debug_find_tree (tree top, tree search)
3358 {
3359   return walk_tree_without_duplicates (&top, debug_find_tree_1, search) != 0;
3360 }
3361
3362
3363 /* Declare the variables created by the inliner.  Add all the variables in
3364    VARS to BIND_EXPR.  */
3365
3366 static void
3367 declare_inline_vars (tree block, tree vars)
3368 {
3369   tree t;
3370   for (t = vars; t; t = TREE_CHAIN (t))
3371     {
3372       DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
3373       gcc_assert (!TREE_STATIC (t) && !TREE_ASM_WRITTEN (t));
3374       cfun->unexpanded_var_list =
3375         tree_cons (NULL_TREE, t,
3376                    cfun->unexpanded_var_list);
3377     }
3378
3379   if (block)
3380     BLOCK_VARS (block) = chainon (BLOCK_VARS (block), vars);
3381 }
3382
3383
3384 /* Copy NODE (which must be a DECL).  The DECL originally was in the FROM_FN,
3385    but now it will be in the TO_FN.  PARM_TO_VAR means enable PARM_DECL to
3386    VAR_DECL translation.  */
3387
3388 static tree
3389 copy_decl_for_dup_finish (copy_body_data *id, tree decl, tree copy)
3390 {
3391   /* Don't generate debug information for the copy if we wouldn't have
3392      generated it for the copy either.  */
3393   DECL_ARTIFICIAL (copy) = DECL_ARTIFICIAL (decl);
3394   DECL_IGNORED_P (copy) = DECL_IGNORED_P (decl);
3395
3396   /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
3397      declaration inspired this copy.  */
3398   DECL_ABSTRACT_ORIGIN (copy) = DECL_ORIGIN (decl);
3399
3400   /* The new variable/label has no RTL, yet.  */
3401   if (CODE_CONTAINS_STRUCT (TREE_CODE (copy), TS_DECL_WRTL)
3402       && !TREE_STATIC (copy) && !DECL_EXTERNAL (copy))
3403     SET_DECL_RTL (copy, NULL_RTX);
3404
3405   /* These args would always appear unused, if not for this.  */
3406   TREE_USED (copy) = 1;
3407
3408   /* Set the context for the new declaration.  */
3409   if (!DECL_CONTEXT (decl))
3410     /* Globals stay global.  */
3411     ;
3412   else if (DECL_CONTEXT (decl) != id->src_fn)
3413     /* Things that weren't in the scope of the function we're inlining
3414        from aren't in the scope we're inlining to, either.  */
3415     ;
3416   else if (TREE_STATIC (decl))
3417     /* Function-scoped static variables should stay in the original
3418        function.  */
3419     ;
3420   else
3421     /* Ordinary automatic local variables are now in the scope of the
3422        new function.  */
3423     DECL_CONTEXT (copy) = id->dst_fn;
3424
3425   return copy;
3426 }
3427
3428 static tree
3429 copy_decl_to_var (tree decl, copy_body_data *id)
3430 {
3431   tree copy, type;
3432
3433   gcc_assert (TREE_CODE (decl) == PARM_DECL
3434               || TREE_CODE (decl) == RESULT_DECL);
3435
3436   type = TREE_TYPE (decl);
3437
3438   copy = build_decl (VAR_DECL, DECL_NAME (decl), type);
3439   TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl);
3440   TREE_READONLY (copy) = TREE_READONLY (decl);
3441   TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl);
3442   DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl);
3443   DECL_NO_TBAA_P (copy) = DECL_NO_TBAA_P (decl);
3444
3445   return copy_decl_for_dup_finish (id, decl, copy);
3446 }
3447
3448 /* Like copy_decl_to_var, but create a return slot object instead of a
3449    pointer variable for return by invisible reference.  */
3450
3451 static tree
3452 copy_result_decl_to_var (tree decl, copy_body_data *id)
3453 {
3454   tree copy, type;
3455
3456   gcc_assert (TREE_CODE (decl) == PARM_DECL
3457               || TREE_CODE (decl) == RESULT_DECL);
3458
3459   type = TREE_TYPE (decl);
3460   if (DECL_BY_REFERENCE (decl))
3461     type = TREE_TYPE (type);
3462
3463   copy = build_decl (VAR_DECL, DECL_NAME (decl), type);
3464   TREE_READONLY (copy) = TREE_READONLY (decl);
3465   TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl);
3466   if (!DECL_BY_REFERENCE (decl))
3467     {
3468       TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl);
3469       DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl);
3470       DECL_NO_TBAA_P (copy) = DECL_NO_TBAA_P (decl);
3471     }
3472
3473   return copy_decl_for_dup_finish (id, decl, copy);
3474 }
3475
3476
3477 static tree
3478 copy_decl_no_change (tree decl, copy_body_data *id)
3479 {
3480   tree copy;
3481
3482   copy = copy_node (decl);
3483
3484   /* The COPY is not abstract; it will be generated in DST_FN.  */
3485   DECL_ABSTRACT (copy) = 0;
3486   lang_hooks.dup_lang_specific_decl (copy);
3487
3488   /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
3489      been taken; it's for internal bookkeeping in expand_goto_internal.  */
3490   if (TREE_CODE (copy) == LABEL_DECL)
3491     {
3492       TREE_ADDRESSABLE (copy) = 0;
3493       LABEL_DECL_UID (copy) = -1;
3494     }
3495
3496   return copy_decl_for_dup_finish (id, decl, copy);
3497 }
3498
3499 static tree
3500 copy_decl_maybe_to_var (tree decl, copy_body_data *id)
3501 {
3502   if (TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL)
3503     return copy_decl_to_var (decl, id);
3504   else
3505     return copy_decl_no_change (decl, id);
3506 }
3507
3508 /* Return a copy of the function's argument tree.  */
3509 static tree
3510 copy_arguments_for_versioning (tree orig_parm, copy_body_data * id)
3511 {
3512   tree *arg_copy, *parg;
3513
3514   arg_copy = &orig_parm;
3515   for (parg = arg_copy; *parg; parg = &TREE_CHAIN (*parg))
3516     {
3517       tree new = remap_decl (*parg, id);
3518       lang_hooks.dup_lang_specific_decl (new);
3519       TREE_CHAIN (new) = TREE_CHAIN (*parg);
3520       *parg = new;
3521     }
3522   return orig_parm;
3523 }
3524
3525 /* Return a copy of the function's static chain.  */
3526 static tree
3527 copy_static_chain (tree static_chain, copy_body_data * id)
3528 {
3529   tree *chain_copy, *pvar;
3530
3531   chain_copy = &static_chain;
3532   for (pvar = chain_copy; *pvar; pvar = &TREE_CHAIN (*pvar))
3533     {
3534       tree new = remap_decl (*pvar, id);
3535       lang_hooks.dup_lang_specific_decl (new);
3536       TREE_CHAIN (new) = TREE_CHAIN (*pvar);
3537       *pvar = new;
3538     }
3539   return static_chain;
3540 }
3541
3542 /* Return true if the function is allowed to be versioned.
3543    This is a guard for the versioning functionality.  */
3544 bool
3545 tree_versionable_function_p (tree fndecl)
3546 {
3547   if (fndecl == NULL_TREE)
3548     return false;
3549   /* ??? There are cases where a function is
3550      uninlinable but can be versioned.  */
3551   if (!tree_inlinable_function_p (fndecl))
3552     return false;
3553
3554   return true;
3555 }
3556
3557 /* Create a copy of a function's tree.
3558    OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
3559    of the original function and the new copied function
3560    respectively.  In case we want to replace a DECL
3561    tree with another tree while duplicating the function's
3562    body, TREE_MAP represents the mapping between these
3563    trees. If UPDATE_CLONES is set, the call_stmt fields
3564    of edges of clones of the function will be updated.  */
3565 void
3566 tree_function_versioning (tree old_decl, tree new_decl, varray_type tree_map,
3567                           bool update_clones)
3568 {
3569   struct cgraph_node *old_version_node;
3570   struct cgraph_node *new_version_node;
3571   copy_body_data id;
3572   tree p;
3573   unsigned i;
3574   struct ipa_replace_map *replace_info;
3575   basic_block old_entry_block;
3576   tree t_step;
3577   tree old_current_function_decl = current_function_decl;
3578
3579   gcc_assert (TREE_CODE (old_decl) == FUNCTION_DECL
3580               && TREE_CODE (new_decl) == FUNCTION_DECL);
3581   DECL_POSSIBLY_INLINED (old_decl) = 1;
3582
3583   old_version_node = cgraph_node (old_decl);
3584   new_version_node = cgraph_node (new_decl);
3585
3586   DECL_ARTIFICIAL (new_decl) = 1;
3587   DECL_ABSTRACT_ORIGIN (new_decl) = DECL_ORIGIN (old_decl);
3588
3589   /* Prepare the data structures for the tree copy.  */
3590   memset (&id, 0, sizeof (id));
3591
3592   /* Generate a new name for the new version. */
3593   if (!update_clones)
3594     {
3595       DECL_NAME (new_decl) =  create_tmp_var_name (NULL);
3596       SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
3597       SET_DECL_RTL (new_decl, NULL_RTX);
3598       id.statements_to_fold = pointer_set_create ();
3599     }
3600
3601   id.decl_map = pointer_map_create ();
3602   id.src_fn = old_decl;
3603   id.dst_fn = new_decl;
3604   id.src_node = old_version_node;
3605   id.dst_node = new_version_node;
3606   id.src_cfun = DECL_STRUCT_FUNCTION (old_decl);
3607
3608   id.copy_decl = copy_decl_no_change;
3609   id.transform_call_graph_edges
3610     = update_clones ? CB_CGE_MOVE_CLONES : CB_CGE_MOVE;
3611   id.transform_new_cfg = true;
3612   id.transform_return_to_modify = false;
3613   id.transform_lang_insert_block = false;
3614
3615   current_function_decl = new_decl;
3616   old_entry_block = ENTRY_BLOCK_PTR_FOR_FUNCTION
3617     (DECL_STRUCT_FUNCTION (old_decl));
3618   initialize_cfun (new_decl, old_decl,
3619                    old_entry_block->count,
3620                    old_entry_block->frequency);
3621   push_cfun (DECL_STRUCT_FUNCTION (new_decl));
3622
3623   /* Copy the function's static chain.  */
3624   p = DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl;
3625   if (p)
3626     DECL_STRUCT_FUNCTION (new_decl)->static_chain_decl =
3627       copy_static_chain (DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl,
3628                          &id);
3629   /* Copy the function's arguments.  */
3630   if (DECL_ARGUMENTS (old_decl) != NULL_TREE)
3631     DECL_ARGUMENTS (new_decl) =
3632       copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl), &id);
3633
3634   /* If there's a tree_map, prepare for substitution.  */
3635   if (tree_map)
3636     for (i = 0; i < VARRAY_ACTIVE_SIZE (tree_map); i++)
3637       {
3638         replace_info = VARRAY_GENERIC_PTR (tree_map, i);
3639         if (replace_info->replace_p)
3640           insert_decl_map (&id, replace_info->old_tree,
3641                            replace_info->new_tree);
3642       }
3643
3644   DECL_INITIAL (new_decl) = remap_blocks (DECL_INITIAL (id.src_fn), &id);
3645
3646   /* Renumber the lexical scoping (non-code) blocks consecutively.  */
3647   number_blocks (id.dst_fn);
3648
3649   if (DECL_STRUCT_FUNCTION (old_decl)->unexpanded_var_list != NULL_TREE)
3650     /* Add local vars.  */
3651     for (t_step = DECL_STRUCT_FUNCTION (old_decl)->unexpanded_var_list;
3652          t_step; t_step = TREE_CHAIN (t_step))
3653       {
3654         tree var = TREE_VALUE (t_step);
3655         if (TREE_STATIC (var) && !TREE_ASM_WRITTEN (var))
3656           cfun->unexpanded_var_list = tree_cons (NULL_TREE, var,
3657                                                  cfun->unexpanded_var_list);
3658         else
3659           cfun->unexpanded_var_list =
3660             tree_cons (NULL_TREE, remap_decl (var, &id),
3661                        cfun->unexpanded_var_list);
3662       }
3663
3664   /* Copy the Function's body.  */
3665   copy_body (&id, old_entry_block->count, old_entry_block->frequency, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR);
3666
3667   if (DECL_RESULT (old_decl) != NULL_TREE)
3668     {
3669       tree *res_decl = &DECL_RESULT (old_decl);
3670       DECL_RESULT (new_decl) = remap_decl (*res_decl, &id);
3671       lang_hooks.dup_lang_specific_decl (DECL_RESULT (new_decl));
3672     }
3673
3674   /* Renumber the lexical scoping (non-code) blocks consecutively.  */
3675   number_blocks (new_decl);
3676
3677   /* Clean up.  */
3678   pointer_map_destroy (id.decl_map);
3679   if (!update_clones)
3680     {
3681       fold_marked_statements (0, id.statements_to_fold);
3682       pointer_set_destroy (id.statements_to_fold);
3683       fold_cond_expr_cond ();
3684     }
3685   if (gimple_in_ssa_p (cfun))
3686     {
3687       free_dominance_info (CDI_DOMINATORS);
3688       free_dominance_info (CDI_POST_DOMINATORS);
3689       if (!update_clones)
3690         delete_unreachable_blocks ();
3691       update_ssa (TODO_update_ssa);
3692       if (!update_clones)
3693         {
3694           fold_cond_expr_cond ();
3695           if (need_ssa_update_p ())
3696             update_ssa (TODO_update_ssa);
3697         }
3698     }
3699   free_dominance_info (CDI_DOMINATORS);
3700   free_dominance_info (CDI_POST_DOMINATORS);
3701   pop_cfun ();
3702   current_function_decl = old_current_function_decl;
3703   gcc_assert (!current_function_decl
3704               || DECL_STRUCT_FUNCTION (current_function_decl) == cfun);
3705   return;
3706 }
3707
3708 /* Duplicate a type, fields and all.  */
3709
3710 tree
3711 build_duplicate_type (tree type)
3712 {
3713   struct copy_body_data id;
3714
3715   memset (&id, 0, sizeof (id));
3716   id.src_fn = current_function_decl;
3717   id.dst_fn = current_function_decl;
3718   id.src_cfun = cfun;
3719   id.decl_map = pointer_map_create ();
3720   id.copy_decl = copy_decl_no_change;
3721
3722   type = remap_type_1 (type, &id);
3723
3724   pointer_map_destroy (id.decl_map);
3725
3726   TYPE_CANONICAL (type) = type;
3727
3728   return type;
3729 }