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