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