gcc/tree-inline.c

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