gcc/tree-inline.c

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