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