gcc/tree-inline.c

   1 /* Tree inlining.
   2    Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
   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 "varray.h"
  36 #include "hashtab.h"
  37 #include "langhooks.h"
  38 #include "basic-block.h"
  39 #include "tree-iterator.h"
  40 #include "cgraph.h"
  41 #include "intl.h"
  42 #include "tree-mudflap.h"
  43 #include "tree-flow.h"
  44 #include "function.h"
  45 #include "ggc.h"
  46 #include "tree-flow.h"
  47 #include "diagnostic.h"
  48 #include "except.h"
  49 #include "debug.h"
  50 #include "pointer-set.h"
  51 #include "ipa-prop.h"
  52 #include "value-prof.h"
  53 #include "tree-pass.h"
  54 #include "target.h"
  55 #include "integrate.h"
  56
  57 /* I'm not real happy about this, but we need to handle gimple and
  58    non-gimple trees.  */
  59 #include "tree-gimple.h"
  60
  61 /* Inlining, Cloning, Versioning, Parallelization
  62
  63    Inlining: a function body is duplicated, but the PARM_DECLs are
  64    remapped into VAR_DECLs, and non-void RETURN_EXPRs become
  65    GIMPLE_MODIFY_STMTs that store to a dedicated returned-value variable.
  66    The duplicated eh_region info of the copy will later be appended
  67    to the info for the caller; the eh_region info in copied throwing
  68    statements and RESX_EXPRs is adjusted accordingly.
  69
  70    Cloning: (only in C++) We have one body for a con/de/structor, and
  71    multiple function decls, each with a unique parameter list.
  72    Duplicate the body, using the given splay tree; some parameters
  73    will become constants (like 0 or 1).
  74
  75    Versioning: a function body is duplicated and the result is a new
  76    function rather than into blocks of an existing function as with
  77    inlining.  Some parameters will become constants.
  78
  79    Parallelization: a region of a function is duplicated resulting in
  80    a new function.  Variables may be replaced with complex expressions
  81    to enable shared variable semantics.
  82
  83    All of these will simultaneously lookup any callgraph edges.  If
  84    we're going to inline the duplicated function body, and the given
  85    function has some cloned callgraph nodes (one for each place this
  86    function will be inlined) those callgraph edges will be duplicated.
  87    If we're cloning the body, those callgraph edges will be
  88    updated to point into the new body.  (Note that the original
  89    callgraph node and edge list will not be altered.)
  90
  91    See the CALL_EXPR handling case in copy_body_r ().  */
  92
  93 /* 0 if we should not perform inlining.
  94    1 if we should expand functions calls inline at the tree level.
  95    2 if we should consider *all* functions to be inline
  96    candidates.  */
  97
  98 int flag_inline_trees = 0;
  99
 100 /* To Do:
 101
 102    o In order to make inlining-on-trees work, we pessimized
 103      function-local static constants.  In particular, they are now
 104      always output, even when not addressed.  Fix this by treating
 105      function-local static constants just like global static
 106      constants; the back-end already knows not to output them if they
 107      are not needed.
 108
 109    o Provide heuristics to clamp inlining of recursive template
 110      calls?  */
 111
 112
 113 /* Weights that estimate_num_insns uses for heuristics in inlining.  */
 114
 115 eni_weights eni_inlining_weights;
 116
 117 /* Weights that estimate_num_insns uses to estimate the size of the
 118    produced code.  */
 119
 120 eni_weights eni_size_weights;
 121
 122 /* Weights that estimate_num_insns uses to estimate the time necessary
 123    to execute the produced code.  */
 124
 125 eni_weights eni_time_weights;
 126
 127 /* Prototypes.  */
 128
 129 static tree declare_return_variable (copy_body_data *, tree, tree, tree *);
 130 static tree copy_generic_body (copy_body_data *);
 131 static bool inlinable_function_p (tree);
 132 static void remap_block (tree *, copy_body_data *);
 133 static tree remap_decls (tree, copy_body_data *);
 134 static void copy_bind_expr (tree *, int *, copy_body_data *);
 135 static tree mark_local_for_remap_r (tree *, int *, void *);
 136 static void unsave_expr_1 (tree);
 137 static tree unsave_r (tree *, int *, void *);
 138 static void declare_inline_vars (tree, tree);
 139 static void remap_save_expr (tree *, void *, int *);
 140 static void add_lexical_block (tree current_block, tree new_block);
 141 static tree copy_decl_to_var (tree, copy_body_data *);
 142 static tree copy_result_decl_to_var (tree, copy_body_data *);
 143 static tree copy_decl_no_change (tree, copy_body_data *);
 144 static tree copy_decl_maybe_to_var (tree, copy_body_data *);
 145
 146 /* Insert a tree->tree mapping for ID.  Despite the name suggests
 147    that the trees should be variables, it is used for more than that.  */
 148
 149 void
 150 insert_decl_map (copy_body_data *id, tree key, tree value)
 151 {
 152   *pointer_map_insert (id->decl_map, key) = value;
 153
 154   /* Always insert an identity map as well.  If we see this same new
 155      node again, we won't want to duplicate it a second time.  */
 156   if (key != value)
 157     *pointer_map_insert (id->decl_map, value) = value;
 158 }
 159
 160 /* Construct new SSA name for old NAME. ID is the inline context.  */
 161
 162 static tree
 163 remap_ssa_name (tree name, copy_body_data *id)
 164 {
 165   tree new;
 166   tree *n;
 167
 168   gcc_assert (TREE_CODE (name) == SSA_NAME);
 169
 170   n = (tree *) pointer_map_contains (id->decl_map, name);
 171   if (n)
 172     return *n;
 173
 174   /* Do not set DEF_STMT yet as statement is not copied yet. We do that
 175      in copy_bb.  */
 176   new = remap_decl (SSA_NAME_VAR (name), id);
 177   /* We might've substituted constant or another SSA_NAME for
 178      the variable.
 179
 180      Replace the SSA name representing RESULT_DECL by variable during
 181      inlining:  this saves us from need to introduce PHI node in a case
 182      return value is just partly initialized.  */
 183   if ((TREE_CODE (new) == VAR_DECL || TREE_CODE (new) == PARM_DECL)
 184       && (TREE_CODE (SSA_NAME_VAR (name)) != RESULT_DECL
 185           || !id->transform_return_to_modify))
 186     {
 187       new = make_ssa_name (new, NULL);
 188       insert_decl_map (id, name, new);
 189       SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new)
 190         = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name);
 191       TREE_TYPE (new) = TREE_TYPE (SSA_NAME_VAR (new));
 192       if (IS_EMPTY_STMT (SSA_NAME_DEF_STMT (name)))
 193         {
 194           /* By inlining function having uninitialized variable, we might
 195              extend the lifetime (variable might get reused).  This cause
 196              ICE in the case we end up extending lifetime of SSA name across
 197              abnormal edge, but also increase register presure.
 198
 199              We simply initialize all uninitialized vars by 0 except for case
 200              we are inlining to very first BB.  We can avoid this for all
 201              BBs that are not withing strongly connected regions of the CFG,
 202              but this is bit expensive to test.
 203            */
 204           if (id->entry_bb && is_gimple_reg (SSA_NAME_VAR (name))
 205               && TREE_CODE (SSA_NAME_VAR (name)) != PARM_DECL
 206               && (id->entry_bb != EDGE_SUCC (ENTRY_BLOCK_PTR, 0)->dest
 207                   || EDGE_COUNT (id->entry_bb->preds) != 1))
 208             {
 209               block_stmt_iterator bsi = bsi_last (id->entry_bb);
 210               tree init_stmt
 211                   = build_gimple_modify_stmt (new,
 212                                               fold_convert (TREE_TYPE (new),
 213                                                             integer_zero_node));
 214               bsi_insert_after (&bsi, init_stmt, BSI_NEW_STMT);
 215               SSA_NAME_DEF_STMT (new) = init_stmt;
 216               SSA_NAME_IS_DEFAULT_DEF (new) = 0;
 217             }
 218           else
 219             {
 220               SSA_NAME_DEF_STMT (new) = build_empty_stmt ();
 221               if (gimple_default_def (id->src_cfun, SSA_NAME_VAR (name)) == name)
 222                 set_default_def (SSA_NAME_VAR (new), new);
 223             }
 224         }
 225     }
 226   else
 227     insert_decl_map (id, name, new);
 228   return new;
 229 }
 230
 231 /* Remap DECL during the copying of the BLOCK tree for the function.  */
 232
 233 tree
 234 remap_decl (tree decl, copy_body_data *id)
 235 {
 236   tree *n;
 237   tree fn;
 238
 239   /* We only remap local variables in the current function.  */
 240   fn = id->src_fn;
 241
 242   /* See if we have remapped this declaration.  */
 243
 244   n = (tree *) pointer_map_contains (id->decl_map, decl);
 245
 246   /* If we didn't already have an equivalent for this declaration,
 247      create one now.  */
 248   if (!n)
 249     {
 250       /* Make a copy of the variable or label.  */
 251       tree t = id->copy_decl (decl, id);
 252
 253       /* Remember it, so that if we encounter this local entity again
 254          we can reuse this copy.  Do this early because remap_type may
 255          need this decl for TYPE_STUB_DECL.  */
 256       insert_decl_map (id, decl, t);
 257
 258       if (!DECL_P (t))
 259         return t;
 260
 261       /* Remap types, if necessary.  */
 262       TREE_TYPE (t) = remap_type (TREE_TYPE (t), id);
 263       if (TREE_CODE (t) == TYPE_DECL)
 264         DECL_ORIGINAL_TYPE (t) = remap_type (DECL_ORIGINAL_TYPE (t), id);
 265
 266       /* Remap sizes as necessary.  */
 267       walk_tree (&DECL_SIZE (t), copy_body_r, id, NULL);
 268       walk_tree (&DECL_SIZE_UNIT (t), copy_body_r, id, NULL);
 269
 270       /* If fields, do likewise for offset and qualifier.  */
 271       if (TREE_CODE (t) == FIELD_DECL)
 272         {
 273           walk_tree (&DECL_FIELD_OFFSET (t), copy_body_r, id, NULL);
 274           if (TREE_CODE (DECL_CONTEXT (t)) == QUAL_UNION_TYPE)
 275             walk_tree (&DECL_QUALIFIER (t), copy_body_r, id, NULL);
 276         }
 277
 278       if (cfun && gimple_in_ssa_p (cfun)
 279           && (TREE_CODE (t) == VAR_DECL
 280               || TREE_CODE (t) == RESULT_DECL || TREE_CODE (t) == PARM_DECL))
 281         {
 282           tree def = gimple_default_def (id->src_cfun, decl);
 283           get_var_ann (t);
 284           if (TREE_CODE (decl) != PARM_DECL && def)
 285             {
 286               tree map = remap_ssa_name (def, id);
 287               /* Watch out RESULT_DECLs whose SSA names map directly
 288                  to them.  */
 289               if (TREE_CODE (map) == SSA_NAME
 290                   && IS_EMPTY_STMT (SSA_NAME_DEF_STMT (map)))
 291                 set_default_def (t, map);
 292             }
 293           add_referenced_var (t);
 294         }
 295       return t;
 296     }
 297
 298   return unshare_expr (*n);
 299 }
 300
 301 static tree
 302 remap_type_1 (tree type, copy_body_data *id)
 303 {
 304   tree new, t;
 305
 306   /* We do need a copy.  build and register it now.  If this is a pointer or
 307      reference type, remap the designated type and make a new pointer or
 308      reference type.  */
 309   if (TREE_CODE (type) == POINTER_TYPE)
 310     {
 311       new = build_pointer_type_for_mode (remap_type (TREE_TYPE (type), id),
 312                                          TYPE_MODE (type),
 313                                          TYPE_REF_CAN_ALIAS_ALL (type));
 314       insert_decl_map (id, type, new);
 315       return new;
 316     }
 317   else if (TREE_CODE (type) == REFERENCE_TYPE)
 318     {
 319       new = build_reference_type_for_mode (remap_type (TREE_TYPE (type), id),
 320                                             TYPE_MODE (type),
 321                                             TYPE_REF_CAN_ALIAS_ALL (type));
 322       insert_decl_map (id, type, new);
 323       return new;
 324     }
 325   else
 326     new = copy_node (type);
 327
 328   insert_decl_map (id, type, new);
 329
 330   /* This is a new type, not a copy of an old type.  Need to reassociate
 331      variants.  We can handle everything except the main variant lazily.  */
 332   t = TYPE_MAIN_VARIANT (type);
 333   if (type != t)
 334     {
 335       t = remap_type (t, id);
 336       TYPE_MAIN_VARIANT (new) = t;
 337       TYPE_NEXT_VARIANT (new) = TYPE_NEXT_VARIANT (t);
 338       TYPE_NEXT_VARIANT (t) = new;
 339     }
 340   else
 341     {
 342       TYPE_MAIN_VARIANT (new) = new;
 343       TYPE_NEXT_VARIANT (new) = NULL;
 344     }
 345
 346   if (TYPE_STUB_DECL (type))
 347     TYPE_STUB_DECL (new) = remap_decl (TYPE_STUB_DECL (type), id);
 348
 349   /* Lazily create pointer and reference types.  */
 350   TYPE_POINTER_TO (new) = NULL;
 351   TYPE_REFERENCE_TO (new) = NULL;
 352
 353   switch (TREE_CODE (new))
 354     {
 355     case INTEGER_TYPE:
 356     case REAL_TYPE:
 357     case FIXED_POINT_TYPE:
 358     case ENUMERAL_TYPE:
 359     case BOOLEAN_TYPE:
 360       t = TYPE_MIN_VALUE (new);
 361       if (t && TREE_CODE (t) != INTEGER_CST)
 362         walk_tree (&TYPE_MIN_VALUE (new), copy_body_r, id, NULL);
 363
 364       t = TYPE_MAX_VALUE (new);
 365       if (t && TREE_CODE (t) != INTEGER_CST)
 366         walk_tree (&TYPE_MAX_VALUE (new), copy_body_r, id, NULL);
 367       return new;
 368
 369     case FUNCTION_TYPE:
 370       TREE_TYPE (new) = remap_type (TREE_TYPE (new), id);
 371       walk_tree (&TYPE_ARG_TYPES (new), copy_body_r, id, NULL);
 372       return new;
 373
 374     case ARRAY_TYPE:
 375       TREE_TYPE (new) = remap_type (TREE_TYPE (new), id);
 376       TYPE_DOMAIN (new) = remap_type (TYPE_DOMAIN (new), id);
 377       break;
 378
 379     case RECORD_TYPE:
 380     case UNION_TYPE:
 381     case QUAL_UNION_TYPE:
 382       {
 383         tree f, nf = NULL;
 384
 385         for (f = TYPE_FIELDS (new); f ; f = TREE_CHAIN (f))
 386           {
 387             t = remap_decl (f, id);
 388             DECL_CONTEXT (t) = new;
 389             TREE_CHAIN (t) = nf;
 390             nf = t;
 391           }
 392         TYPE_FIELDS (new) = nreverse (nf);
 393       }
 394       break;
 395
 396     case OFFSET_TYPE:
 397     default:
 398       /* Shouldn't have been thought variable sized.  */
 399       gcc_unreachable ();
 400     }
 401
 402   walk_tree (&TYPE_SIZE (new), copy_body_r, id, NULL);
 403   walk_tree (&TYPE_SIZE_UNIT (new), copy_body_r, id, NULL);
 404
 405   return new;
 406 }
 407
 408 tree
 409 remap_type (tree type, copy_body_data *id)
 410 {
 411   tree *node;
 412
 413   if (type == NULL)
 414     return type;
 415
 416   /* See if we have remapped this type.  */
 417   node = (tree *) pointer_map_contains (id->decl_map, type);
 418   if (node)
 419     return *node;
 420
 421   /* The type only needs remapping if it's variably modified.  */
 422   if (! variably_modified_type_p (type, id->src_fn))
 423     {
 424       insert_decl_map (id, type, type);
 425       return type;
 426     }
 427
 428   return remap_type_1 (type, id);
 429 }
 430
 431 static tree
 432 remap_decls (tree decls, copy_body_data *id)
 433 {
 434   tree old_var;
 435   tree new_decls = NULL_TREE;
 436
 437   /* Remap its variables.  */
 438   for (old_var = decls; old_var; old_var = TREE_CHAIN (old_var))
 439     {
 440       tree new_var;
 441
 442       /* We can not chain the local static declarations into the unexpanded_var_list
 443          as we can't duplicate them or break one decl rule.  Go ahead and link
 444          them into unexpanded_var_list.  */
 445       if (!auto_var_in_fn_p (old_var, id->src_fn)
 446           && !DECL_EXTERNAL (old_var))
 447         {
 448           cfun->unexpanded_var_list = tree_cons (NULL_TREE, old_var,
 449                                                  cfun->unexpanded_var_list);
 450           continue;
 451         }
 452
 453       /* Remap the variable.  */
 454       new_var = remap_decl (old_var, id);
 455
 456       /* If we didn't remap this variable, so we can't mess with its
 457          TREE_CHAIN.  If we remapped this variable to the return slot, it's
 458          already declared somewhere else, so don't declare it here.  */
 459       if (!new_var || new_var == id->retvar)
 460         ;
 461       else
 462         {
 463           gcc_assert (DECL_P (new_var));
 464           TREE_CHAIN (new_var) = new_decls;
 465           new_decls = new_var;
 466         }
 467     }
 468
 469   return nreverse (new_decls);
 470 }
 471
 472 /* Copy the BLOCK to contain remapped versions of the variables
 473    therein.  And hook the new block into the block-tree.  */
 474
 475 static void
 476 remap_block (tree *block, copy_body_data *id)
 477 {
 478   tree old_block;
 479   tree new_block;
 480   tree fn;
 481
 482   /* Make the new block.  */
 483   old_block = *block;
 484   new_block = make_node (BLOCK);
 485   TREE_USED (new_block) = TREE_USED (old_block);
 486   BLOCK_ABSTRACT_ORIGIN (new_block) = old_block;
 487   BLOCK_SOURCE_LOCATION (new_block) = BLOCK_SOURCE_LOCATION (old_block);
 488   *block = new_block;
 489
 490   /* Remap its variables.  */
 491   BLOCK_VARS (new_block) = remap_decls (BLOCK_VARS (old_block), id);
 492
 493   fn = id->dst_fn;
 494
 495   if (id->transform_lang_insert_block)
 496     lang_hooks.decls.insert_block (new_block);
 497
 498   /* Remember the remapped block.  */
 499   insert_decl_map (id, old_block, new_block);
 500 }
 501
 502 /* Copy the whole block tree and root it in id->block.  */
 503 static tree
 504 remap_blocks (tree block, copy_body_data *id)
 505 {
 506   tree t;
 507   tree new = block;
 508
 509   if (!block)
 510     return NULL;
 511
 512   remap_block (&new, id);
 513   gcc_assert (new != block);
 514   for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
 515     add_lexical_block (new, remap_blocks (t, id));
 516   return new;
 517 }
 518
 519 static void
 520 copy_statement_list (tree *tp)
 521 {
 522   tree_stmt_iterator oi, ni;
 523   tree new;
 524
 525   new = alloc_stmt_list ();
 526   ni = tsi_start (new);
 527   oi = tsi_start (*tp);
 528   *tp = new;
 529
 530   for (; !tsi_end_p (oi); tsi_next (&oi))
 531     tsi_link_after (&ni, tsi_stmt (oi), TSI_NEW_STMT);
 532 }
 533
 534 static void
 535 copy_bind_expr (tree *tp, int *walk_subtrees, copy_body_data *id)
 536 {
 537   tree block = BIND_EXPR_BLOCK (*tp);
 538   /* Copy (and replace) the statement.  */
 539   copy_tree_r (tp, walk_subtrees, NULL);
 540   if (block)
 541     {
 542       remap_block (&block, id);
 543       BIND_EXPR_BLOCK (*tp) = block;
 544     }
 545
 546   if (BIND_EXPR_VARS (*tp))
 547     /* This will remap a lot of the same decls again, but this should be
 548        harmless.  */
 549     BIND_EXPR_VARS (*tp) = remap_decls (BIND_EXPR_VARS (*tp), id);
 550 }
 551
 552 /* Called from copy_body_id via walk_tree.  DATA is really an
 553    `copy_body_data *'.  */
 554
 555 tree
 556 copy_body_r (tree *tp, int *walk_subtrees, void *data)
 557 {
 558   copy_body_data *id = (copy_body_data *) data;
 559   tree fn = id->src_fn;
 560   tree new_block;
 561
 562   /* Begin by recognizing trees that we'll completely rewrite for the
 563      inlining context.  Our output for these trees is completely
 564      different from out input (e.g. RETURN_EXPR is deleted, and morphs
 565      into an edge).  Further down, we'll handle trees that get
 566      duplicated and/or tweaked.  */
 567
 568   /* When requested, RETURN_EXPRs should be transformed to just the
 569      contained GIMPLE_MODIFY_STMT.  The branch semantics of the return will
 570      be handled elsewhere by manipulating the CFG rather than a statement.  */
 571   if (TREE_CODE (*tp) == RETURN_EXPR && id->transform_return_to_modify)
 572     {
 573       tree assignment = TREE_OPERAND (*tp, 0);
 574
 575       /* If we're returning something, just turn that into an
 576          assignment into the equivalent of the original RESULT_DECL.
 577          If the "assignment" is just the result decl, the result
 578          decl has already been set (e.g. a recent "foo (&result_decl,
 579          ...)"); just toss the entire RETURN_EXPR.  */
 580       if (assignment && TREE_CODE (assignment) == GIMPLE_MODIFY_STMT)
 581         {
 582           /* Replace the RETURN_EXPR with (a copy of) the
 583              GIMPLE_MODIFY_STMT hanging underneath.  */
 584           *tp = copy_node (assignment);
 585         }
 586       else /* Else the RETURN_EXPR returns no value.  */
 587         {
 588           *tp = NULL;
 589           return (tree) (void *)1;
 590         }
 591     }
 592   else if (TREE_CODE (*tp) == SSA_NAME)
 593     {
 594       *tp = remap_ssa_name (*tp, id);
 595       *walk_subtrees = 0;
 596       return NULL;
 597     }
 598
 599   /* Local variables and labels need to be replaced by equivalent
 600      variables.  We don't want to copy static variables; there's only
 601      one of those, no matter how many times we inline the containing
 602      function.  Similarly for globals from an outer function.  */
 603   else if (auto_var_in_fn_p (*tp, fn))
 604     {
 605       tree new_decl;
 606
 607       /* Remap the declaration.  */
 608       new_decl = remap_decl (*tp, id);
 609       gcc_assert (new_decl);
 610       /* Replace this variable with the copy.  */
 611       STRIP_TYPE_NOPS (new_decl);
 612       *tp = new_decl;
 613       *walk_subtrees = 0;
 614     }
 615   else if (TREE_CODE (*tp) == STATEMENT_LIST)
 616     copy_statement_list (tp);
 617   else if (TREE_CODE (*tp) == SAVE_EXPR)
 618     remap_save_expr (tp, id->decl_map, walk_subtrees);
 619   else if (TREE_CODE (*tp) == LABEL_DECL
 620            && (! DECL_CONTEXT (*tp)
 621                || decl_function_context (*tp) == id->src_fn))
 622     /* These may need to be remapped for EH handling.  */
 623     *tp = remap_decl (*tp, id);
 624   else if (TREE_CODE (*tp) == BIND_EXPR)
 625     copy_bind_expr (tp, walk_subtrees, id);
 626   /* Types may need remapping as well.  */
 627   else if (TYPE_P (*tp))
 628     *tp = remap_type (*tp, id);
 629
 630   /* If this is a constant, we have to copy the node iff the type will be
 631      remapped.  copy_tree_r will not copy a constant.  */
 632   else if (CONSTANT_CLASS_P (*tp))
 633     {
 634       tree new_type = remap_type (TREE_TYPE (*tp), id);
 635
 636       if (new_type == TREE_TYPE (*tp))
 637         *walk_subtrees = 0;
 638
 639       else if (TREE_CODE (*tp) == INTEGER_CST)
 640         *tp = build_int_cst_wide (new_type, TREE_INT_CST_LOW (*tp),
 641                                   TREE_INT_CST_HIGH (*tp));
 642       else
 643         {
 644           *tp = copy_node (*tp);
 645           TREE_TYPE (*tp) = new_type;
 646         }
 647     }
 648
 649   /* Otherwise, just copy the node.  Note that copy_tree_r already
 650      knows not to copy VAR_DECLs, etc., so this is safe.  */
 651   else
 652     {
 653       /* Here we handle trees that are not completely rewritten.
 654          First we detect some inlining-induced bogosities for
 655          discarding.  */
 656       if (TREE_CODE (*tp) == GIMPLE_MODIFY_STMT
 657           && GIMPLE_STMT_OPERAND (*tp, 0) == GIMPLE_STMT_OPERAND (*tp, 1)
 658           && (auto_var_in_fn_p (GIMPLE_STMT_OPERAND (*tp, 0), fn)))
 659         {
 660           /* Some assignments VAR = VAR; don't generate any rtl code
 661              and thus don't count as variable modification.  Avoid
 662              keeping bogosities like 0 = 0.  */
 663           tree decl = GIMPLE_STMT_OPERAND (*tp, 0), value;
 664           tree *n;
 665
 666           n = (tree *) pointer_map_contains (id->decl_map, decl);
 667           if (n)
 668             {
 669               value = *n;
 670               STRIP_TYPE_NOPS (value);
 671               if (TREE_CONSTANT (value) || TREE_READONLY_DECL_P (value))
 672                 {
 673                   *tp = build_empty_stmt ();
 674                   return copy_body_r (tp, walk_subtrees, data);
 675                 }
 676             }
 677         }
 678       else if (TREE_CODE (*tp) == INDIRECT_REF)
 679         {
 680           /* Get rid of *& from inline substitutions that can happen when a
 681              pointer argument is an ADDR_EXPR.  */
 682           tree decl = TREE_OPERAND (*tp, 0);
 683           tree *n;
 684
 685           n = (tree *) pointer_map_contains (id->decl_map, decl);
 686           if (n)
 687             {
 688               tree new;
 689               tree old;
 690               /* If we happen to get an ADDR_EXPR in n->value, strip
 691                  it manually here as we'll eventually get ADDR_EXPRs
 692                  which lie about their types pointed to.  In this case
 693                  build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
 694                  but we absolutely rely on that.  As fold_indirect_ref
 695                  does other useful transformations, try that first, though.  */
 696               tree type = TREE_TYPE (TREE_TYPE (*n));
 697               new = unshare_expr (*n);
 698               old = *tp;
 699               *tp = fold_indirect_ref_1 (type, new);
 700               if (! *tp)
 701                 {
 702                   if (TREE_CODE (new) == ADDR_EXPR)
 703                     *tp = TREE_OPERAND (new, 0);
 704                   else
 705                     {
 706                       *tp = build1 (INDIRECT_REF, type, new);
 707                       TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old);
 708                     }
 709                 }
 710               *walk_subtrees = 0;
 711               return NULL;
 712             }
 713         }
 714
 715       /* Here is the "usual case".  Copy this tree node, and then
 716          tweak some special cases.  */
 717       copy_tree_r (tp, walk_subtrees, NULL);
 718
 719       /* Global variables we didn't seen yet needs to go into referenced
 720          vars.  */
 721       if (gimple_in_ssa_p (cfun) && TREE_CODE (*tp) == VAR_DECL)
 722         add_referenced_var (*tp);
 723
 724       /* If EXPR has block defined, map it to newly constructed block.
 725          When inlining we want EXPRs without block appear in the block
 726          of function call.  */
 727       if (EXPR_P (*tp) || GIMPLE_STMT_P (*tp))
 728         {
 729           new_block = id->block;
 730           if (TREE_BLOCK (*tp))
 731             {
 732               tree *n;
 733               n = (tree *) pointer_map_contains (id->decl_map,
 734                                                  TREE_BLOCK (*tp));
 735               gcc_assert (n);
 736               new_block = *n;
 737             }
 738           TREE_BLOCK (*tp) = new_block;
 739         }
 740
 741       if (TREE_CODE (*tp) == RESX_EXPR && id->eh_region_offset)
 742         TREE_OPERAND (*tp, 0) =
 743           build_int_cst
 744             (NULL_TREE,
 745              id->eh_region_offset + TREE_INT_CST_LOW (TREE_OPERAND (*tp, 0)));
 746
 747       if (!GIMPLE_TUPLE_P (*tp) && TREE_CODE (*tp) != OMP_CLAUSE)
 748         TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id);
 749
 750       /* The copied TARGET_EXPR has never been expanded, even if the
 751          original node was expanded already.  */
 752       if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3))
 753         {
 754           TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
 755           TREE_OPERAND (*tp, 3) = NULL_TREE;
 756         }
 757
 758       /* Variable substitution need not be simple.  In particular, the
 759          INDIRECT_REF substitution above.  Make sure that TREE_CONSTANT
 760          and friends are up-to-date.  */
 761       else if (TREE_CODE (*tp) == ADDR_EXPR)
 762         {
 763           int invariant = TREE_INVARIANT (*tp);
 764           walk_tree (&TREE_OPERAND (*tp, 0), copy_body_r, id, NULL);
 765           /* Handle the case where we substituted an INDIRECT_REF
 766              into the operand of the ADDR_EXPR.  */
 767           if (TREE_CODE (TREE_OPERAND (*tp, 0)) == INDIRECT_REF)
 768             *tp = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0);
 769           else
 770             recompute_tree_invariant_for_addr_expr (*tp);
 771           /* If this used to be invariant, but is not any longer,
 772              then regimplification is probably needed.  */
 773           if (invariant && !TREE_INVARIANT (*tp))
 774             id->regimplify = true;
 775           *walk_subtrees = 0;
 776         }
 777     }
 778
 779   /* Keep iterating.  */
 780   return NULL_TREE;
 781 }
 782
 783 /* Copy basic block, scale profile accordingly.  Edges will be taken care of
 784    later  */
 785
 786 static basic_block
 787 copy_bb (copy_body_data *id, basic_block bb, int frequency_scale, int count_scale)
 788 {
 789   block_stmt_iterator bsi, copy_bsi;
 790   basic_block copy_basic_block;
 791
 792   /* create_basic_block() will append every new block to
 793      basic_block_info automatically.  */
 794   copy_basic_block = create_basic_block (NULL, (void *) 0,
 795                                          (basic_block) bb->prev_bb->aux);
 796   copy_basic_block->count = bb->count * count_scale / REG_BR_PROB_BASE;
 797
 798   /* We are going to rebuild frequencies from scratch.  These values have just
 799      small importance to drive canonicalize_loop_headers.  */
 800   copy_basic_block->frequency = ((gcov_type)bb->frequency
 801                                      * frequency_scale / REG_BR_PROB_BASE);
 802   if (copy_basic_block->frequency > BB_FREQ_MAX)
 803     copy_basic_block->frequency = BB_FREQ_MAX;
 804   copy_bsi = bsi_start (copy_basic_block);
 805
 806   for (bsi = bsi_start (bb);
 807        !bsi_end_p (bsi); bsi_next (&bsi))
 808     {
 809       tree stmt = bsi_stmt (bsi);
 810       tree orig_stmt = stmt;
 811
 812       id->regimplify = false;
 813       walk_tree (&stmt, copy_body_r, id, NULL);
 814
 815       /* RETURN_EXPR might be removed,
 816          this is signalled by making stmt pointer NULL.  */
 817       if (stmt)
 818         {
 819           tree call, decl;
 820
 821           gimple_duplicate_stmt_histograms (cfun, stmt, id->src_cfun, orig_stmt);
 822
 823           /* With return slot optimization we can end up with
 824              non-gimple (foo *)&this->m, fix that here.  */
 825           if ((TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
 826                && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) == NOP_EXPR
 827                && !is_gimple_val (TREE_OPERAND (GIMPLE_STMT_OPERAND (stmt, 1), 0)))
 828               || id->regimplify)
 829             gimplify_stmt (&stmt);
 830
 831           bsi_insert_after (&copy_bsi, stmt, BSI_NEW_STMT);
 832
 833           /* Process new statement.  gimplify_stmt possibly turned statement
 834              into multiple statements, we need to process all of them.  */
 835           while (!bsi_end_p (copy_bsi))
 836             {
 837               tree *stmtp = bsi_stmt_ptr (copy_bsi);
 838               tree stmt = *stmtp;
 839               call = get_call_expr_in (stmt);
 840
 841               if (call && CALL_EXPR_VA_ARG_PACK (call) && id->call_expr)
 842                 {
 843                   /* __builtin_va_arg_pack () should be replaced by
 844                      all arguments corresponding to ... in the caller.  */
 845                   tree p, *argarray, new_call, *call_ptr;
 846                   int nargs = call_expr_nargs (id->call_expr);
 847
 848                   for (p = DECL_ARGUMENTS (id->src_fn); p; p = TREE_CHAIN (p))
 849                     nargs--;
 850
 851                   argarray = (tree *) alloca ((nargs + call_expr_nargs (call))
 852                                               * sizeof (tree));
 853
 854                   memcpy (argarray, CALL_EXPR_ARGP (call),
 855                           call_expr_nargs (call) * sizeof (*argarray));
 856                   memcpy (argarray + call_expr_nargs (call),
 857                           CALL_EXPR_ARGP (id->call_expr)
 858                           + (call_expr_nargs (id->call_expr) - nargs),
 859                           nargs * sizeof (*argarray));
 860
 861                   new_call = build_call_array (TREE_TYPE (call),
 862                                                CALL_EXPR_FN (call),
 863                                                nargs + call_expr_nargs (call),
 864                                                argarray);
 865                   /* Copy all CALL_EXPR flags, locus and block, except
 866                      CALL_EXPR_VA_ARG_PACK flag.  */
 867                   CALL_EXPR_STATIC_CHAIN (new_call)
 868                     = CALL_EXPR_STATIC_CHAIN (call);
 869                   CALL_EXPR_TAILCALL (new_call) = CALL_EXPR_TAILCALL (call);
 870                   CALL_EXPR_RETURN_SLOT_OPT (new_call)
 871                     = CALL_EXPR_RETURN_SLOT_OPT (call);
 872                   CALL_FROM_THUNK_P (new_call) = CALL_FROM_THUNK_P (call);
 873                   CALL_CANNOT_INLINE_P (new_call)
 874                     = CALL_CANNOT_INLINE_P (call);
 875                   TREE_NOTHROW (new_call) = TREE_NOTHROW (call);
 876                   SET_EXPR_LOCUS (new_call, EXPR_LOCUS (call));
 877                   TREE_BLOCK (new_call) = TREE_BLOCK (call);
 878
 879                   call_ptr = stmtp;
 880                   if (TREE_CODE (*call_ptr) == GIMPLE_MODIFY_STMT)
 881                     call_ptr = &GIMPLE_STMT_OPERAND (*call_ptr, 1);
 882                   if (TREE_CODE (*call_ptr) == WITH_SIZE_EXPR)
 883                     call_ptr = &TREE_OPERAND (*call_ptr, 0);
 884                   gcc_assert (*call_ptr == call);
 885                   if (call_ptr == stmtp)
 886                     {
 887                       bsi_replace (&copy_bsi, new_call, true);
 888                       stmtp = bsi_stmt_ptr (copy_bsi);
 889                       stmt = *stmtp;
 890                     }
 891                   else
 892                     {
 893                       *call_ptr = new_call;
 894                       stmt = *stmtp;
 895                       update_stmt (stmt);
 896                     }
 897                 }
 898               else if (call
 899                        && id->call_expr
 900                        && (decl = get_callee_fndecl (call))
 901                        && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
 902                        && DECL_FUNCTION_CODE (decl)
 903                           == BUILT_IN_VA_ARG_PACK_LEN)
 904                 {
 905                   /* __builtin_va_arg_pack_len () should be replaced by
 906                      the number of anonymous arguments.  */
 907                   int nargs = call_expr_nargs (id->call_expr);
 908                   tree count, *call_ptr, p;
 909
 910                   for (p = DECL_ARGUMENTS (id->src_fn); p; p = TREE_CHAIN (p))
 911                     nargs--;
 912
 913                   count = build_int_cst (integer_type_node, nargs);
 914                   call_ptr = stmtp;
 915                   if (TREE_CODE (*call_ptr) == GIMPLE_MODIFY_STMT)
 916                     call_ptr = &GIMPLE_STMT_OPERAND (*call_ptr, 1);
 917                   if (TREE_CODE (*call_ptr) == WITH_SIZE_EXPR)
 918                     call_ptr = &TREE_OPERAND (*call_ptr, 0);
 919                   gcc_assert (*call_ptr == call && call_ptr != stmtp);
 920                   *call_ptr = count;
 921                   stmt = *stmtp;
 922                   update_stmt (stmt);
 923                   call = NULL_TREE;
 924                 }
 925
 926               /* Statements produced by inlining can be unfolded, especially
 927                  when we constant propagated some operands.  We can't fold
 928                  them right now for two reasons:
 929                  1) folding require SSA_NAME_DEF_STMTs to be correct
 930                  2) we can't change function calls to builtins.
 931                  So we just mark statement for later folding.  We mark
 932                  all new statements, instead just statements that has changed
 933                  by some nontrivial substitution so even statements made
 934                  foldable indirectly are updated.  If this turns out to be
 935                  expensive, copy_body can be told to watch for nontrivial
 936                  changes.  */
 937               if (id->statements_to_fold)
 938                 pointer_set_insert (id->statements_to_fold, stmt);
 939               /* We're duplicating a CALL_EXPR.  Find any corresponding
 940                  callgraph edges and update or duplicate them.  */
 941               if (call && (decl = get_callee_fndecl (call)))
 942                 {
 943                   struct cgraph_node *node;
 944                   struct cgraph_edge *edge;
 945
 946                   switch (id->transform_call_graph_edges)
 947                     {
 948                     case CB_CGE_DUPLICATE:
 949                       edge = cgraph_edge (id->src_node, orig_stmt);
 950                       if (edge)
 951                         cgraph_clone_edge (edge, id->dst_node, stmt,
 952                                            REG_BR_PROB_BASE, 1, edge->frequency, true);
 953                       break;
 954
 955                     case CB_CGE_MOVE_CLONES:
 956                       for (node = id->dst_node->next_clone;
 957                            node;
 958                            node = node->next_clone)
 959                         {
 960                           edge = cgraph_edge (node, orig_stmt);
 961                           gcc_assert (edge);
 962                           cgraph_set_call_stmt (edge, stmt);
 963                         }
 964                       /* FALLTHRU */
 965
 966                     case CB_CGE_MOVE:
 967                       edge = cgraph_edge (id->dst_node, orig_stmt);
 968                       if (edge)
 969                         cgraph_set_call_stmt (edge, stmt);
 970                       break;
 971
 972                     default:
 973                       gcc_unreachable ();
 974                     }
 975                 }
 976               /* If you think we can abort here, you are wrong.
 977                  There is no region 0 in tree land.  */
 978               gcc_assert (lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt)
 979                           != 0);
 980
 981               if (tree_could_throw_p (stmt)
 982                   /* When we are cloning for inlining, we are supposed to
 983                      construct a clone that calls precisely the same functions
 984                      as original.  However IPA optimizers might've proved
 985                      earlier some function calls as non-trapping that might
 986                      render some basic blocks dead that might become
 987                      unreachable.
 988
 989                      We can't update SSA with unreachable blocks in CFG and thus
 990                      we prevent the scenario by preserving even the "dead" eh
 991                      edges until the point they are later removed by
 992                      fixup_cfg pass.  */
 993                   || (id->transform_call_graph_edges == CB_CGE_MOVE_CLONES
 994                       && lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt) > 0))
 995                 {
 996                   int region = lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt);
 997                   /* Add an entry for the copied tree in the EH hashtable.
 998                      When cloning or versioning, use the hashtable in
 999                      cfun, and just copy the EH number.  When inlining, use the
1000                      hashtable in the caller, and adjust the region number.  */
1001                   if (region > 0)
1002                     add_stmt_to_eh_region (stmt, region + id->eh_region_offset);
1003
1004                   /* If this tree doesn't have a region associated with it,
1005                      and there is a "current region,"
1006                      then associate this tree with the current region
1007                      and add edges associated with this region.  */
1008                   if ((lookup_stmt_eh_region_fn (id->src_cfun,
1009                                                  orig_stmt) <= 0
1010                        && id->eh_region > 0)
1011                       && tree_could_throw_p (stmt))
1012                     add_stmt_to_eh_region (stmt, id->eh_region);
1013                 }
1014               if (gimple_in_ssa_p (cfun))
1015                 {
1016                    ssa_op_iter i;
1017                    tree def;
1018
1019                    find_new_referenced_vars (bsi_stmt_ptr (copy_bsi));
1020                    FOR_EACH_SSA_TREE_OPERAND (def, stmt, i, SSA_OP_DEF)
1021                     if (TREE_CODE (def) == SSA_NAME)
1022                       SSA_NAME_DEF_STMT (def) = stmt;
1023                 }
1024               bsi_next (&copy_bsi);
1025             }
1026           copy_bsi = bsi_last (copy_basic_block);
1027         }
1028     }
1029   return copy_basic_block;
1030 }
1031
1032 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
1033    form is quite easy, since dominator relationship for old basic blocks does
1034    not change.
1035
1036    There is however exception where inlining might change dominator relation
1037    across EH edges from basic block within inlined functions destinating
1038    to landing pads in function we inline into.
1039
1040    The function fills in PHI_RESULTs of such PHI nodes if they refer
1041    to gimple regs.  Otherwise, the function mark PHI_RESULT of such
1042    PHI nodes for renaming.  For non-gimple regs, renaming is safe: the
1043    EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
1044    set, and this means that there will be no overlapping live ranges
1045    for the underlying symbol.
1046
1047    This might change in future if we allow redirecting of EH edges and
1048    we might want to change way build CFG pre-inlining to include
1049    all the possible edges then.  */
1050 static void
1051 update_ssa_across_abnormal_edges (basic_block bb, basic_block ret_bb,
1052                                   bool can_throw, bool nonlocal_goto)
1053 {
1054   edge e;
1055   edge_iterator ei;
1056
1057   FOR_EACH_EDGE (e, ei, bb->succs)
1058     if (!e->dest->aux
1059         || ((basic_block)e->dest->aux)->index == ENTRY_BLOCK)
1060       {
1061         tree phi;
1062
1063         gcc_assert (e->flags & EDGE_ABNORMAL);
1064         if (!nonlocal_goto)
1065           gcc_assert (e->flags & EDGE_EH);
1066         if (!can_throw)
1067           gcc_assert (!(e->flags & EDGE_EH));
1068         for (phi = phi_nodes (e->dest); phi; phi = PHI_CHAIN (phi))
1069           {
1070             edge re;
1071
1072             /* There shouldn't be any PHI nodes in the ENTRY_BLOCK.  */
1073             gcc_assert (!e->dest->aux);
1074
1075             gcc_assert (SSA_NAME_OCCURS_IN_ABNORMAL_PHI
1076                         (PHI_RESULT (phi)));
1077
1078             if (!is_gimple_reg (PHI_RESULT (phi)))
1079               {
1080                 mark_sym_for_renaming
1081                   (SSA_NAME_VAR (PHI_RESULT (phi)));
1082                 continue;
1083               }
1084
1085             re = find_edge (ret_bb, e->dest);
1086             gcc_assert (re);
1087             gcc_assert ((re->flags & (EDGE_EH | EDGE_ABNORMAL))
1088                         == (e->flags & (EDGE_EH | EDGE_ABNORMAL)));
1089
1090             SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi, e),
1091                      USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi, re)));
1092           }
1093       }
1094 }
1095
1096 /* Copy edges from BB into its copy constructed earlier, scale profile
1097    accordingly.  Edges will be taken care of later.  Assume aux
1098    pointers to point to the copies of each BB.  */
1099 static void
1100 copy_edges_for_bb (basic_block bb, int count_scale, basic_block ret_bb)
1101 {
1102   basic_block new_bb = (basic_block) bb->aux;
1103   edge_iterator ei;
1104   edge old_edge;
1105   block_stmt_iterator bsi;
1106   int flags;
1107
1108   /* Use the indices from the original blocks to create edges for the
1109      new ones.  */
1110   FOR_EACH_EDGE (old_edge, ei, bb->succs)
1111     if (!(old_edge->flags & EDGE_EH))
1112       {
1113         edge new;
1114
1115         flags = old_edge->flags;
1116
1117         /* Return edges do get a FALLTHRU flag when the get inlined.  */
1118         if (old_edge->dest->index == EXIT_BLOCK && !old_edge->flags
1119             && old_edge->dest->aux != EXIT_BLOCK_PTR)
1120           flags |= EDGE_FALLTHRU;
1121         new = make_edge (new_bb, (basic_block) old_edge->dest->aux, flags);
1122         new->count = old_edge->count * count_scale / REG_BR_PROB_BASE;
1123         new->probability = old_edge->probability;
1124       }
1125
1126   if (bb->index == ENTRY_BLOCK || bb->index == EXIT_BLOCK)
1127     return;
1128
1129   for (bsi = bsi_start (new_bb); !bsi_end_p (bsi);)
1130     {
1131       tree copy_stmt;
1132       bool can_throw, nonlocal_goto;
1133
1134       copy_stmt = bsi_stmt (bsi);
1135       update_stmt (copy_stmt);
1136       if (gimple_in_ssa_p (cfun))
1137         mark_symbols_for_renaming (copy_stmt);
1138       /* Do this before the possible split_block.  */
1139       bsi_next (&bsi);
1140
1141       /* If this tree could throw an exception, there are two
1142          cases where we need to add abnormal edge(s): the
1143          tree wasn't in a region and there is a "current
1144          region" in the caller; or the original tree had
1145          EH edges.  In both cases split the block after the tree,
1146          and add abnormal edge(s) as needed; we need both
1147          those from the callee and the caller.
1148          We check whether the copy can throw, because the const
1149          propagation can change an INDIRECT_REF which throws
1150          into a COMPONENT_REF which doesn't.  If the copy
1151          can throw, the original could also throw.  */
1152
1153       can_throw = tree_can_throw_internal (copy_stmt);
1154       nonlocal_goto = tree_can_make_abnormal_goto (copy_stmt);
1155
1156       if (can_throw || nonlocal_goto)
1157         {
1158           if (!bsi_end_p (bsi))
1159             /* Note that bb's predecessor edges aren't necessarily
1160                right at this point; split_block doesn't care.  */
1161             {
1162               edge e = split_block (new_bb, copy_stmt);
1163
1164               new_bb = e->dest;
1165               new_bb->aux = e->src->aux;
1166               bsi = bsi_start (new_bb);
1167             }
1168         }
1169
1170       if (can_throw)
1171         make_eh_edges (copy_stmt);
1172
1173       if (nonlocal_goto)
1174         make_abnormal_goto_edges (bb_for_stmt (copy_stmt), true);
1175
1176       if ((can_throw || nonlocal_goto)
1177           && gimple_in_ssa_p (cfun))
1178         update_ssa_across_abnormal_edges (bb_for_stmt (copy_stmt), ret_bb,
1179                                           can_throw, nonlocal_goto);
1180     }
1181 }
1182
1183 /* Copy the PHIs.  All blocks and edges are copied, some blocks
1184    was possibly split and new outgoing EH edges inserted.
1185    BB points to the block of original function and AUX pointers links
1186    the original and newly copied blocks.  */
1187
1188 static void
1189 copy_phis_for_bb (basic_block bb, copy_body_data *id)
1190 {
1191   basic_block new_bb = bb->aux;
1192   edge_iterator ei;
1193   tree phi;
1194
1195   for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
1196     {
1197       tree res = PHI_RESULT (phi);
1198       tree new_res = res;
1199       tree new_phi;
1200       edge new_edge;
1201
1202       if (is_gimple_reg (res))
1203         {
1204           walk_tree (&new_res, copy_body_r, id, NULL);
1205           SSA_NAME_DEF_STMT (new_res)
1206             = new_phi = create_phi_node (new_res, new_bb);
1207           FOR_EACH_EDGE (new_edge, ei, new_bb->preds)
1208             {
1209               edge old_edge = find_edge (new_edge->src->aux, bb);
1210               tree arg = PHI_ARG_DEF_FROM_EDGE (phi, old_edge);
1211               tree new_arg = arg;
1212
1213               walk_tree (&new_arg, copy_body_r, id, NULL);
1214               gcc_assert (new_arg);
1215               /* With return slot optimization we can end up with
1216                  non-gimple (foo *)&this->m, fix that here.  */
1217               if (TREE_CODE (new_arg) != SSA_NAME
1218                   && TREE_CODE (new_arg) != FUNCTION_DECL
1219                   && !is_gimple_val (new_arg))
1220                 {
1221                   tree stmts = NULL_TREE;
1222                   new_arg = force_gimple_operand (new_arg, &stmts,
1223                                                   true, NULL);
1224                   bsi_insert_on_edge_immediate (new_edge, stmts);
1225                 }
1226               add_phi_arg (new_phi, new_arg, new_edge);
1227             }
1228         }
1229     }
1230 }
1231
1232 /* Wrapper for remap_decl so it can be used as a callback.  */
1233 static tree
1234 remap_decl_1 (tree decl, void *data)
1235 {
1236   return remap_decl (decl, (copy_body_data *) data);
1237 }
1238
1239 /* Build struct function and associated datastructures for the new clone
1240    NEW_FNDECL to be build.  CALLEE_FNDECL is the original */
1241
1242 static void
1243 initialize_cfun (tree new_fndecl, tree callee_fndecl, gcov_type count,
1244                  int frequency)
1245 {
1246   struct function *new_cfun
1247      = (struct function *) ggc_alloc_cleared (sizeof (struct function));
1248   struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
1249   int count_scale, frequency_scale;
1250
1251   if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count)
1252     count_scale = (REG_BR_PROB_BASE * count
1253                    / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count);
1254   else
1255     count_scale = 1;
1256
1257   if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency)
1258     frequency_scale = (REG_BR_PROB_BASE * frequency
1259                        /
1260                        ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency);
1261   else
1262     frequency_scale = count_scale;
1263
1264   /* Register specific tree functions.  */
1265   tree_register_cfg_hooks ();
1266   *new_cfun = *DECL_STRUCT_FUNCTION (callee_fndecl);
1267   new_cfun->funcdef_no = get_next_funcdef_no ();
1268   VALUE_HISTOGRAMS (new_cfun) = NULL;
1269   new_cfun->unexpanded_var_list = NULL;
1270   new_cfun->cfg = NULL;
1271   new_cfun->decl = new_fndecl /*= copy_node (callee_fndecl)*/;
1272   DECL_STRUCT_FUNCTION (new_fndecl) = new_cfun;
1273   push_cfun (new_cfun);
1274   init_empty_tree_cfg ();
1275
1276   ENTRY_BLOCK_PTR->count =
1277     (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count * count_scale /
1278      REG_BR_PROB_BASE);
1279   ENTRY_BLOCK_PTR->frequency =
1280     (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency *
1281      frequency_scale / REG_BR_PROB_BASE);
1282   EXIT_BLOCK_PTR->count =
1283     (EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count * count_scale /
1284      REG_BR_PROB_BASE);
1285   EXIT_BLOCK_PTR->frequency =
1286     (EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency *
1287      frequency_scale / REG_BR_PROB_BASE);
1288   if (src_cfun->eh)
1289     init_eh_for_function ();
1290
1291   if (src_cfun->gimple_df)
1292     {
1293       init_tree_ssa ();
1294       cfun->gimple_df->in_ssa_p = true;
1295       init_ssa_operands ();
1296     }
1297   pop_cfun ();
1298 }
1299
1300 /* Make a copy of the body of FN so that it can be inserted inline in
1301    another function.  Walks FN via CFG, returns new fndecl.  */
1302
1303 static tree
1304 copy_cfg_body (copy_body_data * id, gcov_type count, int frequency,
1305                basic_block entry_block_map, basic_block exit_block_map)
1306 {
1307   tree callee_fndecl = id->src_fn;
1308   /* Original cfun for the callee, doesn't change.  */
1309   struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
1310   struct function *cfun_to_copy;
1311   basic_block bb;
1312   tree new_fndecl = NULL;
1313   int count_scale, frequency_scale;
1314   int last;
1315
1316   if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count)
1317     count_scale = (REG_BR_PROB_BASE * count
1318                    / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count);
1319   else
1320     count_scale = 1;
1321
1322   if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency)
1323     frequency_scale = (REG_BR_PROB_BASE * frequency
1324                        /
1325                        ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency);
1326   else
1327     frequency_scale = count_scale;
1328
1329   /* Register specific tree functions.  */
1330   tree_register_cfg_hooks ();
1331
1332   /* Must have a CFG here at this point.  */
1333   gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION
1334               (DECL_STRUCT_FUNCTION (callee_fndecl)));
1335
1336   cfun_to_copy = id->src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
1337
1338
1339   ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy)->aux = entry_block_map;
1340   EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy)->aux = exit_block_map;
1341   entry_block_map->aux = ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy);
1342   exit_block_map->aux = EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy);
1343
1344   /* Duplicate any exception-handling regions.  */
1345   if (cfun->eh)
1346     {
1347       id->eh_region_offset
1348         = duplicate_eh_regions (cfun_to_copy, remap_decl_1, id,
1349                                 0, id->eh_region);
1350     }
1351   /* Use aux pointers to map the original blocks to copy.  */
1352   FOR_EACH_BB_FN (bb, cfun_to_copy)
1353     {
1354       basic_block new = copy_bb (id, bb, frequency_scale, count_scale);
1355       bb->aux = new;
1356       new->aux = bb;
1357     }
1358
1359   last = last_basic_block;
1360   /* Now that we've duplicated the blocks, duplicate their edges.  */
1361   FOR_ALL_BB_FN (bb, cfun_to_copy)
1362     copy_edges_for_bb (bb, count_scale, exit_block_map);
1363   if (gimple_in_ssa_p (cfun))
1364     FOR_ALL_BB_FN (bb, cfun_to_copy)
1365       copy_phis_for_bb (bb, id);
1366   FOR_ALL_BB_FN (bb, cfun_to_copy)
1367     {
1368       ((basic_block)bb->aux)->aux = NULL;
1369       bb->aux = NULL;
1370     }
1371   /* Zero out AUX fields of newly created block during EH edge
1372      insertion. */
1373   for (; last < last_basic_block; last++)
1374     BASIC_BLOCK (last)->aux = NULL;
1375   entry_block_map->aux = NULL;
1376   exit_block_map->aux = NULL;
1377
1378   return new_fndecl;
1379 }
1380
1381 /* Make a copy of the body of FN so that it can be inserted inline in
1382    another function.  */
1383
1384 static tree
1385 copy_generic_body (copy_body_data *id)
1386 {
1387   tree body;
1388   tree fndecl = id->src_fn;
1389
1390   body = DECL_SAVED_TREE (fndecl);
1391   walk_tree (&body, copy_body_r, id, NULL);
1392
1393   return body;
1394 }
1395
1396 static tree
1397 copy_body (copy_body_data *id, gcov_type count, int frequency,
1398            basic_block entry_block_map, basic_block exit_block_map)
1399 {
1400   tree fndecl = id->src_fn;
1401   tree body;
1402
1403   /* If this body has a CFG, walk CFG and copy.  */
1404   gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (fndecl)));
1405   body = copy_cfg_body (id, count, frequency, entry_block_map, exit_block_map);
1406
1407   return body;
1408 }
1409
1410 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
1411    defined in function FN, or of a data member thereof.  */
1412
1413 static bool
1414 self_inlining_addr_expr (tree value, tree fn)
1415 {
1416   tree var;
1417
1418   if (TREE_CODE (value) != ADDR_EXPR)
1419     return false;
1420
1421   var = get_base_address (TREE_OPERAND (value, 0));
1422
1423   return var && auto_var_in_fn_p (var, fn);
1424 }
1425
1426 static void
1427 setup_one_parameter (copy_body_data *id, tree p, tree value, tree fn,
1428                      basic_block bb, tree *vars)
1429 {
1430   tree init_stmt;
1431   tree var;
1432   tree var_sub;
1433   tree rhs = value;
1434   tree def = (gimple_in_ssa_p (cfun)
1435               ? gimple_default_def (id->src_cfun, p) : NULL);
1436
1437   if (value
1438       && value != error_mark_node
1439       && !useless_type_conversion_p (TREE_TYPE (p), TREE_TYPE (value)))
1440     rhs = fold_build1 (NOP_EXPR, TREE_TYPE (p), value);
1441
1442   /* If the parameter is never assigned to, has no SSA_NAMEs created,
1443      we may not need to create a new variable here at all.  Instead, we may
1444      be able to just use the argument value.  */
1445   if (TREE_READONLY (p)
1446       && !TREE_ADDRESSABLE (p)
1447       && value && !TREE_SIDE_EFFECTS (value)
1448       && !def)
1449     {
1450       /* We may produce non-gimple trees by adding NOPs or introduce
1451          invalid sharing when operand is not really constant.
1452          It is not big deal to prohibit constant propagation here as
1453          we will constant propagate in DOM1 pass anyway.  */
1454       if (is_gimple_min_invariant (value)
1455           && useless_type_conversion_p (TREE_TYPE (p),
1456                                                  TREE_TYPE (value))
1457           /* We have to be very careful about ADDR_EXPR.  Make sure
1458              the base variable isn't a local variable of the inlined
1459              function, e.g., when doing recursive inlining, direct or
1460              mutually-recursive or whatever, which is why we don't
1461              just test whether fn == current_function_decl.  */
1462           && ! self_inlining_addr_expr (value, fn))
1463         {
1464           insert_decl_map (id, p, value);
1465           return;
1466         }
1467     }
1468
1469   /* Make an equivalent VAR_DECL.  Note that we must NOT remap the type
1470      here since the type of this decl must be visible to the calling
1471      function.  */
1472   var = copy_decl_to_var (p, id);
1473   if (gimple_in_ssa_p (cfun) && TREE_CODE (var) == VAR_DECL)
1474     {
1475       get_var_ann (var);
1476       add_referenced_var (var);
1477     }
1478
1479   /* See if the frontend wants to pass this by invisible reference.  If
1480      so, our new VAR_DECL will have REFERENCE_TYPE, and we need to
1481      replace uses of the PARM_DECL with dereferences.  */
1482   if (TREE_TYPE (var) != TREE_TYPE (p)
1483       && POINTER_TYPE_P (TREE_TYPE (var))
1484       && TREE_TYPE (TREE_TYPE (var)) == TREE_TYPE (p))
1485     {
1486       insert_decl_map (id, var, var);
1487       var_sub = build_fold_indirect_ref (var);
1488     }
1489   else
1490     var_sub = var;
1491
1492   /* Register the VAR_DECL as the equivalent for the PARM_DECL;
1493      that way, when the PARM_DECL is encountered, it will be
1494      automatically replaced by the VAR_DECL.  */
1495   insert_decl_map (id, p, var_sub);
1496
1497   /* Declare this new variable.  */
1498   TREE_CHAIN (var) = *vars;
1499   *vars = var;
1500
1501   /* Make gimplifier happy about this variable.  */
1502   DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
1503
1504   /* Even if P was TREE_READONLY, the new VAR should not be.
1505      In the original code, we would have constructed a
1506      temporary, and then the function body would have never
1507      changed the value of P.  However, now, we will be
1508      constructing VAR directly.  The constructor body may
1509      change its value multiple times as it is being
1510      constructed.  Therefore, it must not be TREE_READONLY;
1511      the back-end assumes that TREE_READONLY variable is
1512      assigned to only once.  */
1513   if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p)))
1514     TREE_READONLY (var) = 0;
1515
1516   /* If there is no setup required and we are in SSA, take the easy route
1517      replacing all SSA names representing the function parameter by the
1518      SSA name passed to function.
1519
1520      We need to construct map for the variable anyway as it might be used
1521      in different SSA names when parameter is set in function.
1522
1523      FIXME: This usually kills the last connection in between inlined
1524      function parameter and the actual value in debug info.  Can we do
1525      better here?  If we just inserted the statement, copy propagation
1526      would kill it anyway as it always did in older versions of GCC.
1527
1528      We might want to introduce a notion that single SSA_NAME might
1529      represent multiple variables for purposes of debugging. */
1530   if (gimple_in_ssa_p (cfun) && rhs && def && is_gimple_reg (p)
1531       && (TREE_CODE (rhs) == SSA_NAME
1532           || is_gimple_min_invariant (rhs))
1533       && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def))
1534     {
1535       insert_decl_map (id, def, rhs);
1536       return;
1537     }
1538
1539   /* If the value of argument is never used, don't care about initializing
1540      it.  */
1541   if (gimple_in_ssa_p (cfun) && !def && is_gimple_reg (p))
1542     {
1543       gcc_assert (!value || !TREE_SIDE_EFFECTS (value));
1544       return;
1545     }
1546
1547   /* Initialize this VAR_DECL from the equivalent argument.  Convert
1548      the argument to the proper type in case it was promoted.  */
1549   if (value)
1550     {
1551       block_stmt_iterator bsi = bsi_last (bb);
1552
1553       if (rhs == error_mark_node)
1554         {
1555           insert_decl_map (id, p, var_sub);
1556           return;
1557         }
1558
1559       STRIP_USELESS_TYPE_CONVERSION (rhs);
1560
1561       /* We want to use GIMPLE_MODIFY_STMT, not INIT_EXPR here so that we
1562          keep our trees in gimple form.  */
1563       if (def && gimple_in_ssa_p (cfun) && is_gimple_reg (p))
1564         {
1565           def = remap_ssa_name (def, id);
1566           init_stmt = build_gimple_modify_stmt (def, rhs);
1567           SSA_NAME_DEF_STMT (def) = init_stmt;
1568           SSA_NAME_IS_DEFAULT_DEF (def) = 0;
1569           set_default_def (var, NULL);
1570         }
1571       else
1572         init_stmt = build_gimple_modify_stmt (var, rhs);
1573
1574       /* If we did not create a gimple value and we did not create a gimple
1575          cast of a gimple value, then we will need to gimplify INIT_STMTS
1576          at the end.  Note that is_gimple_cast only checks the outer
1577          tree code, not its operand.  Thus the explicit check that its
1578          operand is a gimple value.  */
1579       if ((!is_gimple_val (rhs)
1580           && (!is_gimple_cast (rhs)
1581               || !is_gimple_val (TREE_OPERAND (rhs, 0))))
1582           || !is_gimple_reg (var))
1583         {
1584           tree_stmt_iterator i;
1585
1586           push_gimplify_context ();
1587           gimplify_stmt (&init_stmt);
1588           if (gimple_in_ssa_p (cfun)
1589               && init_stmt && TREE_CODE (init_stmt) == STATEMENT_LIST)
1590             {
1591               /* The replacement can expose previously unreferenced
1592                  variables.  */
1593               for (i = tsi_start (init_stmt); !tsi_end_p (i); tsi_next (&i))
1594                 find_new_referenced_vars (tsi_stmt_ptr (i));
1595              }
1596           pop_gimplify_context (NULL);
1597         }
1598
1599       /* If VAR represents a zero-sized variable, it's possible that the
1600          assignment statment may result in no gimple statements.  */
1601       if (init_stmt)
1602         bsi_insert_after (&bsi, init_stmt, BSI_NEW_STMT);
1603       if (gimple_in_ssa_p (cfun))
1604         for (;!bsi_end_p (bsi); bsi_next (&bsi))
1605           mark_symbols_for_renaming (bsi_stmt (bsi));
1606     }
1607 }
1608
1609 /* Generate code to initialize the parameters of the function at the
1610    top of the stack in ID from the CALL_EXPR EXP.  */
1611
1612 static void
1613 initialize_inlined_parameters (copy_body_data *id, tree exp,
1614                                tree fn, basic_block bb)
1615 {
1616   tree parms;
1617   tree a;
1618   tree p;
1619   tree vars = NULL_TREE;
1620   call_expr_arg_iterator iter;
1621   tree static_chain = CALL_EXPR_STATIC_CHAIN (exp);
1622
1623   /* Figure out what the parameters are.  */
1624   parms = DECL_ARGUMENTS (fn);
1625
1626   /* Loop through the parameter declarations, replacing each with an
1627      equivalent VAR_DECL, appropriately initialized.  */
1628   for (p = parms, a = first_call_expr_arg (exp, &iter); p;
1629        a = next_call_expr_arg (&iter), p = TREE_CHAIN (p))
1630     setup_one_parameter (id, p, a, fn, bb, &vars);
1631
1632   /* Initialize the static chain.  */
1633   p = DECL_STRUCT_FUNCTION (fn)->static_chain_decl;
1634   gcc_assert (fn != current_function_decl);
1635   if (p)
1636     {
1637       /* No static chain?  Seems like a bug in tree-nested.c.  */
1638       gcc_assert (static_chain);
1639
1640       setup_one_parameter (id, p, static_chain, fn, bb, &vars);
1641     }
1642
1643   declare_inline_vars (id->block, vars);
1644 }
1645
1646 /* Declare a return variable to replace the RESULT_DECL for the
1647    function we are calling.  An appropriate DECL_STMT is returned.
1648    The USE_STMT is filled to contain a use of the declaration to
1649    indicate the return value of the function.
1650
1651    RETURN_SLOT, if non-null is place where to store the result.  It
1652    is set only for CALL_EXPR_RETURN_SLOT_OPT.  MODIFY_DEST, if non-null,
1653    was the LHS of the GIMPLE_MODIFY_STMT to which this call is the RHS.
1654
1655    The return value is a (possibly null) value that is the result of the
1656    function as seen by the callee.  *USE_P is a (possibly null) value that
1657    holds the result as seen by the caller.  */
1658
1659 static tree
1660 declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest,
1661                          tree *use_p)
1662 {
1663   tree callee = id->src_fn;
1664   tree caller = id->dst_fn;
1665   tree result = DECL_RESULT (callee);
1666   tree callee_type = TREE_TYPE (result);
1667   tree caller_type = TREE_TYPE (TREE_TYPE (callee));
1668   tree var, use;
1669
1670   /* We don't need to do anything for functions that don't return
1671      anything.  */
1672   if (!result || VOID_TYPE_P (callee_type))
1673     {
1674       *use_p = NULL_TREE;
1675       return NULL_TREE;
1676     }
1677
1678   /* If there was a return slot, then the return value is the
1679      dereferenced address of that object.  */
1680   if (return_slot)
1681     {
1682       /* The front end shouldn't have used both return_slot and
1683          a modify expression.  */
1684       gcc_assert (!modify_dest);
1685       if (DECL_BY_REFERENCE (result))
1686         {
1687           tree return_slot_addr = build_fold_addr_expr (return_slot);
1688           STRIP_USELESS_TYPE_CONVERSION (return_slot_addr);
1689
1690           /* We are going to construct *&return_slot and we can't do that
1691              for variables believed to be not addressable.
1692
1693              FIXME: This check possibly can match, because values returned
1694              via return slot optimization are not believed to have address
1695              taken by alias analysis.  */
1696           gcc_assert (TREE_CODE (return_slot) != SSA_NAME);
1697           if (gimple_in_ssa_p (cfun))
1698             {
1699               HOST_WIDE_INT bitsize;
1700               HOST_WIDE_INT bitpos;
1701               tree offset;
1702               enum machine_mode mode;
1703               int unsignedp;
1704               int volatilep;
1705               tree base;
1706               base = get_inner_reference (return_slot, &bitsize, &bitpos,
1707                                           &offset,
1708                                           &mode, &unsignedp, &volatilep,
1709                                           false);
1710               if (TREE_CODE (base) == INDIRECT_REF)
1711                 base = TREE_OPERAND (base, 0);
1712               if (TREE_CODE (base) == SSA_NAME)
1713                 base = SSA_NAME_VAR (base);
1714               mark_sym_for_renaming (base);
1715             }
1716           var = return_slot_addr;
1717         }
1718       else
1719         {
1720           var = return_slot;
1721           gcc_assert (TREE_CODE (var) != SSA_NAME);
1722           TREE_ADDRESSABLE (var) |= TREE_ADDRESSABLE (result);
1723         }
1724       if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
1725            || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
1726           && !DECL_GIMPLE_REG_P (result)
1727           && DECL_P (var))
1728         DECL_GIMPLE_REG_P (var) = 0;
1729       use = NULL;
1730       goto done;
1731     }
1732
1733   /* All types requiring non-trivial constructors should have been handled.  */
1734   gcc_assert (!TREE_ADDRESSABLE (callee_type));
1735
1736   /* Attempt to avoid creating a new temporary variable.  */
1737   if (modify_dest
1738       && TREE_CODE (modify_dest) != SSA_NAME)
1739     {
1740       bool use_it = false;
1741
1742       /* We can't use MODIFY_DEST if there's type promotion involved.  */
1743       if (!useless_type_conversion_p (callee_type, caller_type))
1744         use_it = false;
1745
1746       /* ??? If we're assigning to a variable sized type, then we must
1747          reuse the destination variable, because we've no good way to
1748          create variable sized temporaries at this point.  */
1749       else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type)) != INTEGER_CST)
1750         use_it = true;
1751
1752       /* If the callee cannot possibly modify MODIFY_DEST, then we can
1753          reuse it as the result of the call directly.  Don't do this if
1754          it would promote MODIFY_DEST to addressable.  */
1755       else if (TREE_ADDRESSABLE (result))
1756         use_it = false;
1757       else
1758         {
1759           tree base_m = get_base_address (modify_dest);
1760
1761           /* If the base isn't a decl, then it's a pointer, and we don't
1762              know where that's going to go.  */
1763           if (!DECL_P (base_m))
1764             use_it = false;
1765           else if (is_global_var (base_m))
1766             use_it = false;
1767           else if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
1768                     || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
1769                    && !DECL_GIMPLE_REG_P (result)
1770                    && DECL_GIMPLE_REG_P (base_m))
1771             use_it = false;
1772           else if (!TREE_ADDRESSABLE (base_m))
1773             use_it = true;
1774         }
1775
1776       if (use_it)
1777         {
1778           var = modify_dest;
1779           use = NULL;
1780           goto done;
1781         }
1782     }
1783
1784   gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type)) == INTEGER_CST);
1785
1786   var = copy_result_decl_to_var (result, id);
1787   if (gimple_in_ssa_p (cfun))
1788     {
1789       get_var_ann (var);
1790       add_referenced_var (var);
1791     }
1792
1793   DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
1794   DECL_STRUCT_FUNCTION (caller)->unexpanded_var_list
1795     = tree_cons (NULL_TREE, var,
1796                  DECL_STRUCT_FUNCTION (caller)->unexpanded_var_list);
1797
1798   /* Do not have the rest of GCC warn about this variable as it should
1799      not be visible to the user.  */
1800   TREE_NO_WARNING (var) = 1;
1801
1802   declare_inline_vars (id->block, var);
1803
1804   /* Build the use expr.  If the return type of the function was
1805      promoted, convert it back to the expected type.  */
1806   use = var;
1807   if (!useless_type_conversion_p (caller_type, TREE_TYPE (var)))
1808     use = fold_convert (caller_type, var);
1809
1810   STRIP_USELESS_TYPE_CONVERSION (use);
1811
1812   if (DECL_BY_REFERENCE (result))
1813     var = build_fold_addr_expr (var);
1814
1815  done:
1816   /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
1817      way, when the RESULT_DECL is encountered, it will be
1818      automatically replaced by the VAR_DECL.  */
1819   insert_decl_map (id, result, var);
1820
1821   /* Remember this so we can ignore it in remap_decls.  */
1822   id->retvar = var;
1823
1824   *use_p = use;
1825   return var;
1826 }
1827
1828 /* Returns nonzero if a function can be inlined as a tree.  */
1829
1830 bool
1831 tree_inlinable_function_p (tree fn)
1832 {
1833   return inlinable_function_p (fn);
1834 }
1835
1836 static const char *inline_forbidden_reason;
1837
1838 static tree
1839 inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED,
1840                       void *fnp)
1841 {
1842   tree node = *nodep;
1843   tree fn = (tree) fnp;
1844   tree t;
1845
1846   switch (TREE_CODE (node))
1847     {
1848     case CALL_EXPR:
1849       /* Refuse to inline alloca call unless user explicitly forced so as
1850          this may change program's memory overhead drastically when the
1851          function using alloca is called in loop.  In GCC present in
1852          SPEC2000 inlining into schedule_block cause it to require 2GB of
1853          RAM instead of 256MB.  */
1854       if (alloca_call_p (node)
1855           && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
1856         {
1857           inline_forbidden_reason
1858             = G_("function %q+F can never be inlined because it uses "
1859                  "alloca (override using the always_inline attribute)");
1860           return node;
1861         }
1862       t = get_callee_fndecl (node);
1863       if (! t)
1864         break;
1865
1866       /* We cannot inline functions that call setjmp.  */
1867       if (setjmp_call_p (t))
1868         {
1869           inline_forbidden_reason
1870             = G_("function %q+F can never be inlined because it uses setjmp");
1871           return node;
1872         }
1873
1874       if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL)
1875         switch (DECL_FUNCTION_CODE (t))
1876           {
1877             /* We cannot inline functions that take a variable number of
1878                arguments.  */
1879           case BUILT_IN_VA_START:
1880           case BUILT_IN_STDARG_START:
1881           case BUILT_IN_NEXT_ARG:
1882           case BUILT_IN_VA_END:
1883             inline_forbidden_reason
1884               = G_("function %q+F can never be inlined because it "
1885                    "uses variable argument lists");
1886             return node;
1887
1888           case BUILT_IN_LONGJMP:
1889             /* We can't inline functions that call __builtin_longjmp at
1890                all.  The non-local goto machinery really requires the
1891                destination be in a different function.  If we allow the
1892                function calling __builtin_longjmp to be inlined into the
1893                function calling __builtin_setjmp, Things will Go Awry.  */
1894             inline_forbidden_reason
1895               = G_("function %q+F can never be inlined because "
1896                    "it uses setjmp-longjmp exception handling");
1897             return node;
1898
1899           case BUILT_IN_NONLOCAL_GOTO:
1900             /* Similarly.  */
1901             inline_forbidden_reason
1902               = G_("function %q+F can never be inlined because "
1903                    "it uses non-local goto");
1904             return node;
1905
1906           case BUILT_IN_RETURN:
1907           case BUILT_IN_APPLY_ARGS:
1908             /* If a __builtin_apply_args caller would be inlined,
1909                it would be saving arguments of the function it has
1910                been inlined into.  Similarly __builtin_return would
1911                return from the function the inline has been inlined into.  */
1912             inline_forbidden_reason
1913               = G_("function %q+F can never be inlined because "
1914                    "it uses __builtin_return or __builtin_apply_args");
1915             return node;
1916
1917           default:
1918             break;
1919           }
1920       break;
1921
1922     case GOTO_EXPR:
1923       t = TREE_OPERAND (node, 0);
1924
1925       /* We will not inline a function which uses computed goto.  The
1926          addresses of its local labels, which may be tucked into
1927          global storage, are of course not constant across
1928          instantiations, which causes unexpected behavior.  */
1929       if (TREE_CODE (t) != LABEL_DECL)
1930         {
1931           inline_forbidden_reason
1932             = G_("function %q+F can never be inlined "
1933                  "because it contains a computed goto");
1934           return node;
1935         }
1936       break;
1937
1938     case LABEL_EXPR:
1939       t = TREE_OPERAND (node, 0);
1940       if (DECL_NONLOCAL (t))
1941         {
1942           /* We cannot inline a function that receives a non-local goto
1943              because we cannot remap the destination label used in the
1944              function that is performing the non-local goto.  */
1945           inline_forbidden_reason
1946             = G_("function %q+F can never be inlined "
1947                  "because it receives a non-local goto");
1948           return node;
1949         }
1950       break;
1951
1952     case RECORD_TYPE:
1953     case UNION_TYPE:
1954       /* We cannot inline a function of the form
1955
1956            void F (int i) { struct S { int ar[i]; } s; }
1957
1958          Attempting to do so produces a catch-22.
1959          If walk_tree examines the TYPE_FIELDS chain of RECORD_TYPE/
1960          UNION_TYPE nodes, then it goes into infinite recursion on a
1961          structure containing a pointer to its own type.  If it doesn't,
1962          then the type node for S doesn't get adjusted properly when
1963          F is inlined.
1964
1965          ??? This is likely no longer true, but it's too late in the 4.0
1966          cycle to try to find out.  This should be checked for 4.1.  */
1967       for (t = TYPE_FIELDS (node); t; t = TREE_CHAIN (t))
1968         if (variably_modified_type_p (TREE_TYPE (t), NULL))
1969           {
1970             inline_forbidden_reason
1971               = G_("function %q+F can never be inlined "
1972                    "because it uses variable sized variables");
1973             return node;
1974           }
1975
1976     default:
1977       break;
1978     }
1979
1980   return NULL_TREE;
1981 }
1982
1983 static tree
1984 inline_forbidden_p_2 (tree *nodep, int *walk_subtrees,
1985                       void *fnp)
1986 {
1987   tree node = *nodep;
1988   tree fn = (tree) fnp;
1989
1990   if (TREE_CODE (node) == LABEL_DECL && DECL_CONTEXT (node) == fn)
1991     {
1992       inline_forbidden_reason
1993         = G_("function %q+F can never be inlined "
1994              "because it saves address of local label in a static variable");
1995       return node;
1996     }
1997
1998   if (TYPE_P (node))
1999     *walk_subtrees = 0;
2000
2001   return NULL_TREE;
2002 }
2003
2004 /* Return subexpression representing possible alloca call, if any.  */
2005 static tree
2006 inline_forbidden_p (tree fndecl)
2007 {
2008   location_t saved_loc = input_location;
2009   block_stmt_iterator bsi;
2010   basic_block bb;
2011   tree ret = NULL_TREE;
2012   struct function *fun = DECL_STRUCT_FUNCTION (fndecl);
2013   tree step;
2014
2015   FOR_EACH_BB_FN (bb, fun)
2016     for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2017       {
2018         ret = walk_tree_without_duplicates (bsi_stmt_ptr (bsi),
2019                                             inline_forbidden_p_1, fndecl);
2020         if (ret)
2021           goto egress;
2022       }
2023
2024   for (step = fun->unexpanded_var_list; step; step = TREE_CHAIN (step))
2025     {
2026       tree decl = TREE_VALUE (step);
2027       if (TREE_CODE (decl) == VAR_DECL
2028           && TREE_STATIC (decl)
2029           && !DECL_EXTERNAL (decl)
2030           && DECL_INITIAL (decl))
2031         ret = walk_tree_without_duplicates (&DECL_INITIAL (decl),
2032                                             inline_forbidden_p_2, fndecl);
2033         if (ret)
2034           goto egress;
2035     }
2036
2037 egress:
2038   input_location = saved_loc;
2039   return ret;
2040 }
2041
2042 /* Returns nonzero if FN is a function that does not have any
2043    fundamental inline blocking properties.  */
2044
2045 static bool
2046 inlinable_function_p (tree fn)
2047 {
2048   bool inlinable = true;
2049   bool do_warning;
2050   tree always_inline;
2051
2052   /* If we've already decided this function shouldn't be inlined,
2053      there's no need to check again.  */
2054   if (DECL_UNINLINABLE (fn))
2055     return false;
2056
2057   /* We only warn for functions declared `inline' by the user.  */
2058   do_warning = (warn_inline
2059                 && DECL_INLINE (fn)
2060                 && DECL_DECLARED_INLINE_P (fn)
2061                 && !DECL_IN_SYSTEM_HEADER (fn));
2062
2063   always_inline = lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn));
2064
2065   if (flag_really_no_inline
2066       && always_inline == NULL)
2067     {
2068       if (do_warning)
2069         warning (OPT_Winline, "function %q+F can never be inlined because it "
2070                  "is suppressed using -fno-inline", fn);
2071       inlinable = false;
2072     }
2073
2074   /* Don't auto-inline anything that might not be bound within
2075      this unit of translation.  */
2076   else if (!DECL_DECLARED_INLINE_P (fn)
2077            && DECL_REPLACEABLE_P (fn))
2078     inlinable = false;
2079
2080   else if (!function_attribute_inlinable_p (fn))
2081     {
2082       if (do_warning)
2083         warning (OPT_Winline, "function %q+F can never be inlined because it "
2084                  "uses attributes conflicting with inlining", fn);
2085       inlinable = false;
2086     }
2087
2088   /* If we don't have the function body available, we can't inline it.
2089      However, this should not be recorded since we also get here for
2090      forward declared inline functions.  Therefore, return at once.  */
2091   if (!DECL_SAVED_TREE (fn))
2092     return false;
2093
2094   /* If we're not inlining at all, then we cannot inline this function.  */
2095   else if (!flag_inline_trees)
2096     inlinable = false;
2097
2098   /* Only try to inline functions if DECL_INLINE is set.  This should be
2099      true for all functions declared `inline', and for all other functions
2100      as well with -finline-functions.
2101
2102      Don't think of disregarding DECL_INLINE when flag_inline_trees == 2;
2103      it's the front-end that must set DECL_INLINE in this case, because
2104      dwarf2out loses if a function that does not have DECL_INLINE set is
2105      inlined anyway.  That is why we have both DECL_INLINE and
2106      DECL_DECLARED_INLINE_P.  */
2107   /* FIXME: When flag_inline_trees dies, the check for flag_unit_at_a_time
2108             here should be redundant.  */
2109   else if (!DECL_INLINE (fn) && !flag_unit_at_a_time)
2110     inlinable = false;
2111
2112   else if (inline_forbidden_p (fn))
2113     {
2114       /* See if we should warn about uninlinable functions.  Previously,
2115          some of these warnings would be issued while trying to expand
2116          the function inline, but that would cause multiple warnings
2117          about functions that would for example call alloca.  But since
2118          this a property of the function, just one warning is enough.
2119          As a bonus we can now give more details about the reason why a
2120          function is not inlinable.  */
2121       if (always_inline)
2122         sorry (inline_forbidden_reason, fn);
2123       else if (do_warning)
2124         warning (OPT_Winline, inline_forbidden_reason, fn);
2125
2126       inlinable = false;
2127     }
2128
2129   /* Squirrel away the result so that we don't have to check again.  */
2130   DECL_UNINLINABLE (fn) = !inlinable;
2131
2132   return inlinable;
2133 }
2134
2135 /* Estimate the cost of a memory move.  Use machine dependent
2136    word size and take possible memcpy call into account.  */
2137
2138 int
2139 estimate_move_cost (tree type)
2140 {
2141   HOST_WIDE_INT size;
2142
2143   size = int_size_in_bytes (type);
2144
2145   if (size < 0 || size > MOVE_MAX_PIECES * MOVE_RATIO)
2146     /* Cost of a memcpy call, 3 arguments and the call.  */
2147     return 4;
2148   else
2149     return ((size + MOVE_MAX_PIECES - 1) / MOVE_MAX_PIECES);
2150 }
2151
2152 /* Arguments for estimate_num_insns_1.  */
2153
2154 struct eni_data
2155 {
2156   /* Used to return the number of insns.  */
2157   int count;
2158
2159   /* Weights of various constructs.  */
2160   eni_weights *weights;
2161 };
2162
2163 /* Used by estimate_num_insns.  Estimate number of instructions seen
2164    by given statement.  */
2165
2166 static tree
2167 estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data)
2168 {
2169   struct eni_data *d = data;
2170   tree x = *tp;
2171   unsigned cost;
2172
2173   if (IS_TYPE_OR_DECL_P (x))
2174     {
2175       *walk_subtrees = 0;
2176       return NULL;
2177     }
2178   /* Assume that constants and references counts nothing.  These should
2179      be majorized by amount of operations among them we count later
2180      and are common target of CSE and similar optimizations.  */
2181   else if (CONSTANT_CLASS_P (x) || REFERENCE_CLASS_P (x))
2182     return NULL;
2183
2184   switch (TREE_CODE (x))
2185     {
2186     /* Containers have no cost.  */
2187     case TREE_LIST:
2188     case TREE_VEC:
2189     case BLOCK:
2190     case COMPONENT_REF:
2191     case BIT_FIELD_REF:
2192     case INDIRECT_REF:
2193     case ALIGN_INDIRECT_REF:
2194     case MISALIGNED_INDIRECT_REF:
2195     case ARRAY_REF:
2196     case ARRAY_RANGE_REF:
2197     case OBJ_TYPE_REF:
2198     case EXC_PTR_EXPR: /* ??? */
2199     case FILTER_EXPR: /* ??? */
2200     case COMPOUND_EXPR:
2201     case BIND_EXPR:
2202     case WITH_CLEANUP_EXPR:
2203     case NOP_EXPR:
2204     case CONVERT_EXPR:
2205     case VIEW_CONVERT_EXPR:
2206     case SAVE_EXPR:
2207     case ADDR_EXPR:
2208     case COMPLEX_EXPR:
2209     case RANGE_EXPR:
2210     case CASE_LABEL_EXPR:
2211     case SSA_NAME:
2212     case CATCH_EXPR:
2213     case EH_FILTER_EXPR:
2214     case STATEMENT_LIST:
2215     case ERROR_MARK:
2216     case NON_LVALUE_EXPR:
2217     case FDESC_EXPR:
2218     case VA_ARG_EXPR:
2219     case TRY_CATCH_EXPR:
2220     case TRY_FINALLY_EXPR:
2221     case LABEL_EXPR:
2222     case GOTO_EXPR:
2223     case RETURN_EXPR:
2224     case EXIT_EXPR:
2225     case LOOP_EXPR:
2226     case PHI_NODE:
2227     case WITH_SIZE_EXPR:
2228     case OMP_CLAUSE:
2229     case OMP_RETURN:
2230     case OMP_CONTINUE:
2231     case OMP_SECTIONS_SWITCH:
2232     case OMP_ATOMIC_STORE:
2233       break;
2234
2235     /* We don't account constants for now.  Assume that the cost is amortized
2236        by operations that do use them.  We may re-consider this decision once
2237        we are able to optimize the tree before estimating its size and break
2238        out static initializers.  */
2239     case IDENTIFIER_NODE:
2240     case INTEGER_CST:
2241     case REAL_CST:
2242     case FIXED_CST:
2243     case COMPLEX_CST:
2244     case VECTOR_CST:
2245     case STRING_CST:
2246       *walk_subtrees = 0;
2247       return NULL;
2248
2249       /* CHANGE_DYNAMIC_TYPE_EXPR explicitly expands to nothing.  */
2250     case CHANGE_DYNAMIC_TYPE_EXPR:
2251       *walk_subtrees = 0;
2252       return NULL;
2253
2254     /* Try to estimate the cost of assignments.  We have three cases to
2255        deal with:
2256         1) Simple assignments to registers;
2257         2) Stores to things that must live in memory.  This includes
2258            "normal" stores to scalars, but also assignments of large
2259            structures, or constructors of big arrays;
2260         3) TARGET_EXPRs.
2261
2262        Let us look at the first two cases, assuming we have "a = b + C":
2263        <GIMPLE_MODIFY_STMT <var_decl "a">
2264                            <plus_expr <var_decl "b"> <constant C>>
2265        If "a" is a GIMPLE register, the assignment to it is free on almost
2266        any target, because "a" usually ends up in a real register.  Hence
2267        the only cost of this expression comes from the PLUS_EXPR, and we
2268        can ignore the GIMPLE_MODIFY_STMT.
2269        If "a" is not a GIMPLE register, the assignment to "a" will most
2270        likely be a real store, so the cost of the GIMPLE_MODIFY_STMT is the cost
2271        of moving something into "a", which we compute using the function
2272        estimate_move_cost.
2273
2274        The third case deals with TARGET_EXPRs, for which the semantics are
2275        that a temporary is assigned, unless the TARGET_EXPR itself is being
2276        assigned to something else.  In the latter case we do not need the
2277        temporary.  E.g. in:
2278                 <GIMPLE_MODIFY_STMT <var_decl "a"> <target_expr>>, the
2279        GIMPLE_MODIFY_STMT is free.  */
2280     case INIT_EXPR:
2281     case GIMPLE_MODIFY_STMT:
2282       /* Is the right and side a TARGET_EXPR?  */
2283       if (TREE_CODE (GENERIC_TREE_OPERAND (x, 1)) == TARGET_EXPR)
2284         break;
2285       /* ... fall through ...  */
2286
2287     case TARGET_EXPR:
2288       x = GENERIC_TREE_OPERAND (x, 0);
2289       /* Is this an assignments to a register?  */
2290       if (is_gimple_reg (x))
2291         break;
2292       /* Otherwise it's a store, so fall through to compute the move cost.  */
2293
2294     case CONSTRUCTOR:
2295       d->count += estimate_move_cost (TREE_TYPE (x));
2296       break;
2297
2298     /* Assign cost of 1 to usual operations.
2299        ??? We may consider mapping RTL costs to this.  */
2300     case COND_EXPR:
2301     case VEC_COND_EXPR:
2302
2303     case PLUS_EXPR:
2304     case POINTER_PLUS_EXPR:
2305     case MINUS_EXPR:
2306     case MULT_EXPR:
2307
2308     case FIXED_CONVERT_EXPR:
2309     case FIX_TRUNC_EXPR:
2310
2311     case NEGATE_EXPR:
2312     case FLOAT_EXPR:
2313     case MIN_EXPR:
2314     case MAX_EXPR:
2315     case ABS_EXPR:
2316
2317     case LSHIFT_EXPR:
2318     case RSHIFT_EXPR:
2319     case LROTATE_EXPR:
2320     case RROTATE_EXPR:
2321     case VEC_LSHIFT_EXPR:
2322     case VEC_RSHIFT_EXPR:
2323
2324     case BIT_IOR_EXPR:
2325     case BIT_XOR_EXPR:
2326     case BIT_AND_EXPR:
2327     case BIT_NOT_EXPR:
2328
2329     case TRUTH_ANDIF_EXPR:
2330     case TRUTH_ORIF_EXPR:
2331     case TRUTH_AND_EXPR:
2332     case TRUTH_OR_EXPR:
2333     case TRUTH_XOR_EXPR:
2334     case TRUTH_NOT_EXPR:
2335
2336     case LT_EXPR:
2337     case LE_EXPR:
2338     case GT_EXPR:
2339     case GE_EXPR:
2340     case EQ_EXPR:
2341     case NE_EXPR:
2342     case ORDERED_EXPR:
2343     case UNORDERED_EXPR:
2344
2345     case UNLT_EXPR:
2346     case UNLE_EXPR:
2347     case UNGT_EXPR:
2348     case UNGE_EXPR:
2349     case UNEQ_EXPR:
2350     case LTGT_EXPR:
2351
2352     case CONJ_EXPR:
2353
2354     case PREDECREMENT_EXPR:
2355     case PREINCREMENT_EXPR:
2356     case POSTDECREMENT_EXPR:
2357     case POSTINCREMENT_EXPR:
2358
2359     case ASM_EXPR:
2360
2361     case REALIGN_LOAD_EXPR:
2362
2363     case REDUC_MAX_EXPR:
2364     case REDUC_MIN_EXPR:
2365     case REDUC_PLUS_EXPR:
2366     case WIDEN_SUM_EXPR:
2367     case DOT_PROD_EXPR:
2368     case VEC_WIDEN_MULT_HI_EXPR:
2369     case VEC_WIDEN_MULT_LO_EXPR:
2370     case VEC_UNPACK_HI_EXPR:
2371     case VEC_UNPACK_LO_EXPR:
2372     case VEC_UNPACK_FLOAT_HI_EXPR:
2373     case VEC_UNPACK_FLOAT_LO_EXPR:
2374     case VEC_PACK_TRUNC_EXPR:
2375     case VEC_PACK_SAT_EXPR:
2376     case VEC_PACK_FIX_TRUNC_EXPR:
2377
2378     case WIDEN_MULT_EXPR:
2379
2380     case VEC_EXTRACT_EVEN_EXPR:
2381     case VEC_EXTRACT_ODD_EXPR:
2382     case VEC_INTERLEAVE_HIGH_EXPR:
2383     case VEC_INTERLEAVE_LOW_EXPR:
2384
2385     case RESX_EXPR:
2386       d->count += 1;
2387       break;
2388
2389     case SWITCH_EXPR:
2390       /* Take into account cost of the switch + guess 2 conditional jumps for
2391          each case label.
2392
2393          TODO: once the switch expansion logic is sufficiently separated, we can
2394          do better job on estimating cost of the switch.  */
2395       d->count += TREE_VEC_LENGTH (SWITCH_LABELS (x)) * 2;
2396       break;
2397
2398     /* Few special cases of expensive operations.  This is useful
2399        to avoid inlining on functions having too many of these.  */
2400     case TRUNC_DIV_EXPR:
2401     case CEIL_DIV_EXPR:
2402     case FLOOR_DIV_EXPR:
2403     case ROUND_DIV_EXPR:
2404     case EXACT_DIV_EXPR:
2405     case TRUNC_MOD_EXPR:
2406     case CEIL_MOD_EXPR:
2407     case FLOOR_MOD_EXPR:
2408     case ROUND_MOD_EXPR:
2409     case RDIV_EXPR:
2410       d->count += d->weights->div_mod_cost;
2411       break;
2412     case CALL_EXPR:
2413       {
2414         tree decl = get_callee_fndecl (x);
2415
2416         if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD)
2417           cost = d->weights->target_builtin_call_cost;
2418         else
2419           cost = d->weights->call_cost;
2420
2421         if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
2422           switch (DECL_FUNCTION_CODE (decl))
2423             {
2424             case BUILT_IN_CONSTANT_P:
2425               *walk_subtrees = 0;
2426               return NULL_TREE;
2427             case BUILT_IN_EXPECT:
2428               return NULL_TREE;
2429             /* Prefetch instruction is not expensive.  */
2430             case BUILT_IN_PREFETCH:
2431               cost = 1;
2432               break;
2433             default:
2434               break;
2435             }
2436
2437         /* Our cost must be kept in sync with cgraph_estimate_size_after_inlining
2438            that does use function declaration to figure out the arguments.  */
2439         if (!decl)
2440           {
2441             tree a;
2442             call_expr_arg_iterator iter;
2443             FOR_EACH_CALL_EXPR_ARG (a, iter, x)
2444               d->count += estimate_move_cost (TREE_TYPE (a));
2445           }
2446         else
2447           {
2448             tree arg;
2449             for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg))
2450               d->count += estimate_move_cost (TREE_TYPE (arg));
2451           }
2452
2453         d->count += cost;
2454         break;
2455       }
2456
2457     case OMP_PARALLEL:
2458     case OMP_FOR:
2459     case OMP_SECTIONS:
2460     case OMP_SINGLE:
2461     case OMP_SECTION:
2462     case OMP_MASTER:
2463     case OMP_ORDERED:
2464     case OMP_CRITICAL:
2465     case OMP_ATOMIC:
2466     case OMP_ATOMIC_LOAD:
2467       /* OpenMP directives are generally very expensive.  */
2468       d->count += d->weights->omp_cost;
2469       break;
2470
2471     default:
2472       gcc_unreachable ();
2473     }
2474   return NULL;
2475 }
2476
2477 /* Estimate number of instructions that will be created by expanding EXPR.
2478    WEIGHTS contains weights attributed to various constructs.  */
2479
2480 int
2481 estimate_num_insns (tree expr, eni_weights *weights)
2482 {
2483   struct pointer_set_t *visited_nodes;
2484   basic_block bb;
2485   block_stmt_iterator bsi;
2486   struct function *my_function;
2487   struct eni_data data;
2488
2489   data.count = 0;
2490   data.weights = weights;
2491
2492   /* If we're given an entire function, walk the CFG.  */
2493   if (TREE_CODE (expr) == FUNCTION_DECL)
2494     {
2495       my_function = DECL_STRUCT_FUNCTION (expr);
2496       gcc_assert (my_function && my_function->cfg);
2497       visited_nodes = pointer_set_create ();
2498       FOR_EACH_BB_FN (bb, my_function)
2499         {
2500           for (bsi = bsi_start (bb);
2501                !bsi_end_p (bsi);
2502                bsi_next (&bsi))
2503             {
2504               walk_tree (bsi_stmt_ptr (bsi), estimate_num_insns_1,
2505                          &data, visited_nodes);
2506             }
2507         }
2508       pointer_set_destroy (visited_nodes);
2509     }
2510   else
2511     walk_tree_without_duplicates (&expr, estimate_num_insns_1, &data);
2512
2513   return data.count;
2514 }
2515
2516 /* Initializes weights used by estimate_num_insns.  */
2517
2518 void
2519 init_inline_once (void)
2520 {
2521   eni_inlining_weights.call_cost = PARAM_VALUE (PARAM_INLINE_CALL_COST);
2522   eni_inlining_weights.target_builtin_call_cost = 1;
2523   eni_inlining_weights.div_mod_cost = 10;
2524   eni_inlining_weights.omp_cost = 40;
2525
2526   eni_size_weights.call_cost = 1;
2527   eni_size_weights.target_builtin_call_cost = 1;
2528   eni_size_weights.div_mod_cost = 1;
2529   eni_size_weights.omp_cost = 40;
2530
2531   /* Estimating time for call is difficult, since we have no idea what the
2532      called function does.  In the current uses of eni_time_weights,
2533      underestimating the cost does less harm than overestimating it, so
2534      we choose a rather small value here.  */
2535   eni_time_weights.call_cost = 10;
2536   eni_time_weights.target_builtin_call_cost = 10;
2537   eni_time_weights.div_mod_cost = 10;
2538   eni_time_weights.omp_cost = 40;
2539 }
2540
2541 /* Install new lexical TREE_BLOCK underneath 'current_block'.  */
2542 static void
2543 add_lexical_block (tree current_block, tree new_block)
2544 {
2545   tree *blk_p;
2546
2547   /* Walk to the last sub-block.  */
2548   for (blk_p = &BLOCK_SUBBLOCKS (current_block);
2549        *blk_p;
2550        blk_p = &BLOCK_CHAIN (*blk_p))
2551     ;
2552   *blk_p = new_block;
2553   BLOCK_SUPERCONTEXT (new_block) = current_block;
2554 }
2555
2556 /* If *TP is a CALL_EXPR, replace it with its inline expansion.  */
2557
2558 static bool
2559 expand_call_inline (basic_block bb, tree stmt, tree *tp, void *data)
2560 {
2561   copy_body_data *id;
2562   tree t;
2563   tree use_retvar;
2564   tree fn;
2565   struct pointer_map_t *st;
2566   tree return_slot;
2567   tree modify_dest;
2568   location_t saved_location;
2569   struct cgraph_edge *cg_edge;
2570   const char *reason;
2571   basic_block return_block;
2572   edge e;
2573   block_stmt_iterator bsi, stmt_bsi;
2574   bool successfully_inlined = FALSE;
2575   bool purge_dead_abnormal_edges;
2576   tree t_step;
2577   tree var;
2578
2579   /* See what we've got.  */
2580   id = (copy_body_data *) data;
2581   t = *tp;
2582
2583   /* Set input_location here so we get the right instantiation context
2584      if we call instantiate_decl from inlinable_function_p.  */
2585   saved_location = input_location;
2586   if (EXPR_HAS_LOCATION (t))
2587     input_location = EXPR_LOCATION (t);
2588
2589   /* From here on, we're only interested in CALL_EXPRs.  */
2590   if (TREE_CODE (t) != CALL_EXPR)
2591     goto egress;
2592
2593   /* First, see if we can figure out what function is being called.
2594      If we cannot, then there is no hope of inlining the function.  */
2595   fn = get_callee_fndecl (t);
2596   if (!fn)
2597     goto egress;
2598
2599   /* Turn forward declarations into real ones.  */
2600   fn = cgraph_node (fn)->decl;
2601
2602   /* If fn is a declaration of a function in a nested scope that was
2603      globally declared inline, we don't set its DECL_INITIAL.
2604      However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
2605      C++ front-end uses it for cdtors to refer to their internal
2606      declarations, that are not real functions.  Fortunately those
2607      don't have trees to be saved, so we can tell by checking their
2608      DECL_SAVED_TREE.  */
2609   if (! DECL_INITIAL (fn)
2610       && DECL_ABSTRACT_ORIGIN (fn)
2611       && DECL_SAVED_TREE (DECL_ABSTRACT_ORIGIN (fn)))
2612     fn = DECL_ABSTRACT_ORIGIN (fn);
2613
2614   /* Objective C and fortran still calls tree_rest_of_compilation directly.
2615      Kill this check once this is fixed.  */
2616   if (!id->dst_node->analyzed)
2617     goto egress;
2618
2619   cg_edge = cgraph_edge (id->dst_node, stmt);
2620
2621   /* Constant propagation on argument done during previous inlining
2622      may create new direct call.  Produce an edge for it.  */
2623   if (!cg_edge)
2624     {
2625       struct cgraph_node *dest = cgraph_node (fn);
2626
2627       /* We have missing edge in the callgraph.  This can happen in one case
2628          where previous inlining turned indirect call into direct call by
2629          constant propagating arguments.  In all other cases we hit a bug
2630          (incorrect node sharing is most common reason for missing edges.  */
2631       gcc_assert (dest->needed || !flag_unit_at_a_time);
2632       cgraph_create_edge (id->dst_node, dest, stmt,
2633                           bb->count, CGRAPH_FREQ_BASE,
2634                           bb->loop_depth)->inline_failed
2635         = N_("originally indirect function call not considered for inlining");
2636       if (dump_file)
2637         {
2638            fprintf (dump_file, "Created new direct edge to %s",
2639                     cgraph_node_name (dest));
2640         }
2641       goto egress;
2642     }
2643
2644   /* Don't try to inline functions that are not well-suited to
2645      inlining.  */
2646   if (!cgraph_inline_p (cg_edge, &reason))
2647     {
2648       if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn))
2649           /* Avoid warnings during early inline pass. */
2650           && (!flag_unit_at_a_time || cgraph_global_info_ready))
2651         {
2652           sorry ("inlining failed in call to %q+F: %s", fn, reason);
2653           sorry ("called from here");
2654         }
2655       else if (warn_inline && DECL_DECLARED_INLINE_P (fn)
2656                && !DECL_IN_SYSTEM_HEADER (fn)
2657                && strlen (reason)
2658                && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn))
2659                /* Avoid warnings during early inline pass. */
2660                && (!flag_unit_at_a_time || cgraph_global_info_ready))
2661         {
2662           warning (OPT_Winline, "inlining failed in call to %q+F: %s",
2663                    fn, reason);
2664           warning (OPT_Winline, "called from here");
2665         }
2666       goto egress;
2667     }
2668   fn = cg_edge->callee->decl;
2669
2670 #ifdef ENABLE_CHECKING
2671   if (cg_edge->callee->decl != id->dst_node->decl)
2672     verify_cgraph_node (cg_edge->callee);
2673 #endif
2674
2675   /* We will be inlining this callee.  */
2676   id->eh_region = lookup_stmt_eh_region (stmt);
2677
2678   /* Split the block holding the CALL_EXPR.  */
2679   e = split_block (bb, stmt);
2680   bb = e->src;
2681   return_block = e->dest;
2682   remove_edge (e);
2683
2684   /* split_block splits after the statement; work around this by
2685      moving the call into the second block manually.  Not pretty,
2686      but seems easier than doing the CFG manipulation by hand
2687      when the CALL_EXPR is in the last statement of BB.  */
2688   stmt_bsi = bsi_last (bb);
2689   bsi_remove (&stmt_bsi, false);
2690
2691   /* If the CALL_EXPR was in the last statement of BB, it may have
2692      been the source of abnormal edges.  In this case, schedule
2693      the removal of dead abnormal edges.  */
2694   bsi = bsi_start (return_block);
2695   if (bsi_end_p (bsi))
2696     {
2697       bsi_insert_after (&bsi, stmt, BSI_NEW_STMT);
2698       purge_dead_abnormal_edges = true;
2699     }
2700   else
2701     {
2702       bsi_insert_before (&bsi, stmt, BSI_NEW_STMT);
2703       purge_dead_abnormal_edges = false;
2704     }
2705
2706   stmt_bsi = bsi_start (return_block);
2707
2708   /* Build a block containing code to initialize the arguments, the
2709      actual inline expansion of the body, and a label for the return
2710      statements within the function to jump to.  The type of the
2711      statement expression is the return type of the function call.  */
2712   id->block = make_node (BLOCK);
2713   BLOCK_ABSTRACT_ORIGIN (id->block) = fn;
2714   BLOCK_SOURCE_LOCATION (id->block) = input_location;
2715   add_lexical_block (TREE_BLOCK (stmt), id->block);
2716
2717   /* Local declarations will be replaced by their equivalents in this
2718      map.  */
2719   st = id->decl_map;
2720   id->decl_map = pointer_map_create ();
2721
2722   /* Record the function we are about to inline.  */
2723   id->src_fn = fn;
2724   id->src_node = cg_edge->callee;
2725   id->src_cfun = DECL_STRUCT_FUNCTION (fn);
2726   id->call_expr = t;
2727
2728   gcc_assert (!id->src_cfun->after_inlining);
2729
2730   id->entry_bb = bb;
2731   initialize_inlined_parameters (id, t, fn, bb);
2732
2733   if (DECL_INITIAL (fn))
2734     add_lexical_block (id->block, remap_blocks (DECL_INITIAL (fn), id));
2735
2736   /* Return statements in the function body will be replaced by jumps
2737      to the RET_LABEL.  */
2738
2739   gcc_assert (DECL_INITIAL (fn));
2740   gcc_assert (TREE_CODE (DECL_INITIAL (fn)) == BLOCK);
2741
2742   /* Find the lhs to which the result of this call is assigned.  */
2743   return_slot = NULL;
2744   if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
2745     {
2746       modify_dest = GIMPLE_STMT_OPERAND (stmt, 0);
2747
2748       /* The function which we are inlining might not return a value,
2749          in which case we should issue a warning that the function
2750          does not return a value.  In that case the optimizers will
2751          see that the variable to which the value is assigned was not
2752          initialized.  We do not want to issue a warning about that
2753          uninitialized variable.  */
2754       if (DECL_P (modify_dest))
2755         TREE_NO_WARNING (modify_dest) = 1;
2756       if (CALL_EXPR_RETURN_SLOT_OPT (t))
2757         {
2758           return_slot = modify_dest;
2759           modify_dest = NULL;
2760         }
2761     }
2762   else
2763     modify_dest = NULL;
2764
2765   /* Declare the return variable for the function.  */
2766   declare_return_variable (id, return_slot,
2767                            modify_dest, &use_retvar);
2768
2769   /* This is it.  Duplicate the callee body.  Assume callee is
2770      pre-gimplified.  Note that we must not alter the caller
2771      function in any way before this point, as this CALL_EXPR may be
2772      a self-referential call; if we're calling ourselves, we need to
2773      duplicate our body before altering anything.  */
2774   copy_body (id, bb->count, bb->frequency, bb, return_block);
2775
2776   /* Add local vars in this inlined callee to caller.  */
2777   t_step = id->src_cfun->unexpanded_var_list;
2778   for (; t_step; t_step = TREE_CHAIN (t_step))
2779     {
2780       var = TREE_VALUE (t_step);
2781       if (TREE_STATIC (var) && !TREE_ASM_WRITTEN (var))
2782         cfun->unexpanded_var_list = tree_cons (NULL_TREE, var,
2783                                                cfun->unexpanded_var_list);
2784       else
2785         cfun->unexpanded_var_list = tree_cons (NULL_TREE, remap_decl (var, id),
2786                                                cfun->unexpanded_var_list);
2787     }
2788
2789   /* Clean up.  */
2790   pointer_map_destroy (id->decl_map);
2791   id->decl_map = st;
2792
2793   /* If the inlined function returns a result that we care about,
2794      clobber the CALL_EXPR with a reference to the return variable.  */
2795   if (use_retvar && (TREE_CODE (bsi_stmt (stmt_bsi)) != CALL_EXPR))
2796     {
2797       *tp = use_retvar;
2798       if (gimple_in_ssa_p (cfun))
2799         {
2800           update_stmt (stmt);
2801           mark_symbols_for_renaming (stmt);
2802         }
2803       maybe_clean_or_replace_eh_stmt (stmt, stmt);
2804     }
2805   else
2806     /* We're modifying a TSI owned by gimple_expand_calls_inline();
2807        tsi_delink() will leave the iterator in a sane state.  */
2808     {
2809       /* Handle case of inlining function that miss return statement so
2810          return value becomes undefined.  */
2811       if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
2812           && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) == SSA_NAME)
2813         {
2814           tree name = TREE_OPERAND (stmt, 0);
2815           tree var = SSA_NAME_VAR (TREE_OPERAND (stmt, 0));
2816           tree def = gimple_default_def (cfun, var);
2817
2818           /* If the variable is used undefined, make this name undefined via
2819              move.  */
2820           if (def)
2821             {
2822               TREE_OPERAND (stmt, 1) = def;
2823               update_stmt (stmt);
2824             }
2825           /* Otherwise make this variable undefined.  */
2826           else
2827             {
2828               bsi_remove (&stmt_bsi, true);
2829               set_default_def (var, name);
2830               SSA_NAME_DEF_STMT (name) = build_empty_stmt ();
2831             }
2832         }
2833       else
2834         bsi_remove (&stmt_bsi, true);
2835     }
2836
2837   if (purge_dead_abnormal_edges)
2838     tree_purge_dead_abnormal_call_edges (return_block);
2839
2840   /* If the value of the new expression is ignored, that's OK.  We
2841      don't warn about this for CALL_EXPRs, so we shouldn't warn about
2842      the equivalent inlined version either.  */
2843   TREE_USED (*tp) = 1;
2844
2845   /* Output the inlining info for this abstract function, since it has been
2846      inlined.  If we don't do this now, we can lose the information about the
2847      variables in the function when the blocks get blown away as soon as we
2848      remove the cgraph node.  */
2849   (*debug_hooks->outlining_inline_function) (cg_edge->callee->decl);
2850
2851   /* Update callgraph if needed.  */
2852   cgraph_remove_node (cg_edge->callee);
2853
2854   id->block = NULL_TREE;
2855   successfully_inlined = TRUE;
2856
2857  egress:
2858   input_location = saved_location;
2859   return successfully_inlined;
2860 }
2861
2862 /* Expand call statements reachable from STMT_P.
2863    We can only have CALL_EXPRs as the "toplevel" tree code or nested
2864    in a GIMPLE_MODIFY_STMT.  See tree-gimple.c:get_call_expr_in().  We can
2865    unfortunately not use that function here because we need a pointer
2866    to the CALL_EXPR, not the tree itself.  */
2867
2868 static bool
2869 gimple_expand_calls_inline (basic_block bb, copy_body_data *id)
2870 {
2871   block_stmt_iterator bsi;
2872
2873   /* Register specific tree functions.  */
2874   tree_register_cfg_hooks ();
2875   for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2876     {
2877       tree *expr_p = bsi_stmt_ptr (bsi);
2878       tree stmt = *expr_p;
2879
2880       if (TREE_CODE (*expr_p) == GIMPLE_MODIFY_STMT)
2881         expr_p = &GIMPLE_STMT_OPERAND (*expr_p, 1);
2882       if (TREE_CODE (*expr_p) == WITH_SIZE_EXPR)
2883         expr_p = &TREE_OPERAND (*expr_p, 0);
2884       if (TREE_CODE (*expr_p) == CALL_EXPR)
2885         if (expand_call_inline (bb, stmt, expr_p, id))
2886           return true;
2887     }
2888   return false;
2889 }
2890
2891 /* Walk all basic blocks created after FIRST and try to fold every statement
2892    in the STATEMENTS pointer set.  */
2893 static void
2894 fold_marked_statements (int first, struct pointer_set_t *statements)
2895 {
2896   for (;first < n_basic_blocks;first++)
2897     if (BASIC_BLOCK (first))
2898       {
2899         block_stmt_iterator bsi;
2900         for (bsi = bsi_start (BASIC_BLOCK (first));
2901              !bsi_end_p (bsi); bsi_next (&bsi))
2902           if (pointer_set_contains (statements, bsi_stmt (bsi)))
2903             {
2904               tree old_stmt = bsi_stmt (bsi);
2905               if (fold_stmt (bsi_stmt_ptr (bsi)))
2906                 {
2907                   update_stmt (bsi_stmt (bsi));
2908                   if (maybe_clean_or_replace_eh_stmt (old_stmt, bsi_stmt (bsi)))
2909                      tree_purge_dead_eh_edges (BASIC_BLOCK (first));
2910                 }
2911             }
2912       }
2913 }
2914
2915 /* Return true if BB has at least one abnormal outgoing edge.  */
2916
2917 static inline bool
2918 has_abnormal_outgoing_edge_p (basic_block bb)
2919 {
2920   edge e;
2921   edge_iterator ei;
2922
2923   FOR_EACH_EDGE (e, ei, bb->succs)
2924     if (e->flags & EDGE_ABNORMAL)
2925       return true;
2926
2927   return false;
2928 }
2929
2930 /* Expand calls to inline functions in the body of FN.  */
2931
2932 unsigned int
2933 optimize_inline_calls (tree fn)
2934 {
2935   copy_body_data id;
2936   tree prev_fn;
2937   basic_block bb;
2938   int last = n_basic_blocks;
2939   /* There is no point in performing inlining if errors have already
2940      occurred -- and we might crash if we try to inline invalid
2941      code.  */
2942   if (errorcount || sorrycount)
2943     return 0;
2944
2945   /* Clear out ID.  */
2946   memset (&id, 0, sizeof (id));
2947
2948   id.src_node = id.dst_node = cgraph_node (fn);
2949   id.dst_fn = fn;
2950   /* Or any functions that aren't finished yet.  */
2951   prev_fn = NULL_TREE;
2952   if (current_function_decl)
2953     {
2954       id.dst_fn = current_function_decl;
2955       prev_fn = current_function_decl;
2956     }
2957
2958   id.copy_decl = copy_decl_maybe_to_var;
2959   id.transform_call_graph_edges = CB_CGE_DUPLICATE;
2960   id.transform_new_cfg = false;
2961   id.transform_return_to_modify = true;
2962   id.transform_lang_insert_block = false;
2963   id.statements_to_fold = pointer_set_create ();
2964
2965   push_gimplify_context ();
2966
2967   /* We make no attempts to keep dominance info up-to-date.  */
2968   free_dominance_info (CDI_DOMINATORS);
2969   free_dominance_info (CDI_POST_DOMINATORS);
2970
2971   /* Reach the trees by walking over the CFG, and note the
2972      enclosing basic-blocks in the call edges.  */
2973   /* We walk the blocks going forward, because inlined function bodies
2974      will split id->current_basic_block, and the new blocks will
2975      follow it; we'll trudge through them, processing their CALL_EXPRs
2976      along the way.  */
2977   FOR_EACH_BB (bb)
2978     gimple_expand_calls_inline (bb, &id);
2979
2980   pop_gimplify_context (NULL);
2981
2982 #ifdef ENABLE_CHECKING
2983     {
2984       struct cgraph_edge *e;
2985
2986       verify_cgraph_node (id.dst_node);
2987
2988       /* Double check that we inlined everything we are supposed to inline.  */
2989       for (e = id.dst_node->callees; e; e = e->next_callee)
2990         gcc_assert (e->inline_failed);
2991     }
2992 #endif
2993
2994   /* Fold the statements before compacting/renumbering the basic blocks.  */
2995   fold_marked_statements (last, id.statements_to_fold);
2996   pointer_set_destroy (id.statements_to_fold);
2997
2998   /* Renumber the (code) basic_blocks consecutively.  */
2999   compact_blocks ();
3000   /* Renumber the lexical scoping (non-code) blocks consecutively.  */
3001   number_blocks (fn);
3002
3003   /* We are not going to maintain the cgraph edges up to date.
3004      Kill it so it won't confuse us.  */
3005   cgraph_node_remove_callees (id.dst_node);
3006
3007   fold_cond_expr_cond ();
3008   /* It would be nice to check SSA/CFG/statement consistency here, but it is
3009      not possible yet - the IPA passes might make various functions to not
3010      throw and they don't care to proactively update local EH info.  This is
3011      done later in fixup_cfg pass that also execute the verification.  */
3012   return (TODO_update_ssa | TODO_cleanup_cfg
3013           | (gimple_in_ssa_p (cfun) ? TODO_remove_unused_locals : 0)
3014           | (profile_status != PROFILE_ABSENT ? TODO_rebuild_frequencies : 0));
3015 }
3016
3017 /* FN is a function that has a complete body, and CLONE is a function whose
3018    body is to be set to a copy of FN, mapping argument declarations according
3019    to the ARG_MAP splay_tree.  */
3020
3021 void
3022 clone_body (tree clone, tree fn, void *arg_map)
3023 {
3024   copy_body_data id;
3025
3026   /* Clone the body, as if we were making an inline call.  But, remap the
3027      parameters in the callee to the parameters of caller.  */
3028   memset (&id, 0, sizeof (id));
3029   id.src_fn = fn;
3030   id.dst_fn = clone;
3031   id.src_cfun = DECL_STRUCT_FUNCTION (fn);
3032   id.decl_map = (struct pointer_map_t *)arg_map;
3033
3034   id.copy_decl = copy_decl_no_change;
3035   id.transform_call_graph_edges = CB_CGE_DUPLICATE;
3036   id.transform_new_cfg = true;
3037   id.transform_return_to_modify = false;
3038   id.transform_lang_insert_block = true;
3039
3040   /* We're not inside any EH region.  */
3041   id.eh_region = -1;
3042
3043   /* Actually copy the body.  */
3044   append_to_statement_list_force (copy_generic_body (&id), &DECL_SAVED_TREE (clone));
3045 }
3046
3047 /* Passed to walk_tree.  Copies the node pointed to, if appropriate.  */
3048
3049 tree
3050 copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
3051 {
3052   enum tree_code code = TREE_CODE (*tp);
3053   enum tree_code_class cl = TREE_CODE_CLASS (code);
3054
3055   /* We make copies of most nodes.  */
3056   if (IS_EXPR_CODE_CLASS (cl)
3057       || IS_GIMPLE_STMT_CODE_CLASS (cl)
3058       || code == TREE_LIST
3059       || code == TREE_VEC
3060       || code == TYPE_DECL
3061       || code == OMP_CLAUSE)
3062     {
3063       /* Because the chain gets clobbered when we make a copy, we save it
3064          here.  */
3065       tree chain = NULL_TREE, new;
3066
3067       if (!GIMPLE_TUPLE_P (*tp))
3068         chain = TREE_CHAIN (*tp);
3069
3070       /* Copy the node.  */
3071       new = copy_node (*tp);
3072
3073       /* Propagate mudflap marked-ness.  */
3074       if (flag_mudflap && mf_marked_p (*tp))
3075         mf_mark (new);
3076
3077       *tp = new;
3078
3079       /* Now, restore the chain, if appropriate.  That will cause
3080          walk_tree to walk into the chain as well.  */
3081       if (code == PARM_DECL
3082           || code == TREE_LIST
3083           || code == OMP_CLAUSE)
3084         TREE_CHAIN (*tp) = chain;
3085
3086       /* For now, we don't update BLOCKs when we make copies.  So, we
3087          have to nullify all BIND_EXPRs.  */
3088       if (TREE_CODE (*tp) == BIND_EXPR)
3089         BIND_EXPR_BLOCK (*tp) = NULL_TREE;
3090     }
3091   else if (code == CONSTRUCTOR)
3092     {
3093       /* CONSTRUCTOR nodes need special handling because
3094          we need to duplicate the vector of elements.  */
3095       tree new;
3096
3097       new = copy_node (*tp);
3098
3099       /* Propagate mudflap marked-ness.  */
3100       if (flag_mudflap && mf_marked_p (*tp))
3101         mf_mark (new);
3102
3103       CONSTRUCTOR_ELTS (new) = VEC_copy (constructor_elt, gc,
3104                                          CONSTRUCTOR_ELTS (*tp));
3105       *tp = new;
3106     }
3107   else if (TREE_CODE_CLASS (code) == tcc_type)
3108     *walk_subtrees = 0;
3109   else if (TREE_CODE_CLASS (code) == tcc_declaration)
3110     *walk_subtrees = 0;
3111   else if (TREE_CODE_CLASS (code) == tcc_constant)
3112     *walk_subtrees = 0;
3113   else
3114     gcc_assert (code != STATEMENT_LIST);
3115   return NULL_TREE;
3116 }
3117
3118 /* The SAVE_EXPR pointed to by TP is being copied.  If ST contains
3119    information indicating to what new SAVE_EXPR this one should be mapped,
3120    use that one.  Otherwise, create a new node and enter it in ST.  FN is
3121    the function into which the copy will be placed.  */
3122
3123 static void
3124 remap_save_expr (tree *tp, void *st_, int *walk_subtrees)
3125 {
3126   struct pointer_map_t *st = (struct pointer_map_t *) st_;
3127   tree *n;
3128   tree t;
3129
3130   /* See if we already encountered this SAVE_EXPR.  */
3131   n = (tree *) pointer_map_contains (st, *tp);
3132
3133   /* If we didn't already remap this SAVE_EXPR, do so now.  */
3134   if (!n)
3135     {
3136       t = copy_node (*tp);
3137
3138       /* Remember this SAVE_EXPR.  */
3139       *pointer_map_insert (st, *tp) = t;
3140       /* Make sure we don't remap an already-remapped SAVE_EXPR.  */
3141       *pointer_map_insert (st, t) = t;
3142     }
3143   else
3144     {
3145       /* We've already walked into this SAVE_EXPR; don't do it again.  */
3146       *walk_subtrees = 0;
3147       t = *n;
3148     }
3149
3150   /* Replace this SAVE_EXPR with the copy.  */
3151   *tp = t;
3152 }
3153
3154 /* Called via walk_tree.  If *TP points to a DECL_STMT for a local label,
3155    copies the declaration and enters it in the splay_tree in DATA (which is
3156    really an `copy_body_data *').  */
3157
3158 static tree
3159 mark_local_for_remap_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
3160                         void *data)
3161 {
3162   copy_body_data *id = (copy_body_data *) data;
3163
3164   /* Don't walk into types.  */
3165   if (TYPE_P (*tp))
3166     *walk_subtrees = 0;
3167
3168   else if (TREE_CODE (*tp) == LABEL_EXPR)
3169     {
3170       tree decl = TREE_OPERAND (*tp, 0);
3171
3172       /* Copy the decl and remember the copy.  */
3173       insert_decl_map (id, decl, id->copy_decl (decl, id));
3174     }
3175
3176   return NULL_TREE;
3177 }
3178
3179 /* Perform any modifications to EXPR required when it is unsaved.  Does
3180    not recurse into EXPR's subtrees.  */
3181
3182 static void
3183 unsave_expr_1 (tree expr)
3184 {
3185   switch (TREE_CODE (expr))
3186     {
3187     case TARGET_EXPR:
3188       /* Don't mess with a TARGET_EXPR that hasn't been expanded.
3189          It's OK for this to happen if it was part of a subtree that
3190          isn't immediately expanded, such as operand 2 of another
3191          TARGET_EXPR.  */
3192       if (TREE_OPERAND (expr, 1))
3193         break;
3194
3195       TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
3196       TREE_OPERAND (expr, 3) = NULL_TREE;
3197       break;
3198
3199     default:
3200       break;
3201     }
3202 }
3203
3204 /* Called via walk_tree when an expression is unsaved.  Using the
3205    splay_tree pointed to by ST (which is really a `splay_tree'),
3206    remaps all local declarations to appropriate replacements.  */
3207
3208 static tree
3209 unsave_r (tree *tp, int *walk_subtrees, void *data)
3210 {
3211   copy_body_data *id = (copy_body_data *) data;
3212   struct pointer_map_t *st = id->decl_map;
3213   tree *n;
3214
3215   /* Only a local declaration (variable or label).  */
3216   if ((TREE_CODE (*tp) == VAR_DECL && !TREE_STATIC (*tp))
3217       || TREE_CODE (*tp) == LABEL_DECL)
3218     {
3219       /* Lookup the declaration.  */
3220       n = (tree *) pointer_map_contains (st, *tp);
3221
3222       /* If it's there, remap it.  */
3223       if (n)
3224         *tp = *n;
3225     }
3226
3227   else if (TREE_CODE (*tp) == STATEMENT_LIST)
3228     copy_statement_list (tp);
3229   else if (TREE_CODE (*tp) == BIND_EXPR)
3230     copy_bind_expr (tp, walk_subtrees, id);
3231   else if (TREE_CODE (*tp) == SAVE_EXPR)
3232     remap_save_expr (tp, st, walk_subtrees);
3233   else
3234     {
3235       copy_tree_r (tp, walk_subtrees, NULL);
3236
3237       /* Do whatever unsaving is required.  */
3238       unsave_expr_1 (*tp);
3239     }
3240
3241   /* Keep iterating.  */
3242   return NULL_TREE;
3243 }
3244
3245 /* Copies everything in EXPR and replaces variables, labels
3246    and SAVE_EXPRs local to EXPR.  */
3247
3248 tree
3249 unsave_expr_now (tree expr)
3250 {
3251   copy_body_data id;
3252
3253   /* There's nothing to do for NULL_TREE.  */
3254   if (expr == 0)
3255     return expr;
3256
3257   /* Set up ID.  */
3258   memset (&id, 0, sizeof (id));
3259   id.src_fn = current_function_decl;
3260   id.dst_fn = current_function_decl;
3261   id.decl_map = pointer_map_create ();
3262
3263   id.copy_decl = copy_decl_no_change;
3264   id.transform_call_graph_edges = CB_CGE_DUPLICATE;
3265   id.transform_new_cfg = false;
3266   id.transform_return_to_modify = false;
3267   id.transform_lang_insert_block = false;
3268
3269   /* Walk the tree once to find local labels.  */
3270   walk_tree_without_duplicates (&expr, mark_local_for_remap_r, &id);
3271
3272   /* Walk the tree again, copying, remapping, and unsaving.  */
3273   walk_tree (&expr, unsave_r, &id, NULL);
3274
3275   /* Clean up.  */
3276   pointer_map_destroy (id.decl_map);
3277
3278   return expr;
3279 }
3280
3281 /* Allow someone to determine if SEARCH is a child of TOP from gdb.  */
3282
3283 static tree
3284 debug_find_tree_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
3285 {
3286   if (*tp == data)
3287     return (tree) data;
3288   else
3289     return NULL;
3290 }
3291
3292 bool
3293 debug_find_tree (tree top, tree search)
3294 {
3295   return walk_tree_without_duplicates (&top, debug_find_tree_1, search) != 0;
3296 }
3297
3298
3299 /* Declare the variables created by the inliner.  Add all the variables in
3300    VARS to BIND_EXPR.  */
3301
3302 static void
3303 declare_inline_vars (tree block, tree vars)
3304 {
3305   tree t;
3306   for (t = vars; t; t = TREE_CHAIN (t))
3307     {
3308       DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
3309       gcc_assert (!TREE_STATIC (t) && !TREE_ASM_WRITTEN (t));
3310       cfun->unexpanded_var_list =
3311         tree_cons (NULL_TREE, t,
3312                    cfun->unexpanded_var_list);
3313     }
3314
3315   if (block)
3316     BLOCK_VARS (block) = chainon (BLOCK_VARS (block), vars);
3317 }
3318
3319
3320 /* Copy NODE (which must be a DECL).  The DECL originally was in the FROM_FN,
3321    but now it will be in the TO_FN.  PARM_TO_VAR means enable PARM_DECL to
3322    VAR_DECL translation.  */
3323
3324 static tree
3325 copy_decl_for_dup_finish (copy_body_data *id, tree decl, tree copy)
3326 {
3327   /* Don't generate debug information for the copy if we wouldn't have
3328      generated it for the copy either.  */
3329   DECL_ARTIFICIAL (copy) = DECL_ARTIFICIAL (decl);
3330   DECL_IGNORED_P (copy) = DECL_IGNORED_P (decl);
3331
3332   /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
3333      declaration inspired this copy.  */
3334   DECL_ABSTRACT_ORIGIN (copy) = DECL_ORIGIN (decl);
3335
3336   /* The new variable/label has no RTL, yet.  */
3337   if (CODE_CONTAINS_STRUCT (TREE_CODE (copy), TS_DECL_WRTL)
3338       && !TREE_STATIC (copy) && !DECL_EXTERNAL (copy))
3339     SET_DECL_RTL (copy, NULL_RTX);
3340
3341   /* These args would always appear unused, if not for this.  */
3342   TREE_USED (copy) = 1;
3343
3344   /* Set the context for the new declaration.  */
3345   if (!DECL_CONTEXT (decl))
3346     /* Globals stay global.  */
3347     ;
3348   else if (DECL_CONTEXT (decl) != id->src_fn)
3349     /* Things that weren't in the scope of the function we're inlining
3350        from aren't in the scope we're inlining to, either.  */
3351     ;
3352   else if (TREE_STATIC (decl))
3353     /* Function-scoped static variables should stay in the original
3354        function.  */
3355     ;
3356   else
3357     /* Ordinary automatic local variables are now in the scope of the
3358        new function.  */
3359     DECL_CONTEXT (copy) = id->dst_fn;
3360
3361   return copy;
3362 }
3363
3364 static tree
3365 copy_decl_to_var (tree decl, copy_body_data *id)
3366 {
3367   tree copy, type;
3368
3369   gcc_assert (TREE_CODE (decl) == PARM_DECL
3370               || TREE_CODE (decl) == RESULT_DECL);
3371
3372   type = TREE_TYPE (decl);
3373
3374   copy = build_decl (VAR_DECL, DECL_NAME (decl), type);
3375   TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl);
3376   TREE_READONLY (copy) = TREE_READONLY (decl);
3377   TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl);
3378   DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl);
3379   DECL_NO_TBAA_P (copy) = DECL_NO_TBAA_P (decl);
3380
3381   return copy_decl_for_dup_finish (id, decl, copy);
3382 }
3383
3384 /* Like copy_decl_to_var, but create a return slot object instead of a
3385    pointer variable for return by invisible reference.  */
3386
3387 static tree
3388 copy_result_decl_to_var (tree decl, copy_body_data *id)
3389 {
3390   tree copy, type;
3391
3392   gcc_assert (TREE_CODE (decl) == PARM_DECL
3393               || TREE_CODE (decl) == RESULT_DECL);
3394
3395   type = TREE_TYPE (decl);
3396   if (DECL_BY_REFERENCE (decl))
3397     type = TREE_TYPE (type);
3398
3399   copy = build_decl (VAR_DECL, DECL_NAME (decl), type);
3400   TREE_READONLY (copy) = TREE_READONLY (decl);
3401   TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl);
3402   if (!DECL_BY_REFERENCE (decl))
3403     {
3404       TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl);
3405       DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl);
3406       DECL_NO_TBAA_P (copy) = DECL_NO_TBAA_P (decl);
3407     }
3408
3409   return copy_decl_for_dup_finish (id, decl, copy);
3410 }
3411
3412
3413 static tree
3414 copy_decl_no_change (tree decl, copy_body_data *id)
3415 {
3416   tree copy;
3417
3418   copy = copy_node (decl);
3419
3420   /* The COPY is not abstract; it will be generated in DST_FN.  */
3421   DECL_ABSTRACT (copy) = 0;
3422   lang_hooks.dup_lang_specific_decl (copy);
3423
3424   /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
3425      been taken; it's for internal bookkeeping in expand_goto_internal.  */
3426   if (TREE_CODE (copy) == LABEL_DECL)
3427     {
3428       TREE_ADDRESSABLE (copy) = 0;
3429       LABEL_DECL_UID (copy) = -1;
3430     }
3431
3432   return copy_decl_for_dup_finish (id, decl, copy);
3433 }
3434
3435 static tree
3436 copy_decl_maybe_to_var (tree decl, copy_body_data *id)
3437 {
3438   if (TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL)
3439     return copy_decl_to_var (decl, id);
3440   else
3441     return copy_decl_no_change (decl, id);
3442 }
3443
3444 /* Return a copy of the function's argument tree.  */
3445 static tree
3446 copy_arguments_for_versioning (tree orig_parm, copy_body_data * id)
3447 {
3448   tree *arg_copy, *parg;
3449
3450   arg_copy = &orig_parm;
3451   for (parg = arg_copy; *parg; parg = &TREE_CHAIN (*parg))
3452     {
3453       tree new = remap_decl (*parg, id);
3454       lang_hooks.dup_lang_specific_decl (new);
3455       TREE_CHAIN (new) = TREE_CHAIN (*parg);
3456       *parg = new;
3457     }
3458   return orig_parm;
3459 }
3460
3461 /* Return a copy of the function's static chain.  */
3462 static tree
3463 copy_static_chain (tree static_chain, copy_body_data * id)
3464 {
3465   tree *chain_copy, *pvar;
3466
3467   chain_copy = &static_chain;
3468   for (pvar = chain_copy; *pvar; pvar = &TREE_CHAIN (*pvar))
3469     {
3470       tree new = remap_decl (*pvar, id);
3471       lang_hooks.dup_lang_specific_decl (new);
3472       TREE_CHAIN (new) = TREE_CHAIN (*pvar);
3473       *pvar = new;
3474     }
3475   return static_chain;
3476 }
3477
3478 /* Return true if the function is allowed to be versioned.
3479    This is a guard for the versioning functionality.  */
3480 bool
3481 tree_versionable_function_p (tree fndecl)
3482 {
3483   if (fndecl == NULL_TREE)
3484     return false;
3485   /* ??? There are cases where a function is
3486      uninlinable but can be versioned.  */
3487   if (!tree_inlinable_function_p (fndecl))
3488     return false;
3489
3490   return true;
3491 }
3492
3493 /* Create a copy of a function's tree.
3494    OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
3495    of the original function and the new copied function
3496    respectively.  In case we want to replace a DECL
3497    tree with another tree while duplicating the function's
3498    body, TREE_MAP represents the mapping between these
3499    trees. If UPDATE_CLONES is set, the call_stmt fields
3500    of edges of clones of the function will be updated.  */
3501 void
3502 tree_function_versioning (tree old_decl, tree new_decl, varray_type tree_map,
3503                           bool update_clones)
3504 {
3505   struct cgraph_node *old_version_node;
3506   struct cgraph_node *new_version_node;
3507   copy_body_data id;
3508   tree p;
3509   unsigned i;
3510   struct ipa_replace_map *replace_info;
3511   basic_block old_entry_block;
3512   tree t_step;
3513   tree old_current_function_decl = current_function_decl;
3514
3515   gcc_assert (TREE_CODE (old_decl) == FUNCTION_DECL
3516               && TREE_CODE (new_decl) == FUNCTION_DECL);
3517   DECL_POSSIBLY_INLINED (old_decl) = 1;
3518
3519   old_version_node = cgraph_node (old_decl);
3520   new_version_node = cgraph_node (new_decl);
3521
3522   DECL_ARTIFICIAL (new_decl) = 1;
3523   DECL_ABSTRACT_ORIGIN (new_decl) = DECL_ORIGIN (old_decl);
3524
3525   /* Prepare the data structures for the tree copy.  */
3526   memset (&id, 0, sizeof (id));
3527
3528   /* Generate a new name for the new version. */
3529   if (!update_clones)
3530     {
3531       DECL_NAME (new_decl) =  create_tmp_var_name (NULL);
3532       SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
3533       SET_DECL_RTL (new_decl, NULL_RTX);
3534       id.statements_to_fold = pointer_set_create ();
3535     }
3536
3537   id.decl_map = pointer_map_create ();
3538   id.src_fn = old_decl;
3539   id.dst_fn = new_decl;
3540   id.src_node = old_version_node;
3541   id.dst_node = new_version_node;
3542   id.src_cfun = DECL_STRUCT_FUNCTION (old_decl);
3543
3544   id.copy_decl = copy_decl_no_change;
3545   id.transform_call_graph_edges
3546     = update_clones ? CB_CGE_MOVE_CLONES : CB_CGE_MOVE;
3547   id.transform_new_cfg = true;
3548   id.transform_return_to_modify = false;
3549   id.transform_lang_insert_block = false;
3550
3551   current_function_decl = new_decl;
3552   old_entry_block = ENTRY_BLOCK_PTR_FOR_FUNCTION
3553     (DECL_STRUCT_FUNCTION (old_decl));
3554   initialize_cfun (new_decl, old_decl,
3555                    old_entry_block->count,
3556                    old_entry_block->frequency);
3557   push_cfun (DECL_STRUCT_FUNCTION (new_decl));
3558
3559   /* Copy the function's static chain.  */
3560   p = DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl;
3561   if (p)
3562     DECL_STRUCT_FUNCTION (new_decl)->static_chain_decl =
3563       copy_static_chain (DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl,
3564                          &id);
3565   /* Copy the function's arguments.  */
3566   if (DECL_ARGUMENTS (old_decl) != NULL_TREE)
3567     DECL_ARGUMENTS (new_decl) =
3568       copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl), &id);
3569
3570   /* If there's a tree_map, prepare for substitution.  */
3571   if (tree_map)
3572     for (i = 0; i < VARRAY_ACTIVE_SIZE (tree_map); i++)
3573       {
3574         replace_info = VARRAY_GENERIC_PTR (tree_map, i);
3575         if (replace_info->replace_p)
3576           insert_decl_map (&id, replace_info->old_tree,
3577                            replace_info->new_tree);
3578       }
3579
3580   DECL_INITIAL (new_decl) = remap_blocks (DECL_INITIAL (id.src_fn), &id);
3581
3582   /* Renumber the lexical scoping (non-code) blocks consecutively.  */
3583   number_blocks (id.dst_fn);
3584
3585   if (DECL_STRUCT_FUNCTION (old_decl)->unexpanded_var_list != NULL_TREE)
3586     /* Add local vars.  */
3587     for (t_step = DECL_STRUCT_FUNCTION (old_decl)->unexpanded_var_list;
3588          t_step; t_step = TREE_CHAIN (t_step))
3589       {
3590         tree var = TREE_VALUE (t_step);
3591         if (TREE_STATIC (var) && !TREE_ASM_WRITTEN (var))
3592           cfun->unexpanded_var_list = tree_cons (NULL_TREE, var,
3593                                                  cfun->unexpanded_var_list);
3594         else
3595           cfun->unexpanded_var_list =
3596             tree_cons (NULL_TREE, remap_decl (var, &id),
3597                        cfun->unexpanded_var_list);
3598       }
3599
3600   /* Copy the Function's body.  */
3601   copy_body (&id, old_entry_block->count, old_entry_block->frequency, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR);
3602
3603   if (DECL_RESULT (old_decl) != NULL_TREE)
3604     {
3605       tree *res_decl = &DECL_RESULT (old_decl);
3606       DECL_RESULT (new_decl) = remap_decl (*res_decl, &id);
3607       lang_hooks.dup_lang_specific_decl (DECL_RESULT (new_decl));
3608     }
3609
3610   /* Renumber the lexical scoping (non-code) blocks consecutively.  */
3611   number_blocks (new_decl);
3612
3613   /* Clean up.  */
3614   pointer_map_destroy (id.decl_map);
3615   if (!update_clones)
3616     {
3617       fold_marked_statements (0, id.statements_to_fold);
3618       pointer_set_destroy (id.statements_to_fold);
3619       fold_cond_expr_cond ();
3620     }
3621   if (gimple_in_ssa_p (cfun))
3622     {
3623       free_dominance_info (CDI_DOMINATORS);
3624       free_dominance_info (CDI_POST_DOMINATORS);
3625       if (!update_clones)
3626         delete_unreachable_blocks ();
3627       update_ssa (TODO_update_ssa);
3628       if (!update_clones)
3629         {
3630           fold_cond_expr_cond ();
3631           if (need_ssa_update_p ())
3632             update_ssa (TODO_update_ssa);
3633         }
3634     }
3635   free_dominance_info (CDI_DOMINATORS);
3636   free_dominance_info (CDI_POST_DOMINATORS);
3637   pop_cfun ();
3638   current_function_decl = old_current_function_decl;
3639   gcc_assert (!current_function_decl
3640               || DECL_STRUCT_FUNCTION (current_function_decl) == cfun);
3641   return;
3642 }
3643
3644 /* Duplicate a type, fields and all.  */
3645
3646 tree
3647 build_duplicate_type (tree type)
3648 {
3649   struct copy_body_data id;
3650
3651   memset (&id, 0, sizeof (id));
3652   id.src_fn = current_function_decl;
3653   id.dst_fn = current_function_decl;
3654   id.src_cfun = cfun;
3655   id.decl_map = pointer_map_create ();
3656   id.copy_decl = copy_decl_no_change;
3657
3658   type = remap_type_1 (type, &id);
3659
3660   pointer_map_destroy (id.decl_map);
3661
3662   return type;
3663 }