gcc/tree-inline.c

   1 /* Tree inlining.
   2    Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   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 "hashtab.h"
  36 #include "langhooks.h"
  37 #include "basic-block.h"
  38 #include "tree-iterator.h"
  39 #include "cgraph.h"
  40 #include "intl.h"
  41 #include "tree-mudflap.h"
  42 #include "tree-flow.h"
  43 #include "function.h"
  44 #include "ggc.h"
  45 #include "tree-flow.h"
  46 #include "diagnostic.h"
  47 #include "except.h"
  48 #include "debug.h"
  49 #include "pointer-set.h"
  50 #include "ipa-prop.h"
  51 #include "value-prof.h"
  52 #include "tree-pass.h"
  53 #include "target.h"
  54 #include "integrate.h"
  55
  56 /* I'm not real happy about this, but we need to handle gimple and
  57    non-gimple trees.  */
  58 #include "gimple.h"
  59
  60 /* Inlining, Cloning, Versioning, Parallelization
  61
  62    Inlining: a function body is duplicated, but the PARM_DECLs are
  63    remapped into VAR_DECLs, and non-void RETURN_EXPRs become
  64    MODIFY_EXPRs that store to a dedicated returned-value variable.
  65    The duplicated eh_region info of the copy will later be appended
  66    to the info for the caller; the eh_region info in copied throwing
  67    statements and RESX statements are adjusted accordingly.
  68
  69    Cloning: (only in C++) We have one body for a con/de/structor, and
  70    multiple function decls, each with a unique parameter list.
  71    Duplicate the body, using the given splay tree; some parameters
  72    will become constants (like 0 or 1).
  73
  74    Versioning: a function body is duplicated and the result is a new
  75    function rather than into blocks of an existing function as with
  76    inlining.  Some parameters will become constants.
  77
  78    Parallelization: a region of a function is duplicated resulting in
  79    a new function.  Variables may be replaced with complex expressions
  80    to enable shared variable semantics.
  81
  82    All of these will simultaneously lookup any callgraph edges.  If
  83    we're going to inline the duplicated function body, and the given
  84    function has some cloned callgraph nodes (one for each place this
  85    function will be inlined) those callgraph edges will be duplicated.
  86    If we're cloning the body, those callgraph edges will be
  87    updated to point into the new body.  (Note that the original
  88    callgraph node and edge list will not be altered.)
  89
  90    See the CALL_EXPR handling case in copy_tree_body_r ().  */
  91
  92 /* To Do:
  93
  94    o In order to make inlining-on-trees work, we pessimized
  95      function-local static constants.  In particular, they are now
  96      always output, even when not addressed.  Fix this by treating
  97      function-local static constants just like global static
  98      constants; the back-end already knows not to output them if they
  99      are not needed.
 100
 101    o Provide heuristics to clamp inlining of recursive template
 102      calls?  */
 103
 104
 105 /* Weights that estimate_num_insns uses for heuristics in inlining.  */
 106
 107 eni_weights eni_inlining_weights;
 108
 109 /* Weights that estimate_num_insns uses to estimate the size of the
 110    produced code.  */
 111
 112 eni_weights eni_size_weights;
 113
 114 /* Weights that estimate_num_insns uses to estimate the time necessary
 115    to execute the produced code.  */
 116
 117 eni_weights eni_time_weights;
 118
 119 /* Prototypes.  */
 120
 121 static tree declare_return_variable (copy_body_data *, tree, tree);
 122 static void remap_block (tree *, copy_body_data *);
 123 static void copy_bind_expr (tree *, int *, copy_body_data *);
 124 static tree mark_local_for_remap_r (tree *, int *, void *);
 125 static void unsave_expr_1 (tree);
 126 static tree unsave_r (tree *, int *, void *);
 127 static void declare_inline_vars (tree, tree);
 128 static void remap_save_expr (tree *, void *, int *);
 129 static void prepend_lexical_block (tree current_block, tree new_block);
 130 static tree copy_decl_to_var (tree, copy_body_data *);
 131 static tree copy_result_decl_to_var (tree, copy_body_data *);
 132 static tree copy_decl_maybe_to_var (tree, copy_body_data *);
 133 static gimple remap_gimple_stmt (gimple, copy_body_data *);
 134 static bool delete_unreachable_blocks_update_callgraph (copy_body_data *id);
 135
 136 /* Insert a tree->tree mapping for ID.  Despite the name suggests
 137    that the trees should be variables, it is used for more than that.  */
 138
 139 void
 140 insert_decl_map (copy_body_data *id, tree key, tree value)
 141 {
 142   *pointer_map_insert (id->decl_map, key) = value;
 143
 144   /* Always insert an identity map as well.  If we see this same new
 145      node again, we won't want to duplicate it a second time.  */
 146   if (key != value)
 147     *pointer_map_insert (id->decl_map, value) = value;
 148 }
 149
 150 /* Insert a tree->tree mapping for ID.  This is only used for
 151    variables.  */
 152
 153 static void
 154 insert_debug_decl_map (copy_body_data *id, tree key, tree value)
 155 {
 156   if (!gimple_in_ssa_p (id->src_cfun))
 157     return;
 158
 159   if (!MAY_HAVE_DEBUG_STMTS)
 160     return;
 161
 162   if (!target_for_debug_bind (key))
 163     return;
 164
 165   gcc_assert (TREE_CODE (key) == PARM_DECL);
 166   gcc_assert (TREE_CODE (value) == VAR_DECL);
 167
 168   if (!id->debug_map)
 169     id->debug_map = pointer_map_create ();
 170
 171   *pointer_map_insert (id->debug_map, key) = value;
 172 }
 173
 174 /* If nonzero, we're remapping the contents of inlined debug
 175    statements.  If negative, an error has occurred, such as a
 176    reference to a variable that isn't available in the inlined
 177    context.  */
 178 static int processing_debug_stmt = 0;
 179
 180 /* Construct new SSA name for old NAME. ID is the inline context.  */
 181
 182 static tree
 183 remap_ssa_name (tree name, copy_body_data *id)
 184 {
 185   tree new_tree;
 186   tree *n;
 187
 188   gcc_assert (TREE_CODE (name) == SSA_NAME);
 189
 190   n = (tree *) pointer_map_contains (id->decl_map, name);
 191   if (n)
 192     return unshare_expr (*n);
 193
 194   if (processing_debug_stmt)
 195     {
 196       processing_debug_stmt = -1;
 197       return name;
 198     }
 199
 200   /* Do not set DEF_STMT yet as statement is not copied yet. We do that
 201      in copy_bb.  */
 202   new_tree = remap_decl (SSA_NAME_VAR (name), id);
 203
 204   /* We might've substituted constant or another SSA_NAME for
 205      the variable.
 206
 207      Replace the SSA name representing RESULT_DECL by variable during
 208      inlining:  this saves us from need to introduce PHI node in a case
 209      return value is just partly initialized.  */
 210   if ((TREE_CODE (new_tree) == VAR_DECL || TREE_CODE (new_tree) == PARM_DECL)
 211       && (TREE_CODE (SSA_NAME_VAR (name)) != RESULT_DECL
 212           || !id->transform_return_to_modify))
 213     {
 214       struct ptr_info_def *pi;
 215       new_tree = make_ssa_name (new_tree, NULL);
 216       insert_decl_map (id, name, new_tree);
 217       SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree)
 218         = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name);
 219       TREE_TYPE (new_tree) = TREE_TYPE (SSA_NAME_VAR (new_tree));
 220       /* At least IPA points-to info can be directly transferred.  */
 221       if (id->src_cfun->gimple_df
 222           && id->src_cfun->gimple_df->ipa_pta
 223           && (pi = SSA_NAME_PTR_INFO (name))
 224           && !pi->pt.anything)
 225         {
 226           struct ptr_info_def *new_pi = get_ptr_info (new_tree);
 227           new_pi->pt = pi->pt;
 228         }
 229       if (gimple_nop_p (SSA_NAME_DEF_STMT (name)))
 230         {
 231           /* By inlining function having uninitialized variable, we might
 232              extend the lifetime (variable might get reused).  This cause
 233              ICE in the case we end up extending lifetime of SSA name across
 234              abnormal edge, but also increase register pressure.
 235
 236              We simply initialize all uninitialized vars by 0 except
 237              for case we are inlining to very first BB.  We can avoid
 238              this for all BBs that are not inside strongly connected
 239              regions of the CFG, but this is expensive to test.  */
 240           if (id->entry_bb
 241               && is_gimple_reg (SSA_NAME_VAR (name))
 242               && TREE_CODE (SSA_NAME_VAR (name)) != PARM_DECL
 243               && (id->entry_bb != EDGE_SUCC (ENTRY_BLOCK_PTR, 0)->dest
 244                   || EDGE_COUNT (id->entry_bb->preds) != 1))
 245             {
 246               gimple_stmt_iterator gsi = gsi_last_bb (id->entry_bb);
 247               gimple init_stmt;
 248
 249               init_stmt = gimple_build_assign (new_tree,
 250                                                fold_convert (TREE_TYPE (new_tree),
 251                                                             integer_zero_node));
 252               gsi_insert_after (&gsi, init_stmt, GSI_NEW_STMT);
 253               SSA_NAME_IS_DEFAULT_DEF (new_tree) = 0;
 254             }
 255           else
 256             {
 257               SSA_NAME_DEF_STMT (new_tree) = gimple_build_nop ();
 258               if (gimple_default_def (id->src_cfun, SSA_NAME_VAR (name))
 259                   == name)
 260                 set_default_def (SSA_NAME_VAR (new_tree), new_tree);
 261             }
 262         }
 263     }
 264   else
 265     insert_decl_map (id, name, new_tree);
 266   return new_tree;
 267 }
 268
 269 /* Remap DECL during the copying of the BLOCK tree for the function.  */
 270
 271 tree
 272 remap_decl (tree decl, copy_body_data *id)
 273 {
 274   tree *n;
 275
 276   /* We only remap local variables in the current function.  */
 277
 278   /* See if we have remapped this declaration.  */
 279
 280   n = (tree *) pointer_map_contains (id->decl_map, decl);
 281
 282   if (!n && processing_debug_stmt)
 283     {
 284       processing_debug_stmt = -1;
 285       return decl;
 286     }
 287
 288   /* If we didn't already have an equivalent for this declaration,
 289      create one now.  */
 290   if (!n)
 291     {
 292       /* Make a copy of the variable or label.  */
 293       tree t = id->copy_decl (decl, id);
 294
 295       /* Remember it, so that if we encounter this local entity again
 296          we can reuse this copy.  Do this early because remap_type may
 297          need this decl for TYPE_STUB_DECL.  */
 298       insert_decl_map (id, decl, t);
 299
 300       if (!DECL_P (t))
 301         return t;
 302
 303       /* Remap types, if necessary.  */
 304       TREE_TYPE (t) = remap_type (TREE_TYPE (t), id);
 305       if (TREE_CODE (t) == TYPE_DECL)
 306         DECL_ORIGINAL_TYPE (t) = remap_type (DECL_ORIGINAL_TYPE (t), id);
 307
 308       /* Remap sizes as necessary.  */
 309       walk_tree (&DECL_SIZE (t), copy_tree_body_r, id, NULL);
 310       walk_tree (&DECL_SIZE_UNIT (t), copy_tree_body_r, id, NULL);
 311
 312       /* If fields, do likewise for offset and qualifier.  */
 313       if (TREE_CODE (t) == FIELD_DECL)
 314         {
 315           walk_tree (&DECL_FIELD_OFFSET (t), copy_tree_body_r, id, NULL);
 316           if (TREE_CODE (DECL_CONTEXT (t)) == QUAL_UNION_TYPE)
 317             walk_tree (&DECL_QUALIFIER (t), copy_tree_body_r, id, NULL);
 318         }
 319
 320       if (cfun && gimple_in_ssa_p (cfun)
 321           && (TREE_CODE (t) == VAR_DECL
 322               || TREE_CODE (t) == RESULT_DECL || TREE_CODE (t) == PARM_DECL))
 323         {
 324           get_var_ann (t);
 325           add_referenced_var (t);
 326         }
 327       return t;
 328     }
 329
 330   if (id->do_not_unshare)
 331     return *n;
 332   else
 333     return unshare_expr (*n);
 334 }
 335
 336 static tree
 337 remap_type_1 (tree type, copy_body_data *id)
 338 {
 339   tree new_tree, t;
 340
 341   /* We do need a copy.  build and register it now.  If this is a pointer or
 342      reference type, remap the designated type and make a new pointer or
 343      reference type.  */
 344   if (TREE_CODE (type) == POINTER_TYPE)
 345     {
 346       new_tree = build_pointer_type_for_mode (remap_type (TREE_TYPE (type), id),
 347                                          TYPE_MODE (type),
 348                                          TYPE_REF_CAN_ALIAS_ALL (type));
 349       if (TYPE_ATTRIBUTES (type) || TYPE_QUALS (type))
 350         new_tree = build_type_attribute_qual_variant (new_tree,
 351                                                       TYPE_ATTRIBUTES (type),
 352                                                       TYPE_QUALS (type));
 353       insert_decl_map (id, type, new_tree);
 354       return new_tree;
 355     }
 356   else if (TREE_CODE (type) == REFERENCE_TYPE)
 357     {
 358       new_tree = build_reference_type_for_mode (remap_type (TREE_TYPE (type), id),
 359                                             TYPE_MODE (type),
 360                                             TYPE_REF_CAN_ALIAS_ALL (type));
 361       if (TYPE_ATTRIBUTES (type) || TYPE_QUALS (type))
 362         new_tree = build_type_attribute_qual_variant (new_tree,
 363                                                       TYPE_ATTRIBUTES (type),
 364                                                       TYPE_QUALS (type));
 365       insert_decl_map (id, type, new_tree);
 366       return new_tree;
 367     }
 368   else
 369     new_tree = copy_node (type);
 370
 371   insert_decl_map (id, type, new_tree);
 372
 373   /* This is a new type, not a copy of an old type.  Need to reassociate
 374      variants.  We can handle everything except the main variant lazily.  */
 375   t = TYPE_MAIN_VARIANT (type);
 376   if (type != t)
 377     {
 378       t = remap_type (t, id);
 379       TYPE_MAIN_VARIANT (new_tree) = t;
 380       TYPE_NEXT_VARIANT (new_tree) = TYPE_NEXT_VARIANT (t);
 381       TYPE_NEXT_VARIANT (t) = new_tree;
 382     }
 383   else
 384     {
 385       TYPE_MAIN_VARIANT (new_tree) = new_tree;
 386       TYPE_NEXT_VARIANT (new_tree) = NULL;
 387     }
 388
 389   if (TYPE_STUB_DECL (type))
 390     TYPE_STUB_DECL (new_tree) = remap_decl (TYPE_STUB_DECL (type), id);
 391
 392   /* Lazily create pointer and reference types.  */
 393   TYPE_POINTER_TO (new_tree) = NULL;
 394   TYPE_REFERENCE_TO (new_tree) = NULL;
 395
 396   switch (TREE_CODE (new_tree))
 397     {
 398     case INTEGER_TYPE:
 399     case REAL_TYPE:
 400     case FIXED_POINT_TYPE:
 401     case ENUMERAL_TYPE:
 402     case BOOLEAN_TYPE:
 403       t = TYPE_MIN_VALUE (new_tree);
 404       if (t && TREE_CODE (t) != INTEGER_CST)
 405         walk_tree (&TYPE_MIN_VALUE (new_tree), copy_tree_body_r, id, NULL);
 406
 407       t = TYPE_MAX_VALUE (new_tree);
 408       if (t && TREE_CODE (t) != INTEGER_CST)
 409         walk_tree (&TYPE_MAX_VALUE (new_tree), copy_tree_body_r, id, NULL);
 410       return new_tree;
 411
 412     case FUNCTION_TYPE:
 413       TREE_TYPE (new_tree) = remap_type (TREE_TYPE (new_tree), id);
 414       walk_tree (&TYPE_ARG_TYPES (new_tree), copy_tree_body_r, id, NULL);
 415       return new_tree;
 416
 417     case ARRAY_TYPE:
 418       TREE_TYPE (new_tree) = remap_type (TREE_TYPE (new_tree), id);
 419       TYPE_DOMAIN (new_tree) = remap_type (TYPE_DOMAIN (new_tree), id);
 420       break;
 421
 422     case RECORD_TYPE:
 423     case UNION_TYPE:
 424     case QUAL_UNION_TYPE:
 425       {
 426         tree f, nf = NULL;
 427
 428         for (f = TYPE_FIELDS (new_tree); f ; f = TREE_CHAIN (f))
 429           {
 430             t = remap_decl (f, id);
 431             DECL_CONTEXT (t) = new_tree;
 432             TREE_CHAIN (t) = nf;
 433             nf = t;
 434           }
 435         TYPE_FIELDS (new_tree) = nreverse (nf);
 436       }
 437       break;
 438
 439     case OFFSET_TYPE:
 440     default:
 441       /* Shouldn't have been thought variable sized.  */
 442       gcc_unreachable ();
 443     }
 444
 445   walk_tree (&TYPE_SIZE (new_tree), copy_tree_body_r, id, NULL);
 446   walk_tree (&TYPE_SIZE_UNIT (new_tree), copy_tree_body_r, id, NULL);
 447
 448   return new_tree;
 449 }
 450
 451 tree
 452 remap_type (tree type, copy_body_data *id)
 453 {
 454   tree *node;
 455   tree tmp;
 456
 457   if (type == NULL)
 458     return type;
 459
 460   /* See if we have remapped this type.  */
 461   node = (tree *) pointer_map_contains (id->decl_map, type);
 462   if (node)
 463     return *node;
 464
 465   /* The type only needs remapping if it's variably modified.  */
 466   if (! variably_modified_type_p (type, id->src_fn))
 467     {
 468       insert_decl_map (id, type, type);
 469       return type;
 470     }
 471
 472   id->remapping_type_depth++;
 473   tmp = remap_type_1 (type, id);
 474   id->remapping_type_depth--;
 475
 476   return tmp;
 477 }
 478
 479 /* Return previously remapped type of TYPE in ID.  Return NULL if TYPE
 480    is NULL or TYPE has not been remapped before.  */
 481
 482 static tree
 483 remapped_type (tree type, copy_body_data *id)
 484 {
 485   tree *node;
 486
 487   if (type == NULL)
 488     return type;
 489
 490   /* See if we have remapped this type.  */
 491   node = (tree *) pointer_map_contains (id->decl_map, type);
 492   if (node)
 493     return *node;
 494   else
 495     return NULL;
 496 }
 497
 498   /* The type only needs remapping if it's variably modified.  */
 499 /* Decide if DECL can be put into BLOCK_NONLOCAL_VARs.  */
 500
 501 static bool
 502 can_be_nonlocal (tree decl, copy_body_data *id)
 503 {
 504   /* We can not duplicate function decls.  */
 505   if (TREE_CODE (decl) == FUNCTION_DECL)
 506     return true;
 507
 508   /* Local static vars must be non-local or we get multiple declaration
 509      problems.  */
 510   if (TREE_CODE (decl) == VAR_DECL
 511       && !auto_var_in_fn_p (decl, id->src_fn))
 512     return true;
 513
 514   /* At the moment dwarf2out can handle only these types of nodes.  We
 515      can support more later.  */
 516   if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != PARM_DECL)
 517     return false;
 518
 519   /* We must use global type.  We call remapped_type instead of
 520      remap_type since we don't want to remap this type here if it
 521      hasn't been remapped before.  */
 522   if (TREE_TYPE (decl) != remapped_type (TREE_TYPE (decl), id))
 523     return false;
 524
 525   /* Wihtout SSA we can't tell if variable is used.  */
 526   if (!gimple_in_ssa_p (cfun))
 527     return false;
 528
 529   /* Live variables must be copied so we can attach DECL_RTL.  */
 530   if (var_ann (decl))
 531     return false;
 532
 533   return true;
 534 }
 535
 536 static tree
 537 remap_decls (tree decls, VEC(tree,gc) **nonlocalized_list, copy_body_data *id)
 538 {
 539   tree old_var;
 540   tree new_decls = NULL_TREE;
 541
 542   /* Remap its variables.  */
 543   for (old_var = decls; old_var; old_var = TREE_CHAIN (old_var))
 544     {
 545       tree new_var;
 546
 547       if (can_be_nonlocal (old_var, id))
 548         {
 549           if (TREE_CODE (old_var) == VAR_DECL
 550               && ! DECL_EXTERNAL (old_var)
 551               && (var_ann (old_var) || !gimple_in_ssa_p (cfun)))
 552             cfun->local_decls = tree_cons (NULL_TREE, old_var,
 553                                                    cfun->local_decls);
 554           if ((!optimize || debug_info_level > DINFO_LEVEL_TERSE)
 555               && !DECL_IGNORED_P (old_var)
 556               && nonlocalized_list)
 557             VEC_safe_push (tree, gc, *nonlocalized_list, old_var);
 558           continue;
 559         }
 560
 561       /* Remap the variable.  */
 562       new_var = remap_decl (old_var, id);
 563
 564       /* If we didn't remap this variable, we can't mess with its
 565          TREE_CHAIN.  If we remapped this variable to the return slot, it's
 566          already declared somewhere else, so don't declare it here.  */
 567
 568       if (new_var == id->retvar)
 569         ;
 570       else if (!new_var)
 571         {
 572           if ((!optimize || debug_info_level > DINFO_LEVEL_TERSE)
 573               && !DECL_IGNORED_P (old_var)
 574               && nonlocalized_list)
 575             VEC_safe_push (tree, gc, *nonlocalized_list, old_var);
 576         }
 577       else
 578         {
 579           gcc_assert (DECL_P (new_var));
 580           TREE_CHAIN (new_var) = new_decls;
 581           new_decls = new_var;
 582         }
 583     }
 584
 585   return nreverse (new_decls);
 586 }
 587
 588 /* Copy the BLOCK to contain remapped versions of the variables
 589    therein.  And hook the new block into the block-tree.  */
 590
 591 static void
 592 remap_block (tree *block, copy_body_data *id)
 593 {
 594   tree old_block;
 595   tree new_block;
 596
 597   /* Make the new block.  */
 598   old_block = *block;
 599   new_block = make_node (BLOCK);
 600   TREE_USED (new_block) = TREE_USED (old_block);
 601   BLOCK_ABSTRACT_ORIGIN (new_block) = old_block;
 602   BLOCK_SOURCE_LOCATION (new_block) = BLOCK_SOURCE_LOCATION (old_block);
 603   BLOCK_NONLOCALIZED_VARS (new_block)
 604     = VEC_copy (tree, gc, BLOCK_NONLOCALIZED_VARS (old_block));
 605   *block = new_block;
 606
 607   /* Remap its variables.  */
 608   BLOCK_VARS (new_block) = remap_decls (BLOCK_VARS (old_block),
 609                                         &BLOCK_NONLOCALIZED_VARS (new_block),
 610                                         id);
 611
 612   if (id->transform_lang_insert_block)
 613     id->transform_lang_insert_block (new_block);
 614
 615   /* Remember the remapped block.  */
 616   insert_decl_map (id, old_block, new_block);
 617 }
 618
 619 /* Copy the whole block tree and root it in id->block.  */
 620 static tree
 621 remap_blocks (tree block, copy_body_data *id)
 622 {
 623   tree t;
 624   tree new_tree = block;
 625
 626   if (!block)
 627     return NULL;
 628
 629   remap_block (&new_tree, id);
 630   gcc_assert (new_tree != block);
 631   for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
 632     prepend_lexical_block (new_tree, remap_blocks (t, id));
 633   /* Blocks are in arbitrary order, but make things slightly prettier and do
 634      not swap order when producing a copy.  */
 635   BLOCK_SUBBLOCKS (new_tree) = blocks_nreverse (BLOCK_SUBBLOCKS (new_tree));
 636   return new_tree;
 637 }
 638
 639 static void
 640 copy_statement_list (tree *tp)
 641 {
 642   tree_stmt_iterator oi, ni;
 643   tree new_tree;
 644
 645   new_tree = alloc_stmt_list ();
 646   ni = tsi_start (new_tree);
 647   oi = tsi_start (*tp);
 648   TREE_TYPE (new_tree) = TREE_TYPE (*tp);
 649   *tp = new_tree;
 650
 651   for (; !tsi_end_p (oi); tsi_next (&oi))
 652     {
 653       tree stmt = tsi_stmt (oi);
 654       if (TREE_CODE (stmt) == STATEMENT_LIST)
 655         copy_statement_list (&stmt);
 656       tsi_link_after (&ni, stmt, TSI_CONTINUE_LINKING);
 657     }
 658 }
 659
 660 static void
 661 copy_bind_expr (tree *tp, int *walk_subtrees, copy_body_data *id)
 662 {
 663   tree block = BIND_EXPR_BLOCK (*tp);
 664   /* Copy (and replace) the statement.  */
 665   copy_tree_r (tp, walk_subtrees, NULL);
 666   if (block)
 667     {
 668       remap_block (&block, id);
 669       BIND_EXPR_BLOCK (*tp) = block;
 670     }
 671
 672   if (BIND_EXPR_VARS (*tp))
 673     /* This will remap a lot of the same decls again, but this should be
 674        harmless.  */
 675     BIND_EXPR_VARS (*tp) = remap_decls (BIND_EXPR_VARS (*tp), NULL, id);
 676 }
 677
 678
 679 /* Create a new gimple_seq by remapping all the statements in BODY
 680    using the inlining information in ID.  */
 681
 682 gimple_seq
 683 remap_gimple_seq (gimple_seq body, copy_body_data *id)
 684 {
 685   gimple_stmt_iterator si;
 686   gimple_seq new_body = NULL;
 687
 688   for (si = gsi_start (body); !gsi_end_p (si); gsi_next (&si))
 689     {
 690       gimple new_stmt = remap_gimple_stmt (gsi_stmt (si), id);
 691       gimple_seq_add_stmt (&new_body, new_stmt);
 692     }
 693
 694   return new_body;
 695 }
 696
 697
 698 /* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its
 699    block using the mapping information in ID.  */
 700
 701 static gimple
 702 copy_gimple_bind (gimple stmt, copy_body_data *id)
 703 {
 704   gimple new_bind;
 705   tree new_block, new_vars;
 706   gimple_seq body, new_body;
 707
 708   /* Copy the statement.  Note that we purposely don't use copy_stmt
 709      here because we need to remap statements as we copy.  */
 710   body = gimple_bind_body (stmt);
 711   new_body = remap_gimple_seq (body, id);
 712
 713   new_block = gimple_bind_block (stmt);
 714   if (new_block)
 715     remap_block (&new_block, id);
 716
 717   /* This will remap a lot of the same decls again, but this should be
 718      harmless.  */
 719   new_vars = gimple_bind_vars (stmt);
 720   if (new_vars)
 721     new_vars = remap_decls (new_vars, NULL, id);
 722
 723   new_bind = gimple_build_bind (new_vars, new_body, new_block);
 724
 725   return new_bind;
 726 }
 727
 728
 729 /* Remap the GIMPLE operand pointed to by *TP.  DATA is really a
 730    'struct walk_stmt_info *'.  DATA->INFO is a 'copy_body_data *'.
 731    WALK_SUBTREES is used to indicate walk_gimple_op whether to keep
 732    recursing into the children nodes of *TP.  */
 733
 734 static tree
 735 remap_gimple_op_r (tree *tp, int *walk_subtrees, void *data)
 736 {
 737   struct walk_stmt_info *wi_p = (struct walk_stmt_info *) data;
 738   copy_body_data *id = (copy_body_data *) wi_p->info;
 739   tree fn = id->src_fn;
 740
 741   if (TREE_CODE (*tp) == SSA_NAME)
 742     {
 743       *tp = remap_ssa_name (*tp, id);
 744       *walk_subtrees = 0;
 745       return NULL;
 746     }
 747   else if (auto_var_in_fn_p (*tp, fn))
 748     {
 749       /* Local variables and labels need to be replaced by equivalent
 750          variables.  We don't want to copy static variables; there's
 751          only one of those, no matter how many times we inline the
 752          containing function.  Similarly for globals from an outer
 753          function.  */
 754       tree new_decl;
 755
 756       /* Remap the declaration.  */
 757       new_decl = remap_decl (*tp, id);
 758       gcc_assert (new_decl);
 759       /* Replace this variable with the copy.  */
 760       STRIP_TYPE_NOPS (new_decl);
 761       /* ???  The C++ frontend uses void * pointer zero to initialize
 762          any other type.  This confuses the middle-end type verification.
 763          As cloned bodies do not go through gimplification again the fixup
 764          there doesn't trigger.  */
 765       if (TREE_CODE (new_decl) == INTEGER_CST
 766           && !useless_type_conversion_p (TREE_TYPE (*tp), TREE_TYPE (new_decl)))
 767         new_decl = fold_convert (TREE_TYPE (*tp), new_decl);
 768       *tp = new_decl;
 769       *walk_subtrees = 0;
 770     }
 771   else if (TREE_CODE (*tp) == STATEMENT_LIST)
 772     gcc_unreachable ();
 773   else if (TREE_CODE (*tp) == SAVE_EXPR)
 774     gcc_unreachable ();
 775   else if (TREE_CODE (*tp) == LABEL_DECL
 776            && (!DECL_CONTEXT (*tp)
 777                || decl_function_context (*tp) == id->src_fn))
 778     /* These may need to be remapped for EH handling.  */
 779     *tp = remap_decl (*tp, id);
 780   else if (TYPE_P (*tp))
 781     /* Types may need remapping as well.  */
 782     *tp = remap_type (*tp, id);
 783   else if (CONSTANT_CLASS_P (*tp))
 784     {
 785       /* If this is a constant, we have to copy the node iff the type
 786          will be remapped.  copy_tree_r will not copy a constant.  */
 787       tree new_type = remap_type (TREE_TYPE (*tp), id);
 788
 789       if (new_type == TREE_TYPE (*tp))
 790         *walk_subtrees = 0;
 791
 792       else if (TREE_CODE (*tp) == INTEGER_CST)
 793         *tp = build_int_cst_wide (new_type, TREE_INT_CST_LOW (*tp),
 794                                   TREE_INT_CST_HIGH (*tp));
 795       else
 796         {
 797           *tp = copy_node (*tp);
 798           TREE_TYPE (*tp) = new_type;
 799         }
 800     }
 801   else
 802     {
 803       /* Otherwise, just copy the node.  Note that copy_tree_r already
 804          knows not to copy VAR_DECLs, etc., so this is safe.  */
 805       if (TREE_CODE (*tp) == INDIRECT_REF)
 806         {
 807           /* Get rid of *& from inline substitutions that can happen when a
 808              pointer argument is an ADDR_EXPR.  */
 809           tree decl = TREE_OPERAND (*tp, 0);
 810           tree *n;
 811
 812           n = (tree *) pointer_map_contains (id->decl_map, decl);
 813           if (n)
 814             {
 815               tree type, new_tree, old;
 816
 817               /* If we happen to get an ADDR_EXPR in n->value, strip
 818                  it manually here as we'll eventually get ADDR_EXPRs
 819                  which lie about their types pointed to.  In this case
 820                  build_fold_indirect_ref wouldn't strip the
 821                  INDIRECT_REF, but we absolutely rely on that.  As
 822                  fold_indirect_ref does other useful transformations,
 823                  try that first, though.  */
 824               type = TREE_TYPE (TREE_TYPE (*n));
 825               new_tree = unshare_expr (*n);
 826               old = *tp;
 827               *tp = gimple_fold_indirect_ref (new_tree);
 828               if (!*tp)
 829                 {
 830                   if (TREE_CODE (new_tree) == ADDR_EXPR)
 831                     {
 832                       *tp = fold_indirect_ref_1 (EXPR_LOCATION (new_tree),
 833                                                  type, new_tree);
 834                       /* ???  We should either assert here or build
 835                          a VIEW_CONVERT_EXPR instead of blindly leaking
 836                          incompatible types to our IL.  */
 837                       if (! *tp)
 838                         *tp = TREE_OPERAND (new_tree, 0);
 839                     }
 840                   else
 841                     {
 842                       *tp = build1 (INDIRECT_REF, type, new_tree);
 843                       TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old);
 844                       TREE_NO_WARNING (*tp) = TREE_NO_WARNING (old);
 845                     }
 846                 }
 847               *walk_subtrees = 0;
 848               return NULL;
 849             }
 850         }
 851
 852       /* Here is the "usual case".  Copy this tree node, and then
 853          tweak some special cases.  */
 854       copy_tree_r (tp, walk_subtrees, NULL);
 855
 856       /* Global variables we haven't seen yet need to go into referenced
 857          vars.  If not referenced from types only.  */
 858       if (gimple_in_ssa_p (cfun)
 859           && TREE_CODE (*tp) == VAR_DECL
 860           && id->remapping_type_depth == 0
 861           && !processing_debug_stmt)
 862         add_referenced_var (*tp);
 863
 864       /* We should never have TREE_BLOCK set on non-statements.  */
 865       if (EXPR_P (*tp))
 866         gcc_assert (!TREE_BLOCK (*tp));
 867
 868       if (TREE_CODE (*tp) != OMP_CLAUSE)
 869         TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id);
 870
 871       if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3))
 872         {
 873           /* The copied TARGET_EXPR has never been expanded, even if the
 874              original node was expanded already.  */
 875           TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
 876           TREE_OPERAND (*tp, 3) = NULL_TREE;
 877         }
 878       else if (TREE_CODE (*tp) == ADDR_EXPR)
 879         {
 880           /* Variable substitution need not be simple.  In particular,
 881              the INDIRECT_REF substitution above.  Make sure that
 882              TREE_CONSTANT and friends are up-to-date.  But make sure
 883              to not improperly set TREE_BLOCK on some sub-expressions.  */
 884           int invariant = is_gimple_min_invariant (*tp);
 885           tree block = id->block;
 886           id->block = NULL_TREE;
 887           walk_tree (&TREE_OPERAND (*tp, 0), copy_tree_body_r, id, NULL);
 888           id->block = block;
 889
 890           /* Handle the case where we substituted an INDIRECT_REF
 891              into the operand of the ADDR_EXPR.  */
 892           if (TREE_CODE (TREE_OPERAND (*tp, 0)) == INDIRECT_REF)
 893             *tp = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0);
 894           else
 895             recompute_tree_invariant_for_addr_expr (*tp);
 896
 897           /* If this used to be invariant, but is not any longer,
 898              then regimplification is probably needed.  */
 899           if (invariant && !is_gimple_min_invariant (*tp))
 900             id->regimplify = true;
 901
 902           *walk_subtrees = 0;
 903         }
 904     }
 905
 906   /* Keep iterating.  */
 907   return NULL_TREE;
 908 }
 909
 910
 911 /* Called from copy_body_id via walk_tree.  DATA is really a
 912    `copy_body_data *'.  */
 913
 914 tree
 915 copy_tree_body_r (tree *tp, int *walk_subtrees, void *data)
 916 {
 917   copy_body_data *id = (copy_body_data *) data;
 918   tree fn = id->src_fn;
 919   tree new_block;
 920
 921   /* Begin by recognizing trees that we'll completely rewrite for the
 922      inlining context.  Our output for these trees is completely
 923      different from out input (e.g. RETURN_EXPR is deleted, and morphs
 924      into an edge).  Further down, we'll handle trees that get
 925      duplicated and/or tweaked.  */
 926
 927   /* When requested, RETURN_EXPRs should be transformed to just the
 928      contained MODIFY_EXPR.  The branch semantics of the return will
 929      be handled elsewhere by manipulating the CFG rather than a statement.  */
 930   if (TREE_CODE (*tp) == RETURN_EXPR && id->transform_return_to_modify)
 931     {
 932       tree assignment = TREE_OPERAND (*tp, 0);
 933
 934       /* If we're returning something, just turn that into an
 935          assignment into the equivalent of the original RESULT_DECL.
 936          If the "assignment" is just the result decl, the result
 937          decl has already been set (e.g. a recent "foo (&result_decl,
 938          ...)"); just toss the entire RETURN_EXPR.  */
 939       if (assignment && TREE_CODE (assignment) == MODIFY_EXPR)
 940         {
 941           /* Replace the RETURN_EXPR with (a copy of) the
 942              MODIFY_EXPR hanging underneath.  */
 943           *tp = copy_node (assignment);
 944         }
 945       else /* Else the RETURN_EXPR returns no value.  */
 946         {
 947           *tp = NULL;
 948           return (tree) (void *)1;
 949         }
 950     }
 951   else if (TREE_CODE (*tp) == SSA_NAME)
 952     {
 953       *tp = remap_ssa_name (*tp, id);
 954       *walk_subtrees = 0;
 955       return NULL;
 956     }
 957
 958   /* Local variables and labels need to be replaced by equivalent
 959      variables.  We don't want to copy static variables; there's only
 960      one of those, no matter how many times we inline the containing
 961      function.  Similarly for globals from an outer function.  */
 962   else if (auto_var_in_fn_p (*tp, fn))
 963     {
 964       tree new_decl;
 965
 966       /* Remap the declaration.  */
 967       new_decl = remap_decl (*tp, id);
 968       gcc_assert (new_decl);
 969       /* Replace this variable with the copy.  */
 970       STRIP_TYPE_NOPS (new_decl);
 971       *tp = new_decl;
 972       *walk_subtrees = 0;
 973     }
 974   else if (TREE_CODE (*tp) == STATEMENT_LIST)
 975     copy_statement_list (tp);
 976   else if (TREE_CODE (*tp) == SAVE_EXPR
 977            || TREE_CODE (*tp) == TARGET_EXPR)
 978     remap_save_expr (tp, id->decl_map, walk_subtrees);
 979   else if (TREE_CODE (*tp) == LABEL_DECL
 980            && (! DECL_CONTEXT (*tp)
 981                || decl_function_context (*tp) == id->src_fn))
 982     /* These may need to be remapped for EH handling.  */
 983     *tp = remap_decl (*tp, id);
 984   else if (TREE_CODE (*tp) == BIND_EXPR)
 985     copy_bind_expr (tp, walk_subtrees, id);
 986   /* Types may need remapping as well.  */
 987   else if (TYPE_P (*tp))
 988     *tp = remap_type (*tp, id);
 989
 990   /* If this is a constant, we have to copy the node iff the type will be
 991      remapped.  copy_tree_r will not copy a constant.  */
 992   else if (CONSTANT_CLASS_P (*tp))
 993     {
 994       tree new_type = remap_type (TREE_TYPE (*tp), id);
 995
 996       if (new_type == TREE_TYPE (*tp))
 997         *walk_subtrees = 0;
 998
 999       else if (TREE_CODE (*tp) == INTEGER_CST)
1000         *tp = build_int_cst_wide (new_type, TREE_INT_CST_LOW (*tp),
1001                                   TREE_INT_CST_HIGH (*tp));
1002       else
1003         {
1004           *tp = copy_node (*tp);
1005           TREE_TYPE (*tp) = new_type;
1006         }
1007     }
1008
1009   /* Otherwise, just copy the node.  Note that copy_tree_r already
1010      knows not to copy VAR_DECLs, etc., so this is safe.  */
1011   else
1012     {
1013       /* Here we handle trees that are not completely rewritten.
1014          First we detect some inlining-induced bogosities for
1015          discarding.  */
1016       if (TREE_CODE (*tp) == MODIFY_EXPR
1017           && TREE_OPERAND (*tp, 0) == TREE_OPERAND (*tp, 1)
1018           && (auto_var_in_fn_p (TREE_OPERAND (*tp, 0), fn)))
1019         {
1020           /* Some assignments VAR = VAR; don't generate any rtl code
1021              and thus don't count as variable modification.  Avoid
1022              keeping bogosities like 0 = 0.  */
1023           tree decl = TREE_OPERAND (*tp, 0), value;
1024           tree *n;
1025
1026           n = (tree *) pointer_map_contains (id->decl_map, decl);
1027           if (n)
1028             {
1029               value = *n;
1030               STRIP_TYPE_NOPS (value);
1031               if (TREE_CONSTANT (value) || TREE_READONLY (value))
1032                 {
1033                   *tp = build_empty_stmt (EXPR_LOCATION (*tp));
1034                   return copy_tree_body_r (tp, walk_subtrees, data);
1035                 }
1036             }
1037         }
1038       else if (TREE_CODE (*tp) == INDIRECT_REF)
1039         {
1040           /* Get rid of *& from inline substitutions that can happen when a
1041              pointer argument is an ADDR_EXPR.  */
1042           tree decl = TREE_OPERAND (*tp, 0);
1043           tree *n;
1044
1045           n = (tree *) pointer_map_contains (id->decl_map, decl);
1046           if (n)
1047             {
1048               tree new_tree;
1049               tree old;
1050               /* If we happen to get an ADDR_EXPR in n->value, strip
1051                  it manually here as we'll eventually get ADDR_EXPRs
1052                  which lie about their types pointed to.  In this case
1053                  build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
1054                  but we absolutely rely on that.  As fold_indirect_ref
1055                  does other useful transformations, try that first, though.  */
1056               tree type = TREE_TYPE (TREE_TYPE (*n));
1057               if (id->do_not_unshare)
1058                 new_tree = *n;
1059               else
1060                 new_tree = unshare_expr (*n);
1061               old = *tp;
1062               *tp = gimple_fold_indirect_ref (new_tree);
1063               if (! *tp)
1064                 {
1065                   if (TREE_CODE (new_tree) == ADDR_EXPR)
1066                     {
1067                       *tp = fold_indirect_ref_1 (EXPR_LOCATION (new_tree),
1068                                                  type, new_tree);
1069                       /* ???  We should either assert here or build
1070                          a VIEW_CONVERT_EXPR instead of blindly leaking
1071                          incompatible types to our IL.  */
1072                       if (! *tp)
1073                         *tp = TREE_OPERAND (new_tree, 0);
1074                     }
1075                   else
1076                     {
1077                       *tp = build1 (INDIRECT_REF, type, new_tree);
1078                       TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old);
1079                       TREE_SIDE_EFFECTS (*tp) = TREE_SIDE_EFFECTS (old);
1080                     }
1081                 }
1082               *walk_subtrees = 0;
1083               return NULL;
1084             }
1085         }
1086
1087       /* Here is the "usual case".  Copy this tree node, and then
1088          tweak some special cases.  */
1089       copy_tree_r (tp, walk_subtrees, NULL);
1090
1091       /* Global variables we haven't seen yet needs to go into referenced
1092          vars.  If not referenced from types or debug stmts only.  */
1093       if (gimple_in_ssa_p (cfun)
1094           && TREE_CODE (*tp) == VAR_DECL
1095           && id->remapping_type_depth == 0
1096           && !processing_debug_stmt)
1097         add_referenced_var (*tp);
1098
1099       /* If EXPR has block defined, map it to newly constructed block.
1100          When inlining we want EXPRs without block appear in the block
1101          of function call if we are not remapping a type.  */
1102       if (EXPR_P (*tp))
1103         {
1104           new_block = id->remapping_type_depth == 0 ? id->block : NULL;
1105           if (TREE_BLOCK (*tp))
1106             {
1107               tree *n;
1108               n = (tree *) pointer_map_contains (id->decl_map,
1109                                                  TREE_BLOCK (*tp));
1110               gcc_assert (n);
1111               new_block = *n;
1112             }
1113           TREE_BLOCK (*tp) = new_block;
1114         }
1115
1116       if (TREE_CODE (*tp) != OMP_CLAUSE)
1117         TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id);
1118
1119       /* The copied TARGET_EXPR has never been expanded, even if the
1120          original node was expanded already.  */
1121       if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3))
1122         {
1123           TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
1124           TREE_OPERAND (*tp, 3) = NULL_TREE;
1125         }
1126
1127       /* Variable substitution need not be simple.  In particular, the
1128          INDIRECT_REF substitution above.  Make sure that TREE_CONSTANT
1129          and friends are up-to-date.  */
1130       else if (TREE_CODE (*tp) == ADDR_EXPR)
1131         {
1132           int invariant = is_gimple_min_invariant (*tp);
1133           walk_tree (&TREE_OPERAND (*tp, 0), copy_tree_body_r, id, NULL);
1134
1135           /* Handle the case where we substituted an INDIRECT_REF
1136              into the operand of the ADDR_EXPR.  */
1137           if (TREE_CODE (TREE_OPERAND (*tp, 0)) == INDIRECT_REF)
1138             *tp = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0);
1139           else
1140             recompute_tree_invariant_for_addr_expr (*tp);
1141
1142           /* If this used to be invariant, but is not any longer,
1143              then regimplification is probably needed.  */
1144           if (invariant && !is_gimple_min_invariant (*tp))
1145             id->regimplify = true;
1146
1147           *walk_subtrees = 0;
1148         }
1149     }
1150
1151   /* Keep iterating.  */
1152   return NULL_TREE;
1153 }
1154
1155 /* Helper for remap_gimple_stmt.  Given an EH region number for the
1156    source function, map that to the duplicate EH region number in
1157    the destination function.  */
1158
1159 static int
1160 remap_eh_region_nr (int old_nr, copy_body_data *id)
1161 {
1162   eh_region old_r, new_r;
1163   void **slot;
1164
1165   old_r = get_eh_region_from_number_fn (id->src_cfun, old_nr);
1166   slot = pointer_map_contains (id->eh_map, old_r);
1167   new_r = (eh_region) *slot;
1168
1169   return new_r->index;
1170 }
1171
1172 /* Similar, but operate on INTEGER_CSTs.  */
1173
1174 static tree
1175 remap_eh_region_tree_nr (tree old_t_nr, copy_body_data *id)
1176 {
1177   int old_nr, new_nr;
1178
1179   old_nr = tree_low_cst (old_t_nr, 0);
1180   new_nr = remap_eh_region_nr (old_nr, id);
1181
1182   return build_int_cst (NULL, new_nr);
1183 }
1184
1185 /* Helper for copy_bb.  Remap statement STMT using the inlining
1186    information in ID.  Return the new statement copy.  */
1187
1188 static gimple
1189 remap_gimple_stmt (gimple stmt, copy_body_data *id)
1190 {
1191   gimple copy = NULL;
1192   struct walk_stmt_info wi;
1193   tree new_block;
1194   bool skip_first = false;
1195
1196   /* Begin by recognizing trees that we'll completely rewrite for the
1197      inlining context.  Our output for these trees is completely
1198      different from out input (e.g. RETURN_EXPR is deleted, and morphs
1199      into an edge).  Further down, we'll handle trees that get
1200      duplicated and/or tweaked.  */
1201
1202   /* When requested, GIMPLE_RETURNs should be transformed to just the
1203      contained GIMPLE_ASSIGN.  The branch semantics of the return will
1204      be handled elsewhere by manipulating the CFG rather than the
1205      statement.  */
1206   if (gimple_code (stmt) == GIMPLE_RETURN && id->transform_return_to_modify)
1207     {
1208       tree retval = gimple_return_retval (stmt);
1209
1210       /* If we're returning something, just turn that into an
1211          assignment into the equivalent of the original RESULT_DECL.
1212          If RETVAL is just the result decl, the result decl has
1213          already been set (e.g. a recent "foo (&result_decl, ...)");
1214          just toss the entire GIMPLE_RETURN.  */
1215       if (retval && TREE_CODE (retval) != RESULT_DECL)
1216         {
1217           copy = gimple_build_assign (id->retvar, retval);
1218           /* id->retvar is already substituted.  Skip it on later remapping.  */
1219           skip_first = true;
1220         }
1221       else
1222         return gimple_build_nop ();
1223     }
1224   else if (gimple_has_substatements (stmt))
1225     {
1226       gimple_seq s1, s2;
1227
1228       /* When cloning bodies from the C++ front end, we will be handed bodies
1229          in High GIMPLE form.  Handle here all the High GIMPLE statements that
1230          have embedded statements.  */
1231       switch (gimple_code (stmt))
1232         {
1233         case GIMPLE_BIND:
1234           copy = copy_gimple_bind (stmt, id);
1235           break;
1236
1237         case GIMPLE_CATCH:
1238           s1 = remap_gimple_seq (gimple_catch_handler (stmt), id);
1239           copy = gimple_build_catch (gimple_catch_types (stmt), s1);
1240           break;
1241
1242         case GIMPLE_EH_FILTER:
1243           s1 = remap_gimple_seq (gimple_eh_filter_failure (stmt), id);
1244           copy = gimple_build_eh_filter (gimple_eh_filter_types (stmt), s1);
1245           break;
1246
1247         case GIMPLE_TRY:
1248           s1 = remap_gimple_seq (gimple_try_eval (stmt), id);
1249           s2 = remap_gimple_seq (gimple_try_cleanup (stmt), id);
1250           copy = gimple_build_try (s1, s2, gimple_try_kind (stmt));
1251           break;
1252
1253         case GIMPLE_WITH_CLEANUP_EXPR:
1254           s1 = remap_gimple_seq (gimple_wce_cleanup (stmt), id);
1255           copy = gimple_build_wce (s1);
1256           break;
1257
1258         case GIMPLE_OMP_PARALLEL:
1259           s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1260           copy = gimple_build_omp_parallel
1261                    (s1,
1262                     gimple_omp_parallel_clauses (stmt),
1263                     gimple_omp_parallel_child_fn (stmt),
1264                     gimple_omp_parallel_data_arg (stmt));
1265           break;
1266
1267         case GIMPLE_OMP_TASK:
1268           s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1269           copy = gimple_build_omp_task
1270                    (s1,
1271                     gimple_omp_task_clauses (stmt),
1272                     gimple_omp_task_child_fn (stmt),
1273                     gimple_omp_task_data_arg (stmt),
1274                     gimple_omp_task_copy_fn (stmt),
1275                     gimple_omp_task_arg_size (stmt),
1276                     gimple_omp_task_arg_align (stmt));
1277           break;
1278
1279         case GIMPLE_OMP_FOR:
1280           s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1281           s2 = remap_gimple_seq (gimple_omp_for_pre_body (stmt), id);
1282           copy = gimple_build_omp_for (s1, gimple_omp_for_clauses (stmt),
1283                                        gimple_omp_for_collapse (stmt), s2);
1284           {
1285             size_t i;
1286             for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
1287               {
1288                 gimple_omp_for_set_index (copy, i,
1289                                           gimple_omp_for_index (stmt, i));
1290                 gimple_omp_for_set_initial (copy, i,
1291                                             gimple_omp_for_initial (stmt, i));
1292                 gimple_omp_for_set_final (copy, i,
1293                                           gimple_omp_for_final (stmt, i));
1294                 gimple_omp_for_set_incr (copy, i,
1295                                          gimple_omp_for_incr (stmt, i));
1296                 gimple_omp_for_set_cond (copy, i,
1297                                          gimple_omp_for_cond (stmt, i));
1298               }
1299           }
1300           break;
1301
1302         case GIMPLE_OMP_MASTER:
1303           s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1304           copy = gimple_build_omp_master (s1);
1305           break;
1306
1307         case GIMPLE_OMP_ORDERED:
1308           s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1309           copy = gimple_build_omp_ordered (s1);
1310           break;
1311
1312         case GIMPLE_OMP_SECTION:
1313           s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1314           copy = gimple_build_omp_section (s1);
1315           break;
1316
1317         case GIMPLE_OMP_SECTIONS:
1318           s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1319           copy = gimple_build_omp_sections
1320                    (s1, gimple_omp_sections_clauses (stmt));
1321           break;
1322
1323         case GIMPLE_OMP_SINGLE:
1324           s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1325           copy = gimple_build_omp_single
1326                    (s1, gimple_omp_single_clauses (stmt));
1327           break;
1328
1329         case GIMPLE_OMP_CRITICAL:
1330           s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1331           copy
1332             = gimple_build_omp_critical (s1, gimple_omp_critical_name (stmt));
1333           break;
1334
1335         default:
1336           gcc_unreachable ();
1337         }
1338     }
1339   else
1340     {
1341       if (gimple_assign_copy_p (stmt)
1342           && gimple_assign_lhs (stmt) == gimple_assign_rhs1 (stmt)
1343           && auto_var_in_fn_p (gimple_assign_lhs (stmt), id->src_fn))
1344         {
1345           /* Here we handle statements that are not completely rewritten.
1346              First we detect some inlining-induced bogosities for
1347              discarding.  */
1348
1349           /* Some assignments VAR = VAR; don't generate any rtl code
1350              and thus don't count as variable modification.  Avoid
1351              keeping bogosities like 0 = 0.  */
1352           tree decl = gimple_assign_lhs (stmt), value;
1353           tree *n;
1354
1355           n = (tree *) pointer_map_contains (id->decl_map, decl);
1356           if (n)
1357             {
1358               value = *n;
1359               STRIP_TYPE_NOPS (value);
1360               if (TREE_CONSTANT (value) || TREE_READONLY (value))
1361                 return gimple_build_nop ();
1362             }
1363         }
1364
1365       if (gimple_debug_bind_p (stmt))
1366         {
1367           copy = gimple_build_debug_bind (gimple_debug_bind_get_var (stmt),
1368                                           gimple_debug_bind_get_value (stmt),
1369                                           stmt);
1370           VEC_safe_push (gimple, heap, id->debug_stmts, copy);
1371           return copy;
1372         }
1373
1374       /* Create a new deep copy of the statement.  */
1375       copy = gimple_copy (stmt);
1376
1377       /* Remap the region numbers for __builtin_eh_{pointer,filter},
1378          RESX and EH_DISPATCH.  */
1379       if (id->eh_map)
1380         switch (gimple_code (copy))
1381           {
1382           case GIMPLE_CALL:
1383             {
1384               tree r, fndecl = gimple_call_fndecl (copy);
1385               if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
1386                 switch (DECL_FUNCTION_CODE (fndecl))
1387                   {
1388                   case BUILT_IN_EH_COPY_VALUES:
1389                     r = gimple_call_arg (copy, 1);
1390                     r = remap_eh_region_tree_nr (r, id);
1391                     gimple_call_set_arg (copy, 1, r);
1392                     /* FALLTHRU */
1393
1394                   case BUILT_IN_EH_POINTER:
1395                   case BUILT_IN_EH_FILTER:
1396                     r = gimple_call_arg (copy, 0);
1397                     r = remap_eh_region_tree_nr (r, id);
1398                     gimple_call_set_arg (copy, 0, r);
1399                     break;
1400
1401                   default:
1402                     break;
1403                   }
1404
1405               /* Reset alias info if we didn't apply measures to
1406                  keep it valid over inlining by setting DECL_PT_UID.  */
1407               if (!id->src_cfun->gimple_df
1408                   || !id->src_cfun->gimple_df->ipa_pta)
1409                 gimple_call_reset_alias_info (copy);
1410             }
1411             break;
1412
1413           case GIMPLE_RESX:
1414             {
1415               int r = gimple_resx_region (copy);
1416               r = remap_eh_region_nr (r, id);
1417               gimple_resx_set_region (copy, r);
1418             }
1419             break;
1420
1421           case GIMPLE_EH_DISPATCH:
1422             {
1423               int r = gimple_eh_dispatch_region (copy);
1424               r = remap_eh_region_nr (r, id);
1425               gimple_eh_dispatch_set_region (copy, r);
1426             }
1427             break;
1428
1429           default:
1430             break;
1431           }
1432     }
1433
1434   /* If STMT has a block defined, map it to the newly constructed
1435      block.  When inlining we want statements without a block to
1436      appear in the block of the function call.  */
1437   new_block = id->block;
1438   if (gimple_block (copy))
1439     {
1440       tree *n;
1441       n = (tree *) pointer_map_contains (id->decl_map, gimple_block (copy));
1442       gcc_assert (n);
1443       new_block = *n;
1444     }
1445
1446   gimple_set_block (copy, new_block);
1447
1448   if (gimple_debug_bind_p (copy))
1449     return copy;
1450
1451   /* Remap all the operands in COPY.  */
1452   memset (&wi, 0, sizeof (wi));
1453   wi.info = id;
1454   if (skip_first)
1455     walk_tree (gimple_op_ptr (copy, 1), remap_gimple_op_r, &wi, NULL);
1456   else
1457     walk_gimple_op (copy, remap_gimple_op_r, &wi);
1458
1459   /* Clear the copied virtual operands.  We are not remapping them here
1460      but are going to recreate them from scratch.  */
1461   if (gimple_has_mem_ops (copy))
1462     {
1463       gimple_set_vdef (copy, NULL_TREE);
1464       gimple_set_vuse (copy, NULL_TREE);
1465     }
1466
1467   return copy;
1468 }
1469
1470
1471 /* Copy basic block, scale profile accordingly.  Edges will be taken care of
1472    later  */
1473
1474 static basic_block
1475 copy_bb (copy_body_data *id, basic_block bb, int frequency_scale,
1476          gcov_type count_scale)
1477 {
1478   gimple_stmt_iterator gsi, copy_gsi, seq_gsi;
1479   basic_block copy_basic_block;
1480   tree decl;
1481   gcov_type freq;
1482
1483   /* create_basic_block() will append every new block to
1484      basic_block_info automatically.  */
1485   copy_basic_block = create_basic_block (NULL, (void *) 0,
1486                                          (basic_block) bb->prev_bb->aux);
1487   copy_basic_block->count = bb->count * count_scale / REG_BR_PROB_BASE;
1488
1489   /* We are going to rebuild frequencies from scratch.  These values
1490      have just small importance to drive canonicalize_loop_headers.  */
1491   freq = ((gcov_type)bb->frequency * frequency_scale / REG_BR_PROB_BASE);
1492
1493   /* We recompute frequencies after inlining, so this is quite safe.  */
1494   if (freq > BB_FREQ_MAX)
1495     freq = BB_FREQ_MAX;
1496   copy_basic_block->frequency = freq;
1497
1498   copy_gsi = gsi_start_bb (copy_basic_block);
1499
1500   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1501     {
1502       gimple stmt = gsi_stmt (gsi);
1503       gimple orig_stmt = stmt;
1504
1505       id->regimplify = false;
1506       stmt = remap_gimple_stmt (stmt, id);
1507       if (gimple_nop_p (stmt))
1508         continue;
1509
1510       gimple_duplicate_stmt_histograms (cfun, stmt, id->src_cfun, orig_stmt);
1511       seq_gsi = copy_gsi;
1512
1513       /* With return slot optimization we can end up with
1514          non-gimple (foo *)&this->m, fix that here.  */
1515       if (is_gimple_assign (stmt)
1516           && gimple_assign_rhs_code (stmt) == NOP_EXPR
1517           && !is_gimple_val (gimple_assign_rhs1 (stmt)))
1518         {
1519           tree new_rhs;
1520           new_rhs = force_gimple_operand_gsi (&seq_gsi,
1521                                               gimple_assign_rhs1 (stmt),
1522                                               true, NULL, false, GSI_NEW_STMT);
1523           gimple_assign_set_rhs1 (stmt, new_rhs);
1524           id->regimplify = false;
1525         }
1526
1527       gsi_insert_after (&seq_gsi, stmt, GSI_NEW_STMT);
1528
1529       if (id->regimplify)
1530         gimple_regimplify_operands (stmt, &seq_gsi);
1531
1532       /* If copy_basic_block has been empty at the start of this iteration,
1533          call gsi_start_bb again to get at the newly added statements.  */
1534       if (gsi_end_p (copy_gsi))
1535         copy_gsi = gsi_start_bb (copy_basic_block);
1536       else
1537         gsi_next (&copy_gsi);
1538
1539       /* Process the new statement.  The call to gimple_regimplify_operands
1540          possibly turned the statement into multiple statements, we
1541          need to process all of them.  */
1542       do
1543         {
1544           tree fn;
1545
1546           stmt = gsi_stmt (copy_gsi);
1547           if (is_gimple_call (stmt)
1548               && gimple_call_va_arg_pack_p (stmt)
1549               && id->gimple_call)
1550             {
1551               /* __builtin_va_arg_pack () should be replaced by
1552                  all arguments corresponding to ... in the caller.  */
1553               tree p;
1554               gimple new_call;
1555               VEC(tree, heap) *argarray;
1556               size_t nargs = gimple_call_num_args (id->gimple_call);
1557               size_t n;
1558
1559               for (p = DECL_ARGUMENTS (id->src_fn); p; p = TREE_CHAIN (p))
1560                 nargs--;
1561
1562               /* Create the new array of arguments.  */
1563               n = nargs + gimple_call_num_args (stmt);
1564               argarray = VEC_alloc (tree, heap, n);
1565               VEC_safe_grow (tree, heap, argarray, n);
1566
1567               /* Copy all the arguments before '...'  */
1568               memcpy (VEC_address (tree, argarray),
1569                       gimple_call_arg_ptr (stmt, 0),
1570                       gimple_call_num_args (stmt) * sizeof (tree));
1571
1572               /* Append the arguments passed in '...'  */
1573               memcpy (VEC_address(tree, argarray) + gimple_call_num_args (stmt),
1574                       gimple_call_arg_ptr (id->gimple_call, 0)
1575                         + (gimple_call_num_args (id->gimple_call) - nargs),
1576                       nargs * sizeof (tree));
1577
1578               new_call = gimple_build_call_vec (gimple_call_fn (stmt),
1579                                                 argarray);
1580
1581               VEC_free (tree, heap, argarray);
1582
1583               /* Copy all GIMPLE_CALL flags, location and block, except
1584                  GF_CALL_VA_ARG_PACK.  */
1585               gimple_call_copy_flags (new_call, stmt);
1586               gimple_call_set_va_arg_pack (new_call, false);
1587               gimple_set_location (new_call, gimple_location (stmt));
1588               gimple_set_block (new_call, gimple_block (stmt));
1589               gimple_call_set_lhs (new_call, gimple_call_lhs (stmt));
1590
1591               gsi_replace (&copy_gsi, new_call, false);
1592               gimple_set_bb (stmt, NULL);
1593               stmt = new_call;
1594             }
1595           else if (is_gimple_call (stmt)
1596                    && id->gimple_call
1597                    && (decl = gimple_call_fndecl (stmt))
1598                    && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
1599                    && DECL_FUNCTION_CODE (decl) == BUILT_IN_VA_ARG_PACK_LEN)
1600             {
1601               /* __builtin_va_arg_pack_len () should be replaced by
1602                  the number of anonymous arguments.  */
1603               size_t nargs = gimple_call_num_args (id->gimple_call);
1604               tree count, p;
1605               gimple new_stmt;
1606
1607               for (p = DECL_ARGUMENTS (id->src_fn); p; p = TREE_CHAIN (p))
1608                 nargs--;
1609
1610               count = build_int_cst (integer_type_node, nargs);
1611               new_stmt = gimple_build_assign (gimple_call_lhs (stmt), count);
1612               gsi_replace (&copy_gsi, new_stmt, false);
1613               stmt = new_stmt;
1614             }
1615
1616           /* Statements produced by inlining can be unfolded, especially
1617              when we constant propagated some operands.  We can't fold
1618              them right now for two reasons:
1619              1) folding require SSA_NAME_DEF_STMTs to be correct
1620              2) we can't change function calls to builtins.
1621              So we just mark statement for later folding.  We mark
1622              all new statements, instead just statements that has changed
1623              by some nontrivial substitution so even statements made
1624              foldable indirectly are updated.  If this turns out to be
1625              expensive, copy_body can be told to watch for nontrivial
1626              changes.  */
1627           if (id->statements_to_fold)
1628             pointer_set_insert (id->statements_to_fold, stmt);
1629
1630           /* We're duplicating a CALL_EXPR.  Find any corresponding
1631              callgraph edges and update or duplicate them.  */
1632           if (is_gimple_call (stmt))
1633             {
1634               struct cgraph_edge *edge;
1635               int flags;
1636
1637               switch (id->transform_call_graph_edges)
1638                 {
1639                 case CB_CGE_DUPLICATE:
1640                   edge = cgraph_edge (id->src_node, orig_stmt);
1641                   if (edge)
1642                     {
1643                       int edge_freq = edge->frequency;
1644                       edge = cgraph_clone_edge (edge, id->dst_node, stmt,
1645                                                 gimple_uid (stmt),
1646                                                 REG_BR_PROB_BASE, CGRAPH_FREQ_BASE,
1647                                                 edge->frequency, true);
1648                       /* We could also just rescale the frequency, but
1649                          doing so would introduce roundoff errors and make
1650                          verifier unhappy.  */
1651                       edge->frequency
1652                         = compute_call_stmt_bb_frequency (id->dst_node->decl,
1653                                                           copy_basic_block);
1654                       if (dump_file
1655                           && profile_status_for_function (cfun) != PROFILE_ABSENT
1656                           && (edge_freq > edge->frequency + 10
1657                               || edge_freq < edge->frequency - 10))
1658                         {
1659                           fprintf (dump_file, "Edge frequency estimated by "
1660                                    "cgraph %i diverge from inliner's estimate %i\n",
1661                                    edge_freq,
1662                                    edge->frequency);
1663                           fprintf (dump_file,
1664                                    "Orig bb: %i, orig bb freq %i, new bb freq %i\n",
1665                                    bb->index,
1666                                    bb->frequency,
1667                                    copy_basic_block->frequency);
1668                         }
1669                       stmt = cgraph_redirect_edge_call_stmt_to_callee (edge);
1670                     }
1671                   break;
1672
1673                 case CB_CGE_MOVE_CLONES:
1674                   cgraph_set_call_stmt_including_clones (id->dst_node,
1675                                                          orig_stmt, stmt);
1676                   edge = cgraph_edge (id->dst_node, stmt);
1677                   break;
1678
1679                 case CB_CGE_MOVE:
1680                   edge = cgraph_edge (id->dst_node, orig_stmt);
1681                   if (edge)
1682                     cgraph_set_call_stmt (edge, stmt);
1683                   break;
1684
1685                 default:
1686                   gcc_unreachable ();
1687                 }
1688
1689               /* Constant propagation on argument done during inlining
1690                  may create new direct call.  Produce an edge for it.  */
1691               if ((!edge
1692                    || (edge->indirect_call
1693                        && id->transform_call_graph_edges == CB_CGE_MOVE_CLONES))
1694                   && is_gimple_call (stmt)
1695                   && (fn = gimple_call_fndecl (stmt)) != NULL)
1696                 {
1697                   struct cgraph_node *dest = cgraph_node (fn);
1698
1699                   /* We have missing edge in the callgraph.  This can happen
1700                      when previous inlining turned an indirect call into a
1701                      direct call by constant propagating arguments or we are
1702                      producing dead clone (for further clonning).  In all
1703                      other cases we hit a bug (incorrect node sharing is the
1704                      most common reason for missing edges).  */
1705                   gcc_assert (dest->needed || !dest->analyzed
1706                               || !id->src_node->analyzed);
1707                   if (id->transform_call_graph_edges == CB_CGE_MOVE_CLONES)
1708                     cgraph_create_edge_including_clones
1709                       (id->dst_node, dest, orig_stmt, stmt, bb->count,
1710                        compute_call_stmt_bb_frequency (id->dst_node->decl,
1711                                                        copy_basic_block),
1712                        bb->loop_depth, CIF_ORIGINALLY_INDIRECT_CALL);
1713                   else
1714                     cgraph_create_edge (id->dst_node, dest, stmt,
1715                                         bb->count,
1716                                         compute_call_stmt_bb_frequency
1717                                           (id->dst_node->decl, copy_basic_block),
1718                                         bb->loop_depth)->inline_failed
1719                       = CIF_ORIGINALLY_INDIRECT_CALL;
1720                   if (dump_file)
1721                     {
1722                       fprintf (dump_file, "Created new direct edge to %s",
1723                                cgraph_node_name (dest));
1724                     }
1725                 }
1726
1727               flags = gimple_call_flags (stmt);
1728               if (flags & ECF_MAY_BE_ALLOCA)
1729                 cfun->calls_alloca = true;
1730               if (flags & ECF_RETURNS_TWICE)
1731                 cfun->calls_setjmp = true;
1732             }
1733
1734           maybe_duplicate_eh_stmt_fn (cfun, stmt, id->src_cfun, orig_stmt,
1735                                       id->eh_map, id->eh_lp_nr);
1736
1737           if (gimple_in_ssa_p (cfun) && !is_gimple_debug (stmt))
1738             {
1739               ssa_op_iter i;
1740               tree def;
1741
1742               find_new_referenced_vars (gsi_stmt (copy_gsi));
1743               FOR_EACH_SSA_TREE_OPERAND (def, stmt, i, SSA_OP_DEF)
1744                 if (TREE_CODE (def) == SSA_NAME)
1745                   SSA_NAME_DEF_STMT (def) = stmt;
1746             }
1747
1748           gsi_next (&copy_gsi);
1749         }
1750       while (!gsi_end_p (copy_gsi));
1751
1752       copy_gsi = gsi_last_bb (copy_basic_block);
1753     }
1754
1755   return copy_basic_block;
1756 }
1757
1758 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
1759    form is quite easy, since dominator relationship for old basic blocks does
1760    not change.
1761
1762    There is however exception where inlining might change dominator relation
1763    across EH edges from basic block within inlined functions destinating
1764    to landing pads in function we inline into.
1765
1766    The function fills in PHI_RESULTs of such PHI nodes if they refer
1767    to gimple regs.  Otherwise, the function mark PHI_RESULT of such
1768    PHI nodes for renaming.  For non-gimple regs, renaming is safe: the
1769    EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
1770    set, and this means that there will be no overlapping live ranges
1771    for the underlying symbol.
1772
1773    This might change in future if we allow redirecting of EH edges and
1774    we might want to change way build CFG pre-inlining to include
1775    all the possible edges then.  */
1776 static void
1777 update_ssa_across_abnormal_edges (basic_block bb, basic_block ret_bb,
1778                                   bool can_throw, bool nonlocal_goto)
1779 {
1780   edge e;
1781   edge_iterator ei;
1782
1783   FOR_EACH_EDGE (e, ei, bb->succs)
1784     if (!e->dest->aux
1785         || ((basic_block)e->dest->aux)->index == ENTRY_BLOCK)
1786       {
1787         gimple phi;
1788         gimple_stmt_iterator si;
1789
1790         if (!nonlocal_goto)
1791           gcc_assert (e->flags & EDGE_EH);
1792
1793         if (!can_throw)
1794           gcc_assert (!(e->flags & EDGE_EH));
1795
1796         for (si = gsi_start_phis (e->dest); !gsi_end_p (si); gsi_next (&si))
1797           {
1798             edge re;
1799
1800             phi = gsi_stmt (si);
1801
1802             /* There shouldn't be any PHI nodes in the ENTRY_BLOCK.  */
1803             gcc_assert (!e->dest->aux);
1804
1805             gcc_assert ((e->flags & EDGE_EH)
1806                         || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi)));
1807
1808             if (!is_gimple_reg (PHI_RESULT (phi)))
1809               {
1810                 mark_sym_for_renaming (SSA_NAME_VAR (PHI_RESULT (phi)));
1811                 continue;
1812               }
1813
1814             re = find_edge (ret_bb, e->dest);
1815             gcc_assert (re);
1816             gcc_assert ((re->flags & (EDGE_EH | EDGE_ABNORMAL))
1817                         == (e->flags & (EDGE_EH | EDGE_ABNORMAL)));
1818
1819             SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi, e),
1820                      USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi, re)));
1821           }
1822       }
1823 }
1824
1825
1826 /* Copy edges from BB into its copy constructed earlier, scale profile
1827    accordingly.  Edges will be taken care of later.  Assume aux
1828    pointers to point to the copies of each BB.  */
1829
1830 static void
1831 copy_edges_for_bb (basic_block bb, gcov_type count_scale, basic_block ret_bb)
1832 {
1833   basic_block new_bb = (basic_block) bb->aux;
1834   edge_iterator ei;
1835   edge old_edge;
1836   gimple_stmt_iterator si;
1837   int flags;
1838
1839   /* Use the indices from the original blocks to create edges for the
1840      new ones.  */
1841   FOR_EACH_EDGE (old_edge, ei, bb->succs)
1842     if (!(old_edge->flags & EDGE_EH))
1843       {
1844         edge new_edge;
1845
1846         flags = old_edge->flags;
1847
1848         /* Return edges do get a FALLTHRU flag when the get inlined.  */
1849         if (old_edge->dest->index == EXIT_BLOCK && !old_edge->flags
1850             && old_edge->dest->aux != EXIT_BLOCK_PTR)
1851           flags |= EDGE_FALLTHRU;
1852         new_edge = make_edge (new_bb, (basic_block) old_edge->dest->aux, flags);
1853         new_edge->count = old_edge->count * count_scale / REG_BR_PROB_BASE;
1854         new_edge->probability = old_edge->probability;
1855       }
1856
1857   if (bb->index == ENTRY_BLOCK || bb->index == EXIT_BLOCK)
1858     return;
1859
1860   for (si = gsi_start_bb (new_bb); !gsi_end_p (si);)
1861     {
1862       gimple copy_stmt;
1863       bool can_throw, nonlocal_goto;
1864
1865       copy_stmt = gsi_stmt (si);
1866       if (!is_gimple_debug (copy_stmt))
1867         {
1868           update_stmt (copy_stmt);
1869           if (gimple_in_ssa_p (cfun))
1870             mark_symbols_for_renaming (copy_stmt);
1871         }
1872
1873       /* Do this before the possible split_block.  */
1874       gsi_next (&si);
1875
1876       /* If this tree could throw an exception, there are two
1877          cases where we need to add abnormal edge(s): the
1878          tree wasn't in a region and there is a "current
1879          region" in the caller; or the original tree had
1880          EH edges.  In both cases split the block after the tree,
1881          and add abnormal edge(s) as needed; we need both
1882          those from the callee and the caller.
1883          We check whether the copy can throw, because the const
1884          propagation can change an INDIRECT_REF which throws
1885          into a COMPONENT_REF which doesn't.  If the copy
1886          can throw, the original could also throw.  */
1887       can_throw = stmt_can_throw_internal (copy_stmt);
1888       nonlocal_goto = stmt_can_make_abnormal_goto (copy_stmt);
1889
1890       if (can_throw || nonlocal_goto)
1891         {
1892           if (!gsi_end_p (si))
1893             /* Note that bb's predecessor edges aren't necessarily
1894                right at this point; split_block doesn't care.  */
1895             {
1896               edge e = split_block (new_bb, copy_stmt);
1897
1898               new_bb = e->dest;
1899               new_bb->aux = e->src->aux;
1900               si = gsi_start_bb (new_bb);
1901             }
1902         }
1903
1904       if (gimple_code (copy_stmt) == GIMPLE_EH_DISPATCH)
1905         make_eh_dispatch_edges (copy_stmt);
1906       else if (can_throw)
1907         make_eh_edges (copy_stmt);
1908
1909       if (nonlocal_goto)
1910         make_abnormal_goto_edges (gimple_bb (copy_stmt), true);
1911
1912       if ((can_throw || nonlocal_goto)
1913           && gimple_in_ssa_p (cfun))
1914         update_ssa_across_abnormal_edges (gimple_bb (copy_stmt), ret_bb,
1915                                           can_throw, nonlocal_goto);
1916     }
1917 }
1918
1919 /* Copy the PHIs.  All blocks and edges are copied, some blocks
1920    was possibly split and new outgoing EH edges inserted.
1921    BB points to the block of original function and AUX pointers links
1922    the original and newly copied blocks.  */
1923
1924 static void
1925 copy_phis_for_bb (basic_block bb, copy_body_data *id)
1926 {
1927   basic_block const new_bb = (basic_block) bb->aux;
1928   edge_iterator ei;
1929   gimple phi;
1930   gimple_stmt_iterator si;
1931
1932   for (si = gsi_start (phi_nodes (bb)); !gsi_end_p (si); gsi_next (&si))
1933     {
1934       tree res, new_res;
1935       gimple new_phi;
1936       edge new_edge;
1937
1938       phi = gsi_stmt (si);
1939       res = PHI_RESULT (phi);
1940       new_res = res;
1941       if (is_gimple_reg (res))
1942         {
1943           walk_tree (&new_res, copy_tree_body_r, id, NULL);
1944           SSA_NAME_DEF_STMT (new_res)
1945             = new_phi = create_phi_node (new_res, new_bb);
1946           FOR_EACH_EDGE (new_edge, ei, new_bb->preds)
1947             {
1948               edge const old_edge
1949                 = find_edge ((basic_block) new_edge->src->aux, bb);
1950               tree arg = PHI_ARG_DEF_FROM_EDGE (phi, old_edge);
1951               tree new_arg = arg;
1952               tree block = id->block;
1953               id->block = NULL_TREE;
1954               walk_tree (&new_arg, copy_tree_body_r, id, NULL);
1955               id->block = block;
1956               gcc_assert (new_arg);
1957               /* With return slot optimization we can end up with
1958                  non-gimple (foo *)&this->m, fix that here.  */
1959               if (TREE_CODE (new_arg) != SSA_NAME
1960                   && TREE_CODE (new_arg) != FUNCTION_DECL
1961                   && !is_gimple_val (new_arg))
1962                 {
1963                   gimple_seq stmts = NULL;
1964                   new_arg = force_gimple_operand (new_arg, &stmts, true, NULL);
1965                   gsi_insert_seq_on_edge_immediate (new_edge, stmts);
1966                 }
1967               add_phi_arg (new_phi, new_arg, new_edge,
1968                            gimple_phi_arg_location_from_edge (phi, old_edge));
1969             }
1970         }
1971     }
1972 }
1973
1974
1975 /* Wrapper for remap_decl so it can be used as a callback.  */
1976
1977 static tree
1978 remap_decl_1 (tree decl, void *data)
1979 {
1980   return remap_decl (decl, (copy_body_data *) data);
1981 }
1982
1983 /* Build struct function and associated datastructures for the new clone
1984    NEW_FNDECL to be build.  CALLEE_FNDECL is the original */
1985
1986 static void
1987 initialize_cfun (tree new_fndecl, tree callee_fndecl, gcov_type count)
1988 {
1989   struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
1990   gcov_type count_scale;
1991
1992   if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count)
1993     count_scale = (REG_BR_PROB_BASE * count
1994                    / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count);
1995   else
1996     count_scale = REG_BR_PROB_BASE;
1997
1998   /* Register specific tree functions.  */
1999   gimple_register_cfg_hooks ();
2000
2001   /* Get clean struct function.  */
2002   push_struct_function (new_fndecl);
2003
2004   /* We will rebuild these, so just sanity check that they are empty.  */
2005   gcc_assert (VALUE_HISTOGRAMS (cfun) == NULL);
2006   gcc_assert (cfun->local_decls == NULL);
2007   gcc_assert (cfun->cfg == NULL);
2008   gcc_assert (cfun->decl == new_fndecl);
2009
2010   /* Copy items we preserve during clonning.  */
2011   cfun->static_chain_decl = src_cfun->static_chain_decl;
2012   cfun->nonlocal_goto_save_area = src_cfun->nonlocal_goto_save_area;
2013   cfun->function_end_locus = src_cfun->function_end_locus;
2014   cfun->curr_properties = src_cfun->curr_properties;
2015   cfun->last_verified = src_cfun->last_verified;
2016   cfun->va_list_gpr_size = src_cfun->va_list_gpr_size;
2017   cfun->va_list_fpr_size = src_cfun->va_list_fpr_size;
2018   cfun->function_frequency = src_cfun->function_frequency;
2019   cfun->has_nonlocal_label = src_cfun->has_nonlocal_label;
2020   cfun->stdarg = src_cfun->stdarg;
2021   cfun->dont_save_pending_sizes_p = src_cfun->dont_save_pending_sizes_p;
2022   cfun->after_inlining = src_cfun->after_inlining;
2023   cfun->returns_struct = src_cfun->returns_struct;
2024   cfun->returns_pcc_struct = src_cfun->returns_pcc_struct;
2025   cfun->after_tree_profile = src_cfun->after_tree_profile;
2026
2027   init_empty_tree_cfg ();
2028
2029   profile_status_for_function (cfun) = profile_status_for_function (src_cfun);
2030   ENTRY_BLOCK_PTR->count =
2031     (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count * count_scale /
2032      REG_BR_PROB_BASE);
2033   ENTRY_BLOCK_PTR->frequency
2034     = ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency;
2035   EXIT_BLOCK_PTR->count =
2036     (EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count * count_scale /
2037      REG_BR_PROB_BASE);
2038   EXIT_BLOCK_PTR->frequency =
2039     EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency;
2040   if (src_cfun->eh)
2041     init_eh_for_function ();
2042
2043   if (src_cfun->gimple_df)
2044     {
2045       init_tree_ssa (cfun);
2046       cfun->gimple_df->in_ssa_p = true;
2047       init_ssa_operands ();
2048     }
2049   pop_cfun ();
2050 }
2051
2052 /* Make a copy of the body of FN so that it can be inserted inline in
2053    another function.  Walks FN via CFG, returns new fndecl.  */
2054
2055 static tree
2056 copy_cfg_body (copy_body_data * id, gcov_type count, int frequency_scale,
2057                basic_block entry_block_map, basic_block exit_block_map)
2058 {
2059   tree callee_fndecl = id->src_fn;
2060   /* Original cfun for the callee, doesn't change.  */
2061   struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
2062   struct function *cfun_to_copy;
2063   basic_block bb;
2064   tree new_fndecl = NULL;
2065   gcov_type count_scale;
2066   int last;
2067
2068   if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count)
2069     count_scale = (REG_BR_PROB_BASE * count
2070                    / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count);
2071   else
2072     count_scale = REG_BR_PROB_BASE;
2073
2074   /* Register specific tree functions.  */
2075   gimple_register_cfg_hooks ();
2076
2077   /* Must have a CFG here at this point.  */
2078   gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION
2079               (DECL_STRUCT_FUNCTION (callee_fndecl)));
2080
2081   cfun_to_copy = id->src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
2082
2083   ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy)->aux = entry_block_map;
2084   EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy)->aux = exit_block_map;
2085   entry_block_map->aux = ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy);
2086   exit_block_map->aux = EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy);
2087
2088   /* Duplicate any exception-handling regions.  */
2089   if (cfun->eh)
2090     id->eh_map = duplicate_eh_regions (cfun_to_copy, NULL, id->eh_lp_nr,
2091                                        remap_decl_1, id);
2092
2093   /* Use aux pointers to map the original blocks to copy.  */
2094   FOR_EACH_BB_FN (bb, cfun_to_copy)
2095     {
2096       basic_block new_bb = copy_bb (id, bb, frequency_scale, count_scale);
2097       bb->aux = new_bb;
2098       new_bb->aux = bb;
2099     }
2100
2101   last = last_basic_block;
2102
2103   /* Now that we've duplicated the blocks, duplicate their edges.  */
2104   FOR_ALL_BB_FN (bb, cfun_to_copy)
2105     copy_edges_for_bb (bb, count_scale, exit_block_map);
2106
2107   if (gimple_in_ssa_p (cfun))
2108     FOR_ALL_BB_FN (bb, cfun_to_copy)
2109       copy_phis_for_bb (bb, id);
2110
2111   FOR_ALL_BB_FN (bb, cfun_to_copy)
2112     {
2113       ((basic_block)bb->aux)->aux = NULL;
2114       bb->aux = NULL;
2115     }
2116
2117   /* Zero out AUX fields of newly created block during EH edge
2118      insertion. */
2119   for (; last < last_basic_block; last++)
2120     BASIC_BLOCK (last)->aux = NULL;
2121   entry_block_map->aux = NULL;
2122   exit_block_map->aux = NULL;
2123
2124   if (id->eh_map)
2125     {
2126       pointer_map_destroy (id->eh_map);
2127       id->eh_map = NULL;
2128     }
2129
2130   return new_fndecl;
2131 }
2132
2133 /* Copy the debug STMT using ID.  We deal with these statements in a
2134    special way: if any variable in their VALUE expression wasn't
2135    remapped yet, we won't remap it, because that would get decl uids
2136    out of sync, causing codegen differences between -g and -g0.  If
2137    this arises, we drop the VALUE expression altogether.  */
2138
2139 static void
2140 copy_debug_stmt (gimple stmt, copy_body_data *id)
2141 {
2142   tree t, *n;
2143   struct walk_stmt_info wi;
2144
2145   t = id->block;
2146   if (gimple_block (stmt))
2147     {
2148       tree *n;
2149       n = (tree *) pointer_map_contains (id->decl_map, gimple_block (stmt));
2150       if (n)
2151         t = *n;
2152     }
2153   gimple_set_block (stmt, t);
2154
2155   /* Remap all the operands in COPY.  */
2156   memset (&wi, 0, sizeof (wi));
2157   wi.info = id;
2158
2159   processing_debug_stmt = 1;
2160
2161   t = gimple_debug_bind_get_var (stmt);
2162
2163   if (TREE_CODE (t) == PARM_DECL && id->debug_map
2164       && (n = (tree *) pointer_map_contains (id->debug_map, t)))
2165     {
2166       gcc_assert (TREE_CODE (*n) == VAR_DECL);
2167       t = *n;
2168     }
2169   else if (TREE_CODE (t) == VAR_DECL
2170            && !TREE_STATIC (t)
2171            && gimple_in_ssa_p (cfun)
2172            && !pointer_map_contains (id->decl_map, t)
2173            && !var_ann (t))
2174     /* T is a non-localized variable.  */;
2175   else
2176     walk_tree (&t, remap_gimple_op_r, &wi, NULL);
2177
2178   gimple_debug_bind_set_var (stmt, t);
2179
2180   if (gimple_debug_bind_has_value_p (stmt))
2181     walk_tree (gimple_debug_bind_get_value_ptr (stmt),
2182                remap_gimple_op_r, &wi, NULL);
2183
2184   /* Punt if any decl couldn't be remapped.  */
2185   if (processing_debug_stmt < 0)
2186     gimple_debug_bind_reset_value (stmt);
2187
2188   processing_debug_stmt = 0;
2189
2190   update_stmt (stmt);
2191   if (gimple_in_ssa_p (cfun))
2192     mark_symbols_for_renaming (stmt);
2193 }
2194
2195 /* Process deferred debug stmts.  In order to give values better odds
2196    of being successfully remapped, we delay the processing of debug
2197    stmts until all other stmts that might require remapping are
2198    processed.  */
2199
2200 static void
2201 copy_debug_stmts (copy_body_data *id)
2202 {
2203   size_t i;
2204   gimple stmt;
2205
2206   if (!id->debug_stmts)
2207     return;
2208
2209   for (i = 0; VEC_iterate (gimple, id->debug_stmts, i, stmt); i++)
2210     copy_debug_stmt (stmt, id);
2211
2212   VEC_free (gimple, heap, id->debug_stmts);
2213 }
2214
2215 /* Make a copy of the body of SRC_FN so that it can be inserted inline in
2216    another function.  */
2217
2218 static tree
2219 copy_tree_body (copy_body_data *id)
2220 {
2221   tree fndecl = id->src_fn;
2222   tree body = DECL_SAVED_TREE (fndecl);
2223
2224   walk_tree (&body, copy_tree_body_r, id, NULL);
2225
2226   return body;
2227 }
2228
2229 /* Make a copy of the body of FN so that it can be inserted inline in
2230    another function.  */
2231
2232 static tree
2233 copy_body (copy_body_data *id, gcov_type count, int frequency_scale,
2234            basic_block entry_block_map, basic_block exit_block_map)
2235 {
2236   tree fndecl = id->src_fn;
2237   tree body;
2238
2239   /* If this body has a CFG, walk CFG and copy.  */
2240   gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (fndecl)));
2241   body = copy_cfg_body (id, count, frequency_scale, entry_block_map, exit_block_map);
2242   copy_debug_stmts (id);
2243
2244   return body;
2245 }
2246
2247 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
2248    defined in function FN, or of a data member thereof.  */
2249
2250 static bool
2251 self_inlining_addr_expr (tree value, tree fn)
2252 {
2253   tree var;
2254
2255   if (TREE_CODE (value) != ADDR_EXPR)
2256     return false;
2257
2258   var = get_base_address (TREE_OPERAND (value, 0));
2259
2260   return var && auto_var_in_fn_p (var, fn);
2261 }
2262
2263 /* Append to BB a debug annotation that binds VAR to VALUE, inheriting
2264    lexical block and line number information from base_stmt, if given,
2265    or from the last stmt of the block otherwise.  */
2266
2267 static gimple
2268 insert_init_debug_bind (copy_body_data *id,
2269                         basic_block bb, tree var, tree value,
2270                         gimple base_stmt)
2271 {
2272   gimple note;
2273   gimple_stmt_iterator gsi;
2274   tree tracked_var;
2275
2276   if (!gimple_in_ssa_p (id->src_cfun))
2277     return NULL;
2278
2279   if (!MAY_HAVE_DEBUG_STMTS)
2280     return NULL;
2281
2282   tracked_var = target_for_debug_bind (var);
2283   if (!tracked_var)
2284     return NULL;
2285
2286   if (bb)
2287     {
2288       gsi = gsi_last_bb (bb);
2289       if (!base_stmt && !gsi_end_p (gsi))
2290         base_stmt = gsi_stmt (gsi);
2291     }
2292
2293   note = gimple_build_debug_bind (tracked_var, value, base_stmt);
2294
2295   if (bb)
2296     {
2297       if (!gsi_end_p (gsi))
2298         gsi_insert_after (&gsi, note, GSI_SAME_STMT);
2299       else
2300         gsi_insert_before (&gsi, note, GSI_SAME_STMT);
2301     }
2302
2303   return note;
2304 }
2305
2306 static void
2307 insert_init_stmt (copy_body_data *id, basic_block bb, gimple init_stmt)
2308 {
2309   /* If VAR represents a zero-sized variable, it's possible that the
2310      assignment statement may result in no gimple statements.  */
2311   if (init_stmt)
2312     {
2313       gimple_stmt_iterator si = gsi_last_bb (bb);
2314
2315       /* We can end up with init statements that store to a non-register
2316          from a rhs with a conversion.  Handle that here by forcing the
2317          rhs into a temporary.  gimple_regimplify_operands is not
2318          prepared to do this for us.  */
2319       if (!is_gimple_debug (init_stmt)
2320           && !is_gimple_reg (gimple_assign_lhs (init_stmt))
2321           && is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (init_stmt)))
2322           && gimple_assign_rhs_class (init_stmt) == GIMPLE_UNARY_RHS)
2323         {
2324           tree rhs = build1 (gimple_assign_rhs_code (init_stmt),
2325                              gimple_expr_type (init_stmt),
2326                              gimple_assign_rhs1 (init_stmt));
2327           rhs = force_gimple_operand_gsi (&si, rhs, true, NULL_TREE, false,
2328                                           GSI_NEW_STMT);
2329           gimple_assign_set_rhs_code (init_stmt, TREE_CODE (rhs));
2330           gimple_assign_set_rhs1 (init_stmt, rhs);
2331         }
2332       gsi_insert_after (&si, init_stmt, GSI_NEW_STMT);
2333       gimple_regimplify_operands (init_stmt, &si);
2334       mark_symbols_for_renaming (init_stmt);
2335
2336       if (!is_gimple_debug (init_stmt) && MAY_HAVE_DEBUG_STMTS)
2337         {
2338           tree var, def = gimple_assign_lhs (init_stmt);
2339
2340           if (TREE_CODE (def) == SSA_NAME)
2341             var = SSA_NAME_VAR (def);
2342           else
2343             var = def;
2344
2345           insert_init_debug_bind (id, bb, var, def, init_stmt);
2346         }
2347     }
2348 }
2349
2350 /* Initialize parameter P with VALUE.  If needed, produce init statement
2351    at the end of BB.  When BB is NULL, we return init statement to be
2352    output later.  */
2353 static gimple
2354 setup_one_parameter (copy_body_data *id, tree p, tree value, tree fn,
2355                      basic_block bb, tree *vars)
2356 {
2357   gimple init_stmt = NULL;
2358   tree var;
2359   tree rhs = value;
2360   tree def = (gimple_in_ssa_p (cfun)
2361               ? gimple_default_def (id->src_cfun, p) : NULL);
2362
2363   if (value
2364       && value != error_mark_node
2365       && !useless_type_conversion_p (TREE_TYPE (p), TREE_TYPE (value)))
2366     {
2367       if (fold_convertible_p (TREE_TYPE (p), value))
2368         rhs = fold_build1 (NOP_EXPR, TREE_TYPE (p), value);
2369       else
2370         /* ???  For valid (GIMPLE) programs we should not end up here.
2371            Still if something has gone wrong and we end up with truly
2372            mismatched types here, fall back to using a VIEW_CONVERT_EXPR
2373            to not leak invalid GIMPLE to the following passes.  */
2374         rhs = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (p), value);
2375     }
2376
2377   /* Make an equivalent VAR_DECL.  Note that we must NOT remap the type
2378      here since the type of this decl must be visible to the calling
2379      function.  */
2380   var = copy_decl_to_var (p, id);
2381
2382   /* We're actually using the newly-created var.  */
2383   if (gimple_in_ssa_p (cfun) && TREE_CODE (var) == VAR_DECL)
2384     {
2385       get_var_ann (var);
2386       add_referenced_var (var);
2387     }
2388
2389   /* Declare this new variable.  */
2390   TREE_CHAIN (var) = *vars;
2391   *vars = var;
2392
2393   /* Make gimplifier happy about this variable.  */
2394   DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
2395
2396   /* If the parameter is never assigned to, has no SSA_NAMEs created,
2397      we would not need to create a new variable here at all, if it
2398      weren't for debug info.  Still, we can just use the argument
2399      value.  */
2400   if (TREE_READONLY (p)
2401       && !TREE_ADDRESSABLE (p)
2402       && value && !TREE_SIDE_EFFECTS (value)
2403       && !def)
2404     {
2405       /* We may produce non-gimple trees by adding NOPs or introduce
2406          invalid sharing when operand is not really constant.
2407          It is not big deal to prohibit constant propagation here as
2408          we will constant propagate in DOM1 pass anyway.  */
2409       if (is_gimple_min_invariant (value)
2410           && useless_type_conversion_p (TREE_TYPE (p),
2411                                                  TREE_TYPE (value))
2412           /* We have to be very careful about ADDR_EXPR.  Make sure
2413              the base variable isn't a local variable of the inlined
2414              function, e.g., when doing recursive inlining, direct or
2415              mutually-recursive or whatever, which is why we don't
2416              just test whether fn == current_function_decl.  */
2417           && ! self_inlining_addr_expr (value, fn))
2418         {
2419           insert_decl_map (id, p, value);
2420           insert_debug_decl_map (id, p, var);
2421           return insert_init_debug_bind (id, bb, var, value, NULL);
2422         }
2423     }
2424
2425   /* Register the VAR_DECL as the equivalent for the PARM_DECL;
2426      that way, when the PARM_DECL is encountered, it will be
2427      automatically replaced by the VAR_DECL.  */
2428   insert_decl_map (id, p, var);
2429
2430   /* Even if P was TREE_READONLY, the new VAR should not be.
2431      In the original code, we would have constructed a
2432      temporary, and then the function body would have never
2433      changed the value of P.  However, now, we will be
2434      constructing VAR directly.  The constructor body may
2435      change its value multiple times as it is being
2436      constructed.  Therefore, it must not be TREE_READONLY;
2437      the back-end assumes that TREE_READONLY variable is
2438      assigned to only once.  */
2439   if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p)))
2440     TREE_READONLY (var) = 0;
2441
2442   /* If there is no setup required and we are in SSA, take the easy route
2443      replacing all SSA names representing the function parameter by the
2444      SSA name passed to function.
2445
2446      We need to construct map for the variable anyway as it might be used
2447      in different SSA names when parameter is set in function.
2448
2449      Do replacement at -O0 for const arguments replaced by constant.
2450      This is important for builtin_constant_p and other construct requiring
2451      constant argument to be visible in inlined function body.  */
2452   if (gimple_in_ssa_p (cfun) && rhs && def && is_gimple_reg (p)
2453       && (optimize
2454           || (TREE_READONLY (p)
2455               && is_gimple_min_invariant (rhs)))
2456       && (TREE_CODE (rhs) == SSA_NAME
2457           || is_gimple_min_invariant (rhs))
2458       && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def))
2459     {
2460       insert_decl_map (id, def, rhs);
2461       return insert_init_debug_bind (id, bb, var, rhs, NULL);
2462     }
2463
2464   /* If the value of argument is never used, don't care about initializing
2465      it.  */
2466   if (optimize && gimple_in_ssa_p (cfun) && !def && is_gimple_reg (p))
2467     {
2468       gcc_assert (!value || !TREE_SIDE_EFFECTS (value));
2469       return insert_init_debug_bind (id, bb, var, rhs, NULL);
2470     }
2471
2472   /* Initialize this VAR_DECL from the equivalent argument.  Convert
2473      the argument to the proper type in case it was promoted.  */
2474   if (value)
2475     {
2476       if (rhs == error_mark_node)
2477         {
2478           insert_decl_map (id, p, var);
2479           return insert_init_debug_bind (id, bb, var, rhs, NULL);
2480         }
2481
2482       STRIP_USELESS_TYPE_CONVERSION (rhs);
2483
2484       /* We want to use MODIFY_EXPR, not INIT_EXPR here so that we
2485          keep our trees in gimple form.  */
2486       if (def && gimple_in_ssa_p (cfun) && is_gimple_reg (p))
2487         {
2488           def = remap_ssa_name (def, id);
2489           init_stmt = gimple_build_assign (def, rhs);
2490           SSA_NAME_IS_DEFAULT_DEF (def) = 0;
2491           set_default_def (var, NULL);
2492         }
2493       else
2494         init_stmt = gimple_build_assign (var, rhs);
2495
2496       if (bb && init_stmt)
2497         insert_init_stmt (id, bb, init_stmt);
2498     }
2499   return init_stmt;
2500 }
2501
2502 /* Generate code to initialize the parameters of the function at the
2503    top of the stack in ID from the GIMPLE_CALL STMT.  */
2504
2505 static void
2506 initialize_inlined_parameters (copy_body_data *id, gimple stmt,
2507                                tree fn, basic_block bb)
2508 {
2509   tree parms;
2510   size_t i;
2511   tree p;
2512   tree vars = NULL_TREE;
2513   tree static_chain = gimple_call_chain (stmt);
2514
2515   /* Figure out what the parameters are.  */
2516   parms = DECL_ARGUMENTS (fn);
2517
2518   /* Loop through the parameter declarations, replacing each with an
2519      equivalent VAR_DECL, appropriately initialized.  */
2520   for (p = parms, i = 0; p; p = TREE_CHAIN (p), i++)
2521     {
2522       tree val;
2523       val = i < gimple_call_num_args (stmt) ? gimple_call_arg (stmt, i) : NULL;
2524       setup_one_parameter (id, p, val, fn, bb, &vars);
2525     }
2526
2527   /* Initialize the static chain.  */
2528   p = DECL_STRUCT_FUNCTION (fn)->static_chain_decl;
2529   gcc_assert (fn != current_function_decl);
2530   if (p)
2531     {
2532       /* No static chain?  Seems like a bug in tree-nested.c.  */
2533       gcc_assert (static_chain);
2534
2535       setup_one_parameter (id, p, static_chain, fn, bb, &vars);
2536     }
2537
2538   declare_inline_vars (id->block, vars);
2539 }
2540
2541
2542 /* Declare a return variable to replace the RESULT_DECL for the
2543    function we are calling.  An appropriate DECL_STMT is returned.
2544    The USE_STMT is filled to contain a use of the declaration to
2545    indicate the return value of the function.
2546
2547    RETURN_SLOT, if non-null is place where to store the result.  It
2548    is set only for CALL_EXPR_RETURN_SLOT_OPT.  MODIFY_DEST, if non-null,
2549    was the LHS of the MODIFY_EXPR to which this call is the RHS.
2550
2551    The return value is a (possibly null) value that holds the result
2552    as seen by the caller.  */
2553
2554 static tree
2555 declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest)
2556 {
2557   tree callee = id->src_fn;
2558   tree caller = id->dst_fn;
2559   tree result = DECL_RESULT (callee);
2560   tree callee_type = TREE_TYPE (result);
2561   tree caller_type;
2562   tree var, use;
2563
2564   /* Handle type-mismatches in the function declaration return type
2565      vs. the call expression.  */
2566   if (modify_dest)
2567     caller_type = TREE_TYPE (modify_dest);
2568   else
2569     caller_type = TREE_TYPE (TREE_TYPE (callee));
2570
2571   /* We don't need to do anything for functions that don't return
2572      anything.  */
2573   if (!result || VOID_TYPE_P (callee_type))
2574     return NULL_TREE;
2575
2576   /* If there was a return slot, then the return value is the
2577      dereferenced address of that object.  */
2578   if (return_slot)
2579     {
2580       /* The front end shouldn't have used both return_slot and
2581          a modify expression.  */
2582       gcc_assert (!modify_dest);
2583       if (DECL_BY_REFERENCE (result))
2584         {
2585           tree return_slot_addr = build_fold_addr_expr (return_slot);
2586           STRIP_USELESS_TYPE_CONVERSION (return_slot_addr);
2587
2588           /* We are going to construct *&return_slot and we can't do that
2589              for variables believed to be not addressable.
2590
2591              FIXME: This check possibly can match, because values returned
2592              via return slot optimization are not believed to have address
2593              taken by alias analysis.  */
2594           gcc_assert (TREE_CODE (return_slot) != SSA_NAME);
2595           if (gimple_in_ssa_p (cfun))
2596             {
2597               HOST_WIDE_INT bitsize;
2598               HOST_WIDE_INT bitpos;
2599               tree offset;
2600               enum machine_mode mode;
2601               int unsignedp;
2602               int volatilep;
2603               tree base;
2604               base = get_inner_reference (return_slot, &bitsize, &bitpos,
2605                                           &offset,
2606                                           &mode, &unsignedp, &volatilep,
2607                                           false);
2608               if (TREE_CODE (base) == INDIRECT_REF)
2609                 base = TREE_OPERAND (base, 0);
2610               if (TREE_CODE (base) == SSA_NAME)
2611                 base = SSA_NAME_VAR (base);
2612               mark_sym_for_renaming (base);
2613             }
2614           var = return_slot_addr;
2615         }
2616       else
2617         {
2618           var = return_slot;
2619           gcc_assert (TREE_CODE (var) != SSA_NAME);
2620           TREE_ADDRESSABLE (var) |= TREE_ADDRESSABLE (result);
2621         }
2622       if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
2623            || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
2624           && !DECL_GIMPLE_REG_P (result)
2625           && DECL_P (var))
2626         DECL_GIMPLE_REG_P (var) = 0;
2627       use = NULL;
2628       goto done;
2629     }
2630
2631   /* All types requiring non-trivial constructors should have been handled.  */
2632   gcc_assert (!TREE_ADDRESSABLE (callee_type));
2633
2634   /* Attempt to avoid creating a new temporary variable.  */
2635   if (modify_dest
2636       && TREE_CODE (modify_dest) != SSA_NAME)
2637     {
2638       bool use_it = false;
2639
2640       /* We can't use MODIFY_DEST if there's type promotion involved.  */
2641       if (!useless_type_conversion_p (callee_type, caller_type))
2642         use_it = false;
2643
2644       /* ??? If we're assigning to a variable sized type, then we must
2645          reuse the destination variable, because we've no good way to
2646          create variable sized temporaries at this point.  */
2647       else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type)) != INTEGER_CST)
2648         use_it = true;
2649
2650       /* If the callee cannot possibly modify MODIFY_DEST, then we can
2651          reuse it as the result of the call directly.  Don't do this if
2652          it would promote MODIFY_DEST to addressable.  */
2653       else if (TREE_ADDRESSABLE (result))
2654         use_it = false;
2655       else
2656         {
2657           tree base_m = get_base_address (modify_dest);
2658
2659           /* If the base isn't a decl, then it's a pointer, and we don't
2660              know where that's going to go.  */
2661           if (!DECL_P (base_m))
2662             use_it = false;
2663           else if (is_global_var (base_m))
2664             use_it = false;
2665           else if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
2666                     || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
2667                    && !DECL_GIMPLE_REG_P (result)
2668                    && DECL_GIMPLE_REG_P (base_m))
2669             use_it = false;
2670           else if (!TREE_ADDRESSABLE (base_m))
2671             use_it = true;
2672         }
2673
2674       if (use_it)
2675         {
2676           var = modify_dest;
2677           use = NULL;
2678           goto done;
2679         }
2680     }
2681
2682   gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type)) == INTEGER_CST);
2683
2684   var = copy_result_decl_to_var (result, id);
2685   if (gimple_in_ssa_p (cfun))
2686     {
2687       get_var_ann (var);
2688       add_referenced_var (var);
2689     }
2690
2691   DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
2692   DECL_STRUCT_FUNCTION (caller)->local_decls
2693     = tree_cons (NULL_TREE, var,
2694                  DECL_STRUCT_FUNCTION (caller)->local_decls);
2695
2696   /* Do not have the rest of GCC warn about this variable as it should
2697      not be visible to the user.  */
2698   TREE_NO_WARNING (var) = 1;
2699
2700   declare_inline_vars (id->block, var);
2701
2702   /* Build the use expr.  If the return type of the function was
2703      promoted, convert it back to the expected type.  */
2704   use = var;
2705   if (!useless_type_conversion_p (caller_type, TREE_TYPE (var)))
2706     use = fold_convert (caller_type, var);
2707
2708   STRIP_USELESS_TYPE_CONVERSION (use);
2709
2710   if (DECL_BY_REFERENCE (result))
2711     {
2712       TREE_ADDRESSABLE (var) = 1;
2713       var = build_fold_addr_expr (var);
2714     }
2715
2716  done:
2717   /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
2718      way, when the RESULT_DECL is encountered, it will be
2719      automatically replaced by the VAR_DECL.  */
2720   insert_decl_map (id, result, var);
2721
2722   /* Remember this so we can ignore it in remap_decls.  */
2723   id->retvar = var;
2724
2725   return use;
2726 }
2727
2728 /* Callback through walk_tree.  Determine if a DECL_INITIAL makes reference
2729    to a local label.  */
2730
2731 static tree
2732 has_label_address_in_static_1 (tree *nodep, int *walk_subtrees, void *fnp)
2733 {
2734   tree node = *nodep;
2735   tree fn = (tree) fnp;
2736
2737   if (TREE_CODE (node) == LABEL_DECL && DECL_CONTEXT (node) == fn)
2738     return node;
2739
2740   if (TYPE_P (node))
2741     *walk_subtrees = 0;
2742
2743   return NULL_TREE;
2744 }
2745
2746 /* Determine if the function can be copied.  If so return NULL.  If
2747    not return a string describng the reason for failure.  */
2748
2749 static const char *
2750 copy_forbidden (struct function *fun, tree fndecl)
2751 {
2752   const char *reason = fun->cannot_be_copied_reason;
2753   tree step;
2754
2755   /* Only examine the function once.  */
2756   if (fun->cannot_be_copied_set)
2757     return reason;
2758
2759   /* We cannot copy a function that receives a non-local goto
2760      because we cannot remap the destination label used in the
2761      function that is performing the non-local goto.  */
2762   /* ??? Actually, this should be possible, if we work at it.
2763      No doubt there's just a handful of places that simply
2764      assume it doesn't happen and don't substitute properly.  */
2765   if (fun->has_nonlocal_label)
2766     {
2767       reason = G_("function %q+F can never be copied "
2768                   "because it receives a non-local goto");
2769       goto fail;
2770     }
2771
2772   for (step = fun->local_decls; step; step = TREE_CHAIN (step))
2773     {
2774       tree decl = TREE_VALUE (step);
2775
2776       if (TREE_CODE (decl) == VAR_DECL
2777           && TREE_STATIC (decl)
2778           && !DECL_EXTERNAL (decl)
2779           && DECL_INITIAL (decl)
2780           && walk_tree_without_duplicates (&DECL_INITIAL (decl),
2781                                            has_label_address_in_static_1,
2782                                            fndecl))
2783         {
2784           reason = G_("function %q+F can never be copied because it saves "
2785                       "address of local label in a static variable");
2786           goto fail;
2787         }
2788     }
2789
2790  fail:
2791   fun->cannot_be_copied_reason = reason;
2792   fun->cannot_be_copied_set = true;
2793   return reason;
2794 }
2795
2796
2797 static const char *inline_forbidden_reason;
2798
2799 /* A callback for walk_gimple_seq to handle statements.  Returns non-null
2800    iff a function can not be inlined.  Also sets the reason why. */
2801
2802 static tree
2803 inline_forbidden_p_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
2804                          struct walk_stmt_info *wip)
2805 {
2806   tree fn = (tree) wip->info;
2807   tree t;
2808   gimple stmt = gsi_stmt (*gsi);
2809
2810   switch (gimple_code (stmt))
2811     {
2812     case GIMPLE_CALL:
2813       /* Refuse to inline alloca call unless user explicitly forced so as
2814          this may change program's memory overhead drastically when the
2815          function using alloca is called in loop.  In GCC present in
2816          SPEC2000 inlining into schedule_block cause it to require 2GB of
2817          RAM instead of 256MB.  */
2818       if (gimple_alloca_call_p (stmt)
2819           && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
2820         {
2821           inline_forbidden_reason
2822             = G_("function %q+F can never be inlined because it uses "
2823                  "alloca (override using the always_inline attribute)");
2824           *handled_ops_p = true;
2825           return fn;
2826         }
2827
2828       t = gimple_call_fndecl (stmt);
2829       if (t == NULL_TREE)
2830         break;
2831
2832       /* We cannot inline functions that call setjmp.  */
2833       if (setjmp_call_p (t))
2834         {
2835           inline_forbidden_reason
2836             = G_("function %q+F can never be inlined because it uses setjmp");
2837           *handled_ops_p = true;
2838           return t;
2839         }
2840
2841       if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL)
2842         switch (DECL_FUNCTION_CODE (t))
2843           {
2844             /* We cannot inline functions that take a variable number of
2845                arguments.  */
2846           case BUILT_IN_VA_START:
2847           case BUILT_IN_NEXT_ARG:
2848           case BUILT_IN_VA_END:
2849             inline_forbidden_reason
2850               = G_("function %q+F can never be inlined because it "
2851                    "uses variable argument lists");
2852             *handled_ops_p = true;
2853             return t;
2854
2855           case BUILT_IN_LONGJMP:
2856             /* We can't inline functions that call __builtin_longjmp at
2857                all.  The non-local goto machinery really requires the
2858                destination be in a different function.  If we allow the
2859                function calling __builtin_longjmp to be inlined into the
2860                function calling __builtin_setjmp, Things will Go Awry.  */
2861             inline_forbidden_reason
2862               = G_("function %q+F can never be inlined because "
2863                    "it uses setjmp-longjmp exception handling");
2864             *handled_ops_p = true;
2865             return t;
2866
2867           case BUILT_IN_NONLOCAL_GOTO:
2868             /* Similarly.  */
2869             inline_forbidden_reason
2870               = G_("function %q+F can never be inlined because "
2871                    "it uses non-local goto");
2872             *handled_ops_p = true;
2873             return t;
2874
2875           case BUILT_IN_RETURN:
2876           case BUILT_IN_APPLY_ARGS:
2877             /* If a __builtin_apply_args caller would be inlined,
2878                it would be saving arguments of the function it has
2879                been inlined into.  Similarly __builtin_return would
2880                return from the function the inline has been inlined into.  */
2881             inline_forbidden_reason
2882               = G_("function %q+F can never be inlined because "
2883                    "it uses __builtin_return or __builtin_apply_args");
2884             *handled_ops_p = true;
2885             return t;
2886
2887           default:
2888             break;
2889           }
2890       break;
2891
2892     case GIMPLE_GOTO:
2893       t = gimple_goto_dest (stmt);
2894
2895       /* We will not inline a function which uses computed goto.  The
2896          addresses of its local labels, which may be tucked into
2897          global storage, are of course not constant across
2898          instantiations, which causes unexpected behavior.  */
2899       if (TREE_CODE (t) != LABEL_DECL)
2900         {
2901           inline_forbidden_reason
2902             = G_("function %q+F can never be inlined "
2903                  "because it contains a computed goto");
2904           *handled_ops_p = true;
2905           return t;
2906         }
2907       break;
2908
2909     default:
2910       break;
2911     }
2912
2913   *handled_ops_p = false;
2914   return NULL_TREE;
2915 }
2916
2917 /* Return true if FNDECL is a function that cannot be inlined into
2918    another one.  */
2919
2920 static bool
2921 inline_forbidden_p (tree fndecl)
2922 {
2923   struct function *fun = DECL_STRUCT_FUNCTION (fndecl);
2924   struct walk_stmt_info wi;
2925   struct pointer_set_t *visited_nodes;
2926   basic_block bb;
2927   bool forbidden_p = false;
2928
2929   /* First check for shared reasons not to copy the code.  */
2930   inline_forbidden_reason = copy_forbidden (fun, fndecl);
2931   if (inline_forbidden_reason != NULL)
2932     return true;
2933
2934   /* Next, walk the statements of the function looking for
2935      constraucts we can't handle, or are non-optimal for inlining.  */
2936   visited_nodes = pointer_set_create ();
2937   memset (&wi, 0, sizeof (wi));
2938   wi.info = (void *) fndecl;
2939   wi.pset = visited_nodes;
2940
2941   FOR_EACH_BB_FN (bb, fun)
2942     {
2943       gimple ret;
2944       gimple_seq seq = bb_seq (bb);
2945       ret = walk_gimple_seq (seq, inline_forbidden_p_stmt, NULL, &wi);
2946       forbidden_p = (ret != NULL);
2947       if (forbidden_p)
2948         break;
2949     }
2950
2951   pointer_set_destroy (visited_nodes);
2952   return forbidden_p;
2953 }
2954
2955 /* Returns nonzero if FN is a function that does not have any
2956    fundamental inline blocking properties.  */
2957
2958 bool
2959 tree_inlinable_function_p (tree fn)
2960 {
2961   bool inlinable = true;
2962   bool do_warning;
2963   tree always_inline;
2964
2965   /* If we've already decided this function shouldn't be inlined,
2966      there's no need to check again.  */
2967   if (DECL_UNINLINABLE (fn))
2968     return false;
2969
2970   /* We only warn for functions declared `inline' by the user.  */
2971   do_warning = (warn_inline
2972                 && DECL_DECLARED_INLINE_P (fn)
2973                 && !DECL_NO_INLINE_WARNING_P (fn)
2974                 && !DECL_IN_SYSTEM_HEADER (fn));
2975
2976   always_inline = lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn));
2977
2978   if (flag_no_inline
2979       && always_inline == NULL)
2980     {
2981       if (do_warning)
2982         warning (OPT_Winline, "function %q+F can never be inlined because it "
2983                  "is suppressed using -fno-inline", fn);
2984       inlinable = false;
2985     }
2986
2987   /* Don't auto-inline anything that might not be bound within
2988      this unit of translation.  */
2989   else if (!DECL_DECLARED_INLINE_P (fn)
2990            && DECL_REPLACEABLE_P (fn))
2991     inlinable = false;
2992
2993   else if (!function_attribute_inlinable_p (fn))
2994     {
2995       if (do_warning)
2996         warning (OPT_Winline, "function %q+F can never be inlined because it "
2997                  "uses attributes conflicting with inlining", fn);
2998       inlinable = false;
2999     }
3000
3001   else if (inline_forbidden_p (fn))
3002     {
3003       /* See if we should warn about uninlinable functions.  Previously,
3004          some of these warnings would be issued while trying to expand
3005          the function inline, but that would cause multiple warnings
3006          about functions that would for example call alloca.  But since
3007          this a property of the function, just one warning is enough.
3008          As a bonus we can now give more details about the reason why a
3009          function is not inlinable.  */
3010       if (always_inline)
3011         sorry (inline_forbidden_reason, fn);
3012       else if (do_warning)
3013         warning (OPT_Winline, inline_forbidden_reason, fn);
3014
3015       inlinable = false;
3016     }
3017
3018   /* Squirrel away the result so that we don't have to check again.  */
3019   DECL_UNINLINABLE (fn) = !inlinable;
3020
3021   return inlinable;
3022 }
3023
3024 /* Estimate the cost of a memory move.  Use machine dependent
3025    word size and take possible memcpy call into account.  */
3026
3027 int
3028 estimate_move_cost (tree type)
3029 {
3030   HOST_WIDE_INT size;
3031
3032   gcc_assert (!VOID_TYPE_P (type));
3033
3034   size = int_size_in_bytes (type);
3035
3036   if (size < 0 || size > MOVE_MAX_PIECES * MOVE_RATIO (!optimize_size))
3037     /* Cost of a memcpy call, 3 arguments and the call.  */
3038     return 4;
3039   else
3040     return ((size + MOVE_MAX_PIECES - 1) / MOVE_MAX_PIECES);
3041 }
3042
3043 /* Returns cost of operation CODE, according to WEIGHTS  */
3044
3045 static int
3046 estimate_operator_cost (enum tree_code code, eni_weights *weights,
3047                         tree op1 ATTRIBUTE_UNUSED, tree op2)
3048 {
3049   switch (code)
3050     {
3051     /* These are "free" conversions, or their presumed cost
3052        is folded into other operations.  */
3053     case RANGE_EXPR:
3054     CASE_CONVERT:
3055     case COMPLEX_EXPR:
3056     case PAREN_EXPR:
3057       return 0;
3058
3059     /* Assign cost of 1 to usual operations.
3060        ??? We may consider mapping RTL costs to this.  */
3061     case COND_EXPR:
3062     case VEC_COND_EXPR:
3063
3064     case PLUS_EXPR:
3065     case POINTER_PLUS_EXPR:
3066     case MINUS_EXPR:
3067     case MULT_EXPR:
3068
3069     case ADDR_SPACE_CONVERT_EXPR:
3070     case FIXED_CONVERT_EXPR:
3071     case FIX_TRUNC_EXPR:
3072
3073     case NEGATE_EXPR:
3074     case FLOAT_EXPR:
3075     case MIN_EXPR:
3076     case MAX_EXPR:
3077     case ABS_EXPR:
3078
3079     case LSHIFT_EXPR:
3080     case RSHIFT_EXPR:
3081     case LROTATE_EXPR:
3082     case RROTATE_EXPR:
3083     case VEC_LSHIFT_EXPR:
3084     case VEC_RSHIFT_EXPR:
3085
3086     case BIT_IOR_EXPR:
3087     case BIT_XOR_EXPR:
3088     case BIT_AND_EXPR:
3089     case BIT_NOT_EXPR:
3090
3091     case TRUTH_ANDIF_EXPR:
3092     case TRUTH_ORIF_EXPR:
3093     case TRUTH_AND_EXPR:
3094     case TRUTH_OR_EXPR:
3095     case TRUTH_XOR_EXPR:
3096     case TRUTH_NOT_EXPR:
3097
3098     case LT_EXPR:
3099     case LE_EXPR:
3100     case GT_EXPR:
3101     case GE_EXPR:
3102     case EQ_EXPR:
3103     case NE_EXPR:
3104     case ORDERED_EXPR:
3105     case UNORDERED_EXPR:
3106
3107     case UNLT_EXPR:
3108     case UNLE_EXPR:
3109     case UNGT_EXPR:
3110     case UNGE_EXPR:
3111     case UNEQ_EXPR:
3112     case LTGT_EXPR:
3113
3114     case CONJ_EXPR:
3115
3116     case PREDECREMENT_EXPR:
3117     case PREINCREMENT_EXPR:
3118     case POSTDECREMENT_EXPR:
3119     case POSTINCREMENT_EXPR:
3120
3121     case REALIGN_LOAD_EXPR:
3122
3123     case REDUC_MAX_EXPR:
3124     case REDUC_MIN_EXPR:
3125     case REDUC_PLUS_EXPR:
3126     case WIDEN_SUM_EXPR:
3127     case WIDEN_MULT_EXPR:
3128     case DOT_PROD_EXPR:
3129
3130     case VEC_WIDEN_MULT_HI_EXPR:
3131     case VEC_WIDEN_MULT_LO_EXPR:
3132     case VEC_UNPACK_HI_EXPR:
3133     case VEC_UNPACK_LO_EXPR:
3134     case VEC_UNPACK_FLOAT_HI_EXPR:
3135     case VEC_UNPACK_FLOAT_LO_EXPR:
3136     case VEC_PACK_TRUNC_EXPR:
3137     case VEC_PACK_SAT_EXPR:
3138     case VEC_PACK_FIX_TRUNC_EXPR:
3139     case VEC_EXTRACT_EVEN_EXPR:
3140     case VEC_EXTRACT_ODD_EXPR:
3141     case VEC_INTERLEAVE_HIGH_EXPR:
3142     case VEC_INTERLEAVE_LOW_EXPR:
3143
3144       return 1;
3145
3146     /* Few special cases of expensive operations.  This is useful
3147        to avoid inlining on functions having too many of these.  */
3148     case TRUNC_DIV_EXPR:
3149     case CEIL_DIV_EXPR:
3150     case FLOOR_DIV_EXPR:
3151     case ROUND_DIV_EXPR:
3152     case EXACT_DIV_EXPR:
3153     case TRUNC_MOD_EXPR:
3154     case CEIL_MOD_EXPR:
3155     case FLOOR_MOD_EXPR:
3156     case ROUND_MOD_EXPR:
3157     case RDIV_EXPR:
3158       if (TREE_CODE (op2) != INTEGER_CST)
3159         return weights->div_mod_cost;
3160       return 1;
3161
3162     default:
3163       /* We expect a copy assignment with no operator.  */
3164       gcc_assert (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS);
3165       return 0;
3166     }
3167 }
3168
3169
3170 /* Estimate number of instructions that will be created by expanding
3171    the statements in the statement sequence STMTS.
3172    WEIGHTS contains weights attributed to various constructs.  */
3173
3174 static
3175 int estimate_num_insns_seq (gimple_seq stmts, eni_weights *weights)
3176 {
3177   int cost;
3178   gimple_stmt_iterator gsi;
3179
3180   cost = 0;
3181   for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
3182     cost += estimate_num_insns (gsi_stmt (gsi), weights);
3183
3184   return cost;
3185 }
3186
3187
3188 /* Estimate number of instructions that will be created by expanding STMT.
3189    WEIGHTS contains weights attributed to various constructs.  */
3190
3191 int
3192 estimate_num_insns (gimple stmt, eni_weights *weights)
3193 {
3194   unsigned cost, i;
3195   enum gimple_code code = gimple_code (stmt);
3196   tree lhs;
3197   tree rhs;
3198
3199   switch (code)
3200     {
3201     case GIMPLE_ASSIGN:
3202       /* Try to estimate the cost of assignments.  We have three cases to
3203          deal with:
3204          1) Simple assignments to registers;
3205          2) Stores to things that must live in memory.  This includes
3206             "normal" stores to scalars, but also assignments of large
3207             structures, or constructors of big arrays;
3208
3209          Let us look at the first two cases, assuming we have "a = b + C":
3210          <GIMPLE_ASSIGN <var_decl "a">
3211                 <plus_expr <var_decl "b"> <constant C>>
3212          If "a" is a GIMPLE register, the assignment to it is free on almost
3213          any target, because "a" usually ends up in a real register.  Hence
3214          the only cost of this expression comes from the PLUS_EXPR, and we
3215          can ignore the GIMPLE_ASSIGN.
3216          If "a" is not a GIMPLE register, the assignment to "a" will most
3217          likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost
3218          of moving something into "a", which we compute using the function
3219          estimate_move_cost.  */
3220       lhs = gimple_assign_lhs (stmt);
3221       rhs = gimple_assign_rhs1 (stmt);
3222
3223       if (is_gimple_reg (lhs))
3224         cost = 0;
3225       else
3226         cost = estimate_move_cost (TREE_TYPE (lhs));
3227
3228       if (!is_gimple_reg (rhs) && !is_gimple_min_invariant (rhs))
3229         cost += estimate_move_cost (TREE_TYPE (rhs));
3230
3231       cost += estimate_operator_cost (gimple_assign_rhs_code (stmt), weights,
3232                                       gimple_assign_rhs1 (stmt),
3233                                       get_gimple_rhs_class (gimple_assign_rhs_code (stmt))
3234                                       == GIMPLE_BINARY_RHS
3235                                       ? gimple_assign_rhs2 (stmt) : NULL);
3236       break;
3237
3238     case GIMPLE_COND:
3239       cost = 1 + estimate_operator_cost (gimple_cond_code (stmt), weights,
3240                                          gimple_op (stmt, 0),
3241                                          gimple_op (stmt, 1));
3242       break;
3243
3244     case GIMPLE_SWITCH:
3245       /* Take into account cost of the switch + guess 2 conditional jumps for
3246          each case label.
3247
3248          TODO: once the switch expansion logic is sufficiently separated, we can
3249          do better job on estimating cost of the switch.  */
3250       if (weights->time_based)
3251         cost = floor_log2 (gimple_switch_num_labels (stmt)) * 2;
3252       else
3253         cost = gimple_switch_num_labels (stmt) * 2;
3254       break;
3255
3256     case GIMPLE_CALL:
3257       {
3258         tree decl = gimple_call_fndecl (stmt);
3259         tree addr = gimple_call_fn (stmt);
3260         tree funtype = TREE_TYPE (addr);
3261
3262         if (POINTER_TYPE_P (funtype))
3263           funtype = TREE_TYPE (funtype);
3264
3265         if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD)
3266           cost = weights->target_builtin_call_cost;
3267         else
3268           cost = weights->call_cost;
3269
3270         if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
3271           switch (DECL_FUNCTION_CODE (decl))
3272             {
3273             case BUILT_IN_CONSTANT_P:
3274               return 0;
3275             case BUILT_IN_EXPECT:
3276               return 0;
3277
3278             /* Prefetch instruction is not expensive.  */
3279             case BUILT_IN_PREFETCH:
3280               cost = weights->target_builtin_call_cost;
3281               break;
3282
3283             /* Exception state returns or moves registers around.  */
3284             case BUILT_IN_EH_FILTER:
3285             case BUILT_IN_EH_POINTER:
3286             case BUILT_IN_EH_COPY_VALUES:
3287               return 0;
3288
3289             default:
3290               break;
3291             }
3292
3293         if (decl)
3294           funtype = TREE_TYPE (decl);
3295
3296         if (!VOID_TYPE_P (TREE_TYPE (funtype)))
3297           cost += estimate_move_cost (TREE_TYPE (funtype));
3298         /* Our cost must be kept in sync with
3299            cgraph_estimate_size_after_inlining that does use function
3300            declaration to figure out the arguments.  */
3301         if (decl && DECL_ARGUMENTS (decl))
3302           {
3303             tree arg;
3304             for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg))
3305               if (!VOID_TYPE_P (TREE_TYPE (arg)))
3306                 cost += estimate_move_cost (TREE_TYPE (arg));
3307           }
3308         else if (funtype && prototype_p (funtype))
3309           {
3310             tree t;
3311             for (t = TYPE_ARG_TYPES (funtype); t && t != void_list_node;
3312                  t = TREE_CHAIN (t))
3313               if (!VOID_TYPE_P (TREE_VALUE (t)))
3314                 cost += estimate_move_cost (TREE_VALUE (t));
3315           }
3316         else
3317           {
3318             for (i = 0; i < gimple_call_num_args (stmt); i++)
3319               {
3320                 tree arg = gimple_call_arg (stmt, i);
3321                 if (!VOID_TYPE_P (TREE_TYPE (arg)))
3322                   cost += estimate_move_cost (TREE_TYPE (arg));
3323               }
3324           }
3325
3326         break;
3327       }
3328
3329     case GIMPLE_GOTO:
3330     case GIMPLE_LABEL:
3331     case GIMPLE_NOP:
3332     case GIMPLE_PHI:
3333     case GIMPLE_RETURN:
3334     case GIMPLE_PREDICT:
3335     case GIMPLE_DEBUG:
3336       return 0;
3337
3338     case GIMPLE_ASM:
3339       return asm_str_count (gimple_asm_string (stmt));
3340
3341     case GIMPLE_RESX:
3342       /* This is either going to be an external function call with one
3343          argument, or two register copy statements plus a goto.  */
3344       return 2;
3345
3346     case GIMPLE_EH_DISPATCH:
3347       /* ??? This is going to turn into a switch statement.  Ideally
3348          we'd have a look at the eh region and estimate the number of
3349          edges involved.  */
3350       return 10;
3351
3352     case GIMPLE_BIND:
3353       return estimate_num_insns_seq (gimple_bind_body (stmt), weights);
3354
3355     case GIMPLE_EH_FILTER:
3356       return estimate_num_insns_seq (gimple_eh_filter_failure (stmt), weights);
3357
3358     case GIMPLE_CATCH:
3359       return estimate_num_insns_seq (gimple_catch_handler (stmt), weights);
3360
3361     case GIMPLE_TRY:
3362       return (estimate_num_insns_seq (gimple_try_eval (stmt), weights)
3363               + estimate_num_insns_seq (gimple_try_cleanup (stmt), weights));
3364
3365     /* OpenMP directives are generally very expensive.  */
3366
3367     case GIMPLE_OMP_RETURN:
3368     case GIMPLE_OMP_SECTIONS_SWITCH:
3369     case GIMPLE_OMP_ATOMIC_STORE:
3370     case GIMPLE_OMP_CONTINUE:
3371       /* ...except these, which are cheap.  */
3372       return 0;
3373
3374     case GIMPLE_OMP_ATOMIC_LOAD:
3375       return weights->omp_cost;
3376
3377     case GIMPLE_OMP_FOR:
3378       return (weights->omp_cost
3379               + estimate_num_insns_seq (gimple_omp_body (stmt), weights)
3380               + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt), weights));
3381
3382     case GIMPLE_OMP_PARALLEL:
3383     case GIMPLE_OMP_TASK:
3384     case GIMPLE_OMP_CRITICAL:
3385     case GIMPLE_OMP_MASTER:
3386     case GIMPLE_OMP_ORDERED:
3387     case GIMPLE_OMP_SECTION:
3388     case GIMPLE_OMP_SECTIONS:
3389     case GIMPLE_OMP_SINGLE:
3390       return (weights->omp_cost
3391               + estimate_num_insns_seq (gimple_omp_body (stmt), weights));
3392
3393     default:
3394       gcc_unreachable ();
3395     }
3396
3397   return cost;
3398 }
3399
3400 /* Estimate number of instructions that will be created by expanding
3401    function FNDECL.  WEIGHTS contains weights attributed to various
3402    constructs.  */
3403
3404 int
3405 estimate_num_insns_fn (tree fndecl, eni_weights *weights)
3406 {
3407   struct function *my_function = DECL_STRUCT_FUNCTION (fndecl);
3408   gimple_stmt_iterator bsi;
3409   basic_block bb;
3410   int n = 0;
3411
3412   gcc_assert (my_function && my_function->cfg);
3413   FOR_EACH_BB_FN (bb, my_function)
3414     {
3415       for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
3416         n += estimate_num_insns (gsi_stmt (bsi), weights);
3417     }
3418
3419   return n;
3420 }
3421
3422
3423 /* Initializes weights used by estimate_num_insns.  */
3424
3425 void
3426 init_inline_once (void)
3427 {
3428   eni_size_weights.call_cost = 1;
3429   eni_size_weights.target_builtin_call_cost = 1;
3430   eni_size_weights.div_mod_cost = 1;
3431   eni_size_weights.omp_cost = 40;
3432   eni_size_weights.time_based = false;
3433
3434   /* Estimating time for call is difficult, since we have no idea what the
3435      called function does.  In the current uses of eni_time_weights,
3436      underestimating the cost does less harm than overestimating it, so
3437      we choose a rather small value here.  */
3438   eni_time_weights.call_cost = 10;
3439   eni_time_weights.target_builtin_call_cost = 10;
3440   eni_time_weights.div_mod_cost = 10;
3441   eni_time_weights.omp_cost = 40;
3442   eni_time_weights.time_based = true;
3443 }
3444
3445 /* Estimate the number of instructions in a gimple_seq. */
3446
3447 int
3448 count_insns_seq (gimple_seq seq, eni_weights *weights)
3449 {
3450   gimple_stmt_iterator gsi;
3451   int n = 0;
3452   for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
3453     n += estimate_num_insns (gsi_stmt (gsi), weights);
3454
3455   return n;
3456 }
3457
3458
3459 /* Install new lexical TREE_BLOCK underneath 'current_block'.  */
3460
3461 static void
3462 prepend_lexical_block (tree current_block, tree new_block)
3463 {
3464   BLOCK_CHAIN (new_block) = BLOCK_SUBBLOCKS (current_block);
3465   BLOCK_SUBBLOCKS (current_block) = new_block;
3466   BLOCK_SUPERCONTEXT (new_block) = current_block;
3467 }
3468
3469 /* Fetch callee declaration from the call graph edge going from NODE and
3470    associated with STMR call statement.  Return NULL_TREE if not found.  */
3471 static tree
3472 get_indirect_callee_fndecl (struct cgraph_node *node, gimple stmt)
3473 {
3474   struct cgraph_edge *cs;
3475
3476   cs = cgraph_edge (node, stmt);
3477   if (cs)
3478     return cs->callee->decl;
3479
3480   return NULL_TREE;
3481 }
3482
3483 /* If STMT is a GIMPLE_CALL, replace it with its inline expansion.  */
3484
3485 static bool
3486 expand_call_inline (basic_block bb, gimple stmt, copy_body_data *id)
3487 {
3488   tree use_retvar;
3489   tree fn;
3490   struct pointer_map_t *st, *dst;
3491   tree return_slot;
3492   tree modify_dest;
3493   location_t saved_location;
3494   struct cgraph_edge *cg_edge;
3495   cgraph_inline_failed_t reason;
3496   basic_block return_block;
3497   edge e;
3498   gimple_stmt_iterator gsi, stmt_gsi;
3499   bool successfully_inlined = FALSE;
3500   bool purge_dead_abnormal_edges;
3501   tree t_step;
3502   tree var;
3503
3504   /* Set input_location here so we get the right instantiation context
3505      if we call instantiate_decl from inlinable_function_p.  */
3506   saved_location = input_location;
3507   if (gimple_has_location (stmt))
3508     input_location = gimple_location (stmt);
3509
3510   /* From here on, we're only interested in CALL_EXPRs.  */
3511   if (gimple_code (stmt) != GIMPLE_CALL)
3512     goto egress;
3513
3514   /* First, see if we can figure out what function is being called.
3515      If we cannot, then there is no hope of inlining the function.  */
3516   fn = gimple_call_fndecl (stmt);
3517   if (!fn)
3518     {
3519       fn = get_indirect_callee_fndecl (id->dst_node, stmt);
3520       if (!fn)
3521         goto egress;
3522     }
3523
3524   /* Turn forward declarations into real ones.  */
3525   fn = cgraph_node (fn)->decl;
3526
3527   /* If FN is a declaration of a function in a nested scope that was
3528      globally declared inline, we don't set its DECL_INITIAL.
3529      However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
3530      C++ front-end uses it for cdtors to refer to their internal
3531      declarations, that are not real functions.  Fortunately those
3532      don't have trees to be saved, so we can tell by checking their
3533      gimple_body.  */
3534   if (!DECL_INITIAL (fn)
3535       && DECL_ABSTRACT_ORIGIN (fn)
3536       && gimple_has_body_p (DECL_ABSTRACT_ORIGIN (fn)))
3537     fn = DECL_ABSTRACT_ORIGIN (fn);
3538
3539   /* Objective C and fortran still calls tree_rest_of_compilation directly.
3540      Kill this check once this is fixed.  */
3541   if (!id->dst_node->analyzed)
3542     goto egress;
3543
3544   cg_edge = cgraph_edge (id->dst_node, stmt);
3545
3546   /* Don't inline functions with different EH personalities.  */
3547   if (DECL_FUNCTION_PERSONALITY (cg_edge->caller->decl)
3548       && DECL_FUNCTION_PERSONALITY (cg_edge->callee->decl)
3549       && (DECL_FUNCTION_PERSONALITY (cg_edge->caller->decl)
3550           != DECL_FUNCTION_PERSONALITY (cg_edge->callee->decl)))
3551     goto egress;
3552
3553   /* Don't try to inline functions that are not well-suited to
3554      inlining.  */
3555   if (!cgraph_inline_p (cg_edge, &reason))
3556     {
3557       /* If this call was originally indirect, we do not want to emit any
3558          inlining related warnings or sorry messages because there are no
3559          guarantees regarding those.  */
3560       if (cg_edge->indirect_call)
3561         goto egress;
3562
3563       if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn))
3564           /* Avoid warnings during early inline pass. */
3565           && cgraph_global_info_ready)
3566         {
3567           sorry ("inlining failed in call to %q+F: %s", fn,
3568                  cgraph_inline_failed_string (reason));
3569           sorry ("called from here");
3570         }
3571       else if (warn_inline && DECL_DECLARED_INLINE_P (fn)
3572                && !DECL_IN_SYSTEM_HEADER (fn)
3573                && reason != CIF_UNSPECIFIED
3574                && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn))
3575                /* Avoid warnings during early inline pass. */
3576                && cgraph_global_info_ready)
3577         {
3578           warning (OPT_Winline, "inlining failed in call to %q+F: %s",
3579                    fn, cgraph_inline_failed_string (reason));
3580           warning (OPT_Winline, "called from here");
3581         }
3582       goto egress;
3583     }
3584   fn = cg_edge->callee->decl;
3585
3586 #ifdef ENABLE_CHECKING
3587   if (cg_edge->callee->decl != id->dst_node->decl)
3588     verify_cgraph_node (cg_edge->callee);
3589 #endif
3590
3591   /* We will be inlining this callee.  */
3592   id->eh_lp_nr = lookup_stmt_eh_lp (stmt);
3593
3594   /* Update the callers EH personality.  */
3595   if (DECL_FUNCTION_PERSONALITY (cg_edge->callee->decl))
3596     DECL_FUNCTION_PERSONALITY (cg_edge->caller->decl)
3597       = DECL_FUNCTION_PERSONALITY (cg_edge->callee->decl);
3598
3599   /* Split the block holding the GIMPLE_CALL.  */
3600   e = split_block (bb, stmt);
3601   bb = e->src;
3602   return_block = e->dest;
3603   remove_edge (e);
3604
3605   /* split_block splits after the statement; work around this by
3606      moving the call into the second block manually.  Not pretty,
3607      but seems easier than doing the CFG manipulation by hand
3608      when the GIMPLE_CALL is in the last statement of BB.  */
3609   stmt_gsi = gsi_last_bb (bb);
3610   gsi_remove (&stmt_gsi, false);
3611
3612   /* If the GIMPLE_CALL was in the last statement of BB, it may have
3613      been the source of abnormal edges.  In this case, schedule
3614      the removal of dead abnormal edges.  */
3615   gsi = gsi_start_bb (return_block);
3616   if (gsi_end_p (gsi))
3617     {
3618       gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
3619       purge_dead_abnormal_edges = true;
3620     }
3621   else
3622     {
3623       gsi_insert_before (&gsi, stmt, GSI_NEW_STMT);
3624       purge_dead_abnormal_edges = false;
3625     }
3626
3627   stmt_gsi = gsi_start_bb (return_block);
3628
3629   /* Build a block containing code to initialize the arguments, the
3630      actual inline expansion of the body, and a label for the return
3631      statements within the function to jump to.  The type of the
3632      statement expression is the return type of the function call.  */
3633   id->block = make_node (BLOCK);
3634   BLOCK_ABSTRACT_ORIGIN (id->block) = fn;
3635   BLOCK_SOURCE_LOCATION (id->block) = input_location;
3636   prepend_lexical_block (gimple_block (stmt), id->block);
3637
3638   /* Local declarations will be replaced by their equivalents in this
3639      map.  */
3640   st = id->decl_map;
3641   id->decl_map = pointer_map_create ();
3642   dst = id->debug_map;
3643   id->debug_map = NULL;
3644
3645   /* Record the function we are about to inline.  */
3646   id->src_fn = fn;
3647   id->src_node = cg_edge->callee;
3648   id->src_cfun = DECL_STRUCT_FUNCTION (fn);
3649   id->gimple_call = stmt;
3650
3651   gcc_assert (!id->src_cfun->after_inlining);
3652
3653   id->entry_bb = bb;
3654   if (lookup_attribute ("cold", DECL_ATTRIBUTES (fn)))
3655     {
3656       gimple_stmt_iterator si = gsi_last_bb (bb);
3657       gsi_insert_after (&si, gimple_build_predict (PRED_COLD_FUNCTION,
3658                                                    NOT_TAKEN),
3659                         GSI_NEW_STMT);
3660     }
3661   initialize_inlined_parameters (id, stmt, fn, bb);
3662
3663   if (DECL_INITIAL (fn))
3664     prepend_lexical_block (id->block, remap_blocks (DECL_INITIAL (fn), id));
3665
3666   /* Return statements in the function body will be replaced by jumps
3667      to the RET_LABEL.  */
3668   gcc_assert (DECL_INITIAL (fn));
3669   gcc_assert (TREE_CODE (DECL_INITIAL (fn)) == BLOCK);
3670
3671   /* Find the LHS to which the result of this call is assigned.  */
3672   return_slot = NULL;
3673   if (gimple_call_lhs (stmt))
3674     {
3675       modify_dest = gimple_call_lhs (stmt);
3676
3677       /* The function which we are inlining might not return a value,
3678          in which case we should issue a warning that the function
3679          does not return a value.  In that case the optimizers will
3680          see that the variable to which the value is assigned was not
3681          initialized.  We do not want to issue a warning about that
3682          uninitialized variable.  */
3683       if (DECL_P (modify_dest))
3684         TREE_NO_WARNING (modify_dest) = 1;
3685
3686       if (gimple_call_return_slot_opt_p (stmt))
3687         {
3688           return_slot = modify_dest;
3689           modify_dest = NULL;
3690         }
3691     }
3692   else
3693     modify_dest = NULL;
3694
3695   /* If we are inlining a call to the C++ operator new, we don't want
3696      to use type based alias analysis on the return value.  Otherwise
3697      we may get confused if the compiler sees that the inlined new
3698      function returns a pointer which was just deleted.  See bug
3699      33407.  */
3700   if (DECL_IS_OPERATOR_NEW (fn))
3701     {
3702       return_slot = NULL;
3703       modify_dest = NULL;
3704     }
3705
3706   /* Declare the return variable for the function.  */
3707   use_retvar = declare_return_variable (id, return_slot, modify_dest);
3708
3709   /* Add local vars in this inlined callee to caller.  */
3710   t_step = id->src_cfun->local_decls;
3711   for (; t_step; t_step = TREE_CHAIN (t_step))
3712     {
3713       var = TREE_VALUE (t_step);
3714       if (TREE_STATIC (var) && !TREE_ASM_WRITTEN (var))
3715         {
3716           if (var_ann (var) && add_referenced_var (var))
3717             cfun->local_decls = tree_cons (NULL_TREE, var,
3718                                            cfun->local_decls);
3719         }
3720       else if (!can_be_nonlocal (var, id))
3721         cfun->local_decls = tree_cons (NULL_TREE, remap_decl (var, id),
3722                                        cfun->local_decls);
3723     }
3724
3725   if (dump_file && (dump_flags & TDF_DETAILS))
3726     {
3727       fprintf (dump_file, "Inlining ");
3728       print_generic_expr (dump_file, id->src_fn, 0);
3729       fprintf (dump_file, " to ");
3730       print_generic_expr (dump_file, id->dst_fn, 0);
3731       fprintf (dump_file, " with frequency %i\n", cg_edge->frequency);
3732     }
3733
3734   /* This is it.  Duplicate the callee body.  Assume callee is
3735      pre-gimplified.  Note that we must not alter the caller
3736      function in any way before this point, as this CALL_EXPR may be
3737      a self-referential call; if we're calling ourselves, we need to
3738      duplicate our body before altering anything.  */
3739   copy_body (id, bb->count,
3740              cg_edge->frequency * REG_BR_PROB_BASE / CGRAPH_FREQ_BASE,
3741              bb, return_block);
3742
3743   /* Reset the escaped solution.  */
3744   if (cfun->gimple_df)
3745     pt_solution_reset (&cfun->gimple_df->escaped);
3746
3747   /* Clean up.  */
3748   if (id->debug_map)
3749     {
3750       pointer_map_destroy (id->debug_map);
3751       id->debug_map = dst;
3752     }
3753   pointer_map_destroy (id->decl_map);
3754   id->decl_map = st;
3755
3756   /* Unlink the calls virtual operands before replacing it.  */
3757   unlink_stmt_vdef (stmt);
3758
3759   /* If the inlined function returns a result that we care about,
3760      substitute the GIMPLE_CALL with an assignment of the return
3761      variable to the LHS of the call.  That is, if STMT was
3762      'a = foo (...)', substitute the call with 'a = USE_RETVAR'.  */
3763   if (use_retvar && gimple_call_lhs (stmt))
3764     {
3765       gimple old_stmt = stmt;
3766       stmt = gimple_build_assign (gimple_call_lhs (stmt), use_retvar);
3767       gsi_replace (&stmt_gsi, stmt, false);
3768       if (gimple_in_ssa_p (cfun))
3769         mark_symbols_for_renaming (stmt);
3770       maybe_clean_or_replace_eh_stmt (old_stmt, stmt);
3771     }
3772   else
3773     {
3774       /* Handle the case of inlining a function with no return
3775          statement, which causes the return value to become undefined.  */
3776       if (gimple_call_lhs (stmt)
3777           && TREE_CODE (gimple_call_lhs (stmt)) == SSA_NAME)
3778         {
3779           tree name = gimple_call_lhs (stmt);
3780           tree var = SSA_NAME_VAR (name);
3781           tree def = gimple_default_def (cfun, var);
3782
3783           if (def)
3784             {
3785               /* If the variable is used undefined, make this name
3786                  undefined via a move.  */
3787               stmt = gimple_build_assign (gimple_call_lhs (stmt), def);
3788               gsi_replace (&stmt_gsi, stmt, true);
3789             }
3790           else
3791             {
3792               /* Otherwise make this variable undefined.  */
3793               gsi_remove (&stmt_gsi, true);
3794               set_default_def (var, name);
3795               SSA_NAME_DEF_STMT (name) = gimple_build_nop ();
3796             }
3797         }
3798       else
3799         gsi_remove (&stmt_gsi, true);
3800     }
3801
3802   if (purge_dead_abnormal_edges)
3803     gimple_purge_dead_abnormal_call_edges (return_block);
3804
3805   /* If the value of the new expression is ignored, that's OK.  We
3806      don't warn about this for CALL_EXPRs, so we shouldn't warn about
3807      the equivalent inlined version either.  */
3808   if (is_gimple_assign (stmt))
3809     {
3810       gcc_assert (gimple_assign_single_p (stmt)
3811                   || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt)));
3812       TREE_USED (gimple_assign_rhs1 (stmt)) = 1;
3813     }
3814
3815   /* Output the inlining info for this abstract function, since it has been
3816      inlined.  If we don't do this now, we can lose the information about the
3817      variables in the function when the blocks get blown away as soon as we
3818      remove the cgraph node.  */
3819   (*debug_hooks->outlining_inline_function) (cg_edge->callee->decl);
3820
3821   /* Update callgraph if needed.  */
3822   cgraph_remove_node (cg_edge->callee);
3823
3824   id->block = NULL_TREE;
3825   successfully_inlined = TRUE;
3826
3827  egress:
3828   input_location = saved_location;
3829   return successfully_inlined;
3830 }
3831
3832 /* Expand call statements reachable from STMT_P.
3833    We can only have CALL_EXPRs as the "toplevel" tree code or nested
3834    in a MODIFY_EXPR.  See tree-gimple.c:get_call_expr_in().  We can
3835    unfortunately not use that function here because we need a pointer
3836    to the CALL_EXPR, not the tree itself.  */
3837
3838 static bool
3839 gimple_expand_calls_inline (basic_block bb, copy_body_data *id)
3840 {
3841   gimple_stmt_iterator gsi;
3842
3843   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
3844     {
3845       gimple stmt = gsi_stmt (gsi);
3846
3847       if (is_gimple_call (stmt)
3848           && expand_call_inline (bb, stmt, id))
3849         return true;
3850     }
3851
3852   return false;
3853 }
3854
3855
3856 /* Walk all basic blocks created after FIRST and try to fold every statement
3857    in the STATEMENTS pointer set.  */
3858
3859 static void
3860 fold_marked_statements (int first, struct pointer_set_t *statements)
3861 {
3862   for (; first < n_basic_blocks; first++)
3863     if (BASIC_BLOCK (first))
3864       {
3865         gimple_stmt_iterator gsi;
3866
3867         for (gsi = gsi_start_bb (BASIC_BLOCK (first));
3868              !gsi_end_p (gsi);
3869              gsi_next (&gsi))
3870           if (pointer_set_contains (statements, gsi_stmt (gsi)))
3871             {
3872               gimple old_stmt = gsi_stmt (gsi);
3873               tree old_decl = is_gimple_call (old_stmt) ? gimple_call_fndecl (old_stmt) : 0;
3874
3875               if (old_decl && DECL_BUILT_IN (old_decl))
3876                 {
3877                   /* Folding builtins can create multiple instructions,
3878                      we need to look at all of them.  */
3879                   gimple_stmt_iterator i2 = gsi;
3880                   gsi_prev (&i2);
3881                   if (fold_stmt (&gsi))
3882                     {
3883                       gimple new_stmt;
3884                       if (gsi_end_p (i2))
3885                         i2 = gsi_start_bb (BASIC_BLOCK (first));
3886                       else
3887                         gsi_next (&i2);
3888                       while (1)
3889                         {
3890                           new_stmt = gsi_stmt (i2);
3891                           update_stmt (new_stmt);
3892                           cgraph_update_edges_for_call_stmt (old_stmt, old_decl,
3893                                                              new_stmt);
3894
3895                           if (new_stmt == gsi_stmt (gsi))
3896                             {
3897                               /* It is okay to check only for the very last
3898                                  of these statements.  If it is a throwing
3899                                  statement nothing will change.  If it isn't
3900                                  this can remove EH edges.  If that weren't
3901                                  correct then because some intermediate stmts
3902                                  throw, but not the last one.  That would mean
3903                                  we'd have to split the block, which we can't
3904                                  here and we'd loose anyway.  And as builtins
3905                                  probably never throw, this all
3906                                  is mood anyway.  */
3907                               if (maybe_clean_or_replace_eh_stmt (old_stmt,
3908                                                                   new_stmt))
3909                                 gimple_purge_dead_eh_edges (BASIC_BLOCK (first));
3910                               break;
3911                             }
3912                           gsi_next (&i2);
3913                         }
3914                     }
3915                 }
3916               else if (fold_stmt (&gsi))
3917                 {
3918                   /* Re-read the statement from GSI as fold_stmt() may
3919                      have changed it.  */
3920                   gimple new_stmt = gsi_stmt (gsi);
3921                   update_stmt (new_stmt);
3922
3923                   if (is_gimple_call (old_stmt)
3924                       || is_gimple_call (new_stmt))
3925                     cgraph_update_edges_for_call_stmt (old_stmt, old_decl,
3926                                                        new_stmt);
3927
3928                   if (maybe_clean_or_replace_eh_stmt (old_stmt, new_stmt))
3929                     gimple_purge_dead_eh_edges (BASIC_BLOCK (first));
3930                 }
3931             }
3932       }
3933 }
3934
3935 /* Return true if BB has at least one abnormal outgoing edge.  */
3936
3937 static inline bool
3938 has_abnormal_outgoing_edge_p (basic_block bb)
3939 {
3940   edge e;
3941   edge_iterator ei;
3942
3943   FOR_EACH_EDGE (e, ei, bb->succs)
3944     if (e->flags & EDGE_ABNORMAL)
3945       return true;
3946
3947   return false;
3948 }
3949
3950 /* Expand calls to inline functions in the body of FN.  */
3951
3952 unsigned int
3953 optimize_inline_calls (tree fn)
3954 {
3955   copy_body_data id;
3956   basic_block bb;
3957   int last = n_basic_blocks;
3958   struct gimplify_ctx gctx;
3959
3960   /* There is no point in performing inlining if errors have already
3961      occurred -- and we might crash if we try to inline invalid
3962      code.  */
3963   if (errorcount || sorrycount)
3964     return 0;
3965
3966   /* Clear out ID.  */
3967   memset (&id, 0, sizeof (id));
3968
3969   id.src_node = id.dst_node = cgraph_node (fn);
3970   id.dst_fn = fn;
3971   /* Or any functions that aren't finished yet.  */
3972   if (current_function_decl)
3973     id.dst_fn = current_function_decl;
3974
3975   id.copy_decl = copy_decl_maybe_to_var;
3976   id.transform_call_graph_edges = CB_CGE_DUPLICATE;
3977   id.transform_new_cfg = false;
3978   id.transform_return_to_modify = true;
3979   id.transform_lang_insert_block = NULL;
3980   id.statements_to_fold = pointer_set_create ();
3981
3982   push_gimplify_context (&gctx);
3983
3984   /* We make no attempts to keep dominance info up-to-date.  */
3985   free_dominance_info (CDI_DOMINATORS);
3986   free_dominance_info (CDI_POST_DOMINATORS);
3987
3988   /* Register specific gimple functions.  */
3989   gimple_register_cfg_hooks ();
3990
3991   /* Reach the trees by walking over the CFG, and note the
3992      enclosing basic-blocks in the call edges.  */
3993   /* We walk the blocks going forward, because inlined function bodies
3994      will split id->current_basic_block, and the new blocks will
3995      follow it; we'll trudge through them, processing their CALL_EXPRs
3996      along the way.  */
3997   FOR_EACH_BB (bb)
3998     gimple_expand_calls_inline (bb, &id);
3999
4000   pop_gimplify_context (NULL);
4001
4002 #ifdef ENABLE_CHECKING
4003     {
4004       struct cgraph_edge *e;
4005
4006       verify_cgraph_node (id.dst_node);
4007
4008       /* Double check that we inlined everything we are supposed to inline.  */
4009       for (e = id.dst_node->callees; e; e = e->next_callee)
4010         gcc_assert (e->inline_failed);
4011     }
4012 #endif
4013
4014   /* Fold the statements before compacting/renumbering the basic blocks.  */
4015   fold_marked_statements (last, id.statements_to_fold);
4016   pointer_set_destroy (id.statements_to_fold);
4017
4018   gcc_assert (!id.debug_stmts);
4019
4020   /* Renumber the (code) basic_blocks consecutively.  */
4021   compact_blocks ();
4022   /* Renumber the lexical scoping (non-code) blocks consecutively.  */
4023   number_blocks (fn);
4024
4025   fold_cond_expr_cond ();
4026   delete_unreachable_blocks_update_callgraph (&id);
4027 #ifdef ENABLE_CHECKING
4028   verify_cgraph_node (id.dst_node);
4029 #endif
4030
4031   /* It would be nice to check SSA/CFG/statement consistency here, but it is
4032      not possible yet - the IPA passes might make various functions to not
4033      throw and they don't care to proactively update local EH info.  This is
4034      done later in fixup_cfg pass that also execute the verification.  */
4035   return (TODO_update_ssa
4036           | TODO_cleanup_cfg
4037           | (gimple_in_ssa_p (cfun) ? TODO_remove_unused_locals : 0)
4038           | (profile_status != PROFILE_ABSENT ? TODO_rebuild_frequencies : 0));
4039 }
4040
4041 /* Passed to walk_tree.  Copies the node pointed to, if appropriate.  */
4042
4043 tree
4044 copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
4045 {
4046   enum tree_code code = TREE_CODE (*tp);
4047   enum tree_code_class cl = TREE_CODE_CLASS (code);
4048
4049   /* We make copies of most nodes.  */
4050   if (IS_EXPR_CODE_CLASS (cl)
4051       || code == TREE_LIST
4052       || code == TREE_VEC
4053       || code == TYPE_DECL
4054       || code == OMP_CLAUSE)
4055     {
4056       /* Because the chain gets clobbered when we make a copy, we save it
4057          here.  */
4058       tree chain = NULL_TREE, new_tree;
4059
4060       chain = TREE_CHAIN (*tp);
4061
4062       /* Copy the node.  */
4063       new_tree = copy_node (*tp);
4064
4065       /* Propagate mudflap marked-ness.  */
4066       if (flag_mudflap && mf_marked_p (*tp))
4067         mf_mark (new_tree);
4068
4069       *tp = new_tree;
4070
4071       /* Now, restore the chain, if appropriate.  That will cause
4072          walk_tree to walk into the chain as well.  */
4073       if (code == PARM_DECL
4074           || code == TREE_LIST
4075           || code == OMP_CLAUSE)
4076         TREE_CHAIN (*tp) = chain;
4077
4078       /* For now, we don't update BLOCKs when we make copies.  So, we
4079          have to nullify all BIND_EXPRs.  */
4080       if (TREE_CODE (*tp) == BIND_EXPR)
4081         BIND_EXPR_BLOCK (*tp) = NULL_TREE;
4082     }
4083   else if (code == CONSTRUCTOR)
4084     {
4085       /* CONSTRUCTOR nodes need special handling because
4086          we need to duplicate the vector of elements.  */
4087       tree new_tree;
4088
4089       new_tree = copy_node (*tp);
4090
4091       /* Propagate mudflap marked-ness.  */
4092       if (flag_mudflap && mf_marked_p (*tp))
4093         mf_mark (new_tree);
4094
4095       CONSTRUCTOR_ELTS (new_tree) = VEC_copy (constructor_elt, gc,
4096                                          CONSTRUCTOR_ELTS (*tp));
4097       *tp = new_tree;
4098     }
4099   else if (TREE_CODE_CLASS (code) == tcc_type)
4100     *walk_subtrees = 0;
4101   else if (TREE_CODE_CLASS (code) == tcc_declaration)
4102     *walk_subtrees = 0;
4103   else if (TREE_CODE_CLASS (code) == tcc_constant)
4104     *walk_subtrees = 0;
4105   else
4106     gcc_assert (code != STATEMENT_LIST);
4107   return NULL_TREE;
4108 }
4109
4110 /* The SAVE_EXPR pointed to by TP is being copied.  If ST contains
4111    information indicating to what new SAVE_EXPR this one should be mapped,
4112    use that one.  Otherwise, create a new node and enter it in ST.  FN is
4113    the function into which the copy will be placed.  */
4114
4115 static void
4116 remap_save_expr (tree *tp, void *st_, int *walk_subtrees)
4117 {
4118   struct pointer_map_t *st = (struct pointer_map_t *) st_;
4119   tree *n;
4120   tree t;
4121
4122   /* See if we already encountered this SAVE_EXPR.  */
4123   n = (tree *) pointer_map_contains (st, *tp);
4124
4125   /* If we didn't already remap this SAVE_EXPR, do so now.  */
4126   if (!n)
4127     {
4128       t = copy_node (*tp);
4129
4130       /* Remember this SAVE_EXPR.  */
4131       *pointer_map_insert (st, *tp) = t;
4132       /* Make sure we don't remap an already-remapped SAVE_EXPR.  */
4133       *pointer_map_insert (st, t) = t;
4134     }
4135   else
4136     {
4137       /* We've already walked into this SAVE_EXPR; don't do it again.  */
4138       *walk_subtrees = 0;
4139       t = *n;
4140     }
4141
4142   /* Replace this SAVE_EXPR with the copy.  */
4143   *tp = t;
4144 }
4145
4146 /* Called via walk_tree.  If *TP points to a DECL_STMT for a local label,
4147    copies the declaration and enters it in the splay_tree in DATA (which is
4148    really an `copy_body_data *').  */
4149
4150 static tree
4151 mark_local_for_remap_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
4152                         void *data)
4153 {
4154   copy_body_data *id = (copy_body_data *) data;
4155
4156   /* Don't walk into types.  */
4157   if (TYPE_P (*tp))
4158     *walk_subtrees = 0;
4159
4160   else if (TREE_CODE (*tp) == LABEL_EXPR)
4161     {
4162       tree decl = TREE_OPERAND (*tp, 0);
4163
4164       /* Copy the decl and remember the copy.  */
4165       insert_decl_map (id, decl, id->copy_decl (decl, id));
4166     }
4167
4168   return NULL_TREE;
4169 }
4170
4171 /* Perform any modifications to EXPR required when it is unsaved.  Does
4172    not recurse into EXPR's subtrees.  */
4173
4174 static void
4175 unsave_expr_1 (tree expr)
4176 {
4177   switch (TREE_CODE (expr))
4178     {
4179     case TARGET_EXPR:
4180       /* Don't mess with a TARGET_EXPR that hasn't been expanded.
4181          It's OK for this to happen if it was part of a subtree that
4182          isn't immediately expanded, such as operand 2 of another
4183          TARGET_EXPR.  */
4184       if (TREE_OPERAND (expr, 1))
4185         break;
4186
4187       TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
4188       TREE_OPERAND (expr, 3) = NULL_TREE;
4189       break;
4190
4191     default:
4192       break;
4193     }
4194 }
4195
4196 /* Called via walk_tree when an expression is unsaved.  Using the
4197    splay_tree pointed to by ST (which is really a `splay_tree'),
4198    remaps all local declarations to appropriate replacements.  */
4199
4200 static tree
4201 unsave_r (tree *tp, int *walk_subtrees, void *data)
4202 {
4203   copy_body_data *id = (copy_body_data *) data;
4204   struct pointer_map_t *st = id->decl_map;
4205   tree *n;
4206
4207   /* Only a local declaration (variable or label).  */
4208   if ((TREE_CODE (*tp) == VAR_DECL && !TREE_STATIC (*tp))
4209       || TREE_CODE (*tp) == LABEL_DECL)
4210     {
4211       /* Lookup the declaration.  */
4212       n = (tree *) pointer_map_contains (st, *tp);
4213
4214       /* If it's there, remap it.  */
4215       if (n)
4216         *tp = *n;
4217     }
4218
4219   else if (TREE_CODE (*tp) == STATEMENT_LIST)
4220     gcc_unreachable ();
4221   else if (TREE_CODE (*tp) == BIND_EXPR)
4222     copy_bind_expr (tp, walk_subtrees, id);
4223   else if (TREE_CODE (*tp) == SAVE_EXPR
4224            || TREE_CODE (*tp) == TARGET_EXPR)
4225     remap_save_expr (tp, st, walk_subtrees);
4226   else
4227     {
4228       copy_tree_r (tp, walk_subtrees, NULL);
4229
4230       /* Do whatever unsaving is required.  */
4231       unsave_expr_1 (*tp);
4232     }
4233
4234   /* Keep iterating.  */
4235   return NULL_TREE;
4236 }
4237
4238 /* Copies everything in EXPR and replaces variables, labels
4239    and SAVE_EXPRs local to EXPR.  */
4240
4241 tree
4242 unsave_expr_now (tree expr)
4243 {
4244   copy_body_data id;
4245
4246   /* There's nothing to do for NULL_TREE.  */
4247   if (expr == 0)
4248     return expr;
4249
4250   /* Set up ID.  */
4251   memset (&id, 0, sizeof (id));
4252   id.src_fn = current_function_decl;
4253   id.dst_fn = current_function_decl;
4254   id.decl_map = pointer_map_create ();
4255   id.debug_map = NULL;
4256
4257   id.copy_decl = copy_decl_no_change;
4258   id.transform_call_graph_edges = CB_CGE_DUPLICATE;
4259   id.transform_new_cfg = false;
4260   id.transform_return_to_modify = false;
4261   id.transform_lang_insert_block = NULL;
4262
4263   /* Walk the tree once to find local labels.  */
4264   walk_tree_without_duplicates (&expr, mark_local_for_remap_r, &id);
4265
4266   /* Walk the tree again, copying, remapping, and unsaving.  */
4267   walk_tree (&expr, unsave_r, &id, NULL);
4268
4269   /* Clean up.  */
4270   pointer_map_destroy (id.decl_map);
4271   if (id.debug_map)
4272     pointer_map_destroy (id.debug_map);
4273
4274   return expr;
4275 }
4276
4277 /* Called via walk_gimple_seq.  If *GSIP points to a GIMPLE_LABEL for a local
4278    label, copies the declaration and enters it in the splay_tree in DATA (which
4279    is really a 'copy_body_data *'.  */
4280
4281 static tree
4282 mark_local_labels_stmt (gimple_stmt_iterator *gsip,
4283                         bool *handled_ops_p ATTRIBUTE_UNUSED,
4284                         struct walk_stmt_info *wi)
4285 {
4286   copy_body_data *id = (copy_body_data *) wi->info;
4287   gimple stmt = gsi_stmt (*gsip);
4288
4289   if (gimple_code (stmt) == GIMPLE_LABEL)
4290     {
4291       tree decl = gimple_label_label (stmt);
4292
4293       /* Copy the decl and remember the copy.  */
4294       insert_decl_map (id, decl, id->copy_decl (decl, id));
4295     }
4296
4297   return NULL_TREE;
4298 }
4299
4300
4301 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
4302    Using the splay_tree pointed to by ST (which is really a `splay_tree'),
4303    remaps all local declarations to appropriate replacements in gimple
4304    operands. */
4305
4306 static tree
4307 replace_locals_op (tree *tp, int *walk_subtrees, void *data)
4308 {
4309   struct walk_stmt_info *wi = (struct walk_stmt_info*) data;
4310   copy_body_data *id = (copy_body_data *) wi->info;
4311   struct pointer_map_t *st = id->decl_map;
4312   tree *n;
4313   tree expr = *tp;
4314
4315   /* Only a local declaration (variable or label).  */
4316   if ((TREE_CODE (expr) == VAR_DECL
4317        && !TREE_STATIC (expr))
4318       || TREE_CODE (expr) == LABEL_DECL)
4319     {
4320       /* Lookup the declaration.  */
4321       n = (tree *) pointer_map_contains (st, expr);
4322
4323       /* If it's there, remap it.  */
4324       if (n)
4325         *tp = *n;
4326       *walk_subtrees = 0;
4327     }
4328   else if (TREE_CODE (expr) == STATEMENT_LIST
4329            || TREE_CODE (expr) == BIND_EXPR
4330            || TREE_CODE (expr) == SAVE_EXPR)
4331     gcc_unreachable ();
4332   else if (TREE_CODE (expr) == TARGET_EXPR)
4333     {
4334       /* Don't mess with a TARGET_EXPR that hasn't been expanded.
4335          It's OK for this to happen if it was part of a subtree that
4336          isn't immediately expanded, such as operand 2 of another
4337          TARGET_EXPR.  */
4338       if (!TREE_OPERAND (expr, 1))
4339         {
4340           TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
4341           TREE_OPERAND (expr, 3) = NULL_TREE;
4342         }
4343     }
4344
4345   /* Keep iterating.  */
4346   return NULL_TREE;
4347 }
4348
4349
4350 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
4351    Using the splay_tree pointed to by ST (which is really a `splay_tree'),
4352    remaps all local declarations to appropriate replacements in gimple
4353    statements. */
4354
4355 static tree
4356 replace_locals_stmt (gimple_stmt_iterator *gsip,
4357                      bool *handled_ops_p ATTRIBUTE_UNUSED,
4358                      struct walk_stmt_info *wi)
4359 {
4360   copy_body_data *id = (copy_body_data *) wi->info;
4361   gimple stmt = gsi_stmt (*gsip);
4362
4363   if (gimple_code (stmt) == GIMPLE_BIND)
4364     {
4365       tree block = gimple_bind_block (stmt);
4366
4367       if (block)
4368         {
4369           remap_block (&block, id);
4370           gimple_bind_set_block (stmt, block);
4371         }
4372
4373       /* This will remap a lot of the same decls again, but this should be
4374          harmless.  */
4375       if (gimple_bind_vars (stmt))
4376         gimple_bind_set_vars (stmt, remap_decls (gimple_bind_vars (stmt), NULL, id));
4377     }
4378
4379   /* Keep iterating.  */
4380   return NULL_TREE;
4381 }
4382
4383
4384 /* Copies everything in SEQ and replaces variables and labels local to
4385    current_function_decl.  */
4386
4387 gimple_seq
4388 copy_gimple_seq_and_replace_locals (gimple_seq seq)
4389 {
4390   copy_body_data id;
4391   struct walk_stmt_info wi;
4392   struct pointer_set_t *visited;
4393   gimple_seq copy;
4394
4395   /* There's nothing to do for NULL_TREE.  */
4396   if (seq == NULL)
4397     return seq;
4398
4399   /* Set up ID.  */
4400   memset (&id, 0, sizeof (id));
4401   id.src_fn = current_function_decl;
4402   id.dst_fn = current_function_decl;
4403   id.decl_map = pointer_map_create ();
4404   id.debug_map = NULL;
4405
4406   id.copy_decl = copy_decl_no_change;
4407   id.transform_call_graph_edges = CB_CGE_DUPLICATE;
4408   id.transform_new_cfg = false;
4409   id.transform_return_to_modify = false;
4410   id.transform_lang_insert_block = NULL;
4411
4412   /* Walk the tree once to find local labels.  */
4413   memset (&wi, 0, sizeof (wi));
4414   visited = pointer_set_create ();
4415   wi.info = &id;
4416   wi.pset = visited;
4417   walk_gimple_seq (seq, mark_local_labels_stmt, NULL, &wi);
4418   pointer_set_destroy (visited);
4419
4420   copy = gimple_seq_copy (seq);
4421
4422   /* Walk the copy, remapping decls.  */
4423   memset (&wi, 0, sizeof (wi));
4424   wi.info = &id;
4425   walk_gimple_seq (copy, replace_locals_stmt, replace_locals_op, &wi);
4426
4427   /* Clean up.  */
4428   pointer_map_destroy (id.decl_map);
4429   if (id.debug_map)
4430     pointer_map_destroy (id.debug_map);
4431
4432   return copy;
4433 }
4434
4435
4436 /* Allow someone to determine if SEARCH is a child of TOP from gdb.  */
4437
4438 static tree
4439 debug_find_tree_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
4440 {
4441   if (*tp == data)
4442     return (tree) data;
4443   else
4444     return NULL;
4445 }
4446
4447 bool
4448 debug_find_tree (tree top, tree search)
4449 {
4450   return walk_tree_without_duplicates (&top, debug_find_tree_1, search) != 0;
4451 }
4452
4453
4454 /* Declare the variables created by the inliner.  Add all the variables in
4455    VARS to BIND_EXPR.  */
4456
4457 static void
4458 declare_inline_vars (tree block, tree vars)
4459 {
4460   tree t;
4461   for (t = vars; t; t = TREE_CHAIN (t))
4462     {
4463       DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
4464       gcc_assert (!TREE_STATIC (t) && !TREE_ASM_WRITTEN (t));
4465       cfun->local_decls = tree_cons (NULL_TREE, t, cfun->local_decls);
4466     }
4467
4468   if (block)
4469     BLOCK_VARS (block) = chainon (BLOCK_VARS (block), vars);
4470 }
4471
4472 /* Copy NODE (which must be a DECL).  The DECL originally was in the FROM_FN,
4473    but now it will be in the TO_FN.  PARM_TO_VAR means enable PARM_DECL to
4474    VAR_DECL translation.  */
4475
4476 static tree
4477 copy_decl_for_dup_finish (copy_body_data *id, tree decl, tree copy)
4478 {
4479   /* Don't generate debug information for the copy if we wouldn't have
4480      generated it for the copy either.  */
4481   DECL_ARTIFICIAL (copy) = DECL_ARTIFICIAL (decl);
4482   DECL_IGNORED_P (copy) = DECL_IGNORED_P (decl);
4483
4484   /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
4485      declaration inspired this copy.  */
4486   DECL_ABSTRACT_ORIGIN (copy) = DECL_ORIGIN (decl);
4487
4488   /* The new variable/label has no RTL, yet.  */
4489   if (CODE_CONTAINS_STRUCT (TREE_CODE (copy), TS_DECL_WRTL)
4490       && !TREE_STATIC (copy) && !DECL_EXTERNAL (copy))
4491     SET_DECL_RTL (copy, NULL_RTX);
4492
4493   /* These args would always appear unused, if not for this.  */
4494   TREE_USED (copy) = 1;
4495
4496   /* Set the context for the new declaration.  */
4497   if (!DECL_CONTEXT (decl))
4498     /* Globals stay global.  */
4499     ;
4500   else if (DECL_CONTEXT (decl) != id->src_fn)
4501     /* Things that weren't in the scope of the function we're inlining
4502        from aren't in the scope we're inlining to, either.  */
4503     ;
4504   else if (TREE_STATIC (decl))
4505     /* Function-scoped static variables should stay in the original
4506        function.  */
4507     ;
4508   else
4509     /* Ordinary automatic local variables are now in the scope of the
4510        new function.  */
4511     DECL_CONTEXT (copy) = id->dst_fn;
4512
4513   return copy;
4514 }
4515
4516 static tree
4517 copy_decl_to_var (tree decl, copy_body_data *id)
4518 {
4519   tree copy, type;
4520
4521   gcc_assert (TREE_CODE (decl) == PARM_DECL
4522               || TREE_CODE (decl) == RESULT_DECL);
4523
4524   type = TREE_TYPE (decl);
4525
4526   copy = build_decl (DECL_SOURCE_LOCATION (id->dst_fn),
4527                      VAR_DECL, DECL_NAME (decl), type);
4528   if (DECL_PT_UID_SET_P (decl))
4529     SET_DECL_PT_UID (copy, DECL_PT_UID (decl));
4530   TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl);
4531   TREE_READONLY (copy) = TREE_READONLY (decl);
4532   TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl);
4533   DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl);
4534
4535   return copy_decl_for_dup_finish (id, decl, copy);
4536 }
4537
4538 /* Like copy_decl_to_var, but create a return slot object instead of a
4539    pointer variable for return by invisible reference.  */
4540
4541 static tree
4542 copy_result_decl_to_var (tree decl, copy_body_data *id)
4543 {
4544   tree copy, type;
4545
4546   gcc_assert (TREE_CODE (decl) == PARM_DECL
4547               || TREE_CODE (decl) == RESULT_DECL);
4548
4549   type = TREE_TYPE (decl);
4550   if (DECL_BY_REFERENCE (decl))
4551     type = TREE_TYPE (type);
4552
4553   copy = build_decl (DECL_SOURCE_LOCATION (id->dst_fn),
4554                      VAR_DECL, DECL_NAME (decl), type);
4555   if (DECL_PT_UID_SET_P (decl))
4556     SET_DECL_PT_UID (copy, DECL_PT_UID (decl));
4557   TREE_READONLY (copy) = TREE_READONLY (decl);
4558   TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl);
4559   if (!DECL_BY_REFERENCE (decl))
4560     {
4561       TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl);
4562       DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl);
4563     }
4564
4565   return copy_decl_for_dup_finish (id, decl, copy);
4566 }
4567
4568 tree
4569 copy_decl_no_change (tree decl, copy_body_data *id)
4570 {
4571   tree copy;
4572
4573   copy = copy_node (decl);
4574
4575   /* The COPY is not abstract; it will be generated in DST_FN.  */
4576   DECL_ABSTRACT (copy) = 0;
4577   lang_hooks.dup_lang_specific_decl (copy);
4578
4579   /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
4580      been taken; it's for internal bookkeeping in expand_goto_internal.  */
4581   if (TREE_CODE (copy) == LABEL_DECL)
4582     {
4583       TREE_ADDRESSABLE (copy) = 0;
4584       LABEL_DECL_UID (copy) = -1;
4585     }
4586
4587   return copy_decl_for_dup_finish (id, decl, copy);
4588 }
4589
4590 static tree
4591 copy_decl_maybe_to_var (tree decl, copy_body_data *id)
4592 {
4593   if (TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL)
4594     return copy_decl_to_var (decl, id);
4595   else
4596     return copy_decl_no_change (decl, id);
4597 }
4598
4599 /* Return a copy of the function's argument tree.  */
4600 static tree
4601 copy_arguments_for_versioning (tree orig_parm, copy_body_data * id,
4602                                bitmap args_to_skip, tree *vars)
4603 {
4604   tree arg, *parg;
4605   tree new_parm = NULL;
4606   int i = 0;
4607
4608   parg = &new_parm;
4609
4610   for (arg = orig_parm; arg; arg = TREE_CHAIN (arg), i++)
4611     if (!args_to_skip || !bitmap_bit_p (args_to_skip, i))
4612       {
4613         tree new_tree = remap_decl (arg, id);
4614         lang_hooks.dup_lang_specific_decl (new_tree);
4615         *parg = new_tree;
4616         parg = &TREE_CHAIN (new_tree);
4617       }
4618     else if (!pointer_map_contains (id->decl_map, arg))
4619       {
4620         /* Make an equivalent VAR_DECL.  If the argument was used
4621            as temporary variable later in function, the uses will be
4622            replaced by local variable.  */
4623         tree var = copy_decl_to_var (arg, id);
4624         get_var_ann (var);
4625         add_referenced_var (var);
4626         insert_decl_map (id, arg, var);
4627         /* Declare this new variable.  */
4628         TREE_CHAIN (var) = *vars;
4629         *vars = var;
4630       }
4631   return new_parm;
4632 }
4633
4634 /* Return a copy of the function's static chain.  */
4635 static tree
4636 copy_static_chain (tree static_chain, copy_body_data * id)
4637 {
4638   tree *chain_copy, *pvar;
4639
4640   chain_copy = &static_chain;
4641   for (pvar = chain_copy; *pvar; pvar = &TREE_CHAIN (*pvar))
4642     {
4643       tree new_tree = remap_decl (*pvar, id);
4644       lang_hooks.dup_lang_specific_decl (new_tree);
4645       TREE_CHAIN (new_tree) = TREE_CHAIN (*pvar);
4646       *pvar = new_tree;
4647     }
4648   return static_chain;
4649 }
4650
4651 /* Return true if the function is allowed to be versioned.
4652    This is a guard for the versioning functionality.  */
4653
4654 bool
4655 tree_versionable_function_p (tree fndecl)
4656 {
4657   return (!lookup_attribute ("noclone", DECL_ATTRIBUTES (fndecl))
4658           && copy_forbidden (DECL_STRUCT_FUNCTION (fndecl), fndecl) == NULL);
4659 }
4660
4661 /* Delete all unreachable basic blocks and update callgraph.
4662    Doing so is somewhat nontrivial because we need to update all clones and
4663    remove inline function that become unreachable.  */
4664
4665 static bool
4666 delete_unreachable_blocks_update_callgraph (copy_body_data *id)
4667 {
4668   bool changed = false;
4669   basic_block b, next_bb;
4670
4671   find_unreachable_blocks ();
4672
4673   /* Delete all unreachable basic blocks.  */
4674
4675   for (b = ENTRY_BLOCK_PTR->next_bb; b != EXIT_BLOCK_PTR; b = next_bb)
4676     {
4677       next_bb = b->next_bb;
4678
4679       if (!(b->flags & BB_REACHABLE))
4680         {
4681           gimple_stmt_iterator bsi;
4682
4683           for (bsi = gsi_start_bb (b); !gsi_end_p (bsi); gsi_next (&bsi))
4684             if (gimple_code (gsi_stmt (bsi)) == GIMPLE_CALL)
4685               {
4686                 struct cgraph_edge *e;
4687                 struct cgraph_node *node;
4688
4689                 if ((e = cgraph_edge (id->dst_node, gsi_stmt (bsi))) != NULL)
4690                   {
4691                     if (!e->inline_failed)
4692                       cgraph_remove_node_and_inline_clones (e->callee);
4693                     else
4694                       cgraph_remove_edge (e);
4695                   }
4696                 if (id->transform_call_graph_edges == CB_CGE_MOVE_CLONES
4697                     && id->dst_node->clones)
4698                   for (node = id->dst_node->clones; node != id->dst_node;)
4699                     {
4700                       if ((e = cgraph_edge (node, gsi_stmt (bsi))) != NULL)
4701                         {
4702                           if (!e->inline_failed)
4703                             cgraph_remove_node_and_inline_clones (e->callee);
4704                           else
4705                             cgraph_remove_edge (e);
4706                         }
4707
4708                       if (node->clones)
4709                         node = node->clones;
4710                       else if (node->next_sibling_clone)
4711                         node = node->next_sibling_clone;
4712                       else
4713                         {
4714                           while (node != id->dst_node && !node->next_sibling_clone)
4715                             node = node->clone_of;
4716                           if (node != id->dst_node)
4717                             node = node->next_sibling_clone;
4718                         }
4719                     }
4720               }
4721           delete_basic_block (b);
4722           changed = true;
4723         }
4724     }
4725
4726   if (changed)
4727     tidy_fallthru_edges ();
4728   return changed;
4729 }
4730
4731 /* Update clone info after duplication.  */
4732
4733 static void
4734 update_clone_info (copy_body_data * id)
4735 {
4736   struct cgraph_node *node;
4737   if (!id->dst_node->clones)
4738     return;
4739   for (node = id->dst_node->clones; node != id->dst_node;)
4740     {
4741       /* First update replace maps to match the new body.  */
4742       if (node->clone.tree_map)
4743         {
4744           unsigned int i;
4745           for (i = 0; i < VEC_length (ipa_replace_map_p, node->clone.tree_map); i++)
4746             {
4747               struct ipa_replace_map *replace_info;
4748               replace_info = VEC_index (ipa_replace_map_p, node->clone.tree_map, i);
4749               walk_tree (&replace_info->old_tree, copy_tree_body_r, id, NULL);
4750               walk_tree (&replace_info->new_tree, copy_tree_body_r, id, NULL);
4751             }
4752         }
4753       if (node->clones)
4754         node = node->clones;
4755       else if (node->next_sibling_clone)
4756         node = node->next_sibling_clone;
4757       else
4758         {
4759           while (node != id->dst_node && !node->next_sibling_clone)
4760             node = node->clone_of;
4761           if (node != id->dst_node)
4762             node = node->next_sibling_clone;
4763         }
4764     }
4765 }
4766
4767 /* Create a copy of a function's tree.
4768    OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
4769    of the original function and the new copied function
4770    respectively.  In case we want to replace a DECL
4771    tree with another tree while duplicating the function's
4772    body, TREE_MAP represents the mapping between these
4773    trees. If UPDATE_CLONES is set, the call_stmt fields
4774    of edges of clones of the function will be updated.  */
4775 void
4776 tree_function_versioning (tree old_decl, tree new_decl,
4777                           VEC(ipa_replace_map_p,gc)* tree_map,
4778                           bool update_clones, bitmap args_to_skip)
4779 {
4780   struct cgraph_node *old_version_node;
4781   struct cgraph_node *new_version_node;
4782   copy_body_data id;
4783   tree p;
4784   unsigned i;
4785   struct ipa_replace_map *replace_info;
4786   basic_block old_entry_block, bb;
4787   VEC (gimple, heap) *init_stmts = VEC_alloc (gimple, heap, 10);
4788
4789   tree t_step;
4790   tree old_current_function_decl = current_function_decl;
4791   tree vars = NULL_TREE;
4792
4793   gcc_assert (TREE_CODE (old_decl) == FUNCTION_DECL
4794               && TREE_CODE (new_decl) == FUNCTION_DECL);
4795   DECL_POSSIBLY_INLINED (old_decl) = 1;
4796
4797   old_version_node = cgraph_node (old_decl);
4798   new_version_node = cgraph_node (new_decl);
4799
4800   /* Output the inlining info for this abstract function, since it has been
4801      inlined.  If we don't do this now, we can lose the information about the
4802      variables in the function when the blocks get blown away as soon as we
4803      remove the cgraph node.  */
4804   (*debug_hooks->outlining_inline_function) (old_decl);
4805
4806   DECL_ARTIFICIAL (new_decl) = 1;
4807   DECL_ABSTRACT_ORIGIN (new_decl) = DECL_ORIGIN (old_decl);
4808   DECL_FUNCTION_PERSONALITY (new_decl) = DECL_FUNCTION_PERSONALITY (old_decl);
4809
4810   /* Prepare the data structures for the tree copy.  */
4811   memset (&id, 0, sizeof (id));
4812
4813   /* Generate a new name for the new version. */
4814   id.statements_to_fold = pointer_set_create ();
4815
4816   id.decl_map = pointer_map_create ();
4817   id.debug_map = NULL;
4818   id.src_fn = old_decl;
4819   id.dst_fn = new_decl;
4820   id.src_node = old_version_node;
4821   id.dst_node = new_version_node;
4822   id.src_cfun = DECL_STRUCT_FUNCTION (old_decl);
4823   if (id.src_node->ipa_transforms_to_apply)
4824     {
4825       VEC(ipa_opt_pass,heap) * old_transforms_to_apply = id.dst_node->ipa_transforms_to_apply;
4826       unsigned int i;
4827
4828       id.dst_node->ipa_transforms_to_apply = VEC_copy (ipa_opt_pass, heap,
4829                                                        id.src_node->ipa_transforms_to_apply);
4830       for (i = 0; i < VEC_length (ipa_opt_pass, old_transforms_to_apply); i++)
4831         VEC_safe_push (ipa_opt_pass, heap, id.dst_node->ipa_transforms_to_apply,
4832                        VEC_index (ipa_opt_pass,
4833                                   old_transforms_to_apply,
4834                                   i));
4835     }
4836
4837   id.copy_decl = copy_decl_no_change;
4838   id.transform_call_graph_edges
4839     = update_clones ? CB_CGE_MOVE_CLONES : CB_CGE_MOVE;
4840   id.transform_new_cfg = true;
4841   id.transform_return_to_modify = false;
4842   id.transform_lang_insert_block = NULL;
4843
4844   current_function_decl = new_decl;
4845   old_entry_block = ENTRY_BLOCK_PTR_FOR_FUNCTION
4846     (DECL_STRUCT_FUNCTION (old_decl));
4847   initialize_cfun (new_decl, old_decl,
4848                    old_entry_block->count);
4849   push_cfun (DECL_STRUCT_FUNCTION (new_decl));
4850
4851   /* Copy the function's static chain.  */
4852   p = DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl;
4853   if (p)
4854     DECL_STRUCT_FUNCTION (new_decl)->static_chain_decl =
4855       copy_static_chain (DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl,
4856                          &id);
4857
4858   /* If there's a tree_map, prepare for substitution.  */
4859   if (tree_map)
4860     for (i = 0; i < VEC_length (ipa_replace_map_p, tree_map); i++)
4861       {
4862         gimple init;
4863         replace_info = VEC_index (ipa_replace_map_p, tree_map, i);
4864         if (replace_info->replace_p)
4865           {
4866             tree op = replace_info->new_tree;
4867
4868             STRIP_NOPS (op);
4869
4870             if (TREE_CODE (op) == VIEW_CONVERT_EXPR)
4871               op = TREE_OPERAND (op, 0);
4872
4873             if (TREE_CODE (op) == ADDR_EXPR)
4874               {
4875                 op = TREE_OPERAND (op, 0);
4876                 while (handled_component_p (op))
4877                   op = TREE_OPERAND (op, 0);
4878                 if (TREE_CODE (op) == VAR_DECL)
4879                   add_referenced_var (op);
4880               }
4881             gcc_assert (TREE_CODE (replace_info->old_tree) == PARM_DECL);
4882             init = setup_one_parameter (&id, replace_info->old_tree,
4883                                         replace_info->new_tree, id.src_fn,
4884                                         NULL,
4885                                         &vars);
4886             if (init)
4887               VEC_safe_push (gimple, heap, init_stmts, init);
4888           }
4889       }
4890   /* Copy the function's arguments.  */
4891   if (DECL_ARGUMENTS (old_decl) != NULL_TREE)
4892     DECL_ARGUMENTS (new_decl) =
4893       copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl), &id,
4894                                      args_to_skip, &vars);
4895
4896   DECL_INITIAL (new_decl) = remap_blocks (DECL_INITIAL (id.src_fn), &id);
4897
4898   /* Renumber the lexical scoping (non-code) blocks consecutively.  */
4899   number_blocks (id.dst_fn);
4900
4901   declare_inline_vars (DECL_INITIAL (new_decl), vars);
4902
4903   if (DECL_STRUCT_FUNCTION (old_decl)->local_decls != NULL_TREE)
4904     /* Add local vars.  */
4905     for (t_step = DECL_STRUCT_FUNCTION (old_decl)->local_decls;
4906          t_step; t_step = TREE_CHAIN (t_step))
4907       {
4908         tree var = TREE_VALUE (t_step);
4909         if (TREE_STATIC (var) && !TREE_ASM_WRITTEN (var))
4910           cfun->local_decls = tree_cons (NULL_TREE, var, cfun->local_decls);
4911         else if (!can_be_nonlocal (var, &id))
4912           cfun->local_decls =
4913             tree_cons (NULL_TREE, remap_decl (var, &id),
4914                        cfun->local_decls);
4915       }
4916
4917   /* Copy the Function's body.  */
4918   copy_body (&id, old_entry_block->count, REG_BR_PROB_BASE,
4919              ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR);
4920
4921   if (DECL_RESULT (old_decl) != NULL_TREE)
4922     {
4923       tree *res_decl = &DECL_RESULT (old_decl);
4924       DECL_RESULT (new_decl) = remap_decl (*res_decl, &id);
4925       lang_hooks.dup_lang_specific_decl (DECL_RESULT (new_decl));
4926     }
4927
4928   /* Renumber the lexical scoping (non-code) blocks consecutively.  */
4929   number_blocks (new_decl);
4930
4931   /* We want to create the BB unconditionally, so that the addition of
4932      debug stmts doesn't affect BB count, which may in the end cause
4933      codegen differences.  */
4934   bb = split_edge (single_succ_edge (ENTRY_BLOCK_PTR));
4935   while (VEC_length (gimple, init_stmts))
4936     insert_init_stmt (&id, bb, VEC_pop (gimple, init_stmts));
4937   update_clone_info (&id);
4938
4939   /* Remap the nonlocal_goto_save_area, if any.  */
4940   if (cfun->nonlocal_goto_save_area)
4941     {
4942       struct walk_stmt_info wi;
4943
4944       memset (&wi, 0, sizeof (wi));
4945       wi.info = &id;
4946       walk_tree (&cfun->nonlocal_goto_save_area, remap_gimple_op_r, &wi, NULL);
4947     }
4948
4949   /* Clean up.  */
4950   pointer_map_destroy (id.decl_map);
4951   if (id.debug_map)
4952     pointer_map_destroy (id.debug_map);
4953   free_dominance_info (CDI_DOMINATORS);
4954   free_dominance_info (CDI_POST_DOMINATORS);
4955
4956   fold_marked_statements (0, id.statements_to_fold);
4957   pointer_set_destroy (id.statements_to_fold);
4958   fold_cond_expr_cond ();
4959   delete_unreachable_blocks_update_callgraph (&id);
4960   update_ssa (TODO_update_ssa);
4961   free_dominance_info (CDI_DOMINATORS);
4962   free_dominance_info (CDI_POST_DOMINATORS);
4963
4964   gcc_assert (!id.debug_stmts);
4965   VEC_free (gimple, heap, init_stmts);
4966   pop_cfun ();
4967   current_function_decl = old_current_function_decl;
4968   gcc_assert (!current_function_decl
4969               || DECL_STRUCT_FUNCTION (current_function_decl) == cfun);
4970   return;
4971 }
4972
4973 /* EXP is CALL_EXPR present in a GENERIC expression tree.  Try to integrate
4974    the callee and return the inlined body on success.  */
4975
4976 tree
4977 maybe_inline_call_in_expr (tree exp)
4978 {
4979   tree fn = get_callee_fndecl (exp);
4980
4981   /* We can only try to inline "const" functions.  */
4982   if (fn && TREE_READONLY (fn) && DECL_SAVED_TREE (fn))
4983     {
4984       struct pointer_map_t *decl_map = pointer_map_create ();
4985       call_expr_arg_iterator iter;
4986       copy_body_data id;
4987       tree param, arg, t;
4988
4989       /* Remap the parameters.  */
4990       for (param = DECL_ARGUMENTS (fn), arg = first_call_expr_arg (exp, &iter);
4991            param;
4992            param = TREE_CHAIN (param), arg = next_call_expr_arg (&iter))
4993         *pointer_map_insert (decl_map, param) = arg;
4994
4995       memset (&id, 0, sizeof (id));
4996       id.src_fn = fn;
4997       id.dst_fn = current_function_decl;
4998       id.src_cfun = DECL_STRUCT_FUNCTION (fn);
4999       id.decl_map = decl_map;
5000
5001       id.copy_decl = copy_decl_no_change;
5002       id.transform_call_graph_edges = CB_CGE_DUPLICATE;
5003       id.transform_new_cfg = false;
5004       id.transform_return_to_modify = true;
5005       id.transform_lang_insert_block = false;
5006
5007       /* Make sure not to unshare trees behind the front-end's back
5008          since front-end specific mechanisms may rely on sharing.  */
5009       id.regimplify = false;
5010       id.do_not_unshare = true;
5011
5012       /* We're not inside any EH region.  */
5013       id.eh_lp_nr = 0;
5014
5015       t = copy_tree_body (&id);
5016       pointer_map_destroy (decl_map);
5017
5018       /* We can only return something suitable for use in a GENERIC
5019          expression tree.  */
5020       if (TREE_CODE (t) == MODIFY_EXPR)
5021         return TREE_OPERAND (t, 1);
5022     }
5023
5024    return NULL_TREE;
5025 }
5026
5027 /* Duplicate a type, fields and all.  */
5028
5029 tree
5030 build_duplicate_type (tree type)
5031 {
5032   struct copy_body_data id;
5033
5034   memset (&id, 0, sizeof (id));
5035   id.src_fn = current_function_decl;
5036   id.dst_fn = current_function_decl;
5037   id.src_cfun = cfun;
5038   id.decl_map = pointer_map_create ();
5039   id.debug_map = NULL;
5040   id.copy_decl = copy_decl_no_change;
5041
5042   type = remap_type_1 (type, &id);
5043
5044   pointer_map_destroy (id.decl_map);
5045   if (id.debug_map)
5046     pointer_map_destroy (id.debug_map);
5047
5048   TYPE_CANONICAL (type) = type;
5049
5050   return type;
5051 }
5052
5053 /* Return whether it is safe to inline a function because it used different
5054    target specific options or call site actual types mismatch parameter types.
5055    E is the call edge to be checked.  */
5056 bool
5057 tree_can_inline_p (struct cgraph_edge *e)
5058 {
5059 #if 0
5060   /* This causes a regression in SPEC in that it prevents a cold function from
5061      inlining a hot function.  Perhaps this should only apply to functions
5062      that the user declares hot/cold/optimize explicitly.  */
5063
5064   /* Don't inline a function with a higher optimization level than the
5065      caller, or with different space constraints (hot/cold functions).  */
5066   tree caller_tree = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (caller);
5067   tree callee_tree = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (callee);
5068
5069   if (caller_tree != callee_tree)
5070     {
5071       struct cl_optimization *caller_opt
5072         = TREE_OPTIMIZATION ((caller_tree)
5073                              ? caller_tree
5074                              : optimization_default_node);
5075
5076       struct cl_optimization *callee_opt
5077         = TREE_OPTIMIZATION ((callee_tree)
5078                              ? callee_tree
5079                              : optimization_default_node);
5080
5081       if ((caller_opt->optimize > callee_opt->optimize)
5082           || (caller_opt->optimize_size != callee_opt->optimize_size))
5083         return false;
5084     }
5085 #endif
5086   tree caller, callee;
5087
5088   caller = e->caller->decl;
5089   callee = e->callee->decl;
5090
5091   /* We cannot inline a function that uses a different EH personality
5092      than the caller.  */
5093   if (DECL_FUNCTION_PERSONALITY (caller)
5094       && DECL_FUNCTION_PERSONALITY (callee)
5095       && (DECL_FUNCTION_PERSONALITY (caller)
5096           != DECL_FUNCTION_PERSONALITY (callee)))
5097     {
5098       e->inline_failed = CIF_UNSPECIFIED;
5099       gimple_call_set_cannot_inline (e->call_stmt, true);
5100       return false;
5101     }
5102
5103   /* Allow the backend to decide if inlining is ok.  */
5104   if (!targetm.target_option.can_inline_p (caller, callee))
5105     {
5106       e->inline_failed = CIF_TARGET_OPTION_MISMATCH;
5107       gimple_call_set_cannot_inline (e->call_stmt, true);
5108       e->call_stmt_cannot_inline_p = true;
5109       return false;
5110     }
5111
5112   if (e->call_stmt
5113       && !gimple_check_call_args (e->call_stmt))
5114     {
5115       e->inline_failed = CIF_MISMATCHED_ARGUMENTS;
5116       gimple_call_set_cannot_inline (e->call_stmt, true);
5117       e->call_stmt_cannot_inline_p = true;
5118       return false;
5119     }
5120
5121   return true;
5122 }