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