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