gcc/tree-inline.c

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