gcc/tree-inline.c

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