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
1594           push_gimplify_context ();
1595           gimplify_stmt (&init_stmt);
1596           if (gimple_in_ssa_p (cfun)
1597               && init_stmt && TREE_CODE (init_stmt) == STATEMENT_LIST)
1598             {
1599               /* The replacement can expose previously unreferenced
1600                  variables.  */
1601               for (i = tsi_start (init_stmt); !tsi_end_p (i); tsi_next (&i))
1602                 find_new_referenced_vars (tsi_stmt_ptr (i));
1603              }
1604           pop_gimplify_context (NULL);
1605         }
1606
1607       /* If VAR represents a zero-sized variable, it's possible that the
1608          assignment statement may result in no gimple statements.  */
1609       if (init_stmt)
1610         bsi_insert_after (&bsi, init_stmt, BSI_NEW_STMT);
1611       if (gimple_in_ssa_p (cfun))
1612         for (;!bsi_end_p (bsi); bsi_next (&bsi))
1613           mark_symbols_for_renaming (bsi_stmt (bsi));
1614     }
1615 }
1616
1617 /* Generate code to initialize the parameters of the function at the
1618    top of the stack in ID from the CALL_EXPR EXP.  */
1619
1620 static void
1621 initialize_inlined_parameters (copy_body_data *id, tree exp,
1622                                tree fn, basic_block bb)
1623 {
1624   tree parms;
1625   tree a;
1626   tree p;
1627   tree vars = NULL_TREE;
1628   call_expr_arg_iterator iter;
1629   tree static_chain = CALL_EXPR_STATIC_CHAIN (exp);
1630
1631   /* Figure out what the parameters are.  */
1632   parms = DECL_ARGUMENTS (fn);
1633
1634   /* Loop through the parameter declarations, replacing each with an
1635      equivalent VAR_DECL, appropriately initialized.  */
1636   for (p = parms, a = first_call_expr_arg (exp, &iter); p;
1637        a = next_call_expr_arg (&iter), p = TREE_CHAIN (p))
1638     setup_one_parameter (id, p, a, fn, bb, &vars);
1639
1640   /* Initialize the static chain.  */
1641   p = DECL_STRUCT_FUNCTION (fn)->static_chain_decl;
1642   gcc_assert (fn != current_function_decl);
1643   if (p)
1644     {
1645       /* No static chain?  Seems like a bug in tree-nested.c.  */
1646       gcc_assert (static_chain);
1647
1648       setup_one_parameter (id, p, static_chain, fn, bb, &vars);
1649     }
1650
1651   declare_inline_vars (id->block, vars);
1652 }
1653
1654 /* Declare a return variable to replace the RESULT_DECL for the
1655    function we are calling.  An appropriate DECL_STMT is returned.
1656    The USE_STMT is filled to contain a use of the declaration to
1657    indicate the return value of the function.
1658
1659    RETURN_SLOT, if non-null is place where to store the result.  It
1660    is set only for CALL_EXPR_RETURN_SLOT_OPT.  MODIFY_DEST, if non-null,
1661    was the LHS of the GIMPLE_MODIFY_STMT to which this call is the RHS.
1662
1663    The return value is a (possibly null) value that is the result of the
1664    function as seen by the callee.  *USE_P is a (possibly null) value that
1665    holds the result as seen by the caller.  */
1666
1667 static tree
1668 declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest,
1669                          tree *use_p)
1670 {
1671   tree callee = id->src_fn;
1672   tree caller = id->dst_fn;
1673   tree result = DECL_RESULT (callee);
1674   tree callee_type = TREE_TYPE (result);
1675   tree caller_type = TREE_TYPE (TREE_TYPE (callee));
1676   tree var, use;
1677
1678   /* We don't need to do anything for functions that don't return
1679      anything.  */
1680   if (!result || VOID_TYPE_P (callee_type))
1681     {
1682       *use_p = NULL_TREE;
1683       return NULL_TREE;
1684     }
1685
1686   /* If there was a return slot, then the return value is the
1687      dereferenced address of that object.  */
1688   if (return_slot)
1689     {
1690       /* The front end shouldn't have used both return_slot and
1691          a modify expression.  */
1692       gcc_assert (!modify_dest);
1693       if (DECL_BY_REFERENCE (result))
1694         {
1695           tree return_slot_addr = build_fold_addr_expr (return_slot);
1696           STRIP_USELESS_TYPE_CONVERSION (return_slot_addr);
1697
1698           /* We are going to construct *&return_slot and we can't do that
1699              for variables believed to be not addressable.
1700
1701              FIXME: This check possibly can match, because values returned
1702              via return slot optimization are not believed to have address
1703              taken by alias analysis.  */
1704           gcc_assert (TREE_CODE (return_slot) != SSA_NAME);
1705           if (gimple_in_ssa_p (cfun))
1706             {
1707               HOST_WIDE_INT bitsize;
1708               HOST_WIDE_INT bitpos;
1709               tree offset;
1710               enum machine_mode mode;
1711               int unsignedp;
1712               int volatilep;
1713               tree base;
1714               base = get_inner_reference (return_slot, &bitsize, &bitpos,
1715                                           &offset,
1716                                           &mode, &unsignedp, &volatilep,
1717                                           false);
1718               if (TREE_CODE (base) == INDIRECT_REF)
1719                 base = TREE_OPERAND (base, 0);
1720               if (TREE_CODE (base) == SSA_NAME)
1721                 base = SSA_NAME_VAR (base);
1722               mark_sym_for_renaming (base);
1723             }
1724           var = return_slot_addr;
1725         }
1726       else
1727         {
1728           var = return_slot;
1729           gcc_assert (TREE_CODE (var) != SSA_NAME);
1730           TREE_ADDRESSABLE (var) |= TREE_ADDRESSABLE (result);
1731         }
1732       if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
1733            || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
1734           && !DECL_GIMPLE_REG_P (result)
1735           && DECL_P (var))
1736         DECL_GIMPLE_REG_P (var) = 0;
1737       use = NULL;
1738       goto done;
1739     }
1740
1741   /* All types requiring non-trivial constructors should have been handled.  */
1742   gcc_assert (!TREE_ADDRESSABLE (callee_type));
1743
1744   /* Attempt to avoid creating a new temporary variable.  */
1745   if (modify_dest
1746       && TREE_CODE (modify_dest) != SSA_NAME)
1747     {
1748       bool use_it = false;
1749
1750       /* We can't use MODIFY_DEST if there's type promotion involved.  */
1751       if (!useless_type_conversion_p (callee_type, caller_type))
1752         use_it = false;
1753
1754       /* ??? If we're assigning to a variable sized type, then we must
1755          reuse the destination variable, because we've no good way to
1756          create variable sized temporaries at this point.  */
1757       else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type)) != INTEGER_CST)
1758         use_it = true;
1759
1760       /* If the callee cannot possibly modify MODIFY_DEST, then we can
1761          reuse it as the result of the call directly.  Don't do this if
1762          it would promote MODIFY_DEST to addressable.  */
1763       else if (TREE_ADDRESSABLE (result))
1764         use_it = false;
1765       else
1766         {
1767           tree base_m = get_base_address (modify_dest);
1768
1769           /* If the base isn't a decl, then it's a pointer, and we don't
1770              know where that's going to go.  */
1771           if (!DECL_P (base_m))
1772             use_it = false;
1773           else if (is_global_var (base_m))
1774             use_it = false;
1775           else if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
1776                     || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
1777                    && !DECL_GIMPLE_REG_P (result)
1778                    && DECL_GIMPLE_REG_P (base_m))
1779             use_it = false;
1780           else if (!TREE_ADDRESSABLE (base_m))
1781             use_it = true;
1782         }
1783
1784       if (use_it)
1785         {
1786           var = modify_dest;
1787           use = NULL;
1788           goto done;
1789         }
1790     }
1791
1792   gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type)) == INTEGER_CST);
1793
1794   var = copy_result_decl_to_var (result, id);
1795   if (gimple_in_ssa_p (cfun))
1796     {
1797       get_var_ann (var);
1798       add_referenced_var (var);
1799     }
1800
1801   DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
1802   DECL_STRUCT_FUNCTION (caller)->local_decls
1803     = tree_cons (NULL_TREE, var,
1804                  DECL_STRUCT_FUNCTION (caller)->local_decls);
1805
1806   /* Do not have the rest of GCC warn about this variable as it should
1807      not be visible to the user.  */
1808   TREE_NO_WARNING (var) = 1;
1809
1810   declare_inline_vars (id->block, var);
1811
1812   /* Build the use expr.  If the return type of the function was
1813      promoted, convert it back to the expected type.  */
1814   use = var;
1815   if (!useless_type_conversion_p (caller_type, TREE_TYPE (var)))
1816     use = fold_convert (caller_type, var);
1817
1818   STRIP_USELESS_TYPE_CONVERSION (use);
1819
1820   if (DECL_BY_REFERENCE (result))
1821     var = build_fold_addr_expr (var);
1822
1823  done:
1824   /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
1825      way, when the RESULT_DECL is encountered, it will be
1826      automatically replaced by the VAR_DECL.  */
1827   insert_decl_map (id, result, var);
1828
1829   /* Remember this so we can ignore it in remap_decls.  */
1830   id->retvar = var;
1831
1832   *use_p = use;
1833   return var;
1834 }
1835
1836 /* Returns nonzero if a function can be inlined as a tree.  */
1837
1838 bool
1839 tree_inlinable_function_p (tree fn)
1840 {
1841   return inlinable_function_p (fn);
1842 }
1843
1844 static const char *inline_forbidden_reason;
1845
1846 static tree
1847 inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED,
1848                       void *fnp)
1849 {
1850   tree node = *nodep;
1851   tree fn = (tree) fnp;
1852   tree t;
1853
1854   switch (TREE_CODE (node))
1855     {
1856     case CALL_EXPR:
1857       /* Refuse to inline alloca call unless user explicitly forced so as
1858          this may change program's memory overhead drastically when the
1859          function using alloca is called in loop.  In GCC present in
1860          SPEC2000 inlining into schedule_block cause it to require 2GB of
1861          RAM instead of 256MB.  */
1862       if (alloca_call_p (node)
1863           && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
1864         {
1865           inline_forbidden_reason
1866             = G_("function %q+F can never be inlined because it uses "
1867                  "alloca (override using the always_inline attribute)");
1868           return node;
1869         }
1870       t = get_callee_fndecl (node);
1871       if (! t)
1872         break;
1873
1874       /* We cannot inline functions that call setjmp.  */
1875       if (setjmp_call_p (t))
1876         {
1877           inline_forbidden_reason
1878             = G_("function %q+F can never be inlined because it uses setjmp");
1879           return node;
1880         }
1881
1882       if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL)
1883         switch (DECL_FUNCTION_CODE (t))
1884           {
1885             /* We cannot inline functions that take a variable number of
1886                arguments.  */
1887           case BUILT_IN_VA_START:
1888           case BUILT_IN_NEXT_ARG:
1889           case BUILT_IN_VA_END:
1890             inline_forbidden_reason
1891               = G_("function %q+F can never be inlined because it "
1892                    "uses variable argument lists");
1893             return node;
1894
1895           case BUILT_IN_LONGJMP:
1896             /* We can't inline functions that call __builtin_longjmp at
1897                all.  The non-local goto machinery really requires the
1898                destination be in a different function.  If we allow the
1899                function calling __builtin_longjmp to be inlined into the
1900                function calling __builtin_setjmp, Things will Go Awry.  */
1901             inline_forbidden_reason
1902               = G_("function %q+F can never be inlined because "
1903                    "it uses setjmp-longjmp exception handling");
1904             return node;
1905
1906           case BUILT_IN_NONLOCAL_GOTO:
1907             /* Similarly.  */
1908             inline_forbidden_reason
1909               = G_("function %q+F can never be inlined because "
1910                    "it uses non-local goto");
1911             return node;
1912
1913           case BUILT_IN_RETURN:
1914           case BUILT_IN_APPLY_ARGS:
1915             /* If a __builtin_apply_args caller would be inlined,
1916                it would be saving arguments of the function it has
1917                been inlined into.  Similarly __builtin_return would
1918                return from the function the inline has been inlined into.  */
1919             inline_forbidden_reason
1920               = G_("function %q+F can never be inlined because "
1921                    "it uses __builtin_return or __builtin_apply_args");
1922             return node;
1923
1924           default:
1925             break;
1926           }
1927       break;
1928
1929     case GOTO_EXPR:
1930       t = TREE_OPERAND (node, 0);
1931
1932       /* We will not inline a function which uses computed goto.  The
1933          addresses of its local labels, which may be tucked into
1934          global storage, are of course not constant across
1935          instantiations, which causes unexpected behavior.  */
1936       if (TREE_CODE (t) != LABEL_DECL)
1937         {
1938           inline_forbidden_reason
1939             = G_("function %q+F can never be inlined "
1940                  "because it contains a computed goto");
1941           return node;
1942         }
1943       break;
1944
1945     case LABEL_EXPR:
1946       t = TREE_OPERAND (node, 0);
1947       if (DECL_NONLOCAL (t))
1948         {
1949           /* We cannot inline a function that receives a non-local goto
1950              because we cannot remap the destination label used in the
1951              function that is performing the non-local goto.  */
1952           inline_forbidden_reason
1953             = G_("function %q+F can never be inlined "
1954                  "because it receives a non-local goto");
1955           return node;
1956         }
1957       break;
1958
1959     case RECORD_TYPE:
1960     case UNION_TYPE:
1961       /* We cannot inline a function of the form
1962
1963            void F (int i) { struct S { int ar[i]; } s; }
1964
1965          Attempting to do so produces a catch-22.
1966          If walk_tree examines the TYPE_FIELDS chain of RECORD_TYPE/
1967          UNION_TYPE nodes, then it goes into infinite recursion on a
1968          structure containing a pointer to its own type.  If it doesn't,
1969          then the type node for S doesn't get adjusted properly when
1970          F is inlined.
1971
1972          ??? This is likely no longer true, but it's too late in the 4.0
1973          cycle to try to find out.  This should be checked for 4.1.  */
1974       for (t = TYPE_FIELDS (node); t; t = TREE_CHAIN (t))
1975         if (variably_modified_type_p (TREE_TYPE (t), NULL))
1976           {
1977             inline_forbidden_reason
1978               = G_("function %q+F can never be inlined "
1979                    "because it uses variable sized variables");
1980             return node;
1981           }
1982
1983     default:
1984       break;
1985     }
1986
1987   return NULL_TREE;
1988 }
1989
1990 static tree
1991 inline_forbidden_p_2 (tree *nodep, int *walk_subtrees,
1992                       void *fnp)
1993 {
1994   tree node = *nodep;
1995   tree fn = (tree) fnp;
1996
1997   if (TREE_CODE (node) == LABEL_DECL && DECL_CONTEXT (node) == fn)
1998     {
1999       inline_forbidden_reason
2000         = G_("function %q+F can never be inlined "
2001              "because it saves address of local label in a static variable");
2002       return node;
2003     }
2004
2005   if (TYPE_P (node))
2006     *walk_subtrees = 0;
2007
2008   return NULL_TREE;
2009 }
2010
2011 /* Return subexpression representing possible alloca call, if any.  */
2012 static tree
2013 inline_forbidden_p (tree fndecl)
2014 {
2015   location_t saved_loc = input_location;
2016   block_stmt_iterator bsi;
2017   basic_block bb;
2018   tree ret = NULL_TREE;
2019   struct function *fun = DECL_STRUCT_FUNCTION (fndecl);
2020   tree step;
2021
2022   FOR_EACH_BB_FN (bb, fun)
2023     for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2024       {
2025         ret = walk_tree_without_duplicates (bsi_stmt_ptr (bsi),
2026                                             inline_forbidden_p_1, fndecl);
2027         if (ret)
2028           goto egress;
2029       }
2030
2031   for (step = fun->local_decls; step; step = TREE_CHAIN (step))
2032     {
2033       tree decl = TREE_VALUE (step);
2034       if (TREE_CODE (decl) == VAR_DECL
2035           && TREE_STATIC (decl)
2036           && !DECL_EXTERNAL (decl)
2037           && DECL_INITIAL (decl))
2038         ret = walk_tree_without_duplicates (&DECL_INITIAL (decl),
2039                                             inline_forbidden_p_2, fndecl);
2040         if (ret)
2041           goto egress;
2042     }
2043
2044 egress:
2045   input_location = saved_loc;
2046   return ret;
2047 }
2048
2049 /* Returns nonzero if FN is a function that does not have any
2050    fundamental inline blocking properties.  */
2051
2052 static bool
2053 inlinable_function_p (tree fn)
2054 {
2055   bool inlinable = true;
2056   bool do_warning;
2057   tree always_inline;
2058
2059   /* If we've already decided this function shouldn't be inlined,
2060      there's no need to check again.  */
2061   if (DECL_UNINLINABLE (fn))
2062     return false;
2063
2064   /* We only warn for functions declared `inline' by the user.  */
2065   do_warning = (warn_inline
2066                 && DECL_INLINE (fn)
2067                 && DECL_DECLARED_INLINE_P (fn)
2068                 && !DECL_IN_SYSTEM_HEADER (fn));
2069
2070   always_inline = lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn));
2071
2072   if (flag_really_no_inline
2073       && always_inline == NULL)
2074     {
2075       if (do_warning)
2076         warning (OPT_Winline, "function %q+F can never be inlined because it "
2077                  "is suppressed using -fno-inline", fn);
2078       inlinable = false;
2079     }
2080
2081   /* Don't auto-inline anything that might not be bound within
2082      this unit of translation.  */
2083   else if (!DECL_DECLARED_INLINE_P (fn)
2084            && DECL_REPLACEABLE_P (fn))
2085     inlinable = false;
2086
2087   else if (!function_attribute_inlinable_p (fn))
2088     {
2089       if (do_warning)
2090         warning (OPT_Winline, "function %q+F can never be inlined because it "
2091                  "uses attributes conflicting with inlining", fn);
2092       inlinable = false;
2093     }
2094
2095   /* If we don't have the function body available, we can't inline it.
2096      However, this should not be recorded since we also get here for
2097      forward declared inline functions.  Therefore, return at once.  */
2098   if (!DECL_SAVED_TREE (fn))
2099     return false;
2100
2101   /* If we're not inlining at all, then we cannot inline this function.  */
2102   else if (!flag_inline_trees)
2103     inlinable = false;
2104
2105   /* Only try to inline functions if DECL_INLINE is set.  This should be
2106      true for all functions declared `inline', and for all other functions
2107      as well with -finline-functions.
2108
2109      Don't think of disregarding DECL_INLINE when flag_inline_trees == 2;
2110      it's the front-end that must set DECL_INLINE in this case, because
2111      dwarf2out loses if a function that does not have DECL_INLINE set is
2112      inlined anyway.  That is why we have both DECL_INLINE and
2113      DECL_DECLARED_INLINE_P.  */
2114   /* FIXME: When flag_inline_trees dies, the check for flag_unit_at_a_time
2115             here should be redundant.  */
2116   else if (!DECL_INLINE (fn) && !flag_unit_at_a_time)
2117     inlinable = false;
2118
2119   else if (inline_forbidden_p (fn))
2120     {
2121       /* See if we should warn about uninlinable functions.  Previously,
2122          some of these warnings would be issued while trying to expand
2123          the function inline, but that would cause multiple warnings
2124          about functions that would for example call alloca.  But since
2125          this a property of the function, just one warning is enough.
2126          As a bonus we can now give more details about the reason why a
2127          function is not inlinable.  */
2128       if (always_inline)
2129         sorry (inline_forbidden_reason, fn);
2130       else if (do_warning)
2131         warning (OPT_Winline, inline_forbidden_reason, fn);
2132
2133       inlinable = false;
2134     }
2135
2136   /* Squirrel away the result so that we don't have to check again.  */
2137   DECL_UNINLINABLE (fn) = !inlinable;
2138
2139   return inlinable;
2140 }
2141
2142 /* Estimate the cost of a memory move.  Use machine dependent
2143    word size and take possible memcpy call into account.  */
2144
2145 int
2146 estimate_move_cost (tree type)
2147 {
2148   HOST_WIDE_INT size;
2149
2150   size = int_size_in_bytes (type);
2151
2152   if (size < 0 || size > MOVE_MAX_PIECES * MOVE_RATIO)
2153     /* Cost of a memcpy call, 3 arguments and the call.  */
2154     return 4;
2155   else
2156     return ((size + MOVE_MAX_PIECES - 1) / MOVE_MAX_PIECES);
2157 }
2158
2159 /* Arguments for estimate_num_insns_1.  */
2160
2161 struct eni_data
2162 {
2163   /* Used to return the number of insns.  */
2164   int count;
2165
2166   /* Weights of various constructs.  */
2167   eni_weights *weights;
2168 };
2169
2170 /* Used by estimate_num_insns.  Estimate number of instructions seen
2171    by given statement.  */
2172
2173 static tree
2174 estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data)
2175 {
2176   struct eni_data *const d = (struct eni_data *) data;
2177   tree x = *tp;
2178   unsigned cost;
2179
2180   if (IS_TYPE_OR_DECL_P (x))
2181     {
2182       *walk_subtrees = 0;
2183       return NULL;
2184     }
2185   /* Assume that constants and references counts nothing.  These should
2186      be majorized by amount of operations among them we count later
2187      and are common target of CSE and similar optimizations.  */
2188   else if (CONSTANT_CLASS_P (x) || REFERENCE_CLASS_P (x))
2189     return NULL;
2190
2191   switch (TREE_CODE (x))
2192     {
2193     /* Containers have no cost.  */
2194     case TREE_LIST:
2195     case TREE_VEC:
2196     case BLOCK:
2197     case COMPONENT_REF:
2198     case BIT_FIELD_REF:
2199     case INDIRECT_REF:
2200     case ALIGN_INDIRECT_REF:
2201     case MISALIGNED_INDIRECT_REF:
2202     case ARRAY_REF:
2203     case ARRAY_RANGE_REF:
2204     case OBJ_TYPE_REF:
2205     case EXC_PTR_EXPR: /* ??? */
2206     case FILTER_EXPR: /* ??? */
2207     case COMPOUND_EXPR:
2208     case BIND_EXPR:
2209     case WITH_CLEANUP_EXPR:
2210     case PAREN_EXPR:
2211     CASE_CONVERT:
2212     case VIEW_CONVERT_EXPR:
2213     case SAVE_EXPR:
2214     case ADDR_EXPR:
2215     case COMPLEX_EXPR:
2216     case RANGE_EXPR:
2217     case CASE_LABEL_EXPR:
2218     case SSA_NAME:
2219     case CATCH_EXPR:
2220     case EH_FILTER_EXPR:
2221     case STATEMENT_LIST:
2222     case ERROR_MARK:
2223     case FDESC_EXPR:
2224     case VA_ARG_EXPR:
2225     case TRY_CATCH_EXPR:
2226     case TRY_FINALLY_EXPR:
2227     case LABEL_EXPR:
2228     case GOTO_EXPR:
2229     case RETURN_EXPR:
2230     case EXIT_EXPR:
2231     case LOOP_EXPR:
2232     case PHI_NODE:
2233     case WITH_SIZE_EXPR:
2234     case OMP_CLAUSE:
2235     case OMP_RETURN:
2236     case OMP_CONTINUE:
2237     case OMP_SECTIONS_SWITCH:
2238     case OMP_ATOMIC_STORE:
2239       break;
2240
2241     /* We don't account constants for now.  Assume that the cost is amortized
2242        by operations that do use them.  We may re-consider this decision once
2243        we are able to optimize the tree before estimating its size and break
2244        out static initializers.  */
2245     case IDENTIFIER_NODE:
2246     case INTEGER_CST:
2247     case REAL_CST:
2248     case FIXED_CST:
2249     case COMPLEX_CST:
2250     case VECTOR_CST:
2251     case STRING_CST:
2252     case PREDICT_EXPR:
2253       *walk_subtrees = 0;
2254       return NULL;
2255
2256       /* CHANGE_DYNAMIC_TYPE_EXPR explicitly expands to nothing.  */
2257     case CHANGE_DYNAMIC_TYPE_EXPR:
2258       *walk_subtrees = 0;
2259       return NULL;
2260
2261     /* Try to estimate the cost of assignments.  We have three cases to
2262        deal with:
2263         1) Simple assignments to registers;
2264         2) Stores to things that must live in memory.  This includes
2265            "normal" stores to scalars, but also assignments of large
2266            structures, or constructors of big arrays;
2267         3) TARGET_EXPRs.
2268
2269        Let us look at the first two cases, assuming we have "a = b + C":
2270        <GIMPLE_MODIFY_STMT <var_decl "a">
2271                            <plus_expr <var_decl "b"> <constant C>>
2272        If "a" is a GIMPLE register, the assignment to it is free on almost
2273        any target, because "a" usually ends up in a real register.  Hence
2274        the only cost of this expression comes from the PLUS_EXPR, and we
2275        can ignore the GIMPLE_MODIFY_STMT.
2276        If "a" is not a GIMPLE register, the assignment to "a" will most
2277        likely be a real store, so the cost of the GIMPLE_MODIFY_STMT is the cost
2278        of moving something into "a", which we compute using the function
2279        estimate_move_cost.
2280
2281        The third case deals with TARGET_EXPRs, for which the semantics are
2282        that a temporary is assigned, unless the TARGET_EXPR itself is being
2283        assigned to something else.  In the latter case we do not need the
2284        temporary.  E.g. in:
2285                 <GIMPLE_MODIFY_STMT <var_decl "a"> <target_expr>>, the
2286        GIMPLE_MODIFY_STMT is free.  */
2287     case INIT_EXPR:
2288     case GIMPLE_MODIFY_STMT:
2289       /* Is the right and side a TARGET_EXPR?  */
2290       if (TREE_CODE (GENERIC_TREE_OPERAND (x, 1)) == TARGET_EXPR)
2291         break;
2292       /* ... fall through ...  */
2293
2294     case TARGET_EXPR:
2295       x = GENERIC_TREE_OPERAND (x, 0);
2296       /* Is this an assignments to a register?  */
2297       if (is_gimple_reg (x))
2298         break;
2299       /* Otherwise it's a store, so fall through to compute the move cost.  */
2300
2301     case CONSTRUCTOR:
2302       d->count += estimate_move_cost (TREE_TYPE (x));
2303       break;
2304
2305     /* Assign cost of 1 to usual operations.
2306        ??? We may consider mapping RTL costs to this.  */
2307     case COND_EXPR:
2308     case VEC_COND_EXPR:
2309
2310     case PLUS_EXPR:
2311     case POINTER_PLUS_EXPR:
2312     case MINUS_EXPR:
2313     case MULT_EXPR:
2314
2315     case FIXED_CONVERT_EXPR:
2316     case FIX_TRUNC_EXPR:
2317
2318     case NEGATE_EXPR:
2319     case FLOAT_EXPR:
2320     case MIN_EXPR:
2321     case MAX_EXPR:
2322     case ABS_EXPR:
2323
2324     case LSHIFT_EXPR:
2325     case RSHIFT_EXPR:
2326     case LROTATE_EXPR:
2327     case RROTATE_EXPR:
2328     case VEC_LSHIFT_EXPR:
2329     case VEC_RSHIFT_EXPR:
2330
2331     case BIT_IOR_EXPR:
2332     case BIT_XOR_EXPR:
2333     case BIT_AND_EXPR:
2334     case BIT_NOT_EXPR:
2335
2336     case TRUTH_ANDIF_EXPR:
2337     case TRUTH_ORIF_EXPR:
2338     case TRUTH_AND_EXPR:
2339     case TRUTH_OR_EXPR:
2340     case TRUTH_XOR_EXPR:
2341     case TRUTH_NOT_EXPR:
2342
2343     case LT_EXPR:
2344     case LE_EXPR:
2345     case GT_EXPR:
2346     case GE_EXPR:
2347     case EQ_EXPR:
2348     case NE_EXPR:
2349     case ORDERED_EXPR:
2350     case UNORDERED_EXPR:
2351
2352     case UNLT_EXPR:
2353     case UNLE_EXPR:
2354     case UNGT_EXPR:
2355     case UNGE_EXPR:
2356     case UNEQ_EXPR:
2357     case LTGT_EXPR:
2358
2359     case CONJ_EXPR:
2360
2361     case PREDECREMENT_EXPR:
2362     case PREINCREMENT_EXPR:
2363     case POSTDECREMENT_EXPR:
2364     case POSTINCREMENT_EXPR:
2365
2366     case ASM_EXPR:
2367
2368     case REALIGN_LOAD_EXPR:
2369
2370     case REDUC_MAX_EXPR:
2371     case REDUC_MIN_EXPR:
2372     case REDUC_PLUS_EXPR:
2373     case WIDEN_SUM_EXPR:
2374     case DOT_PROD_EXPR:
2375     case VEC_WIDEN_MULT_HI_EXPR:
2376     case VEC_WIDEN_MULT_LO_EXPR:
2377     case VEC_UNPACK_HI_EXPR:
2378     case VEC_UNPACK_LO_EXPR:
2379     case VEC_UNPACK_FLOAT_HI_EXPR:
2380     case VEC_UNPACK_FLOAT_LO_EXPR:
2381     case VEC_PACK_TRUNC_EXPR:
2382     case VEC_PACK_SAT_EXPR:
2383     case VEC_PACK_FIX_TRUNC_EXPR:
2384
2385     case WIDEN_MULT_EXPR:
2386
2387     case VEC_EXTRACT_EVEN_EXPR:
2388     case VEC_EXTRACT_ODD_EXPR:
2389     case VEC_INTERLEAVE_HIGH_EXPR:
2390     case VEC_INTERLEAVE_LOW_EXPR:
2391
2392     case RESX_EXPR:
2393       d->count += 1;
2394       break;
2395
2396     case SWITCH_EXPR:
2397       /* Take into account cost of the switch + guess 2 conditional jumps for
2398          each case label.
2399
2400          TODO: once the switch expansion logic is sufficiently separated, we can
2401          do better job on estimating cost of the switch.  */
2402       d->count += TREE_VEC_LENGTH (SWITCH_LABELS (x)) * 2;
2403       break;
2404
2405     /* Few special cases of expensive operations.  This is useful
2406        to avoid inlining on functions having too many of these.  */
2407     case TRUNC_DIV_EXPR:
2408     case CEIL_DIV_EXPR:
2409     case FLOOR_DIV_EXPR:
2410     case ROUND_DIV_EXPR:
2411     case EXACT_DIV_EXPR:
2412     case TRUNC_MOD_EXPR:
2413     case CEIL_MOD_EXPR:
2414     case FLOOR_MOD_EXPR:
2415     case ROUND_MOD_EXPR:
2416     case RDIV_EXPR:
2417       d->count += d->weights->div_mod_cost;
2418       break;
2419     case CALL_EXPR:
2420       {
2421         tree decl = get_callee_fndecl (x);
2422         tree addr = CALL_EXPR_FN (x);
2423         tree funtype = TREE_TYPE (addr);
2424
2425         gcc_assert (POINTER_TYPE_P (funtype));
2426         funtype = TREE_TYPE (funtype);
2427
2428         if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD)
2429           cost = d->weights->target_builtin_call_cost;
2430         else
2431           cost = d->weights->call_cost;
2432
2433         if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
2434           switch (DECL_FUNCTION_CODE (decl))
2435             {
2436             case BUILT_IN_CONSTANT_P:
2437               *walk_subtrees = 0;
2438               return NULL_TREE;
2439             case BUILT_IN_EXPECT:
2440               return NULL_TREE;
2441             /* Prefetch instruction is not expensive.  */
2442             case BUILT_IN_PREFETCH:
2443               cost = 1;
2444               break;
2445             default:
2446               break;
2447             }
2448
2449         if (decl)
2450           funtype = TREE_TYPE (decl);
2451
2452         /* Our cost must be kept in sync with cgraph_estimate_size_after_inlining
2453            that does use function declaration to figure out the arguments.
2454
2455            When we deal with function with no body nor prototype, base estimates on
2456            actual parameters of the call expression.  Otherwise use either the actual
2457            arguments types or function declaration for more precise answer.  */
2458         if (decl && DECL_ARGUMENTS (decl))
2459           {
2460             tree arg;
2461             for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg))
2462               d->count += estimate_move_cost (TREE_TYPE (arg));
2463           }
2464         else if (funtype && prototype_p (funtype))
2465           {
2466             tree t;
2467             for (t = TYPE_ARG_TYPES (funtype); t; t = TREE_CHAIN (t))
2468               d->count += estimate_move_cost (TREE_VALUE (t));
2469           }
2470         else
2471           {
2472             tree a;
2473             call_expr_arg_iterator iter;
2474             FOR_EACH_CALL_EXPR_ARG (a, iter, x)
2475               d->count += estimate_move_cost (TREE_TYPE (a));
2476           }
2477
2478         d->count += cost;
2479         break;
2480       }
2481
2482     case OMP_PARALLEL:
2483     case OMP_TASK:
2484     case OMP_FOR:
2485     case OMP_SECTIONS:
2486     case OMP_SINGLE:
2487     case OMP_SECTION:
2488     case OMP_MASTER:
2489     case OMP_ORDERED:
2490     case OMP_CRITICAL:
2491     case OMP_ATOMIC:
2492     case OMP_ATOMIC_LOAD:
2493       /* OpenMP directives are generally very expensive.  */
2494       d->count += d->weights->omp_cost;
2495       break;
2496
2497     default:
2498       gcc_unreachable ();
2499     }
2500   return NULL;
2501 }
2502
2503 /* Estimate number of instructions that will be created by expanding EXPR.
2504    WEIGHTS contains weights attributed to various constructs.  */
2505
2506 int
2507 estimate_num_insns (tree expr, eni_weights *weights)
2508 {
2509   struct pointer_set_t *visited_nodes;
2510   basic_block bb;
2511   block_stmt_iterator bsi;
2512   struct function *my_function;
2513   struct eni_data data;
2514
2515   data.count = 0;
2516   data.weights = weights;
2517
2518   /* If we're given an entire function, walk the CFG.  */
2519   if (TREE_CODE (expr) == FUNCTION_DECL)
2520     {
2521       my_function = DECL_STRUCT_FUNCTION (expr);
2522       gcc_assert (my_function && my_function->cfg);
2523       visited_nodes = pointer_set_create ();
2524       FOR_EACH_BB_FN (bb, my_function)
2525         {
2526           for (bsi = bsi_start (bb);
2527                !bsi_end_p (bsi);
2528                bsi_next (&bsi))
2529             {
2530               walk_tree (bsi_stmt_ptr (bsi), estimate_num_insns_1,
2531                          &data, visited_nodes);
2532             }
2533         }
2534       pointer_set_destroy (visited_nodes);
2535     }
2536   else
2537     walk_tree_without_duplicates (&expr, estimate_num_insns_1, &data);
2538
2539   return data.count;
2540 }
2541
2542 /* Initializes weights used by estimate_num_insns.  */
2543
2544 void
2545 init_inline_once (void)
2546 {
2547   eni_inlining_weights.call_cost = PARAM_VALUE (PARAM_INLINE_CALL_COST);
2548   eni_inlining_weights.target_builtin_call_cost = 1;
2549   eni_inlining_weights.div_mod_cost = 10;
2550   eni_inlining_weights.omp_cost = 40;
2551
2552   eni_size_weights.call_cost = 1;
2553   eni_size_weights.target_builtin_call_cost = 1;
2554   eni_size_weights.div_mod_cost = 1;
2555   eni_size_weights.omp_cost = 40;
2556
2557   /* Estimating time for call is difficult, since we have no idea what the
2558      called function does.  In the current uses of eni_time_weights,
2559      underestimating the cost does less harm than overestimating it, so
2560      we choose a rather small value here.  */
2561   eni_time_weights.call_cost = 10;
2562   eni_time_weights.target_builtin_call_cost = 10;
2563   eni_time_weights.div_mod_cost = 10;
2564   eni_time_weights.omp_cost = 40;
2565 }
2566
2567 /* Install new lexical TREE_BLOCK underneath 'current_block'.  */
2568 static void
2569 add_lexical_block (tree current_block, tree new_block)
2570 {
2571   tree *blk_p;
2572
2573   /* Walk to the last sub-block.  */
2574   for (blk_p = &BLOCK_SUBBLOCKS (current_block);
2575        *blk_p;
2576        blk_p = &BLOCK_CHAIN (*blk_p))
2577     ;
2578   *blk_p = new_block;
2579   BLOCK_SUPERCONTEXT (new_block) = current_block;
2580 }
2581
2582 /* If *TP is a CALL_EXPR, replace it with its inline expansion.  */
2583
2584 static bool
2585 expand_call_inline (basic_block bb, tree stmt, tree *tp, void *data)
2586 {
2587   copy_body_data *id;
2588   tree t;
2589   tree retvar, use_retvar;
2590   tree fn;
2591   struct pointer_map_t *st;
2592   tree return_slot;
2593   tree modify_dest;
2594   location_t saved_location;
2595   struct cgraph_edge *cg_edge;
2596   const char *reason;
2597   basic_block return_block;
2598   edge e;
2599   block_stmt_iterator bsi, stmt_bsi;
2600   bool successfully_inlined = FALSE;
2601   bool purge_dead_abnormal_edges;
2602   tree t_step;
2603   tree var;
2604
2605   /* See what we've got.  */
2606   id = (copy_body_data *) data;
2607   t = *tp;
2608
2609   /* Set input_location here so we get the right instantiation context
2610      if we call instantiate_decl from inlinable_function_p.  */
2611   saved_location = input_location;
2612   if (EXPR_HAS_LOCATION (t))
2613     input_location = EXPR_LOCATION (t);
2614
2615   /* From here on, we're only interested in CALL_EXPRs.  */
2616   if (TREE_CODE (t) != CALL_EXPR)
2617     goto egress;
2618
2619   /* First, see if we can figure out what function is being called.
2620      If we cannot, then there is no hope of inlining the function.  */
2621   fn = get_callee_fndecl (t);
2622   if (!fn)
2623     goto egress;
2624
2625   /* Turn forward declarations into real ones.  */
2626   fn = cgraph_node (fn)->decl;
2627
2628   /* If fn is a declaration of a function in a nested scope that was
2629      globally declared inline, we don't set its DECL_INITIAL.
2630      However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
2631      C++ front-end uses it for cdtors to refer to their internal
2632      declarations, that are not real functions.  Fortunately those
2633      don't have trees to be saved, so we can tell by checking their
2634      DECL_SAVED_TREE.  */
2635   if (! DECL_INITIAL (fn)
2636       && DECL_ABSTRACT_ORIGIN (fn)
2637       && DECL_SAVED_TREE (DECL_ABSTRACT_ORIGIN (fn)))
2638     fn = DECL_ABSTRACT_ORIGIN (fn);
2639
2640   /* Objective C and fortran still calls tree_rest_of_compilation directly.
2641      Kill this check once this is fixed.  */
2642   if (!id->dst_node->analyzed)
2643     goto egress;
2644
2645   cg_edge = cgraph_edge (id->dst_node, stmt);
2646
2647   /* Constant propagation on argument done during previous inlining
2648      may create new direct call.  Produce an edge for it.  */
2649   if (!cg_edge)
2650     {
2651       struct cgraph_node *dest = cgraph_node (fn);
2652
2653       /* We have missing edge in the callgraph.  This can happen in one case
2654          where previous inlining turned indirect call into direct call by
2655          constant propagating arguments.  In all other cases we hit a bug
2656          (incorrect node sharing is most common reason for missing edges.  */
2657       gcc_assert (dest->needed || !flag_unit_at_a_time);
2658       cgraph_create_edge (id->dst_node, dest, stmt,
2659                           bb->count, CGRAPH_FREQ_BASE,
2660                           bb->loop_depth)->inline_failed
2661         = N_("originally indirect function call not considered for inlining");
2662       if (dump_file)
2663         {
2664            fprintf (dump_file, "Created new direct edge to %s",
2665                     cgraph_node_name (dest));
2666         }
2667       goto egress;
2668     }
2669
2670   /* Don't try to inline functions that are not well-suited to
2671      inlining.  */
2672   if (!cgraph_inline_p (cg_edge, &reason))
2673     {
2674       if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn))
2675           /* Avoid warnings during early inline pass. */
2676           && (!flag_unit_at_a_time || cgraph_global_info_ready))
2677         {
2678           sorry ("inlining failed in call to %q+F: %s", fn, reason);
2679           sorry ("called from here");
2680         }
2681       else if (warn_inline && DECL_DECLARED_INLINE_P (fn)
2682                && !DECL_IN_SYSTEM_HEADER (fn)
2683                && strlen (reason)
2684                && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn))
2685                /* Avoid warnings during early inline pass. */
2686                && (!flag_unit_at_a_time || cgraph_global_info_ready))
2687         {
2688           warning (OPT_Winline, "inlining failed in call to %q+F: %s",
2689                    fn, reason);
2690           warning (OPT_Winline, "called from here");
2691         }
2692       goto egress;
2693     }
2694   fn = cg_edge->callee->decl;
2695
2696 #ifdef ENABLE_CHECKING
2697   if (cg_edge->callee->decl != id->dst_node->decl)
2698     verify_cgraph_node (cg_edge->callee);
2699 #endif
2700
2701   /* We will be inlining this callee.  */
2702   id->eh_region = lookup_stmt_eh_region (stmt);
2703
2704   /* Split the block holding the CALL_EXPR.  */
2705   e = split_block (bb, stmt);
2706   bb = e->src;
2707   return_block = e->dest;
2708   remove_edge (e);
2709
2710   /* split_block splits after the statement; work around this by
2711      moving the call into the second block manually.  Not pretty,
2712      but seems easier than doing the CFG manipulation by hand
2713      when the CALL_EXPR is in the last statement of BB.  */
2714   stmt_bsi = bsi_last (bb);
2715   bsi_remove (&stmt_bsi, false);
2716
2717   /* If the CALL_EXPR was in the last statement of BB, it may have
2718      been the source of abnormal edges.  In this case, schedule
2719      the removal of dead abnormal edges.  */
2720   bsi = bsi_start (return_block);
2721   if (bsi_end_p (bsi))
2722     {
2723       bsi_insert_after (&bsi, stmt, BSI_NEW_STMT);
2724       purge_dead_abnormal_edges = true;
2725     }
2726   else
2727     {
2728       bsi_insert_before (&bsi, stmt, BSI_NEW_STMT);
2729       purge_dead_abnormal_edges = false;
2730     }
2731
2732   stmt_bsi = bsi_start (return_block);
2733
2734   /* Build a block containing code to initialize the arguments, the
2735      actual inline expansion of the body, and a label for the return
2736      statements within the function to jump to.  The type of the
2737      statement expression is the return type of the function call.  */
2738   id->block = make_node (BLOCK);
2739   BLOCK_ABSTRACT_ORIGIN (id->block) = fn;
2740   BLOCK_SOURCE_LOCATION (id->block) = input_location;
2741   add_lexical_block (TREE_BLOCK (stmt), id->block);
2742
2743   /* Local declarations will be replaced by their equivalents in this
2744      map.  */
2745   st = id->decl_map;
2746   id->decl_map = pointer_map_create ();
2747
2748   /* Record the function we are about to inline.  */
2749   id->src_fn = fn;
2750   id->src_node = cg_edge->callee;
2751   id->src_cfun = DECL_STRUCT_FUNCTION (fn);
2752   id->call_expr = t;
2753
2754   gcc_assert (!id->src_cfun->after_inlining);
2755
2756   id->entry_bb = bb;
2757   initialize_inlined_parameters (id, t, fn, bb);
2758
2759   if (DECL_INITIAL (fn))
2760     add_lexical_block (id->block, remap_blocks (DECL_INITIAL (fn), id));
2761
2762   /* Return statements in the function body will be replaced by jumps
2763      to the RET_LABEL.  */
2764
2765   gcc_assert (DECL_INITIAL (fn));
2766   gcc_assert (TREE_CODE (DECL_INITIAL (fn)) == BLOCK);
2767
2768   /* Find the lhs to which the result of this call is assigned.  */
2769   return_slot = NULL;
2770   if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
2771     {
2772       modify_dest = GIMPLE_STMT_OPERAND (stmt, 0);
2773
2774       /* The function which we are inlining might not return a value,
2775          in which case we should issue a warning that the function
2776          does not return a value.  In that case the optimizers will
2777          see that the variable to which the value is assigned was not
2778          initialized.  We do not want to issue a warning about that
2779          uninitialized variable.  */
2780       if (DECL_P (modify_dest))
2781         TREE_NO_WARNING (modify_dest) = 1;
2782       if (CALL_EXPR_RETURN_SLOT_OPT (t))
2783         {
2784           return_slot = modify_dest;
2785           modify_dest = NULL;
2786         }
2787     }
2788   else
2789     modify_dest = NULL;
2790
2791   /* If we are inlining a call to the C++ operator new, we don't want
2792      to use type based alias analysis on the return value.  Otherwise
2793      we may get confused if the compiler sees that the inlined new
2794      function returns a pointer which was just deleted.  See bug
2795      33407.  */
2796   if (DECL_IS_OPERATOR_NEW (fn))
2797     {
2798       return_slot = NULL;
2799       modify_dest = NULL;
2800     }
2801
2802   /* Declare the return variable for the function.  */
2803   retvar = declare_return_variable (id, return_slot,
2804                                     modify_dest, &use_retvar);
2805
2806   if (DECL_IS_OPERATOR_NEW (fn))
2807     {
2808       gcc_assert (TREE_CODE (retvar) == VAR_DECL
2809                   && POINTER_TYPE_P (TREE_TYPE (retvar)));
2810       DECL_NO_TBAA_P (retvar) = 1;
2811     }
2812
2813   /* This is it.  Duplicate the callee body.  Assume callee is
2814      pre-gimplified.  Note that we must not alter the caller
2815      function in any way before this point, as this CALL_EXPR may be
2816      a self-referential call; if we're calling ourselves, we need to
2817      duplicate our body before altering anything.  */
2818   copy_body (id, bb->count, bb->frequency, bb, return_block);
2819
2820   /* Add local vars in this inlined callee to caller.  */
2821   t_step = id->src_cfun->local_decls;
2822   for (; t_step; t_step = TREE_CHAIN (t_step))
2823     {
2824       var = TREE_VALUE (t_step);
2825       if (TREE_STATIC (var) && !TREE_ASM_WRITTEN (var))
2826         cfun->local_decls = tree_cons (NULL_TREE, var,
2827                                                cfun->local_decls);
2828       else
2829         cfun->local_decls = tree_cons (NULL_TREE, remap_decl (var, id),
2830                                                cfun->local_decls);
2831     }
2832
2833   /* Clean up.  */
2834   pointer_map_destroy (id->decl_map);
2835   id->decl_map = st;
2836
2837   /* If the inlined function returns a result that we care about,
2838      clobber the CALL_EXPR with a reference to the return variable.  */
2839   if (use_retvar && (TREE_CODE (bsi_stmt (stmt_bsi)) != CALL_EXPR))
2840     {
2841       *tp = use_retvar;
2842       if (gimple_in_ssa_p (cfun))
2843         {
2844           update_stmt (stmt);
2845           mark_symbols_for_renaming (stmt);
2846         }
2847       maybe_clean_or_replace_eh_stmt (stmt, stmt);
2848     }
2849   else
2850     /* We're modifying a TSI owned by gimple_expand_calls_inline();
2851        tsi_delink() will leave the iterator in a sane state.  */
2852     {
2853       /* Handle case of inlining function that miss return statement so
2854          return value becomes undefined.  */
2855       if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
2856           && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) == SSA_NAME)
2857         {
2858           tree name = GIMPLE_STMT_OPERAND (stmt, 0);
2859           tree var = SSA_NAME_VAR (GIMPLE_STMT_OPERAND (stmt, 0));
2860           tree def = gimple_default_def (cfun, var);
2861
2862           /* If the variable is used undefined, make this name undefined via
2863              move.  */
2864           if (def)
2865             {
2866               GIMPLE_STMT_OPERAND (stmt, 1) = def;
2867               update_stmt (stmt);
2868             }
2869           /* Otherwise make this variable undefined.  */
2870           else
2871             {
2872               bsi_remove (&stmt_bsi, true);
2873               set_default_def (var, name);
2874               SSA_NAME_DEF_STMT (name) = build_empty_stmt ();
2875             }
2876         }
2877       else
2878         bsi_remove (&stmt_bsi, true);
2879     }
2880
2881   if (purge_dead_abnormal_edges)
2882     tree_purge_dead_abnormal_call_edges (return_block);
2883
2884   /* If the value of the new expression is ignored, that's OK.  We
2885      don't warn about this for CALL_EXPRs, so we shouldn't warn about
2886      the equivalent inlined version either.  */
2887   TREE_USED (*tp) = 1;
2888
2889   /* Output the inlining info for this abstract function, since it has been
2890      inlined.  If we don't do this now, we can lose the information about the
2891      variables in the function when the blocks get blown away as soon as we
2892      remove the cgraph node.  */
2893   (*debug_hooks->outlining_inline_function) (cg_edge->callee->decl);
2894
2895   /* Update callgraph if needed.  */
2896   cgraph_remove_node (cg_edge->callee);
2897
2898   id->block = NULL_TREE;
2899   successfully_inlined = TRUE;
2900
2901  egress:
2902   input_location = saved_location;
2903   return successfully_inlined;
2904 }
2905
2906 /* Expand call statements reachable from STMT_P.
2907    We can only have CALL_EXPRs as the "toplevel" tree code or nested
2908    in a GIMPLE_MODIFY_STMT.  See tree-gimple.c:get_call_expr_in().  We can
2909    unfortunately not use that function here because we need a pointer
2910    to the CALL_EXPR, not the tree itself.  */
2911
2912 static bool
2913 gimple_expand_calls_inline (basic_block bb, copy_body_data *id)
2914 {
2915   block_stmt_iterator bsi;
2916
2917   /* Register specific tree functions.  */
2918   tree_register_cfg_hooks ();
2919   for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2920     {
2921       tree *expr_p = bsi_stmt_ptr (bsi);
2922       tree stmt = *expr_p;
2923
2924       if (TREE_CODE (*expr_p) == GIMPLE_MODIFY_STMT)
2925         expr_p = &GIMPLE_STMT_OPERAND (*expr_p, 1);
2926       if (TREE_CODE (*expr_p) == WITH_SIZE_EXPR)
2927         expr_p = &TREE_OPERAND (*expr_p, 0);
2928       if (TREE_CODE (*expr_p) == CALL_EXPR)
2929         if (expand_call_inline (bb, stmt, expr_p, id))
2930           return true;
2931     }
2932   return false;
2933 }
2934
2935 /* Walk all basic blocks created after FIRST and try to fold every statement
2936    in the STATEMENTS pointer set.  */
2937 static void
2938 fold_marked_statements (int first, struct pointer_set_t *statements)
2939 {
2940   for (;first < n_basic_blocks;first++)
2941     if (BASIC_BLOCK (first))
2942       {
2943         block_stmt_iterator bsi;
2944         for (bsi = bsi_start (BASIC_BLOCK (first));
2945              !bsi_end_p (bsi); bsi_next (&bsi))
2946           if (pointer_set_contains (statements, bsi_stmt (bsi)))
2947             {
2948               tree old_stmt = bsi_stmt (bsi);
2949               tree old_call = get_call_expr_in (old_stmt);
2950
2951               if (fold_stmt (bsi_stmt_ptr (bsi)))
2952                 {
2953                   update_stmt (bsi_stmt (bsi));
2954                   if (old_call)
2955                     cgraph_update_edges_for_call_stmt (old_stmt, old_call,
2956                                                        bsi_stmt (bsi));
2957                   if (maybe_clean_or_replace_eh_stmt (old_stmt,
2958                                                       bsi_stmt (bsi)))
2959                     tree_purge_dead_eh_edges (BASIC_BLOCK (first));
2960                 }
2961             }
2962       }
2963 }
2964
2965 /* Return true if BB has at least one abnormal outgoing edge.  */
2966
2967 static inline bool
2968 has_abnormal_outgoing_edge_p (basic_block bb)
2969 {
2970   edge e;
2971   edge_iterator ei;
2972
2973   FOR_EACH_EDGE (e, ei, bb->succs)
2974     if (e->flags & EDGE_ABNORMAL)
2975       return true;
2976
2977   return false;
2978 }
2979
2980 /* Expand calls to inline functions in the body of FN.  */
2981
2982 unsigned int
2983 optimize_inline_calls (tree fn)
2984 {
2985   copy_body_data id;
2986   tree prev_fn;
2987   basic_block bb;
2988   int last = n_basic_blocks;
2989   /* There is no point in performing inlining if errors have already
2990      occurred -- and we might crash if we try to inline invalid
2991      code.  */
2992   if (errorcount || sorrycount)
2993     return 0;
2994
2995   /* Clear out ID.  */
2996   memset (&id, 0, sizeof (id));
2997
2998   id.src_node = id.dst_node = cgraph_node (fn);
2999   id.dst_fn = fn;
3000   /* Or any functions that aren't finished yet.  */
3001   prev_fn = NULL_TREE;
3002   if (current_function_decl)
3003     {
3004       id.dst_fn = current_function_decl;
3005       prev_fn = current_function_decl;
3006     }
3007
3008   id.copy_decl = copy_decl_maybe_to_var;
3009   id.transform_call_graph_edges = CB_CGE_DUPLICATE;
3010   id.transform_new_cfg = false;
3011   id.transform_return_to_modify = true;
3012   id.transform_lang_insert_block = NULL;
3013   id.statements_to_fold = pointer_set_create ();
3014
3015   push_gimplify_context ();
3016
3017   /* We make no attempts to keep dominance info up-to-date.  */
3018   free_dominance_info (CDI_DOMINATORS);
3019   free_dominance_info (CDI_POST_DOMINATORS);
3020
3021   /* Reach the trees by walking over the CFG, and note the
3022      enclosing basic-blocks in the call edges.  */
3023   /* We walk the blocks going forward, because inlined function bodies
3024      will split id->current_basic_block, and the new blocks will
3025      follow it; we'll trudge through them, processing their CALL_EXPRs
3026      along the way.  */
3027   FOR_EACH_BB (bb)
3028     gimple_expand_calls_inline (bb, &id);
3029
3030   pop_gimplify_context (NULL);
3031
3032 #ifdef ENABLE_CHECKING
3033     {
3034       struct cgraph_edge *e;
3035
3036       verify_cgraph_node (id.dst_node);
3037
3038       /* Double check that we inlined everything we are supposed to inline.  */
3039       for (e = id.dst_node->callees; e; e = e->next_callee)
3040         gcc_assert (e->inline_failed);
3041     }
3042 #endif
3043
3044   /* Fold the statements before compacting/renumbering the basic blocks.  */
3045   fold_marked_statements (last, id.statements_to_fold);
3046   pointer_set_destroy (id.statements_to_fold);
3047
3048   /* Renumber the (code) basic_blocks consecutively.  */
3049   compact_blocks ();
3050   /* Renumber the lexical scoping (non-code) blocks consecutively.  */
3051   number_blocks (fn);
3052
3053   /* We are not going to maintain the cgraph edges up to date.
3054      Kill it so it won't confuse us.  */
3055   cgraph_node_remove_callees (id.dst_node);
3056
3057   fold_cond_expr_cond ();
3058   /* It would be nice to check SSA/CFG/statement consistency here, but it is
3059      not possible yet - the IPA passes might make various functions to not
3060      throw and they don't care to proactively update local EH info.  This is
3061      done later in fixup_cfg pass that also execute the verification.  */
3062   return (TODO_update_ssa | TODO_cleanup_cfg
3063           | (gimple_in_ssa_p (cfun) ? TODO_remove_unused_locals : 0)
3064           | (profile_status != PROFILE_ABSENT ? TODO_rebuild_frequencies : 0));
3065 }
3066
3067 /* Passed to walk_tree.  Copies the node pointed to, if appropriate.  */
3068
3069 tree
3070 copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
3071 {
3072   enum tree_code code = TREE_CODE (*tp);
3073   enum tree_code_class cl = TREE_CODE_CLASS (code);
3074
3075   /* We make copies of most nodes.  */
3076   if (IS_EXPR_CODE_CLASS (cl)
3077       || IS_GIMPLE_STMT_CODE_CLASS (cl)
3078       || code == TREE_LIST
3079       || code == TREE_VEC
3080       || code == TYPE_DECL
3081       || code == OMP_CLAUSE)
3082     {
3083       /* Because the chain gets clobbered when we make a copy, we save it
3084          here.  */
3085       tree chain = NULL_TREE, new;
3086
3087       if (!GIMPLE_TUPLE_P (*tp))
3088         chain = TREE_CHAIN (*tp);
3089
3090       /* Copy the node.  */
3091       new = copy_node (*tp);
3092
3093       /* Propagate mudflap marked-ness.  */
3094       if (flag_mudflap && mf_marked_p (*tp))
3095         mf_mark (new);
3096
3097       *tp = new;
3098
3099       /* Now, restore the chain, if appropriate.  That will cause
3100          walk_tree to walk into the chain as well.  */
3101       if (code == PARM_DECL
3102           || code == TREE_LIST
3103           || code == OMP_CLAUSE)
3104         TREE_CHAIN (*tp) = chain;
3105
3106       /* For now, we don't update BLOCKs when we make copies.  So, we
3107          have to nullify all BIND_EXPRs.  */
3108       if (TREE_CODE (*tp) == BIND_EXPR)
3109         BIND_EXPR_BLOCK (*tp) = NULL_TREE;
3110     }
3111   else if (code == CONSTRUCTOR)
3112     {
3113       /* CONSTRUCTOR nodes need special handling because
3114          we need to duplicate the vector of elements.  */
3115       tree new;
3116
3117       new = copy_node (*tp);
3118
3119       /* Propagate mudflap marked-ness.  */
3120       if (flag_mudflap && mf_marked_p (*tp))
3121         mf_mark (new);
3122
3123       CONSTRUCTOR_ELTS (new) = VEC_copy (constructor_elt, gc,
3124                                          CONSTRUCTOR_ELTS (*tp));
3125       *tp = new;
3126     }
3127   else if (TREE_CODE_CLASS (code) == tcc_type)
3128     *walk_subtrees = 0;
3129   else if (TREE_CODE_CLASS (code) == tcc_declaration)
3130     *walk_subtrees = 0;
3131   else if (TREE_CODE_CLASS (code) == tcc_constant)
3132     *walk_subtrees = 0;
3133   else
3134     gcc_assert (code != STATEMENT_LIST);
3135   return NULL_TREE;
3136 }
3137
3138 /* The SAVE_EXPR pointed to by TP is being copied.  If ST contains
3139    information indicating to what new SAVE_EXPR this one should be mapped,
3140    use that one.  Otherwise, create a new node and enter it in ST.  FN is
3141    the function into which the copy will be placed.  */
3142
3143 static void
3144 remap_save_expr (tree *tp, void *st_, int *walk_subtrees)
3145 {
3146   struct pointer_map_t *st = (struct pointer_map_t *) st_;
3147   tree *n;
3148   tree t;
3149
3150   /* See if we already encountered this SAVE_EXPR.  */
3151   n = (tree *) pointer_map_contains (st, *tp);
3152
3153   /* If we didn't already remap this SAVE_EXPR, do so now.  */
3154   if (!n)
3155     {
3156       t = copy_node (*tp);
3157
3158       /* Remember this SAVE_EXPR.  */
3159       *pointer_map_insert (st, *tp) = t;
3160       /* Make sure we don't remap an already-remapped SAVE_EXPR.  */
3161       *pointer_map_insert (st, t) = t;
3162     }
3163   else
3164     {
3165       /* We've already walked into this SAVE_EXPR; don't do it again.  */
3166       *walk_subtrees = 0;
3167       t = *n;
3168     }
3169
3170   /* Replace this SAVE_EXPR with the copy.  */
3171   *tp = t;
3172 }
3173
3174 /* Called via walk_tree.  If *TP points to a DECL_STMT for a local label,
3175    copies the declaration and enters it in the splay_tree in DATA (which is
3176    really an `copy_body_data *').  */
3177
3178 static tree
3179 mark_local_for_remap_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
3180                         void *data)
3181 {
3182   copy_body_data *id = (copy_body_data *) data;
3183
3184   /* Don't walk into types.  */
3185   if (TYPE_P (*tp))
3186     *walk_subtrees = 0;
3187
3188   else if (TREE_CODE (*tp) == LABEL_EXPR)
3189     {
3190       tree decl = TREE_OPERAND (*tp, 0);
3191
3192       /* Copy the decl and remember the copy.  */
3193       insert_decl_map (id, decl, id->copy_decl (decl, id));
3194     }
3195
3196   return NULL_TREE;
3197 }
3198
3199 /* Perform any modifications to EXPR required when it is unsaved.  Does
3200    not recurse into EXPR's subtrees.  */
3201
3202 static void
3203 unsave_expr_1 (tree expr)
3204 {
3205   switch (TREE_CODE (expr))
3206     {
3207     case TARGET_EXPR:
3208       /* Don't mess with a TARGET_EXPR that hasn't been expanded.
3209          It's OK for this to happen if it was part of a subtree that
3210          isn't immediately expanded, such as operand 2 of another
3211          TARGET_EXPR.  */
3212       if (TREE_OPERAND (expr, 1))
3213         break;
3214
3215       TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
3216       TREE_OPERAND (expr, 3) = NULL_TREE;
3217       break;
3218
3219     default:
3220       break;
3221     }
3222 }
3223
3224 /* Called via walk_tree when an expression is unsaved.  Using the
3225    splay_tree pointed to by ST (which is really a `splay_tree'),
3226    remaps all local declarations to appropriate replacements.  */
3227
3228 static tree
3229 unsave_r (tree *tp, int *walk_subtrees, void *data)
3230 {
3231   copy_body_data *id = (copy_body_data *) data;
3232   struct pointer_map_t *st = id->decl_map;
3233   tree *n;
3234
3235   /* Only a local declaration (variable or label).  */
3236   if ((TREE_CODE (*tp) == VAR_DECL && !TREE_STATIC (*tp))
3237       || TREE_CODE (*tp) == LABEL_DECL)
3238     {
3239       /* Lookup the declaration.  */
3240       n = (tree *) pointer_map_contains (st, *tp);
3241
3242       /* If it's there, remap it.  */
3243       if (n)
3244         *tp = *n;
3245     }
3246
3247   else if (TREE_CODE (*tp) == STATEMENT_LIST)
3248     copy_statement_list (tp);
3249   else if (TREE_CODE (*tp) == BIND_EXPR)
3250     copy_bind_expr (tp, walk_subtrees, id);
3251   else if (TREE_CODE (*tp) == SAVE_EXPR)
3252     remap_save_expr (tp, st, walk_subtrees);
3253   else
3254     {
3255       copy_tree_r (tp, walk_subtrees, NULL);
3256
3257       /* Do whatever unsaving is required.  */
3258       unsave_expr_1 (*tp);
3259     }
3260
3261   /* Keep iterating.  */
3262   return NULL_TREE;
3263 }
3264
3265 /* Copies everything in EXPR and replaces variables, labels
3266    and SAVE_EXPRs local to EXPR.  */
3267
3268 tree
3269 unsave_expr_now (tree expr)
3270 {
3271   copy_body_data id;
3272
3273   /* There's nothing to do for NULL_TREE.  */
3274   if (expr == 0)
3275     return expr;
3276
3277   /* Set up ID.  */
3278   memset (&id, 0, sizeof (id));
3279   id.src_fn = current_function_decl;
3280   id.dst_fn = current_function_decl;
3281   id.decl_map = pointer_map_create ();
3282
3283   id.copy_decl = copy_decl_no_change;
3284   id.transform_call_graph_edges = CB_CGE_DUPLICATE;
3285   id.transform_new_cfg = false;
3286   id.transform_return_to_modify = false;
3287   id.transform_lang_insert_block = NULL;
3288
3289   /* Walk the tree once to find local labels.  */
3290   walk_tree_without_duplicates (&expr, mark_local_for_remap_r, &id);
3291
3292   /* Walk the tree again, copying, remapping, and unsaving.  */
3293   walk_tree (&expr, unsave_r, &id, NULL);
3294
3295   /* Clean up.  */
3296   pointer_map_destroy (id.decl_map);
3297
3298   return expr;
3299 }
3300
3301 /* Allow someone to determine if SEARCH is a child of TOP from gdb.  */
3302
3303 static tree
3304 debug_find_tree_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
3305 {
3306   if (*tp == data)
3307     return (tree) data;
3308   else
3309     return NULL;
3310 }
3311
3312 bool
3313 debug_find_tree (tree top, tree search)
3314 {
3315   return walk_tree_without_duplicates (&top, debug_find_tree_1, search) != 0;
3316 }
3317
3318
3319 /* Declare the variables created by the inliner.  Add all the variables in
3320    VARS to BIND_EXPR.  */
3321
3322 static void
3323 declare_inline_vars (tree block, tree vars)
3324 {
3325   tree t;
3326   for (t = vars; t; t = TREE_CHAIN (t))
3327     {
3328       DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
3329       gcc_assert (!TREE_STATIC (t) && !TREE_ASM_WRITTEN (t));
3330       cfun->local_decls = tree_cons (NULL_TREE, t, cfun->local_decls);
3331     }
3332
3333   if (block)
3334     BLOCK_VARS (block) = chainon (BLOCK_VARS (block), vars);
3335 }
3336
3337
3338 /* Copy NODE (which must be a DECL).  The DECL originally was in the FROM_FN,
3339    but now it will be in the TO_FN.  PARM_TO_VAR means enable PARM_DECL to
3340    VAR_DECL translation.  */
3341
3342 static tree
3343 copy_decl_for_dup_finish (copy_body_data *id, tree decl, tree copy)
3344 {
3345   /* Don't generate debug information for the copy if we wouldn't have
3346      generated it for the copy either.  */
3347   DECL_ARTIFICIAL (copy) = DECL_ARTIFICIAL (decl);
3348   DECL_IGNORED_P (copy) = DECL_IGNORED_P (decl);
3349
3350   /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
3351      declaration inspired this copy.  */
3352   DECL_ABSTRACT_ORIGIN (copy) = DECL_ORIGIN (decl);
3353
3354   /* The new variable/label has no RTL, yet.  */
3355   if (CODE_CONTAINS_STRUCT (TREE_CODE (copy), TS_DECL_WRTL)
3356       && !TREE_STATIC (copy) && !DECL_EXTERNAL (copy))
3357     SET_DECL_RTL (copy, NULL_RTX);
3358
3359   /* These args would always appear unused, if not for this.  */
3360   TREE_USED (copy) = 1;
3361
3362   /* Set the context for the new declaration.  */
3363   if (!DECL_CONTEXT (decl))
3364     /* Globals stay global.  */
3365     ;
3366   else if (DECL_CONTEXT (decl) != id->src_fn)
3367     /* Things that weren't in the scope of the function we're inlining
3368        from aren't in the scope we're inlining to, either.  */
3369     ;
3370   else if (TREE_STATIC (decl))
3371     /* Function-scoped static variables should stay in the original
3372        function.  */
3373     ;
3374   else
3375     /* Ordinary automatic local variables are now in the scope of the
3376        new function.  */
3377     DECL_CONTEXT (copy) = id->dst_fn;
3378
3379   return copy;
3380 }
3381
3382 static tree
3383 copy_decl_to_var (tree decl, copy_body_data *id)
3384 {
3385   tree copy, type;
3386
3387   gcc_assert (TREE_CODE (decl) == PARM_DECL
3388               || TREE_CODE (decl) == RESULT_DECL);
3389
3390   type = TREE_TYPE (decl);
3391
3392   copy = build_decl (VAR_DECL, DECL_NAME (decl), type);
3393   TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl);
3394   TREE_READONLY (copy) = TREE_READONLY (decl);
3395   TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl);
3396   DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl);
3397   DECL_NO_TBAA_P (copy) = DECL_NO_TBAA_P (decl);
3398
3399   return copy_decl_for_dup_finish (id, decl, copy);
3400 }
3401
3402 /* Like copy_decl_to_var, but create a return slot object instead of a
3403    pointer variable for return by invisible reference.  */
3404
3405 static tree
3406 copy_result_decl_to_var (tree decl, copy_body_data *id)
3407 {
3408   tree copy, type;
3409
3410   gcc_assert (TREE_CODE (decl) == PARM_DECL
3411               || TREE_CODE (decl) == RESULT_DECL);
3412
3413   type = TREE_TYPE (decl);
3414   if (DECL_BY_REFERENCE (decl))
3415     type = TREE_TYPE (type);
3416
3417   copy = build_decl (VAR_DECL, DECL_NAME (decl), type);
3418   TREE_READONLY (copy) = TREE_READONLY (decl);
3419   TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl);
3420   if (!DECL_BY_REFERENCE (decl))
3421     {
3422       TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl);
3423       DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl);
3424       DECL_NO_TBAA_P (copy) = DECL_NO_TBAA_P (decl);
3425     }
3426
3427   return copy_decl_for_dup_finish (id, decl, copy);
3428 }
3429
3430
3431 tree
3432 copy_decl_no_change (tree decl, copy_body_data *id)
3433 {
3434   tree copy;
3435
3436   copy = copy_node (decl);
3437
3438   /* The COPY is not abstract; it will be generated in DST_FN.  */
3439   DECL_ABSTRACT (copy) = 0;
3440   lang_hooks.dup_lang_specific_decl (copy);
3441
3442   /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
3443      been taken; it's for internal bookkeeping in expand_goto_internal.  */
3444   if (TREE_CODE (copy) == LABEL_DECL)
3445     {
3446       TREE_ADDRESSABLE (copy) = 0;
3447       LABEL_DECL_UID (copy) = -1;
3448     }
3449
3450   return copy_decl_for_dup_finish (id, decl, copy);
3451 }
3452
3453 static tree
3454 copy_decl_maybe_to_var (tree decl, copy_body_data *id)
3455 {
3456   if (TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL)
3457     return copy_decl_to_var (decl, id);
3458   else
3459     return copy_decl_no_change (decl, id);
3460 }
3461
3462 /* Return a copy of the function's argument tree.  */
3463 static tree
3464 copy_arguments_for_versioning (tree orig_parm, copy_body_data * id)
3465 {
3466   tree *arg_copy, *parg;
3467
3468   arg_copy = &orig_parm;
3469   for (parg = arg_copy; *parg; parg = &TREE_CHAIN (*parg))
3470     {
3471       tree new = remap_decl (*parg, id);
3472       lang_hooks.dup_lang_specific_decl (new);
3473       TREE_CHAIN (new) = TREE_CHAIN (*parg);
3474       *parg = new;
3475     }
3476   return orig_parm;
3477 }
3478
3479 /* Return a copy of the function's static chain.  */
3480 static tree
3481 copy_static_chain (tree static_chain, copy_body_data * id)
3482 {
3483   tree *chain_copy, *pvar;
3484
3485   chain_copy = &static_chain;
3486   for (pvar = chain_copy; *pvar; pvar = &TREE_CHAIN (*pvar))
3487     {
3488       tree new = remap_decl (*pvar, id);
3489       lang_hooks.dup_lang_specific_decl (new);
3490       TREE_CHAIN (new) = TREE_CHAIN (*pvar);
3491       *pvar = new;
3492     }
3493   return static_chain;
3494 }
3495
3496 /* Return true if the function is allowed to be versioned.
3497    This is a guard for the versioning functionality.  */
3498 bool
3499 tree_versionable_function_p (tree fndecl)
3500 {
3501   if (fndecl == NULL_TREE)
3502     return false;
3503   /* ??? There are cases where a function is
3504      uninlinable but can be versioned.  */
3505   if (!tree_inlinable_function_p (fndecl))
3506     return false;
3507
3508   return true;
3509 }
3510
3511 /* Create a copy of a function's tree.
3512    OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
3513    of the original function and the new copied function
3514    respectively.  In case we want to replace a DECL
3515    tree with another tree while duplicating the function's
3516    body, TREE_MAP represents the mapping between these
3517    trees. If UPDATE_CLONES is set, the call_stmt fields
3518    of edges of clones of the function will be updated.  */
3519 void
3520 tree_function_versioning (tree old_decl, tree new_decl, varray_type tree_map,
3521                           bool update_clones)
3522 {
3523   struct cgraph_node *old_version_node;
3524   struct cgraph_node *new_version_node;
3525   copy_body_data id;
3526   tree p;
3527   unsigned i;
3528   struct ipa_replace_map *replace_info;
3529   basic_block old_entry_block;
3530   tree t_step;
3531   tree old_current_function_decl = current_function_decl;
3532
3533   gcc_assert (TREE_CODE (old_decl) == FUNCTION_DECL
3534               && TREE_CODE (new_decl) == FUNCTION_DECL);
3535   DECL_POSSIBLY_INLINED (old_decl) = 1;
3536
3537   old_version_node = cgraph_node (old_decl);
3538   new_version_node = cgraph_node (new_decl);
3539
3540   DECL_ARTIFICIAL (new_decl) = 1;
3541   DECL_ABSTRACT_ORIGIN (new_decl) = DECL_ORIGIN (old_decl);
3542
3543   /* Prepare the data structures for the tree copy.  */
3544   memset (&id, 0, sizeof (id));
3545
3546   /* Generate a new name for the new version. */
3547   if (!update_clones)
3548     {
3549       DECL_NAME (new_decl) =  create_tmp_var_name (NULL);
3550       SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
3551       SET_DECL_RTL (new_decl, NULL_RTX);
3552       id.statements_to_fold = pointer_set_create ();
3553     }
3554
3555   id.decl_map = pointer_map_create ();
3556   id.src_fn = old_decl;
3557   id.dst_fn = new_decl;
3558   id.src_node = old_version_node;
3559   id.dst_node = new_version_node;
3560   id.src_cfun = DECL_STRUCT_FUNCTION (old_decl);
3561
3562   id.copy_decl = copy_decl_no_change;
3563   id.transform_call_graph_edges
3564     = update_clones ? CB_CGE_MOVE_CLONES : CB_CGE_MOVE;
3565   id.transform_new_cfg = true;
3566   id.transform_return_to_modify = false;
3567   id.transform_lang_insert_block = NULL;
3568
3569   current_function_decl = new_decl;
3570   old_entry_block = ENTRY_BLOCK_PTR_FOR_FUNCTION
3571     (DECL_STRUCT_FUNCTION (old_decl));
3572   initialize_cfun (new_decl, old_decl,
3573                    old_entry_block->count,
3574                    old_entry_block->frequency);
3575   push_cfun (DECL_STRUCT_FUNCTION (new_decl));
3576
3577   /* Copy the function's static chain.  */
3578   p = DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl;
3579   if (p)
3580     DECL_STRUCT_FUNCTION (new_decl)->static_chain_decl =
3581       copy_static_chain (DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl,
3582                          &id);
3583   /* Copy the function's arguments.  */
3584   if (DECL_ARGUMENTS (old_decl) != NULL_TREE)
3585     DECL_ARGUMENTS (new_decl) =
3586       copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl), &id);
3587
3588   /* If there's a tree_map, prepare for substitution.  */
3589   if (tree_map)
3590     for (i = 0; i < VARRAY_ACTIVE_SIZE (tree_map); i++)
3591       {
3592         replace_info = (struct ipa_replace_map *) VARRAY_GENERIC_PTR (tree_map, i);
3593         if (replace_info->replace_p)
3594           insert_decl_map (&id, replace_info->old_tree,
3595                            replace_info->new_tree);
3596       }
3597
3598   DECL_INITIAL (new_decl) = remap_blocks (DECL_INITIAL (id.src_fn), &id);
3599
3600   /* Renumber the lexical scoping (non-code) blocks consecutively.  */
3601   number_blocks (id.dst_fn);
3602
3603   if (DECL_STRUCT_FUNCTION (old_decl)->local_decls != NULL_TREE)
3604     /* Add local vars.  */
3605     for (t_step = DECL_STRUCT_FUNCTION (old_decl)->local_decls;
3606          t_step; t_step = TREE_CHAIN (t_step))
3607       {
3608         tree var = TREE_VALUE (t_step);
3609         if (TREE_STATIC (var) && !TREE_ASM_WRITTEN (var))
3610           cfun->local_decls = tree_cons (NULL_TREE, var, cfun->local_decls);
3611         else
3612           cfun->local_decls =
3613             tree_cons (NULL_TREE, remap_decl (var, &id),
3614                        cfun->local_decls);
3615       }
3616
3617   /* Copy the Function's body.  */
3618   copy_body (&id, old_entry_block->count, old_entry_block->frequency, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR);
3619
3620   if (DECL_RESULT (old_decl) != NULL_TREE)
3621     {
3622       tree *res_decl = &DECL_RESULT (old_decl);
3623       DECL_RESULT (new_decl) = remap_decl (*res_decl, &id);
3624       lang_hooks.dup_lang_specific_decl (DECL_RESULT (new_decl));
3625     }
3626
3627   /* Renumber the lexical scoping (non-code) blocks consecutively.  */
3628   number_blocks (new_decl);
3629
3630   /* Clean up.  */
3631   pointer_map_destroy (id.decl_map);
3632   if (!update_clones)
3633     {
3634       fold_marked_statements (0, id.statements_to_fold);
3635       pointer_set_destroy (id.statements_to_fold);
3636       fold_cond_expr_cond ();
3637     }
3638   if (gimple_in_ssa_p (cfun))
3639     {
3640       free_dominance_info (CDI_DOMINATORS);
3641       free_dominance_info (CDI_POST_DOMINATORS);
3642       if (!update_clones)
3643         delete_unreachable_blocks ();
3644       update_ssa (TODO_update_ssa);
3645       if (!update_clones)
3646         {
3647           fold_cond_expr_cond ();
3648           if (need_ssa_update_p ())
3649             update_ssa (TODO_update_ssa);
3650         }
3651     }
3652   free_dominance_info (CDI_DOMINATORS);
3653   free_dominance_info (CDI_POST_DOMINATORS);
3654   pop_cfun ();
3655   current_function_decl = old_current_function_decl;
3656   gcc_assert (!current_function_decl
3657               || DECL_STRUCT_FUNCTION (current_function_decl) == cfun);
3658   return;
3659 }
3660
3661 /* Duplicate a type, fields and all.  */
3662
3663 tree
3664 build_duplicate_type (tree type)
3665 {
3666   struct copy_body_data id;
3667
3668   memset (&id, 0, sizeof (id));
3669   id.src_fn = current_function_decl;
3670   id.dst_fn = current_function_decl;
3671   id.src_cfun = cfun;
3672   id.decl_map = pointer_map_create ();
3673   id.copy_decl = copy_decl_no_change;
3674
3675   type = remap_type_1 (type, &id);
3676
3677   pointer_map_destroy (id.decl_map);
3678
3679   TYPE_CANONICAL (type) = type;
3680
3681   return type;
3682 }