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