gcc/tree-inline.c

   1 /* Tree inlining.
   2    Copyright 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   3    Contributed by Alexandre Oliva <aoliva@redhat.com>
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GCC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  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 "integrate.h"
  36 #include "varray.h"
  37 #include "hashtab.h"
  38 #include "splay-tree.h"
  39 #include "langhooks.h"
  40 #include "cgraph.h"
  41 #include "intl.h"
  42 #include "tree-mudflap.h"
  43 #include "function.h"
  44 #include "diagnostic.h"
  45
  46 /* I'm not real happy about this, but we need to handle gimple and
  47    non-gimple trees.  */
  48 #include "tree-iterator.h"
  49 #include "tree-gimple.h"
  50
  51 /* 0 if we should not perform inlining.
  52    1 if we should expand functions calls inline at the tree level.
  53    2 if we should consider *all* functions to be inline
  54    candidates.  */
  55
  56 int flag_inline_trees = 0;
  57
  58 /* To Do:
  59
  60    o In order to make inlining-on-trees work, we pessimized
  61      function-local static constants.  In particular, they are now
  62      always output, even when not addressed.  Fix this by treating
  63      function-local static constants just like global static
  64      constants; the back-end already knows not to output them if they
  65      are not needed.
  66
  67    o Provide heuristics to clamp inlining of recursive template
  68      calls?  */
  69
  70 /* Data required for function inlining.  */
  71
  72 typedef struct inline_data
  73 {
  74   /* A stack of the functions we are inlining.  For example, if we are
  75      compiling `f', which calls `g', which calls `h', and we are
  76      inlining the body of `h', the stack will contain, `h', followed
  77      by `g', followed by `f'.  The first few elements of the stack may
  78      contain other functions that we know we should not recurse into,
  79      even though they are not directly being inlined.  */
  80   varray_type fns;
  81   /* The index of the first element of FNS that really represents an
  82      inlined function.  */
  83   unsigned first_inlined_fn;
  84   /* The label to jump to when a return statement is encountered.  If
  85      this value is NULL, then return statements will simply be
  86      remapped as return statements, rather than as jumps.  */
  87   tree ret_label;
  88   /* The VAR_DECL for the return value.  */
  89   tree retvar;
  90   /* The map from local declarations in the inlined function to
  91      equivalents in the function into which it is being inlined.  */
  92   splay_tree decl_map;
  93   /* Nonzero if we are currently within the cleanup for a
  94      TARGET_EXPR.  */
  95   int in_target_cleanup_p;
  96   /* A list of the functions current function has inlined.  */
  97   varray_type inlined_fns;
  98   /* We use the same mechanism to build clones that we do to perform
  99      inlining.  However, there are a few places where we need to
 100      distinguish between those two situations.  This flag is true if
 101      we are cloning, rather than inlining.  */
 102   bool cloning_p;
 103   /* Similarly for saving function body.  */
 104   bool saving_p;
 105   /* Hash table used to prevent walk_tree from visiting the same node
 106      umpteen million times.  */
 107   htab_t tree_pruner;
 108   /* Callgraph node of function we are inlining into.  */
 109   struct cgraph_node *node;
 110   /* Callgraph node of currently inlined function.  */
 111   struct cgraph_node *current_node;
 112   /* Statement iterator.  We need this so we can keep the tree in
 113      gimple form when we insert the inlined function.   It is not
 114      used when we are not dealing with gimple trees.  */
 115   tree_stmt_iterator tsi;
 116 } inline_data;
 117
 118 /* Prototypes.  */
 119
 120 /* The approximate number of instructions per statement.  This number
 121    need not be particularly accurate; it is used only to make
 122    decisions about when a function is too big to inline.  */
 123 #define INSNS_PER_STMT (10)
 124
 125 static tree copy_body_r (tree *, int *, void *);
 126 static tree copy_body (inline_data *);
 127 static tree expand_call_inline (tree *, int *, void *);
 128 static void expand_calls_inline (tree *, inline_data *);
 129 static bool inlinable_function_p (tree);
 130 static tree remap_decl (tree, inline_data *);
 131 static tree remap_type (tree, inline_data *);
 132 static tree initialize_inlined_parameters (inline_data *, tree,
 133                                            tree, tree, tree);
 134 static void remap_block (tree *, inline_data *);
 135 static tree remap_decls (tree, inline_data *);
 136 static void copy_bind_expr (tree *, int *, inline_data *);
 137 static tree mark_local_for_remap_r (tree *, int *, void *);
 138 static tree unsave_r (tree *, int *, void *);
 139 static void declare_inline_vars (tree bind_expr, tree vars);
 140
 141 /* Insert a tree->tree mapping for ID.  Despite the name suggests
 142    that the trees should be variables, it is used for more than that.  */
 143
 144 static void
 145 insert_decl_map (inline_data *id, tree key, tree value)
 146 {
 147   splay_tree_insert (id->decl_map, (splay_tree_key) key,
 148                      (splay_tree_value) value);
 149
 150   /* Always insert an identity map as well.  If we see this same new
 151      node again, we won't want to duplicate it a second time.  */
 152   if (key != value)
 153     splay_tree_insert (id->decl_map, (splay_tree_key) value,
 154                        (splay_tree_value) value);
 155 }
 156
 157 /* Remap DECL during the copying of the BLOCK tree for the function.
 158    We are only called to remap local variables in the current function.  */
 159
 160 static tree
 161 remap_decl (tree decl, inline_data *id)
 162 {
 163   splay_tree_node n = splay_tree_lookup (id->decl_map, (splay_tree_key) decl);
 164   tree fn = VARRAY_TOP_TREE (id->fns);
 165
 166   /* See if we have remapped this declaration.  If we didn't already have an
 167      equivalent for this declaration, create one now.  */
 168   if (!n)
 169     {
 170       /* Make a copy of the variable or label.  */
 171       tree t = copy_decl_for_inlining (decl, fn, VARRAY_TREE (id->fns, 0));
 172
 173       /* Remap types, if necessary.  */
 174       TREE_TYPE (t) = remap_type (TREE_TYPE (t), id);
 175       if (TREE_CODE (t) == TYPE_DECL)
 176         DECL_ORIGINAL_TYPE (t) = remap_type (DECL_ORIGINAL_TYPE (t), id);
 177       else if (TREE_CODE (t) == PARM_DECL)
 178         DECL_ARG_TYPE_AS_WRITTEN (t)
 179           = remap_type (DECL_ARG_TYPE_AS_WRITTEN (t), id);
 180
 181       /* Remap sizes as necessary.  */
 182       walk_tree (&DECL_SIZE (t), copy_body_r, id, NULL);
 183       walk_tree (&DECL_SIZE_UNIT (t), copy_body_r, id, NULL);
 184
 185       /* If fields, do likewise for offset and qualifier. */
 186       if (TREE_CODE (t) == FIELD_DECL)
 187         {
 188           walk_tree (&DECL_FIELD_OFFSET (t), copy_body_r, id, NULL);
 189           if (TREE_CODE (DECL_CONTEXT (t)) == QUAL_UNION_TYPE)
 190             walk_tree (&DECL_QUALIFIER (t), copy_body_r, id, NULL);
 191         }
 192
 193 #if 0
 194       /* FIXME handle anon aggrs.  */
 195       if (! DECL_NAME (t) && TREE_TYPE (t)
 196           && lang_hooks.tree_inlining.anon_aggr_type_p (TREE_TYPE (t)))
 197         {
 198           /* For a VAR_DECL of anonymous type, we must also copy the
 199              member VAR_DECLS here and rechain the DECL_ANON_UNION_ELEMS.  */
 200           tree members = NULL;
 201           tree src;
 202
 203           for (src = DECL_ANON_UNION_ELEMS (t); src;
 204                src = TREE_CHAIN (src))
 205             {
 206               tree member = remap_decl (TREE_VALUE (src), id);
 207
 208               if (TREE_PURPOSE (src))
 209                 abort ();
 210               members = tree_cons (NULL, member, members);
 211             }
 212           DECL_ANON_UNION_ELEMS (t) = nreverse (members);
 213         }
 214 #endif
 215
 216       /* Remember it, so that if we encounter this local entity
 217          again we can reuse this copy.  */
 218       insert_decl_map (id, decl, t);
 219       return t;
 220     }
 221
 222   return unshare_expr ((tree) n->value);
 223 }
 224
 225 static tree
 226 remap_type (tree type, inline_data *id)
 227 {
 228   splay_tree_node node;
 229   tree new, t;
 230
 231   if (type == NULL)
 232     return type;
 233
 234   /* See if we have remapped this type.  */
 235   node = splay_tree_lookup (id->decl_map, (splay_tree_key) type);
 236   if (node)
 237     return (tree) node->value;
 238
 239   /* The type only needs remapping if it's variably modified by a variable
 240      in the function we are inlining.  */
 241   if (! variably_modified_type_p (type, VARRAY_TOP_TREE (id->fns)))
 242     {
 243       insert_decl_map (id, type, type);
 244       return type;
 245     }
 246
 247   /* We do need a copy.  build and register it now.  If this is a pointer or
 248      reference type, remap the designated type and make a new pointer or
 249      reference type.  */
 250   if (TREE_CODE (type) == POINTER_TYPE)
 251     {
 252       new = build_pointer_type_for_mode (remap_type (TREE_TYPE (type), id),
 253                                          TYPE_MODE (type),
 254                                          TYPE_REF_CAN_ALIAS_ALL (type));
 255       insert_decl_map (id, type, new);
 256       return new;
 257     }
 258   else if (TREE_CODE (type) == REFERENCE_TYPE)
 259     {
 260       new = build_reference_type_for_mode (remap_type (TREE_TYPE (type), id),
 261                                             TYPE_MODE (type),
 262                                             TYPE_REF_CAN_ALIAS_ALL (type));
 263       insert_decl_map (id, type, new);
 264       return new;
 265     }
 266   else
 267     new = copy_node (type);
 268
 269   insert_decl_map (id, type, new);
 270
 271   /* This is a new type, not a copy of an old type.  Need to reassociate
 272      variants.  We can handle everything except the main variant lazily.  */
 273   t = TYPE_MAIN_VARIANT (type);
 274   if (type != t)
 275     {
 276       t = remap_type (t, id);
 277       TYPE_MAIN_VARIANT (new) = t;
 278       TYPE_NEXT_VARIANT (new) = TYPE_MAIN_VARIANT (t);
 279       TYPE_NEXT_VARIANT (t) = new;
 280     }
 281   else
 282     {
 283       TYPE_MAIN_VARIANT (new) = new;
 284       TYPE_NEXT_VARIANT (new) = NULL;
 285     }
 286
 287   /* Lazily create pointer and reference types.  */
 288   TYPE_POINTER_TO (new) = NULL;
 289   TYPE_REFERENCE_TO (new) = NULL;
 290
 291   switch (TREE_CODE (new))
 292     {
 293     case INTEGER_TYPE:
 294     case REAL_TYPE:
 295     case ENUMERAL_TYPE:
 296     case BOOLEAN_TYPE:
 297     case CHAR_TYPE:
 298       t = TYPE_MIN_VALUE (new);
 299       if (t && TREE_CODE (t) != INTEGER_CST)
 300         walk_tree (&TYPE_MIN_VALUE (new), copy_body_r, id, NULL);
 301
 302       t = TYPE_MAX_VALUE (new);
 303       if (t && TREE_CODE (t) != INTEGER_CST)
 304         walk_tree (&TYPE_MAX_VALUE (new), copy_body_r, id, NULL);
 305       return new;
 306
 307     case FUNCTION_TYPE:
 308       TREE_TYPE (new) = remap_type (TREE_TYPE (new), id);
 309       walk_tree (&TYPE_ARG_TYPES (new), copy_body_r, id, NULL);
 310       return new;
 311
 312     case ARRAY_TYPE:
 313       TREE_TYPE (new) = remap_type (TREE_TYPE (new), id);
 314       TYPE_DOMAIN (new) = remap_type (TYPE_DOMAIN (new), id);
 315       break;
 316
 317     case RECORD_TYPE:
 318     case UNION_TYPE:
 319     case QUAL_UNION_TYPE:
 320       walk_tree (&TYPE_FIELDS (new), copy_body_r, id, NULL);
 321       break;
 322
 323     case FILE_TYPE:
 324     case SET_TYPE:
 325     case OFFSET_TYPE:
 326     default:
 327       /* Shouldn't have been thought variable sized.  */
 328       abort ();
 329     }
 330
 331   walk_tree (&TYPE_SIZE (new), copy_body_r, id, NULL);
 332   walk_tree (&TYPE_SIZE_UNIT (new), copy_body_r, id, NULL);
 333
 334   return new;
 335 }
 336
 337 static tree
 338 remap_decls (tree decls, inline_data *id)
 339 {
 340   tree old_var;
 341   tree new_decls = NULL_TREE;
 342
 343   /* Remap its variables.  */
 344   for (old_var = decls; old_var; old_var = TREE_CHAIN (old_var))
 345     {
 346       tree new_var;
 347
 348       /* Remap the variable.  */
 349       new_var = remap_decl (old_var, id);
 350
 351       /* If we didn't remap this variable, so we can't mess with its
 352          TREE_CHAIN.  If we remapped this variable to the return slot, it's
 353          already declared somewhere else, so don't declare it here.  */
 354       if (!new_var || new_var == id->retvar)
 355         ;
 356 #ifdef ENABLE_CHECKING
 357       else if (!DECL_P (new_var))
 358         abort ();
 359 #endif
 360       else
 361         {
 362           TREE_CHAIN (new_var) = new_decls;
 363           new_decls = new_var;
 364         }
 365     }
 366
 367   return nreverse (new_decls);
 368 }
 369
 370 /* Copy the BLOCK to contain remapped versions of the variables
 371    therein.  And hook the new block into the block-tree.  */
 372
 373 static void
 374 remap_block (tree *block, inline_data *id)
 375 {
 376   tree old_block;
 377   tree new_block;
 378   tree fn;
 379
 380   /* Make the new block.  */
 381   old_block = *block;
 382   new_block = make_node (BLOCK);
 383   TREE_USED (new_block) = TREE_USED (old_block);
 384   BLOCK_ABSTRACT_ORIGIN (new_block) = old_block;
 385   *block = new_block;
 386
 387   /* Remap its variables.  */
 388   BLOCK_VARS (new_block) = remap_decls (BLOCK_VARS (old_block), id);
 389
 390   fn = VARRAY_TREE (id->fns, 0);
 391 #if 1
 392   /* FIXME!  It shouldn't be so hard to manage blocks.  Rebuilding them in
 393      rest_of_compilation is a good start.  */
 394   if (id->cloning_p)
 395     /* We're building a clone; DECL_INITIAL is still
 396        error_mark_node, and current_binding_level is the parm
 397        binding level.  */
 398     lang_hooks.decls.insert_block (new_block);
 399   else
 400     {
 401       /* Attach this new block after the DECL_INITIAL block for the
 402          function into which this block is being inlined.  In
 403          rest_of_compilation we will straighten out the BLOCK tree.  */
 404       tree *first_block;
 405       if (DECL_INITIAL (fn))
 406         first_block = &BLOCK_CHAIN (DECL_INITIAL (fn));
 407       else
 408         first_block = &DECL_INITIAL (fn);
 409       BLOCK_CHAIN (new_block) = *first_block;
 410       *first_block = new_block;
 411     }
 412 #endif
 413   /* Remember the remapped block.  */
 414   insert_decl_map (id, old_block, new_block);
 415 }
 416
 417 static void
 418 copy_statement_list (tree *tp)
 419 {
 420   tree_stmt_iterator oi, ni;
 421   tree new;
 422
 423   new = alloc_stmt_list ();
 424   ni = tsi_start (new);
 425   oi = tsi_start (*tp);
 426   *tp = new;
 427
 428   for (; !tsi_end_p (oi); tsi_next (&oi))
 429     tsi_link_after (&ni, tsi_stmt (oi), TSI_NEW_STMT);
 430 }
 431
 432 static void
 433 copy_bind_expr (tree *tp, int *walk_subtrees, inline_data *id)
 434 {
 435   tree block = BIND_EXPR_BLOCK (*tp);
 436   /* Copy (and replace) the statement.  */
 437   copy_tree_r (tp, walk_subtrees, NULL);
 438   if (block)
 439     {
 440       remap_block (&block, id);
 441       BIND_EXPR_BLOCK (*tp) = block;
 442     }
 443
 444   if (BIND_EXPR_VARS (*tp))
 445     /* This will remap a lot of the same decls again, but this should be
 446        harmless.  */
 447     BIND_EXPR_VARS (*tp) = remap_decls (BIND_EXPR_VARS (*tp), id);
 448 }
 449
 450 /* Called from copy_body via walk_tree.  DATA is really an `inline_data *'.  */
 451
 452 static tree
 453 copy_body_r (tree *tp, int *walk_subtrees, void *data)
 454 {
 455   inline_data *id = (inline_data *) data;
 456   tree fn = VARRAY_TOP_TREE (id->fns);
 457
 458 #if 0
 459   /* All automatic variables should have a DECL_CONTEXT indicating
 460      what function they come from.  */
 461   if ((TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == LABEL_DECL)
 462       && DECL_NAMESPACE_SCOPE_P (*tp))
 463     if (! DECL_EXTERNAL (*tp) && ! TREE_STATIC (*tp))
 464       abort ();
 465 #endif
 466
 467   /* If this is a RETURN_EXPR, change it into a MODIFY_EXPR and a
 468      GOTO_EXPR with the RET_LABEL as its target.  */
 469   if (TREE_CODE (*tp) == RETURN_EXPR && id->ret_label)
 470     {
 471       tree return_stmt = *tp;
 472       tree goto_stmt;
 473
 474       /* Build the GOTO_EXPR.  */
 475       tree assignment = TREE_OPERAND (return_stmt, 0);
 476       goto_stmt = build1 (GOTO_EXPR, void_type_node, id->ret_label);
 477       TREE_USED (id->ret_label) = 1;
 478
 479       /* If we're returning something, just turn that into an
 480          assignment into the equivalent of the original
 481          RESULT_DECL.  */
 482       if (assignment)
 483         {
 484           /* Do not create a statement containing a naked RESULT_DECL.  */
 485           if (TREE_CODE (assignment) == RESULT_DECL)
 486             gimplify_stmt (&assignment);
 487
 488           *tp = build (BIND_EXPR, void_type_node, NULL, NULL, NULL);
 489           append_to_statement_list (assignment, &BIND_EXPR_BODY (*tp));
 490           append_to_statement_list (goto_stmt, &BIND_EXPR_BODY (*tp));
 491         }
 492       /* If we're not returning anything just do the jump.  */
 493       else
 494         *tp = goto_stmt;
 495     }
 496   /* Local variables and labels need to be replaced by equivalent
 497      variables.  We don't want to copy static variables; there's only
 498      one of those, no matter how many times we inline the containing
 499      function.  Similarly for globals from an outer function.  */
 500   else if (lang_hooks.tree_inlining.auto_var_in_fn_p (*tp, fn))
 501     {
 502       tree new_decl;
 503
 504       /* Remap the declaration.  */
 505       new_decl = remap_decl (*tp, id);
 506       if (! new_decl)
 507         abort ();
 508       /* Replace this variable with the copy.  */
 509       STRIP_TYPE_NOPS (new_decl);
 510       *tp = new_decl;
 511     }
 512 #if 0
 513   else if (nonstatic_local_decl_p (*tp)
 514            && DECL_CONTEXT (*tp) != VARRAY_TREE (id->fns, 0))
 515     abort ();
 516 #endif
 517   else if (TREE_CODE (*tp) == STATEMENT_LIST)
 518     copy_statement_list (tp);
 519   else if (TREE_CODE (*tp) == SAVE_EXPR)
 520     remap_save_expr (tp, id->decl_map, walk_subtrees);
 521   else if (TREE_CODE (*tp) == BIND_EXPR)
 522     copy_bind_expr (tp, walk_subtrees, id);
 523   else if (TREE_CODE (*tp) == LABELED_BLOCK_EXPR)
 524     {
 525       /* We need a new copy of this labeled block; the EXIT_BLOCK_EXPR
 526          will refer to it, so save a copy ready for remapping.  We
 527          save it in the decl_map, although it isn't a decl.  */
 528       tree new_block = copy_node (*tp);
 529       insert_decl_map (id, *tp, new_block);
 530       *tp = new_block;
 531     }
 532   else if (TREE_CODE (*tp) == EXIT_BLOCK_EXPR)
 533     {
 534       splay_tree_node n
 535         = splay_tree_lookup (id->decl_map,
 536                              (splay_tree_key) TREE_OPERAND (*tp, 0));
 537       /* We _must_ have seen the enclosing LABELED_BLOCK_EXPR.  */
 538       if (! n)
 539         abort ();
 540       *tp = copy_node (*tp);
 541       TREE_OPERAND (*tp, 0) = (tree) n->value;
 542     }
 543   /* Types may need remapping as well.  */
 544   else if (TYPE_P (*tp))
 545     *tp = remap_type (*tp, id);
 546
 547   /* Otherwise, just copy the node.  Note that copy_tree_r already
 548      knows not to copy VAR_DECLs, etc., so this is safe.  */
 549   else
 550     {
 551       tree old_node = *tp;
 552
 553       if (TREE_CODE (*tp) == MODIFY_EXPR
 554           && TREE_OPERAND (*tp, 0) == TREE_OPERAND (*tp, 1)
 555           && (lang_hooks.tree_inlining.auto_var_in_fn_p
 556               (TREE_OPERAND (*tp, 0), fn)))
 557         {
 558           /* Some assignments VAR = VAR; don't generate any rtl code
 559              and thus don't count as variable modification.  Avoid
 560              keeping bogosities like 0 = 0.  */
 561           tree decl = TREE_OPERAND (*tp, 0), value;
 562           splay_tree_node n;
 563
 564           n = splay_tree_lookup (id->decl_map, (splay_tree_key) decl);
 565           if (n)
 566             {
 567               value = (tree) n->value;
 568               STRIP_TYPE_NOPS (value);
 569               if (TREE_CONSTANT (value) || TREE_READONLY_DECL_P (value))
 570                 {
 571                   *tp = value;
 572                   return copy_body_r (tp, walk_subtrees, data);
 573                 }
 574             }
 575         }
 576       else if (TREE_CODE (*tp) == ADDR_EXPR
 577                && (lang_hooks.tree_inlining.auto_var_in_fn_p
 578                    (TREE_OPERAND (*tp, 0), fn)))
 579         {
 580           /* Get rid of &* from inline substitutions.  It can occur when
 581              someone takes the address of a parm or return slot passed by
 582              invisible reference.  */
 583           tree decl = TREE_OPERAND (*tp, 0), value;
 584           splay_tree_node n;
 585
 586           n = splay_tree_lookup (id->decl_map, (splay_tree_key) decl);
 587           if (n)
 588             {
 589               value = (tree) n->value;
 590               if (TREE_CODE (value) == INDIRECT_REF)
 591                 {
 592                   if  (!lang_hooks.types_compatible_p
 593                        (TREE_TYPE (*tp), TREE_TYPE (TREE_OPERAND (value, 0))))
 594                     *tp = fold_convert (TREE_TYPE (*tp),
 595                                         TREE_OPERAND (value, 0));
 596                   else
 597                     *tp = TREE_OPERAND (value, 0);
 598
 599                   return copy_body_r (tp, walk_subtrees, data);
 600                 }
 601             }
 602         }
 603       else if (TREE_CODE (*tp) == INDIRECT_REF)
 604         {
 605           /* Get rid of *& from inline substitutions that can happen when a
 606              pointer argument is an ADDR_EXPR.  */
 607           tree decl = TREE_OPERAND (*tp, 0), value;
 608           splay_tree_node n;
 609
 610           n = splay_tree_lookup (id->decl_map, (splay_tree_key) decl);
 611           if (n)
 612             {
 613               value = (tree) n->value;
 614               STRIP_NOPS (value);
 615               if (TREE_CODE (value) == ADDR_EXPR
 616                   && (lang_hooks.types_compatible_p
 617                       (TREE_TYPE (*tp), TREE_TYPE (TREE_OPERAND (value, 0)))))
 618                 {
 619                   *tp = TREE_OPERAND (value, 0);
 620                   return copy_body_r (tp, walk_subtrees, data);
 621                 }
 622             }
 623         }
 624
 625       copy_tree_r (tp, walk_subtrees, NULL);
 626
 627       if (TREE_CODE (*tp) == CALL_EXPR && id->node && get_callee_fndecl (*tp))
 628         {
 629           if (id->saving_p)
 630             {
 631               struct cgraph_node *node;
 632               struct cgraph_edge *edge;
 633
 634               for (node = id->node->next_clone; node; node = node->next_clone)
 635                 {
 636                   edge = cgraph_edge (node, old_node);
 637                   if (edge)
 638                     edge->call_expr = *tp;
 639                   else
 640                     abort ();
 641                 }
 642             }
 643           else
 644             {
 645               struct cgraph_edge *edge
 646                 = cgraph_edge (id->current_node, old_node);
 647
 648               if (edge)
 649                 cgraph_clone_edge (edge, id->node, *tp);
 650             }
 651         }
 652
 653       TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id);
 654
 655       /* The copied TARGET_EXPR has never been expanded, even if the
 656          original node was expanded already.  */
 657       if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3))
 658         {
 659           TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
 660           TREE_OPERAND (*tp, 3) = NULL_TREE;
 661         }
 662     }
 663
 664   /* Keep iterating.  */
 665   return NULL_TREE;
 666 }
 667
 668 /* Make a copy of the body of FN so that it can be inserted inline in
 669    another function.  */
 670
 671 static tree
 672 copy_body (inline_data *id)
 673 {
 674   tree body;
 675   tree fndecl = VARRAY_TOP_TREE (id->fns);
 676
 677   if (fndecl == current_function_decl
 678       && cfun->saved_tree)
 679     body = cfun->saved_tree;
 680   else
 681     body = DECL_SAVED_TREE (fndecl);
 682   walk_tree (&body, copy_body_r, id, NULL);
 683
 684   return body;
 685 }
 686
 687 static void
 688 setup_one_parameter (inline_data *id, tree p, tree value, tree fn,
 689                      tree *init_stmts, tree *vars, bool *gimplify_init_stmts_p)
 690 {
 691   tree init_stmt;
 692   tree var;
 693
 694   /* If the parameter is never assigned to, we may not need to
 695      create a new variable here at all.  Instead, we may be able
 696      to just use the argument value.  */
 697   if (TREE_READONLY (p)
 698       && !TREE_ADDRESSABLE (p)
 699       && value && !TREE_SIDE_EFFECTS (value))
 700     {
 701       /* We can't risk substituting complex expressions.  They
 702          might contain variables that will be assigned to later.
 703          Theoretically, we could check the expression to see if
 704          all of the variables that determine its value are
 705          read-only, but we don't bother.  */
 706       /* We may produce non-gimple trees by adding NOPs or introduce
 707          invalid sharing when operand is not really constant.
 708          It is not big deal to prohibit constant propagation here as
 709          we will constant propagate in DOM1 pass anyway.  */
 710       if (is_gimple_min_invariant (value)
 711           && lang_hooks.types_compatible_p (TREE_TYPE (value), TREE_TYPE (p)))
 712         {
 713           insert_decl_map (id, p, value);
 714           return;
 715         }
 716     }
 717
 718   /* Make an equivalent VAR_DECL.  Note that we must NOT remap the type
 719      here since the type of this decl must be visible to the calling
 720      function. */
 721   var = copy_decl_for_inlining (p, fn, VARRAY_TREE (id->fns, 0));
 722
 723   /* Register the VAR_DECL as the equivalent for the PARM_DECL;
 724      that way, when the PARM_DECL is encountered, it will be
 725      automatically replaced by the VAR_DECL.  */
 726   insert_decl_map (id, p, var);
 727
 728   /* Declare this new variable.  */
 729   TREE_CHAIN (var) = *vars;
 730   *vars = var;
 731
 732   /* Make gimplifier happy about this variable.  */
 733   DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
 734
 735   /* Even if P was TREE_READONLY, the new VAR should not be.
 736      In the original code, we would have constructed a
 737      temporary, and then the function body would have never
 738      changed the value of P.  However, now, we will be
 739      constructing VAR directly.  The constructor body may
 740      change its value multiple times as it is being
 741      constructed.  Therefore, it must not be TREE_READONLY;
 742      the back-end assumes that TREE_READONLY variable is
 743      assigned to only once.  */
 744   if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p)))
 745     TREE_READONLY (var) = 0;
 746
 747   /* Initialize this VAR_DECL from the equivalent argument.  Convert
 748      the argument to the proper type in case it was promoted.  */
 749   if (value)
 750     {
 751       tree rhs = fold_convert (TREE_TYPE (var), value);
 752
 753       if (rhs == error_mark_node)
 754         return;
 755
 756       /* We want to use MODIFY_EXPR, not INIT_EXPR here so that we
 757          keep our trees in gimple form.  */
 758       init_stmt = build (MODIFY_EXPR, TREE_TYPE (var), var, rhs);
 759       append_to_statement_list (init_stmt, init_stmts);
 760
 761       /* If we did not create a gimple value and we did not create a gimple
 762          cast of a gimple value, then we will need to gimplify INIT_STMTS
 763          at the end.  Note that is_gimple_cast only checks the outer
 764          tree code, not its operand.  Thus the explicit check that it's
 765          operand is a gimple value.  */
 766       if (!is_gimple_val (rhs)
 767           && (!is_gimple_cast (rhs)
 768               || !is_gimple_val (TREE_OPERAND (rhs, 0))))
 769         *gimplify_init_stmts_p = true;
 770     }
 771 }
 772
 773 /* Generate code to initialize the parameters of the function at the
 774    top of the stack in ID from the ARGS (presented as a TREE_LIST).  */
 775
 776 static tree
 777 initialize_inlined_parameters (inline_data *id, tree args, tree static_chain,
 778                                tree fn, tree bind_expr)
 779 {
 780   tree init_stmts = NULL_TREE;
 781   tree parms;
 782   tree a;
 783   tree p;
 784   tree vars = NULL_TREE;
 785   bool gimplify_init_stmts_p = false;
 786   int argnum = 0;
 787
 788   /* Figure out what the parameters are.  */
 789   parms = DECL_ARGUMENTS (fn);
 790   if (fn == current_function_decl)
 791     parms = cfun->saved_args;
 792
 793   /* Loop through the parameter declarations, replacing each with an
 794      equivalent VAR_DECL, appropriately initialized.  */
 795   for (p = parms, a = args; p;
 796        a = a ? TREE_CHAIN (a) : a, p = TREE_CHAIN (p))
 797     {
 798       tree value;
 799
 800       ++argnum;
 801
 802       /* Find the initializer.  */
 803       value = lang_hooks.tree_inlining.convert_parm_for_inlining
 804               (p, a ? TREE_VALUE (a) : NULL_TREE, fn, argnum);
 805
 806       setup_one_parameter (id, p, value, fn, &init_stmts, &vars,
 807                            &gimplify_init_stmts_p);
 808     }
 809
 810   /* Evaluate trailing arguments.  */
 811   for (; a; a = TREE_CHAIN (a))
 812     {
 813       tree value = TREE_VALUE (a);
 814       append_to_statement_list (value, &init_stmts);
 815     }
 816
 817   /* Initialize the static chain.  */
 818   p = DECL_STRUCT_FUNCTION (fn)->static_chain_decl;
 819   if (p)
 820     {
 821       /* No static chain?  Seems like a bug in tree-nested.c.  */
 822       if (!static_chain)
 823         abort ();
 824
 825        setup_one_parameter (id, p, static_chain, fn, &init_stmts, &vars,
 826                             &gimplify_init_stmts_p);
 827     }
 828
 829   if (gimplify_init_stmts_p)
 830     gimplify_body (&init_stmts, current_function_decl);
 831
 832   declare_inline_vars (bind_expr, vars);
 833   return init_stmts;
 834 }
 835
 836 /* Declare a return variable to replace the RESULT_DECL for the function we
 837    are calling.  RETURN_SLOT_ADDR, if non-null, was a fake parameter that
 838    took the address of the result.  MODIFY_DEST, if non-null, was the LHS of
 839    the MODIFY_EXPR to which this call is the RHS.
 840
 841    The return value is a (possibly null) value that is the result of the
 842    function as seen by the callee.  *USE_P is a (possibly null) value that
 843    holds the result as seen by the caller.  */
 844
 845 static tree
 846 declare_return_variable (inline_data *id, tree return_slot_addr,
 847                          tree modify_dest, tree *use_p)
 848 {
 849   tree callee = VARRAY_TOP_TREE (id->fns);
 850   tree caller = VARRAY_TREE (id->fns, 0);
 851   tree result = DECL_RESULT (callee);
 852   tree callee_type = TREE_TYPE (result);
 853   tree caller_type = TREE_TYPE (TREE_TYPE (callee));
 854   tree var, use;
 855
 856   /* We don't need to do anything for functions that don't return
 857      anything.  */
 858   if (!result || VOID_TYPE_P (callee_type))
 859     {
 860       *use_p = NULL_TREE;
 861       return NULL_TREE;
 862     }
 863
 864   /* If there was a return slot, then the return value the the
 865      dereferenced address of that object.  */
 866   if (return_slot_addr)
 867     {
 868       /* The front end shouldn't have used both return_slot_addr and
 869          a modify expression.  */
 870       if (modify_dest)
 871         abort ();
 872       var = build_fold_indirect_ref (return_slot_addr);
 873       use = NULL;
 874       goto done;
 875     }
 876
 877   /* All types requiring non-trivial constructors should have been handled.  */
 878   if (TREE_ADDRESSABLE (callee_type))
 879     abort ();
 880
 881   /* Attempt to avoid creating a new temporary variable.  */
 882   if (modify_dest)
 883     {
 884       bool use_it = false;
 885
 886       /* We can't use MODIFY_DEST if there's type promotion involved.  */
 887       if (!lang_hooks.types_compatible_p (caller_type, callee_type))
 888         use_it = false;
 889
 890       /* ??? If we're assigning to a variable sized type, then we must
 891          reuse the destination variable, because we've no good way to
 892          create variable sized temporaries at this point.  */
 893       else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type)) != INTEGER_CST)
 894         use_it = true;
 895
 896       /* If the callee cannot possibly modify MODIFY_DEST, then we can
 897          reuse it as the result of the call directly.  Don't do this if
 898          it would promote MODIFY_DEST to addressable.  */
 899       else if (!TREE_STATIC (modify_dest)
 900                && !TREE_ADDRESSABLE (modify_dest)
 901                && !TREE_ADDRESSABLE (result))
 902         use_it = true;
 903
 904       if (use_it)
 905         {
 906           var = modify_dest;
 907           use = NULL;
 908           goto done;
 909         }
 910     }
 911
 912   if (TREE_CODE (TYPE_SIZE_UNIT (callee_type)) != INTEGER_CST)
 913     abort ();
 914
 915   var = copy_decl_for_inlining (result, callee, caller);
 916   DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
 917   DECL_STRUCT_FUNCTION (caller)->unexpanded_var_list
 918     = tree_cons (NULL_TREE, var,
 919                  DECL_STRUCT_FUNCTION (caller)->unexpanded_var_list);
 920
 921   /* Do not have the rest of GCC warn about this variable as it should
 922      not be visible to the user.   */
 923   TREE_NO_WARNING (var) = 1;
 924
 925   /* Build the use expr.  If the return type of the function was
 926      promoted, convert it back to the expected type.  */
 927   use = var;
 928   if (!lang_hooks.types_compatible_p (TREE_TYPE (var), caller_type))
 929     use = fold_convert (caller_type, var);
 930
 931  done:
 932   /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
 933      way, when the RESULT_DECL is encountered, it will be
 934      automatically replaced by the VAR_DECL.  */
 935   insert_decl_map (id, result, var);
 936
 937   /* Remember this so we can ignore it in remap_decls.  */
 938   id->retvar = var;
 939
 940   *use_p = use;
 941   return var;
 942 }
 943
 944 /* Returns nonzero if a function can be inlined as a tree.  */
 945
 946 bool
 947 tree_inlinable_function_p (tree fn)
 948 {
 949   return inlinable_function_p (fn);
 950 }
 951
 952 static const char *inline_forbidden_reason;
 953
 954 static tree
 955 inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED,
 956                       void *fnp)
 957 {
 958   tree node = *nodep;
 959   tree fn = (tree) fnp;
 960   tree t;
 961
 962   switch (TREE_CODE (node))
 963     {
 964     case CALL_EXPR:
 965       /* Refuse to inline alloca call unless user explicitly forced so as
 966          this may change program's memory overhead drastically when the
 967          function using alloca is called in loop.  In GCC present in
 968          SPEC2000 inlining into schedule_block cause it to require 2GB of
 969          RAM instead of 256MB.  */
 970       if (alloca_call_p (node)
 971           && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
 972         {
 973           inline_forbidden_reason
 974             = N_("%Jfunction '%F' can never be inlined because it uses "
 975                  "alloca (override using the always_inline attribute)");
 976           return node;
 977         }
 978       t = get_callee_fndecl (node);
 979       if (! t)
 980         break;
 981
 982       /* We cannot inline functions that call setjmp.  */
 983       if (setjmp_call_p (t))
 984         {
 985           inline_forbidden_reason
 986             = N_("%Jfunction '%F' can never be inlined because it uses setjmp");
 987           return node;
 988         }
 989
 990       if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL)
 991         switch (DECL_FUNCTION_CODE (t))
 992           {
 993             /* We cannot inline functions that take a variable number of
 994                arguments.  */
 995           case BUILT_IN_VA_START:
 996           case BUILT_IN_STDARG_START:
 997           case BUILT_IN_NEXT_ARG:
 998           case BUILT_IN_VA_END:
 999             inline_forbidden_reason
1000               = N_("%Jfunction '%F' can never be inlined because it "
1001                    "uses variable argument lists");
1002             return node;
1003
1004           case BUILT_IN_LONGJMP:
1005             /* We can't inline functions that call __builtin_longjmp at
1006                all.  The non-local goto machinery really requires the
1007                destination be in a different function.  If we allow the
1008                function calling __builtin_longjmp to be inlined into the
1009                function calling __builtin_setjmp, Things will Go Awry.  */
1010             inline_forbidden_reason
1011               = N_("%Jfunction '%F' can never be inlined because "
1012                    "it uses setjmp-longjmp exception handling");
1013             return node;
1014
1015           case BUILT_IN_NONLOCAL_GOTO:
1016             /* Similarly.  */
1017             inline_forbidden_reason
1018               = N_("%Jfunction '%F' can never be inlined because "
1019                    "it uses non-local goto");
1020             return node;
1021
1022           default:
1023             break;
1024           }
1025       break;
1026
1027     case BIND_EXPR:
1028       for (t = BIND_EXPR_VARS (node); t ; t = TREE_CHAIN (t))
1029         {
1030           /* We cannot inline functions that contain other functions.  */
1031           if (TREE_CODE (t) == FUNCTION_DECL && DECL_INITIAL (t))
1032             {
1033               inline_forbidden_reason
1034                 = N_("%Jfunction '%F' can never be inlined "
1035                      "because it contains a nested function");
1036               return node;
1037             }
1038         }
1039       break;
1040
1041     case GOTO_EXPR:
1042       t = TREE_OPERAND (node, 0);
1043
1044       /* We will not inline a function which uses computed goto.  The
1045          addresses of its local labels, which may be tucked into
1046          global storage, are of course not constant across
1047          instantiations, which causes unexpected behavior.  */
1048       if (TREE_CODE (t) != LABEL_DECL)
1049         {
1050           inline_forbidden_reason
1051             = N_("%Jfunction '%F' can never be inlined "
1052                  "because it contains a computed goto");
1053           return node;
1054         }
1055       break;
1056
1057     case LABEL_EXPR:
1058       t = TREE_OPERAND (node, 0);
1059       if (DECL_NONLOCAL (t))
1060         {
1061           /* We cannot inline a function that receives a non-local goto
1062              because we cannot remap the destination label used in the
1063              function that is performing the non-local goto.  */
1064           inline_forbidden_reason
1065             = N_("%Jfunction '%F' can never be inlined "
1066                  "because it receives a non-local goto");
1067           return node;
1068         }
1069       break;
1070
1071     case RECORD_TYPE:
1072     case UNION_TYPE:
1073       /* We cannot inline a function of the form
1074
1075            void F (int i) { struct S { int ar[i]; } s; }
1076
1077          Attempting to do so produces a catch-22.
1078          If walk_tree examines the TYPE_FIELDS chain of RECORD_TYPE/
1079          UNION_TYPE nodes, then it goes into infinite recursion on a
1080          structure containing a pointer to its own type.  If it doesn't,
1081          then the type node for S doesn't get adjusted properly when
1082          F is inlined, and we abort in find_function_data.  */
1083       for (t = TYPE_FIELDS (node); t; t = TREE_CHAIN (t))
1084         if (variably_modified_type_p (TREE_TYPE (t), NULL))
1085           {
1086             inline_forbidden_reason
1087               = N_("%Jfunction '%F' can never be inlined "
1088                    "because it uses variable sized variables");
1089             return node;
1090           }
1091
1092     default:
1093       break;
1094     }
1095
1096   return NULL_TREE;
1097 }
1098
1099 /* Return subexpression representing possible alloca call, if any.  */
1100 static tree
1101 inline_forbidden_p (tree fndecl)
1102 {
1103   location_t saved_loc = input_location;
1104   tree ret = walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl),
1105                                            inline_forbidden_p_1, fndecl);
1106
1107   input_location = saved_loc;
1108   return ret;
1109 }
1110
1111 /* Returns nonzero if FN is a function that does not have any
1112    fundamental inline blocking properties.  */
1113
1114 static bool
1115 inlinable_function_p (tree fn)
1116 {
1117   bool inlinable = true;
1118
1119   /* If we've already decided this function shouldn't be inlined,
1120      there's no need to check again.  */
1121   if (DECL_UNINLINABLE (fn))
1122     return false;
1123
1124   /* See if there is any language-specific reason it cannot be
1125      inlined.  (It is important that this hook be called early because
1126      in C++ it may result in template instantiation.)
1127      If the function is not inlinable for language-specific reasons,
1128      it is left up to the langhook to explain why.  */
1129   inlinable = !lang_hooks.tree_inlining.cannot_inline_tree_fn (&fn);
1130
1131   /* If we don't have the function body available, we can't inline it.
1132      However, this should not be recorded since we also get here for
1133      forward declared inline functions.  Therefore, return at once.  */
1134   if (!DECL_SAVED_TREE (fn))
1135     return false;
1136
1137   /* If we're not inlining at all, then we cannot inline this function.  */
1138   else if (!flag_inline_trees)
1139     inlinable = false;
1140
1141   /* Only try to inline functions if DECL_INLINE is set.  This should be
1142      true for all functions declared `inline', and for all other functions
1143      as well with -finline-functions.
1144
1145      Don't think of disregarding DECL_INLINE when flag_inline_trees == 2;
1146      it's the front-end that must set DECL_INLINE in this case, because
1147      dwarf2out loses if a function that does not have DECL_INLINE set is
1148      inlined anyway.  That is why we have both DECL_INLINE and
1149      DECL_DECLARED_INLINE_P.  */
1150   /* FIXME: When flag_inline_trees dies, the check for flag_unit_at_a_time
1151             here should be redundant.  */
1152   else if (!DECL_INLINE (fn) && !flag_unit_at_a_time)
1153     inlinable = false;
1154
1155   else if (inline_forbidden_p (fn))
1156     {
1157       /* See if we should warn about uninlinable functions.  Previously,
1158          some of these warnings would be issued while trying to expand
1159          the function inline, but that would cause multiple warnings
1160          about functions that would for example call alloca.  But since
1161          this a property of the function, just one warning is enough.
1162          As a bonus we can now give more details about the reason why a
1163          function is not inlinable.
1164          We only warn for functions declared `inline' by the user.  */
1165       bool do_warning = (warn_inline
1166                          && DECL_INLINE (fn)
1167                          && DECL_DECLARED_INLINE_P (fn)
1168                          && !DECL_IN_SYSTEM_HEADER (fn));
1169
1170       if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
1171         sorry (inline_forbidden_reason, fn, fn);
1172       else if (do_warning)
1173         warning (inline_forbidden_reason, fn, fn);
1174
1175       inlinable = false;
1176     }
1177
1178   /* Squirrel away the result so that we don't have to check again.  */
1179   DECL_UNINLINABLE (fn) = !inlinable;
1180
1181   return inlinable;
1182 }
1183
1184 /* Used by estimate_num_insns.  Estimate number of instructions seen
1185    by given statement.  */
1186
1187 static tree
1188 estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data)
1189 {
1190   int *count = data;
1191   tree x = *tp;
1192
1193   if (TYPE_P (x) || DECL_P (x))
1194     {
1195       *walk_subtrees = 0;
1196       return NULL;
1197     }
1198   /* Assume that constants and references counts nothing.  These should
1199      be majorized by amount of operations among them we count later
1200      and are common target of CSE and similar optimizations.  */
1201   else if (TREE_CODE_CLASS (TREE_CODE (x)) == 'c'
1202            || TREE_CODE_CLASS (TREE_CODE (x)) == 'r')
1203     return NULL;
1204
1205   switch (TREE_CODE (x))
1206     {
1207     /* Containers have no cost.  */
1208     case TREE_LIST:
1209     case TREE_VEC:
1210     case BLOCK:
1211     case COMPONENT_REF:
1212     case BIT_FIELD_REF:
1213     case INDIRECT_REF:
1214     case ARRAY_REF:
1215     case ARRAY_RANGE_REF:
1216     case OBJ_TYPE_REF:
1217     case EXC_PTR_EXPR: /* ??? */
1218     case FILTER_EXPR: /* ??? */
1219     case COMPOUND_EXPR:
1220     case BIND_EXPR:
1221     case LABELED_BLOCK_EXPR:
1222     case WITH_CLEANUP_EXPR:
1223     case NOP_EXPR:
1224     case VIEW_CONVERT_EXPR:
1225     case SAVE_EXPR:
1226     case ADDR_EXPR:
1227     case COMPLEX_EXPR:
1228     case EXIT_BLOCK_EXPR:
1229     case CASE_LABEL_EXPR:
1230     case SSA_NAME:
1231     case CATCH_EXPR:
1232     case EH_FILTER_EXPR:
1233     case STATEMENT_LIST:
1234     case ERROR_MARK:
1235     case NON_LVALUE_EXPR:
1236     case FDESC_EXPR:
1237     case VA_ARG_EXPR:
1238     case TRY_CATCH_EXPR:
1239     case TRY_FINALLY_EXPR:
1240     case LABEL_EXPR:
1241     case GOTO_EXPR:
1242     case RETURN_EXPR:
1243     case EXIT_EXPR:
1244     case LOOP_EXPR:
1245     case PHI_NODE:
1246     case WITH_SIZE_EXPR:
1247       break;
1248
1249     /* We don't account constants for now.  Assume that the cost is amortized
1250        by operations that do use them.  We may re-consider this decision once
1251        we are able to optimize the tree before estimating it's size and break
1252        out static initializers.  */
1253     case IDENTIFIER_NODE:
1254     case INTEGER_CST:
1255     case REAL_CST:
1256     case COMPLEX_CST:
1257     case VECTOR_CST:
1258     case STRING_CST:
1259       *walk_subtrees = 0;
1260       return NULL;
1261
1262     /* Recognize assignments of large structures and constructors of
1263        big arrays.  */
1264     case INIT_EXPR:
1265     case MODIFY_EXPR:
1266       x = TREE_OPERAND (x, 0);
1267       /* FALLTHRU */
1268     case TARGET_EXPR:
1269     case CONSTRUCTOR:
1270       {
1271         HOST_WIDE_INT size;
1272
1273         size = int_size_in_bytes (TREE_TYPE (x));
1274
1275         if (size < 0 || size > MOVE_MAX_PIECES * MOVE_RATIO)
1276           *count += 10;
1277         else
1278           *count += ((size + MOVE_MAX_PIECES - 1) / MOVE_MAX_PIECES);
1279       }
1280       break;
1281
1282       /* Assign cost of 1 to usual operations.
1283          ??? We may consider mapping RTL costs to this.  */
1284     case COND_EXPR:
1285
1286     case PLUS_EXPR:
1287     case MINUS_EXPR:
1288     case MULT_EXPR:
1289
1290     case FIX_TRUNC_EXPR:
1291     case FIX_CEIL_EXPR:
1292     case FIX_FLOOR_EXPR:
1293     case FIX_ROUND_EXPR:
1294
1295     case NEGATE_EXPR:
1296     case FLOAT_EXPR:
1297     case MIN_EXPR:
1298     case MAX_EXPR:
1299     case ABS_EXPR:
1300
1301     case LSHIFT_EXPR:
1302     case RSHIFT_EXPR:
1303     case LROTATE_EXPR:
1304     case RROTATE_EXPR:
1305
1306     case BIT_IOR_EXPR:
1307     case BIT_XOR_EXPR:
1308     case BIT_AND_EXPR:
1309     case BIT_NOT_EXPR:
1310
1311     case TRUTH_ANDIF_EXPR:
1312     case TRUTH_ORIF_EXPR:
1313     case TRUTH_AND_EXPR:
1314     case TRUTH_OR_EXPR:
1315     case TRUTH_XOR_EXPR:
1316     case TRUTH_NOT_EXPR:
1317
1318     case LT_EXPR:
1319     case LE_EXPR:
1320     case GT_EXPR:
1321     case GE_EXPR:
1322     case EQ_EXPR:
1323     case NE_EXPR:
1324     case ORDERED_EXPR:
1325     case UNORDERED_EXPR:
1326
1327     case UNLT_EXPR:
1328     case UNLE_EXPR:
1329     case UNGT_EXPR:
1330     case UNGE_EXPR:
1331     case UNEQ_EXPR:
1332     case LTGT_EXPR:
1333
1334     case CONVERT_EXPR:
1335
1336     case CONJ_EXPR:
1337
1338     case PREDECREMENT_EXPR:
1339     case PREINCREMENT_EXPR:
1340     case POSTDECREMENT_EXPR:
1341     case POSTINCREMENT_EXPR:
1342
1343     case SWITCH_EXPR:
1344
1345     case ASM_EXPR:
1346
1347     case RESX_EXPR:
1348       *count += 1;
1349       break;
1350
1351     /* Few special cases of expensive operations.  This is useful
1352        to avoid inlining on functions having too many of these.  */
1353     case TRUNC_DIV_EXPR:
1354     case CEIL_DIV_EXPR:
1355     case FLOOR_DIV_EXPR:
1356     case ROUND_DIV_EXPR:
1357     case EXACT_DIV_EXPR:
1358     case TRUNC_MOD_EXPR:
1359     case CEIL_MOD_EXPR:
1360     case FLOOR_MOD_EXPR:
1361     case ROUND_MOD_EXPR:
1362     case RDIV_EXPR:
1363       *count += 10;
1364       break;
1365     case CALL_EXPR:
1366       {
1367         tree decl = get_callee_fndecl (x);
1368
1369         if (decl && DECL_BUILT_IN (decl))
1370           switch (DECL_FUNCTION_CODE (decl))
1371             {
1372             case BUILT_IN_CONSTANT_P:
1373               *walk_subtrees = 0;
1374               return NULL_TREE;
1375             case BUILT_IN_EXPECT:
1376               return NULL_TREE;
1377             default:
1378               break;
1379             }
1380         *count += 10;
1381         break;
1382       }
1383     default:
1384       /* Abort here se we know we don't miss any nodes.  */
1385       abort ();
1386     }
1387   return NULL;
1388 }
1389
1390 /* Estimate number of instructions that will be created by expanding EXPR.  */
1391
1392 int
1393 estimate_num_insns (tree expr)
1394 {
1395   int num = 0;
1396   walk_tree_without_duplicates (&expr, estimate_num_insns_1, &num);
1397   return num;
1398 }
1399
1400 /* If *TP is a CALL_EXPR, replace it with its inline expansion.  */
1401
1402 static tree
1403 expand_call_inline (tree *tp, int *walk_subtrees, void *data)
1404 {
1405   inline_data *id;
1406   tree t;
1407   tree expr;
1408   tree stmt;
1409   tree use_retvar;
1410   tree decl;
1411   tree fn;
1412   tree arg_inits;
1413   tree *inlined_body;
1414   splay_tree st;
1415   tree args;
1416   tree return_slot_addr;
1417   tree modify_dest;
1418   location_t saved_location;
1419   struct cgraph_edge *edge;
1420   const char *reason;
1421
1422   /* See what we've got.  */
1423   id = (inline_data *) data;
1424   t = *tp;
1425
1426   /* Set input_location here so we get the right instantiation context
1427      if we call instantiate_decl from inlinable_function_p.  */
1428   saved_location = input_location;
1429   if (EXPR_HAS_LOCATION (t))
1430     input_location = EXPR_LOCATION (t);
1431
1432   /* Recurse, but letting recursive invocations know that we are
1433      inside the body of a TARGET_EXPR.  */
1434   if (TREE_CODE (*tp) == TARGET_EXPR)
1435     {
1436 #if 0
1437       int i, len = first_rtl_op (TARGET_EXPR);
1438
1439       /* We're walking our own subtrees.  */
1440       *walk_subtrees = 0;
1441
1442       /* Actually walk over them.  This loop is the body of
1443          walk_trees, omitting the case where the TARGET_EXPR
1444          itself is handled.  */
1445       for (i = 0; i < len; ++i)
1446         {
1447           if (i == 2)
1448             ++id->in_target_cleanup_p;
1449           walk_tree (&TREE_OPERAND (*tp, i), expand_call_inline, data,
1450                      id->tree_pruner);
1451           if (i == 2)
1452             --id->in_target_cleanup_p;
1453         }
1454
1455       goto egress;
1456 #endif
1457     }
1458
1459   if (TYPE_P (t))
1460     /* Because types were not copied in copy_body, CALL_EXPRs beneath
1461        them should not be expanded.  This can happen if the type is a
1462        dynamic array type, for example.  */
1463     *walk_subtrees = 0;
1464
1465   /* From here on, we're only interested in CALL_EXPRs.  */
1466   if (TREE_CODE (t) != CALL_EXPR)
1467     goto egress;
1468
1469   /* First, see if we can figure out what function is being called.
1470      If we cannot, then there is no hope of inlining the function.  */
1471   fn = get_callee_fndecl (t);
1472   if (!fn)
1473     goto egress;
1474
1475   /* Turn forward declarations into real ones.  */
1476   fn = cgraph_node (fn)->decl;
1477
1478   /* If fn is a declaration of a function in a nested scope that was
1479      globally declared inline, we don't set its DECL_INITIAL.
1480      However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
1481      C++ front-end uses it for cdtors to refer to their internal
1482      declarations, that are not real functions.  Fortunately those
1483      don't have trees to be saved, so we can tell by checking their
1484      DECL_SAVED_TREE.  */
1485   if (! DECL_INITIAL (fn)
1486       && DECL_ABSTRACT_ORIGIN (fn)
1487       && DECL_SAVED_TREE (DECL_ABSTRACT_ORIGIN (fn)))
1488     fn = DECL_ABSTRACT_ORIGIN (fn);
1489
1490   /* Objective C and fortran still calls tree_rest_of_compilation directly.
1491      Kill this check once this is fixed.  */
1492   if (!id->current_node->analyzed)
1493     goto egress;
1494
1495   edge = cgraph_edge (id->current_node, t);
1496
1497   /* Constant propagation on argument done during previous inlining
1498      may create new direct call.  Produce an edge for it.  */
1499   if (!edge)
1500     {
1501       struct cgraph_node *dest = cgraph_node (fn);
1502
1503       /* We have missing edge in the callgraph.  This can happen in one case
1504          where previous inlining turned indirect call into direct call by
1505          constant propagating arguments.  In all other cases we hit a bug
1506          (incorrect node sharing is most common reason for missing edges.  */
1507       if (!dest->needed)
1508         abort ();
1509       cgraph_create_edge (id->node, dest, t)->inline_failed
1510         = N_("originally indirect function call not considered for inlining");
1511       goto egress;
1512     }
1513
1514   /* Don't try to inline functions that are not well-suited to
1515      inlining.  */
1516   if (!cgraph_inline_p (edge, &reason))
1517     {
1518       if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
1519         {
1520           sorry ("%Jinlining failed in call to '%F': %s", fn, fn, reason);
1521           sorry ("called from here");
1522         }
1523       else if (warn_inline && DECL_DECLARED_INLINE_P (fn)
1524                && !DECL_IN_SYSTEM_HEADER (fn)
1525                && strlen (reason))
1526         {
1527           warning ("%Jinlining failed in call to '%F': %s", fn, fn, reason);
1528           warning ("called from here");
1529         }
1530       goto egress;
1531     }
1532
1533 #ifdef ENABLE_CHECKING
1534   if (edge->callee->decl != id->node->decl)
1535     verify_cgraph_node (edge->callee);
1536 #endif
1537
1538   if (! lang_hooks.tree_inlining.start_inlining (fn))
1539     goto egress;
1540
1541   /* Build a block containing code to initialize the arguments, the
1542      actual inline expansion of the body, and a label for the return
1543      statements within the function to jump to.  The type of the
1544      statement expression is the return type of the function call.  */
1545   stmt = NULL;
1546   expr = build (BIND_EXPR, void_type_node, NULL_TREE,
1547                 stmt, make_node (BLOCK));
1548   BLOCK_ABSTRACT_ORIGIN (BIND_EXPR_BLOCK (expr)) = fn;
1549
1550   /* Local declarations will be replaced by their equivalents in this
1551      map.  */
1552   st = id->decl_map;
1553   id->decl_map = splay_tree_new (splay_tree_compare_pointers,
1554                                  NULL, NULL);
1555
1556   /* Initialize the parameters.  */
1557   args = TREE_OPERAND (t, 1);
1558   return_slot_addr = NULL_TREE;
1559   if (CALL_EXPR_HAS_RETURN_SLOT_ADDR (t))
1560     {
1561       return_slot_addr = TREE_VALUE (args);
1562       args = TREE_CHAIN (args);
1563       TREE_TYPE (expr) = void_type_node;
1564     }
1565
1566   arg_inits = initialize_inlined_parameters (id, args, TREE_OPERAND (t, 2),
1567                                              fn, expr);
1568   if (arg_inits)
1569     {
1570       /* Expand any inlined calls in the initializers.  Do this before we
1571          push FN on the stack of functions we are inlining; we want to
1572          inline calls to FN that appear in the initializers for the
1573          parameters.
1574
1575          Note we need to save and restore the saved tree statement iterator
1576          to avoid having it clobbered by expand_calls_inline.  */
1577       tree_stmt_iterator save_tsi;
1578
1579       save_tsi = id->tsi;
1580       expand_calls_inline (&arg_inits, id);
1581       id->tsi = save_tsi;
1582
1583       /* And add them to the tree.  */
1584       append_to_statement_list (arg_inits, &BIND_EXPR_BODY (expr));
1585     }
1586
1587   /* Record the function we are about to inline so that we can avoid
1588      recursing into it.  */
1589   VARRAY_PUSH_TREE (id->fns, fn);
1590
1591   /* Record the function we are about to inline if optimize_function
1592      has not been called on it yet and we don't have it in the list.  */
1593   if (! DECL_INLINED_FNS (fn))
1594     {
1595       int i;
1596
1597       for (i = VARRAY_ACTIVE_SIZE (id->inlined_fns) - 1; i >= 0; i--)
1598         if (VARRAY_TREE (id->inlined_fns, i) == fn)
1599           break;
1600       if (i < 0)
1601         VARRAY_PUSH_TREE (id->inlined_fns, fn);
1602     }
1603
1604   /* Return statements in the function body will be replaced by jumps
1605      to the RET_LABEL.  */
1606   id->ret_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
1607   DECL_ARTIFICIAL (id->ret_label) = 1;
1608   DECL_CONTEXT (id->ret_label) = VARRAY_TREE (id->fns, 0);
1609   insert_decl_map (id, id->ret_label, id->ret_label);
1610
1611   if (! DECL_INITIAL (fn)
1612       || TREE_CODE (DECL_INITIAL (fn)) != BLOCK)
1613     abort ();
1614
1615   /* Find the lhs to which the result of this call is assigned.  */
1616   modify_dest = tsi_stmt (id->tsi);
1617   if (TREE_CODE (modify_dest) == MODIFY_EXPR)
1618     modify_dest = TREE_OPERAND (modify_dest, 0);
1619   else
1620     modify_dest = NULL;
1621
1622   /* Declare the return variable for the function.  */
1623   decl = declare_return_variable (id, return_slot_addr,
1624                                   modify_dest, &use_retvar);
1625
1626   /* After we've initialized the parameters, we insert the body of the
1627      function itself.  */
1628   {
1629     struct cgraph_node *old_node = id->current_node;
1630
1631     id->current_node = edge->callee;
1632     append_to_statement_list (copy_body (id), &BIND_EXPR_BODY (expr));
1633     id->current_node = old_node;
1634   }
1635   inlined_body = &BIND_EXPR_BODY (expr);
1636
1637   /* After the body of the function comes the RET_LABEL.  This must come
1638      before we evaluate the returned value below, because that evaluation
1639      may cause RTL to be generated.  */
1640   if (TREE_USED (id->ret_label))
1641     {
1642       tree label = build1 (LABEL_EXPR, void_type_node, id->ret_label);
1643       append_to_statement_list (label, &BIND_EXPR_BODY (expr));
1644     }
1645
1646   /* Clean up.  */
1647   splay_tree_delete (id->decl_map);
1648   id->decl_map = st;
1649
1650   /* The new expression has side-effects if the old one did.  */
1651   TREE_SIDE_EFFECTS (expr) = TREE_SIDE_EFFECTS (t);
1652
1653   tsi_link_before (&id->tsi, expr, TSI_SAME_STMT);
1654
1655   /* If the inlined function returns a result that we care about,
1656      then we're going to need to splice in a MODIFY_EXPR.  Otherwise
1657      the call was a standalone statement and we can just replace it
1658      with the BIND_EXPR inline representation of the called function.  */
1659   if (!use_retvar || !modify_dest)
1660     *tsi_stmt_ptr (id->tsi) = build_empty_stmt ();
1661   else
1662     *tp = use_retvar;
1663
1664   /* When we gimplify a function call, we may clear TREE_SIDE_EFFECTS on
1665      the call if it is to a "const" function.  Thus the copy of
1666      TREE_SIDE_EFFECTS from the CALL_EXPR to the BIND_EXPR above with
1667      result in TREE_SIDE_EFFECTS not being set for the inlined copy of a
1668      "const" function.
1669
1670      Unfortunately, that is wrong as inlining the function can create/expose
1671      interesting side effects (such as setting of a return value).
1672
1673      The easiest solution is to simply recalculate TREE_SIDE_EFFECTS for
1674      the toplevel expression.  */
1675   recalculate_side_effects (expr);
1676
1677   /* Update callgraph if needed.  */
1678   cgraph_remove_node (edge->callee);
1679
1680   /* Recurse into the body of the just inlined function.  */
1681   expand_calls_inline (inlined_body, id);
1682   VARRAY_POP (id->fns);
1683
1684   /* Don't walk into subtrees.  We've already handled them above.  */
1685   *walk_subtrees = 0;
1686
1687   lang_hooks.tree_inlining.end_inlining (fn);
1688
1689   /* Keep iterating.  */
1690  egress:
1691   input_location = saved_location;
1692   return NULL_TREE;
1693 }
1694
1695 static void
1696 expand_calls_inline (tree *stmt_p, inline_data *id)
1697 {
1698   tree stmt = *stmt_p;
1699   enum tree_code code = TREE_CODE (stmt);
1700   int dummy;
1701
1702   switch (code)
1703     {
1704     case STATEMENT_LIST:
1705       {
1706         tree_stmt_iterator i;
1707         tree new;
1708
1709         for (i = tsi_start (stmt); !tsi_end_p (i); )
1710           {
1711             id->tsi = i;
1712             expand_calls_inline (tsi_stmt_ptr (i), id);
1713
1714             new = tsi_stmt (i);
1715             if (TREE_CODE (new) == STATEMENT_LIST)
1716               {
1717                 tsi_link_before (&i, new, TSI_SAME_STMT);
1718                 tsi_delink (&i);
1719               }
1720             else
1721               tsi_next (&i);
1722           }
1723       }
1724       break;
1725
1726     case COND_EXPR:
1727       expand_calls_inline (&COND_EXPR_THEN (stmt), id);
1728       expand_calls_inline (&COND_EXPR_ELSE (stmt), id);
1729       break;
1730
1731     case CATCH_EXPR:
1732       expand_calls_inline (&CATCH_BODY (stmt), id);
1733       break;
1734
1735     case EH_FILTER_EXPR:
1736       expand_calls_inline (&EH_FILTER_FAILURE (stmt), id);
1737       break;
1738
1739     case TRY_CATCH_EXPR:
1740     case TRY_FINALLY_EXPR:
1741       expand_calls_inline (&TREE_OPERAND (stmt, 0), id);
1742       expand_calls_inline (&TREE_OPERAND (stmt, 1), id);
1743       break;
1744
1745     case BIND_EXPR:
1746       expand_calls_inline (&BIND_EXPR_BODY (stmt), id);
1747       break;
1748
1749     case COMPOUND_EXPR:
1750       /* We're gimple.  We should have gotten rid of all these.  */
1751       abort ();
1752
1753     case RETURN_EXPR:
1754       stmt_p = &TREE_OPERAND (stmt, 0);
1755       stmt = *stmt_p;
1756       if (!stmt || TREE_CODE (stmt) != MODIFY_EXPR)
1757         break;
1758
1759       /* FALLTHRU */
1760
1761     case MODIFY_EXPR:
1762       stmt_p = &TREE_OPERAND (stmt, 1);
1763       stmt = *stmt_p;
1764       if (TREE_CODE (stmt) == WITH_SIZE_EXPR)
1765         {
1766           stmt_p = &TREE_OPERAND (stmt, 0);
1767           stmt = *stmt_p;
1768         }
1769       if (TREE_CODE (stmt) != CALL_EXPR)
1770         break;
1771
1772       /* FALLTHRU */
1773
1774     case CALL_EXPR:
1775       expand_call_inline (stmt_p, &dummy, id);
1776       break;
1777
1778     default:
1779       break;
1780     }
1781 }
1782
1783 /* Expand calls to inline functions in the body of FN.  */
1784
1785 void
1786 optimize_inline_calls (tree fn)
1787 {
1788   inline_data id;
1789   tree prev_fn;
1790   tree ifn;
1791
1792   /* There is no point in performing inlining if errors have already
1793      occurred -- and we might crash if we try to inline invalid
1794      code.  */
1795   if (errorcount || sorrycount)
1796     return;
1797
1798   /* Clear out ID.  */
1799   memset (&id, 0, sizeof (id));
1800
1801   id.current_node = id.node = cgraph_node (fn);
1802   /* Don't allow recursion into FN.  */
1803   VARRAY_TREE_INIT (id.fns, 32, "fns");
1804   VARRAY_PUSH_TREE (id.fns, fn);
1805   /* Or any functions that aren't finished yet.  */
1806   prev_fn = NULL_TREE;
1807   if (current_function_decl)
1808     {
1809       VARRAY_PUSH_TREE (id.fns, current_function_decl);
1810       prev_fn = current_function_decl;
1811     }
1812
1813   prev_fn = lang_hooks.tree_inlining.add_pending_fn_decls (&id.fns, prev_fn);
1814
1815   /* Create the list of functions this call will inline.  */
1816   VARRAY_TREE_INIT (id.inlined_fns, 32, "inlined_fns");
1817
1818   /* Keep track of the low-water mark, i.e., the point where the first
1819      real inlining is represented in ID.FNS.  */
1820   id.first_inlined_fn = VARRAY_ACTIVE_SIZE (id.fns);
1821
1822   /* Replace all calls to inline functions with the bodies of those
1823      functions.  */
1824   id.tree_pruner = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
1825   expand_calls_inline (&DECL_SAVED_TREE (fn), &id);
1826
1827   /* Clean up.  */
1828   htab_delete (id.tree_pruner);
1829   ifn = make_tree_vec (VARRAY_ACTIVE_SIZE (id.inlined_fns));
1830   if (VARRAY_ACTIVE_SIZE (id.inlined_fns))
1831     memcpy (&TREE_VEC_ELT (ifn, 0), &VARRAY_TREE (id.inlined_fns, 0),
1832             VARRAY_ACTIVE_SIZE (id.inlined_fns) * sizeof (tree));
1833   DECL_INLINED_FNS (fn) = ifn;
1834
1835 #ifdef ENABLE_CHECKING
1836     {
1837       struct cgraph_edge *e;
1838
1839       verify_cgraph_node (id.node);
1840
1841       /* Double check that we inlined everything we are supposed to inline.  */
1842       for (e = id.node->callees; e; e = e->next_callee)
1843         if (!e->inline_failed)
1844           abort ();
1845     }
1846 #endif
1847 }
1848
1849 /* FN is a function that has a complete body, and CLONE is a function whose
1850    body is to be set to a copy of FN, mapping argument declarations according
1851    to the ARG_MAP splay_tree.  */
1852
1853 void
1854 clone_body (tree clone, tree fn, void *arg_map)
1855 {
1856   inline_data id;
1857
1858   /* Clone the body, as if we were making an inline call.  But, remap the
1859      parameters in the callee to the parameters of caller.  If there's an
1860      in-charge parameter, map it to an appropriate constant.  */
1861   memset (&id, 0, sizeof (id));
1862   VARRAY_TREE_INIT (id.fns, 2, "fns");
1863   VARRAY_PUSH_TREE (id.fns, clone);
1864   VARRAY_PUSH_TREE (id.fns, fn);
1865   id.decl_map = (splay_tree)arg_map;
1866
1867   /* Cloning is treated slightly differently from inlining.  Set
1868      CLONING_P so that it's clear which operation we're performing.  */
1869   id.cloning_p = true;
1870
1871   /* Actually copy the body.  */
1872   append_to_statement_list_force (copy_body (&id), &DECL_SAVED_TREE (clone));
1873 }
1874
1875 /* Make and return duplicate of body in FN.  Put copies of DECL_ARGUMENTS
1876    in *arg_copy and of the static chain, if any, in *sc_copy.  */
1877
1878 tree
1879 save_body (tree fn, tree *arg_copy, tree *sc_copy)
1880 {
1881   inline_data id;
1882   tree body, *parg;
1883
1884   memset (&id, 0, sizeof (id));
1885   VARRAY_TREE_INIT (id.fns, 1, "fns");
1886   VARRAY_PUSH_TREE (id.fns, fn);
1887   id.node = cgraph_node (fn);
1888   id.saving_p = true;
1889   id.decl_map = splay_tree_new (splay_tree_compare_pointers, NULL, NULL);
1890   *arg_copy = DECL_ARGUMENTS (fn);
1891
1892   for (parg = arg_copy; *parg; parg = &TREE_CHAIN (*parg))
1893     {
1894       tree new = copy_node (*parg);
1895
1896       lang_hooks.dup_lang_specific_decl (new);
1897       DECL_ABSTRACT_ORIGIN (new) = DECL_ORIGIN (*parg);
1898       insert_decl_map (&id, *parg, new);
1899       TREE_CHAIN (new) = TREE_CHAIN (*parg);
1900       *parg = new;
1901     }
1902
1903   *sc_copy = DECL_STRUCT_FUNCTION (fn)->static_chain_decl;
1904   if (*sc_copy)
1905     {
1906       tree new = copy_node (*sc_copy);
1907
1908       lang_hooks.dup_lang_specific_decl (new);
1909       DECL_ABSTRACT_ORIGIN (new) = DECL_ORIGIN (*sc_copy);
1910       insert_decl_map (&id, *sc_copy, new);
1911       TREE_CHAIN (new) = TREE_CHAIN (*sc_copy);
1912       *sc_copy = new;
1913     }
1914
1915   insert_decl_map (&id, DECL_RESULT (fn), DECL_RESULT (fn));
1916
1917   /* Actually copy the body.  */
1918   body = copy_body (&id);
1919
1920   /* Clean up.  */
1921   splay_tree_delete (id.decl_map);
1922   return body;
1923 }
1924
1925 #define WALK_SUBTREE(NODE)                              \
1926   do                                                    \
1927     {                                                   \
1928       result = walk_tree (&(NODE), func, data, htab);   \
1929       if (result)                                       \
1930         return result;                                  \
1931     }                                                   \
1932   while (0)
1933
1934 /* This is a subroutine of walk_tree that walks field of TYPE that are to
1935    be walked whenever a type is seen in the tree.  Rest of operands and return
1936    value are as for walk_tree.  */
1937
1938 static tree
1939 walk_type_fields (tree type, walk_tree_fn func, void *data, void *htab)
1940 {
1941   tree result = NULL_TREE;
1942
1943   switch (TREE_CODE (type))
1944     {
1945     case POINTER_TYPE:
1946     case REFERENCE_TYPE:
1947       /* We have to worry about mutually recursive pointers.  These can't
1948          be written in C.  They can in Ada.  It's pathlogical, but
1949          there's an ACATS test (c38102a) that checks it.  Deal with this
1950          by checking if we're pointing to another pointer, that one
1951          points to another pointer, that one does too, and we have no htab.
1952          If so, get a hash table.  We check three levels deep to avoid
1953          the cost of the hash table if we don't need one.  */
1954       if (POINTER_TYPE_P (TREE_TYPE (type))
1955           && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type)))
1956           && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type))))
1957           && !htab)
1958         {
1959           result = walk_tree_without_duplicates (&TREE_TYPE (type),
1960                                                  func, data);
1961           if (result)
1962             return result;
1963
1964           break;
1965         }
1966
1967       /* ... fall through ... */
1968
1969     case COMPLEX_TYPE:
1970       WALK_SUBTREE (TREE_TYPE (type));
1971       break;
1972
1973     case METHOD_TYPE:
1974       WALK_SUBTREE (TYPE_METHOD_BASETYPE (type));
1975
1976       /* Fall through.  */
1977
1978     case FUNCTION_TYPE:
1979       WALK_SUBTREE (TREE_TYPE (type));
1980       {
1981         tree arg;
1982
1983         /* We never want to walk into default arguments.  */
1984         for (arg = TYPE_ARG_TYPES (type); arg; arg = TREE_CHAIN (arg))
1985           WALK_SUBTREE (TREE_VALUE (arg));
1986       }
1987       break;
1988
1989     case ARRAY_TYPE:
1990       /* Don't follow this nodes's type if a pointer for fear that we'll
1991          have infinite recursion.  Those types are uninteresting anyway. */
1992       if (!POINTER_TYPE_P (TREE_TYPE (type))
1993           && TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE)
1994         WALK_SUBTREE (TREE_TYPE (type));
1995       WALK_SUBTREE (TYPE_DOMAIN (type));
1996       break;
1997
1998     case BOOLEAN_TYPE:
1999     case ENUMERAL_TYPE:
2000     case INTEGER_TYPE:
2001     case CHAR_TYPE:
2002     case REAL_TYPE:
2003       WALK_SUBTREE (TYPE_MIN_VALUE (type));
2004       WALK_SUBTREE (TYPE_MAX_VALUE (type));
2005       break;
2006
2007     case OFFSET_TYPE:
2008       WALK_SUBTREE (TREE_TYPE (type));
2009       WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type));
2010       break;
2011
2012     default:
2013       break;
2014     }
2015
2016   return NULL_TREE;
2017 }
2018
2019 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal.  FUNC is
2020    called with the DATA and the address of each sub-tree.  If FUNC returns a
2021    non-NULL value, the traversal is aborted, and the value returned by FUNC
2022    is returned.  If HTAB is non-NULL it is used to record the nodes visited,
2023    and to avoid visiting a node more than once.  */
2024
2025 tree
2026 walk_tree (tree *tp, walk_tree_fn func, void *data, void *htab_)
2027 {
2028   htab_t htab = (htab_t) htab_;
2029   enum tree_code code;
2030   int walk_subtrees;
2031   tree result;
2032
2033 #define WALK_SUBTREE_TAIL(NODE)                         \
2034   do                                                    \
2035     {                                                   \
2036        tp = & (NODE);                                   \
2037        goto tail_recurse;                               \
2038     }                                                   \
2039   while (0)
2040
2041  tail_recurse:
2042   /* Skip empty subtrees.  */
2043   if (!*tp)
2044     return NULL_TREE;
2045
2046   if (htab)
2047     {
2048       void **slot;
2049
2050       /* Don't walk the same tree twice, if the user has requested
2051          that we avoid doing so.  */
2052       slot = htab_find_slot (htab, *tp, INSERT);
2053       if (*slot)
2054         return NULL_TREE;
2055       *slot = *tp;
2056     }
2057
2058   /* Call the function.  */
2059   walk_subtrees = 1;
2060   result = (*func) (tp, &walk_subtrees, data);
2061
2062   /* If we found something, return it.  */
2063   if (result)
2064     return result;
2065
2066   code = TREE_CODE (*tp);
2067
2068   /* Even if we didn't, FUNC may have decided that there was nothing
2069      interesting below this point in the tree.  */
2070   if (!walk_subtrees)
2071     {
2072       if (code == TREE_LIST)
2073         /* But we still need to check our siblings.  */
2074         WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
2075       else
2076         return NULL_TREE;
2077     }
2078
2079   result = lang_hooks.tree_inlining.walk_subtrees (tp, &walk_subtrees, func,
2080                                                    data, htab);
2081   if (result || ! walk_subtrees)
2082     return result;
2083
2084   /* If this is a DECL_EXPR, walk into various fields of the type that it's
2085      defining.  We only want to walk into these fields of a type in this
2086      case.  Note that decls get walked as part of the processing of a
2087      BIND_EXPR.
2088
2089      ??? Precisely which fields of types that we are supposed to walk in
2090      this case vs. the normal case aren't well defined.  */
2091   if (code == DECL_EXPR
2092       && TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL
2093       && TREE_CODE (TREE_TYPE (DECL_EXPR_DECL (*tp))) != ERROR_MARK)
2094     {
2095       tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp));
2096
2097       /* Call the function for the type.  See if it returns anything or
2098          doesn't want us to continue.  If we are to continue, walk both
2099          the normal fields and those for the declaration case.  */
2100       result = (*func) (type_p, &walk_subtrees, data);
2101       if (result || !walk_subtrees)
2102         return NULL_TREE;
2103
2104       result = walk_type_fields (*type_p, func, data, htab_);
2105       if (result)
2106         return result;
2107
2108       WALK_SUBTREE (TYPE_SIZE (*type_p));
2109       WALK_SUBTREE (TYPE_SIZE_UNIT (*type_p));
2110
2111       /* If this is a record type, also walk the fields.  */
2112       if (TREE_CODE (*type_p) == RECORD_TYPE
2113           || TREE_CODE (*type_p) == UNION_TYPE
2114           || TREE_CODE (*type_p) == QUAL_UNION_TYPE)
2115         {
2116           tree field;
2117
2118           for (field = TYPE_FIELDS (*type_p); field;
2119                field = TREE_CHAIN (field))
2120             {
2121               /* We'd like to look at the type of the field, but we can easily
2122                  get infinite recursion.  So assume it's pointed to elsewhere
2123                  in the tree.  Also, ignore things that aren't fields.  */
2124               if (TREE_CODE (field) != FIELD_DECL)
2125                 continue;
2126
2127               WALK_SUBTREE (DECL_FIELD_OFFSET (field));
2128               WALK_SUBTREE (DECL_SIZE (field));
2129               WALK_SUBTREE (DECL_SIZE_UNIT (field));
2130               if (TREE_CODE (*type_p) == QUAL_UNION_TYPE)
2131                 WALK_SUBTREE (DECL_QUALIFIER (field));
2132             }
2133         }
2134     }
2135
2136   else if (code != EXIT_BLOCK_EXPR
2137            && code != SAVE_EXPR
2138            && code != BIND_EXPR
2139            && IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
2140     {
2141       int i, len;
2142
2143       /* Walk over all the sub-trees of this operand.  */
2144       len = first_rtl_op (code);
2145       /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
2146          But, we only want to walk once.  */
2147       if (code == TARGET_EXPR
2148           && TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1))
2149         --len;
2150
2151       /* Go through the subtrees.  We need to do this in forward order so
2152          that the scope of a FOR_EXPR is handled properly.  */
2153 #ifdef DEBUG_WALK_TREE
2154       for (i = 0; i < len; ++i)
2155         WALK_SUBTREE (TREE_OPERAND (*tp, i));
2156 #else
2157       for (i = 0; i < len - 1; ++i)
2158         WALK_SUBTREE (TREE_OPERAND (*tp, i));
2159
2160       if (len)
2161         {
2162           /* The common case is that we may tail recurse here.  */
2163           if (code != BIND_EXPR
2164               && !TREE_CHAIN (*tp))
2165             WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len - 1));
2166           else
2167             WALK_SUBTREE (TREE_OPERAND (*tp, len - 1));
2168         }
2169 #endif
2170     }
2171
2172   /* If this is a type, walk the needed fields in the type.  */
2173   else if (TYPE_P (*tp))
2174     {
2175       result = walk_type_fields (*tp, func, data, htab_);
2176       if (result)
2177         return result;
2178     }
2179   else
2180     {
2181       /* Not one of the easy cases.  We must explicitly go through the
2182          children.  */
2183       switch (code)
2184         {
2185         case ERROR_MARK:
2186         case IDENTIFIER_NODE:
2187         case INTEGER_CST:
2188         case REAL_CST:
2189         case VECTOR_CST:
2190         case STRING_CST:
2191         case BLOCK:
2192         case PLACEHOLDER_EXPR:
2193         case SSA_NAME:
2194         case FIELD_DECL:
2195         case RESULT_DECL:
2196           /* None of thse have subtrees other than those already walked
2197              above.  */
2198           break;
2199
2200         case TREE_LIST:
2201           WALK_SUBTREE (TREE_VALUE (*tp));
2202           WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
2203           break;
2204
2205         case TREE_VEC:
2206           {
2207             int len = TREE_VEC_LENGTH (*tp);
2208
2209             if (len == 0)
2210               break;
2211
2212             /* Walk all elements but the first.  */
2213             while (--len)
2214               WALK_SUBTREE (TREE_VEC_ELT (*tp, len));
2215
2216             /* Now walk the first one as a tail call.  */
2217             WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0));
2218           }
2219
2220         case COMPLEX_CST:
2221           WALK_SUBTREE (TREE_REALPART (*tp));
2222           WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp));
2223
2224         case CONSTRUCTOR:
2225           WALK_SUBTREE_TAIL (CONSTRUCTOR_ELTS (*tp));
2226
2227         case EXIT_BLOCK_EXPR:
2228           WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 1));
2229
2230         case SAVE_EXPR:
2231           WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0));
2232
2233         case BIND_EXPR:
2234           {
2235             tree decl;
2236             for (decl = BIND_EXPR_VARS (*tp); decl; decl = TREE_CHAIN (decl))
2237               {
2238                 /* Walk the DECL_INITIAL and DECL_SIZE.  We don't want to walk
2239                    into declarations that are just mentioned, rather than
2240                    declared; they don't really belong to this part of the tree.
2241                    And, we can see cycles: the initializer for a declaration
2242                    can refer to the declaration itself.  */
2243                 WALK_SUBTREE (DECL_INITIAL (decl));
2244                 WALK_SUBTREE (DECL_SIZE (decl));
2245                 WALK_SUBTREE (DECL_SIZE_UNIT (decl));
2246               }
2247             WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp));
2248           }
2249
2250         case STATEMENT_LIST:
2251           {
2252             tree_stmt_iterator i;
2253             for (i = tsi_start (*tp); !tsi_end_p (i); tsi_next (&i))
2254               WALK_SUBTREE (*tsi_stmt_ptr (i));
2255           }
2256           break;
2257
2258         default:
2259           /* ??? This could be a language-defined node.  We really should make
2260              a hook for it, but right now just ignore it.  */
2261           break;
2262         }
2263     }
2264
2265   /* We didn't find what we were looking for.  */
2266   return NULL_TREE;
2267
2268 #undef WALK_SUBTREE
2269 #undef WALK_SUBTREE_TAIL
2270 }
2271
2272 /* Like walk_tree, but does not walk duplicate nodes more than once.  */
2273
2274 tree
2275 walk_tree_without_duplicates (tree *tp, walk_tree_fn func, void *data)
2276 {
2277   tree result;
2278   htab_t htab;
2279
2280   htab = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
2281   result = walk_tree (tp, func, data, htab);
2282   htab_delete (htab);
2283   return result;
2284 }
2285
2286 /* Passed to walk_tree.  Copies the node pointed to, if appropriate.  */
2287
2288 tree
2289 copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
2290 {
2291   enum tree_code code = TREE_CODE (*tp);
2292
2293   /* We make copies of most nodes.  */
2294   if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code))
2295       || TREE_CODE_CLASS (code) == 'c'
2296       || code == TREE_LIST
2297       || code == TREE_VEC
2298       || code == TYPE_DECL)
2299     {
2300       /* Because the chain gets clobbered when we make a copy, we save it
2301          here.  */
2302       tree chain = TREE_CHAIN (*tp);
2303       tree new;
2304
2305       /* Copy the node.  */
2306       new = copy_node (*tp);
2307
2308       /* Propagate mudflap marked-ness.  */
2309       if (flag_mudflap && mf_marked_p (*tp))
2310         mf_mark (new);
2311
2312       *tp = new;
2313
2314       /* Now, restore the chain, if appropriate.  That will cause
2315          walk_tree to walk into the chain as well.  */
2316       if (code == PARM_DECL || code == TREE_LIST)
2317         TREE_CHAIN (*tp) = chain;
2318
2319       /* For now, we don't update BLOCKs when we make copies.  So, we
2320          have to nullify all BIND_EXPRs.  */
2321       if (TREE_CODE (*tp) == BIND_EXPR)
2322         BIND_EXPR_BLOCK (*tp) = NULL_TREE;
2323     }
2324
2325   else if (TREE_CODE_CLASS (code) == 't')
2326     *walk_subtrees = 0;
2327   else if (TREE_CODE_CLASS (code) == 'd')
2328     *walk_subtrees = 0;
2329  else if (code == STATEMENT_LIST)
2330     abort ();
2331
2332   return NULL_TREE;
2333 }
2334
2335 /* The SAVE_EXPR pointed to by TP is being copied.  If ST contains
2336    information indicating to what new SAVE_EXPR this one should be mapped,
2337    use that one.  Otherwise, create a new node and enter it in ST.  */
2338
2339 void
2340 remap_save_expr (tree *tp, void *st_, int *walk_subtrees)
2341 {
2342   splay_tree st = (splay_tree) st_;
2343   splay_tree_node n;
2344   tree t;
2345
2346   /* See if we already encountered this SAVE_EXPR.  */
2347   n = splay_tree_lookup (st, (splay_tree_key) *tp);
2348
2349   /* If we didn't already remap this SAVE_EXPR, do so now.  */
2350   if (!n)
2351     {
2352       t = copy_node (*tp);
2353
2354       /* Remember this SAVE_EXPR.  */
2355       splay_tree_insert (st, (splay_tree_key) *tp, (splay_tree_value) t);
2356       /* Make sure we don't remap an already-remapped SAVE_EXPR.  */
2357       splay_tree_insert (st, (splay_tree_key) t, (splay_tree_value) t);
2358     }
2359   else
2360     {
2361       /* We've already walked into this SAVE_EXPR; don't do it again.  */
2362       *walk_subtrees = 0;
2363       t = (tree) n->value;
2364     }
2365
2366   /* Replace this SAVE_EXPR with the copy.  */
2367   *tp = t;
2368 }
2369
2370 /* Called via walk_tree.  If *TP points to a DECL_STMT for a local label,
2371    copies the declaration and enters it in the splay_tree in DATA (which is
2372    really an `inline_data *').  */
2373
2374 static tree
2375 mark_local_for_remap_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
2376                         void *data)
2377 {
2378   inline_data *id = (inline_data *) data;
2379
2380   /* Don't walk into types.  */
2381   if (TYPE_P (*tp))
2382     *walk_subtrees = 0;
2383
2384   else if (TREE_CODE (*tp) == LABEL_EXPR)
2385     {
2386       tree decl = TREE_OPERAND (*tp, 0);
2387
2388       /* Copy the decl and remember the copy.  */
2389       insert_decl_map (id, decl,
2390                        copy_decl_for_inlining (decl, DECL_CONTEXT (decl),
2391                                                DECL_CONTEXT (decl)));
2392     }
2393
2394   return NULL_TREE;
2395 }
2396
2397 /* Called via walk_tree when an expression is unsaved.  Using the
2398    splay_tree pointed to by ST (which is really a `splay_tree'),
2399    remaps all local declarations to appropriate replacements.  */
2400
2401 static tree
2402 unsave_r (tree *tp, int *walk_subtrees, void *data)
2403 {
2404   inline_data *id = (inline_data *) data;
2405   splay_tree st = id->decl_map;
2406   splay_tree_node n;
2407
2408   /* Only a local declaration (variable or label).  */
2409   if ((TREE_CODE (*tp) == VAR_DECL && !TREE_STATIC (*tp))
2410       || TREE_CODE (*tp) == LABEL_DECL)
2411     {
2412       /* Lookup the declaration.  */
2413       n = splay_tree_lookup (st, (splay_tree_key) *tp);
2414
2415       /* If it's there, remap it.  */
2416       if (n)
2417         *tp = (tree) n->value;
2418     }
2419
2420   else if (TREE_CODE (*tp) == STATEMENT_LIST)
2421     copy_statement_list (tp);
2422   else if (TREE_CODE (*tp) == BIND_EXPR)
2423     copy_bind_expr (tp, walk_subtrees, id);
2424   else if (TREE_CODE (*tp) == SAVE_EXPR)
2425     remap_save_expr (tp, st, walk_subtrees);
2426   else
2427     {
2428       copy_tree_r (tp, walk_subtrees, NULL);
2429
2430       /* Do whatever unsaving is required.  */
2431       unsave_expr_1 (*tp);
2432     }
2433
2434   /* Keep iterating.  */
2435   return NULL_TREE;
2436 }
2437
2438 /* Default lang hook for "unsave_expr_now".  Copies everything in EXPR and
2439    replaces variables, labels and SAVE_EXPRs local to EXPR.  */
2440
2441 tree
2442 lhd_unsave_expr_now (tree expr)
2443 {
2444   inline_data id;
2445
2446   /* There's nothing to do for NULL_TREE.  */
2447   if (expr == 0)
2448     return expr;
2449
2450   /* Set up ID.  */
2451   memset (&id, 0, sizeof (id));
2452   VARRAY_TREE_INIT (id.fns, 1, "fns");
2453   VARRAY_PUSH_TREE (id.fns, current_function_decl);
2454   id.decl_map = splay_tree_new (splay_tree_compare_pointers, NULL, NULL);
2455
2456   /* Walk the tree once to find local labels.  */
2457   walk_tree_without_duplicates (&expr, mark_local_for_remap_r, &id);
2458
2459   /* Walk the tree again, copying, remapping, and unsaving.  */
2460   walk_tree (&expr, unsave_r, &id, NULL);
2461
2462   /* Clean up.  */
2463   splay_tree_delete (id.decl_map);
2464
2465   return expr;
2466 }
2467
2468 /* Allow someone to determine if SEARCH is a child of TOP from gdb.  */
2469
2470 static tree
2471 debug_find_tree_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
2472 {
2473   if (*tp == data)
2474     return (tree) data;
2475   else
2476     return NULL;
2477 }
2478
2479 bool
2480 debug_find_tree (tree top, tree search)
2481 {
2482   return walk_tree_without_duplicates (&top, debug_find_tree_1, search) != 0;
2483 }
2484
2485 /* Declare the variables created by the inliner.  Add all the variables in
2486    VARS to BIND_EXPR.  */
2487
2488 static void
2489 declare_inline_vars (tree bind_expr, tree vars)
2490 {
2491   tree t;
2492   for (t = vars; t; t = TREE_CHAIN (t))
2493     DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
2494
2495   add_var_to_bind_expr (bind_expr, vars);
2496 }