gcc/tree-inline.c

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