gcc/tree-inline.c

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