gcc/tree-inline.c

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