OSDN Git Service

* cgraph.c (cgraph_release_function_body): Update use of
[pf3gnuchains/gcc-fork.git] / gcc / tree-inline.c
1 /* Tree inlining.
2    Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
3    Free Software Foundation, Inc.
4    Contributed by Alexandre Oliva <aoliva@redhat.com>
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
12
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "toplev.h"
27 #include "tree.h"
28 #include "tree-inline.h"
29 #include "rtl.h"
30 #include "expr.h"
31 #include "flags.h"
32 #include "params.h"
33 #include "input.h"
34 #include "insn-config.h"
35 #include "hashtab.h"
36 #include "langhooks.h"
37 #include "basic-block.h"
38 #include "tree-iterator.h"
39 #include "cgraph.h"
40 #include "intl.h"
41 #include "tree-mudflap.h"
42 #include "tree-flow.h"
43 #include "function.h"
44 #include "ggc.h"
45 #include "tree-flow.h"
46 #include "diagnostic.h"
47 #include "except.h"
48 #include "debug.h"
49 #include "pointer-set.h"
50 #include "ipa-prop.h"
51 #include "value-prof.h"
52 #include "tree-pass.h"
53 #include "target.h"
54 #include "integrate.h"
55
56 /* I'm not real happy about this, but we need to handle gimple and
57    non-gimple trees.  */
58 #include "gimple.h"
59
60 /* Inlining, Cloning, Versioning, Parallelization
61
62    Inlining: a function body is duplicated, but the PARM_DECLs are
63    remapped into VAR_DECLs, and non-void RETURN_EXPRs become
64    MODIFY_EXPRs that store to a dedicated returned-value variable.
65    The duplicated eh_region info of the copy will later be appended
66    to the info for the caller; the eh_region info in copied throwing
67    statements and RESX statements are adjusted accordingly.
68
69    Cloning: (only in C++) We have one body for a con/de/structor, and
70    multiple function decls, each with a unique parameter list.
71    Duplicate the body, using the given splay tree; some parameters
72    will become constants (like 0 or 1).
73
74    Versioning: a function body is duplicated and the result is a new
75    function rather than into blocks of an existing function as with
76    inlining.  Some parameters will become constants.
77
78    Parallelization: a region of a function is duplicated resulting in
79    a new function.  Variables may be replaced with complex expressions
80    to enable shared variable semantics.
81
82    All of these will simultaneously lookup any callgraph edges.  If
83    we're going to inline the duplicated function body, and the given
84    function has some cloned callgraph nodes (one for each place this
85    function will be inlined) those callgraph edges will be duplicated.
86    If we're cloning the body, those callgraph edges will be
87    updated to point into the new body.  (Note that the original
88    callgraph node and edge list will not be altered.)
89
90    See the CALL_EXPR handling case in copy_tree_body_r ().  */
91
92 /* To Do:
93
94    o In order to make inlining-on-trees work, we pessimized
95      function-local static constants.  In particular, they are now
96      always output, even when not addressed.  Fix this by treating
97      function-local static constants just like global static
98      constants; the back-end already knows not to output them if they
99      are not needed.
100
101    o Provide heuristics to clamp inlining of recursive template
102      calls?  */
103
104
105 /* Weights that estimate_num_insns uses for heuristics in inlining.  */
106
107 eni_weights eni_inlining_weights;
108
109 /* Weights that estimate_num_insns uses to estimate the size of the
110    produced code.  */
111
112 eni_weights eni_size_weights;
113
114 /* Weights that estimate_num_insns uses to estimate the time necessary
115    to execute the produced code.  */
116
117 eni_weights eni_time_weights;
118
119 /* Prototypes.  */
120
121 static tree declare_return_variable (copy_body_data *, tree, tree, tree *);
122 static void remap_block (tree *, copy_body_data *);
123 static void copy_bind_expr (tree *, int *, copy_body_data *);
124 static tree mark_local_for_remap_r (tree *, int *, void *);
125 static void unsave_expr_1 (tree);
126 static tree unsave_r (tree *, int *, void *);
127 static void declare_inline_vars (tree, tree);
128 static void remap_save_expr (tree *, void *, int *);
129 static void prepend_lexical_block (tree current_block, tree new_block);
130 static tree copy_decl_to_var (tree, copy_body_data *);
131 static tree copy_result_decl_to_var (tree, copy_body_data *);
132 static tree copy_decl_maybe_to_var (tree, copy_body_data *);
133 static gimple remap_gimple_stmt (gimple, copy_body_data *);
134 static bool delete_unreachable_blocks_update_callgraph (copy_body_data *id);
135
136 /* Insert a tree->tree mapping for ID.  Despite the name suggests
137    that the trees should be variables, it is used for more than that.  */
138
139 void
140 insert_decl_map (copy_body_data *id, tree key, tree value)
141 {
142   *pointer_map_insert (id->decl_map, key) = value;
143
144   /* Always insert an identity map as well.  If we see this same new
145      node again, we won't want to duplicate it a second time.  */
146   if (key != value)
147     *pointer_map_insert (id->decl_map, value) = value;
148 }
149
150 /* Insert a tree->tree mapping for ID.  This is only used for
151    variables.  */
152
153 static void
154 insert_debug_decl_map (copy_body_data *id, tree key, tree value)
155 {
156   if (!gimple_in_ssa_p (id->src_cfun))
157     return;
158
159   if (!MAY_HAVE_DEBUG_STMTS)
160     return;
161
162   if (!target_for_debug_bind (key))
163     return;
164
165   gcc_assert (TREE_CODE (key) == PARM_DECL);
166   gcc_assert (TREE_CODE (value) == VAR_DECL);
167
168   if (!id->debug_map)
169     id->debug_map = pointer_map_create ();
170
171   *pointer_map_insert (id->debug_map, key) = value;
172 }
173
174 /* Construct new SSA name for old NAME. ID is the inline context.  */
175
176 static tree
177 remap_ssa_name (tree name, copy_body_data *id)
178 {
179   tree new_tree;
180   tree *n;
181
182   gcc_assert (TREE_CODE (name) == SSA_NAME);
183
184   n = (tree *) pointer_map_contains (id->decl_map, name);
185   if (n)
186     return unshare_expr (*n);
187
188   /* Do not set DEF_STMT yet as statement is not copied yet. We do that
189      in copy_bb.  */
190   new_tree = remap_decl (SSA_NAME_VAR (name), id);
191
192   /* We might've substituted constant or another SSA_NAME for
193      the variable. 
194
195      Replace the SSA name representing RESULT_DECL by variable during
196      inlining:  this saves us from need to introduce PHI node in a case
197      return value is just partly initialized.  */
198   if ((TREE_CODE (new_tree) == VAR_DECL || TREE_CODE (new_tree) == PARM_DECL)
199       && (TREE_CODE (SSA_NAME_VAR (name)) != RESULT_DECL
200           || !id->transform_return_to_modify))
201     {
202       new_tree = make_ssa_name (new_tree, NULL);
203       insert_decl_map (id, name, new_tree);
204       SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree)
205         = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name);
206       TREE_TYPE (new_tree) = TREE_TYPE (SSA_NAME_VAR (new_tree));
207       if (gimple_nop_p (SSA_NAME_DEF_STMT (name)))
208         {
209           /* By inlining function having uninitialized variable, we might
210              extend the lifetime (variable might get reused).  This cause
211              ICE in the case we end up extending lifetime of SSA name across
212              abnormal edge, but also increase register pressure.
213
214              We simply initialize all uninitialized vars by 0 except
215              for case we are inlining to very first BB.  We can avoid
216              this for all BBs that are not inside strongly connected
217              regions of the CFG, but this is expensive to test.  */
218           if (id->entry_bb
219               && is_gimple_reg (SSA_NAME_VAR (name))
220               && TREE_CODE (SSA_NAME_VAR (name)) != PARM_DECL
221               && (id->entry_bb != EDGE_SUCC (ENTRY_BLOCK_PTR, 0)->dest
222                   || EDGE_COUNT (id->entry_bb->preds) != 1))
223             {
224               gimple_stmt_iterator gsi = gsi_last_bb (id->entry_bb);
225               gimple init_stmt;
226               
227               init_stmt = gimple_build_assign (new_tree,
228                                                fold_convert (TREE_TYPE (new_tree),
229                                                             integer_zero_node));
230               gsi_insert_after (&gsi, init_stmt, GSI_NEW_STMT);
231               SSA_NAME_IS_DEFAULT_DEF (new_tree) = 0;
232             }
233           else
234             {
235               SSA_NAME_DEF_STMT (new_tree) = gimple_build_nop ();
236               if (gimple_default_def (id->src_cfun, SSA_NAME_VAR (name))
237                   == name)
238                 set_default_def (SSA_NAME_VAR (new_tree), new_tree);
239             }
240         }
241     }
242   else
243     insert_decl_map (id, name, new_tree);
244   return new_tree;
245 }
246
247 /* If nonzero, we're remapping the contents of inlined debug
248    statements.  If negative, an error has occurred, such as a
249    reference to a variable that isn't available in the inlined
250    context.  */
251 int processing_debug_stmt = 0;
252
253 /* Remap DECL during the copying of the BLOCK tree for the function.  */
254
255 tree
256 remap_decl (tree decl, copy_body_data *id)
257 {
258   tree *n;
259   tree fn;
260
261   /* We only remap local variables in the current function.  */
262   fn = id->src_fn;
263
264   /* See if we have remapped this declaration.  */
265
266   n = (tree *) pointer_map_contains (id->decl_map, decl);
267
268   if (!n && processing_debug_stmt)
269     {
270       processing_debug_stmt = -1;
271       return decl;
272     }
273
274   /* If we didn't already have an equivalent for this declaration,
275      create one now.  */
276   if (!n)
277     {
278       /* Make a copy of the variable or label.  */
279       tree t = id->copy_decl (decl, id);
280      
281       /* Remember it, so that if we encounter this local entity again
282          we can reuse this copy.  Do this early because remap_type may
283          need this decl for TYPE_STUB_DECL.  */
284       insert_decl_map (id, decl, t);
285
286       if (!DECL_P (t))
287         return t;
288
289       /* Remap types, if necessary.  */
290       TREE_TYPE (t) = remap_type (TREE_TYPE (t), id);
291       if (TREE_CODE (t) == TYPE_DECL)
292         DECL_ORIGINAL_TYPE (t) = remap_type (DECL_ORIGINAL_TYPE (t), id);
293
294       /* Remap sizes as necessary.  */
295       walk_tree (&DECL_SIZE (t), copy_tree_body_r, id, NULL);
296       walk_tree (&DECL_SIZE_UNIT (t), copy_tree_body_r, id, NULL);
297
298       /* If fields, do likewise for offset and qualifier.  */
299       if (TREE_CODE (t) == FIELD_DECL)
300         {
301           walk_tree (&DECL_FIELD_OFFSET (t), copy_tree_body_r, id, NULL);
302           if (TREE_CODE (DECL_CONTEXT (t)) == QUAL_UNION_TYPE)
303             walk_tree (&DECL_QUALIFIER (t), copy_tree_body_r, id, NULL);
304         }
305
306       if (cfun && gimple_in_ssa_p (cfun)
307           && (TREE_CODE (t) == VAR_DECL
308               || TREE_CODE (t) == RESULT_DECL || TREE_CODE (t) == PARM_DECL))
309         {
310           tree def = gimple_default_def (id->src_cfun, decl);
311           get_var_ann (t);
312           if (TREE_CODE (decl) != PARM_DECL && def)
313             {
314               tree map = remap_ssa_name (def, id);
315               /* Watch out RESULT_DECLs whose SSA names map directly
316                  to them.  */
317               if (TREE_CODE (map) == SSA_NAME
318                   && gimple_nop_p (SSA_NAME_DEF_STMT (map)))
319                 set_default_def (t, map);
320             }
321           add_referenced_var (t);
322         }
323       return t;
324     }
325
326   if (id->do_not_unshare)
327     return *n;
328   else
329     return unshare_expr (*n);
330 }
331
332 static tree
333 remap_type_1 (tree type, copy_body_data *id)
334 {
335   tree new_tree, t;
336
337   /* We do need a copy.  build and register it now.  If this is a pointer or
338      reference type, remap the designated type and make a new pointer or
339      reference type.  */
340   if (TREE_CODE (type) == POINTER_TYPE)
341     {
342       new_tree = build_pointer_type_for_mode (remap_type (TREE_TYPE (type), id),
343                                          TYPE_MODE (type),
344                                          TYPE_REF_CAN_ALIAS_ALL (type));
345       if (TYPE_ATTRIBUTES (type) || TYPE_QUALS (type))
346         new_tree = build_type_attribute_qual_variant (new_tree,
347                                                       TYPE_ATTRIBUTES (type),
348                                                       TYPE_QUALS (type));
349       insert_decl_map (id, type, new_tree);
350       return new_tree;
351     }
352   else if (TREE_CODE (type) == REFERENCE_TYPE)
353     {
354       new_tree = build_reference_type_for_mode (remap_type (TREE_TYPE (type), id),
355                                             TYPE_MODE (type),
356                                             TYPE_REF_CAN_ALIAS_ALL (type));
357       if (TYPE_ATTRIBUTES (type) || TYPE_QUALS (type))
358         new_tree = build_type_attribute_qual_variant (new_tree,
359                                                       TYPE_ATTRIBUTES (type),
360                                                       TYPE_QUALS (type));
361       insert_decl_map (id, type, new_tree);
362       return new_tree;
363     }
364   else
365     new_tree = copy_node (type);
366
367   insert_decl_map (id, type, new_tree);
368
369   /* This is a new type, not a copy of an old type.  Need to reassociate
370      variants.  We can handle everything except the main variant lazily.  */
371   t = TYPE_MAIN_VARIANT (type);
372   if (type != t)
373     {
374       t = remap_type (t, id);
375       TYPE_MAIN_VARIANT (new_tree) = t;
376       TYPE_NEXT_VARIANT (new_tree) = TYPE_NEXT_VARIANT (t);
377       TYPE_NEXT_VARIANT (t) = new_tree;
378     }
379   else
380     {
381       TYPE_MAIN_VARIANT (new_tree) = new_tree;
382       TYPE_NEXT_VARIANT (new_tree) = NULL;
383     }
384
385   if (TYPE_STUB_DECL (type))
386     TYPE_STUB_DECL (new_tree) = remap_decl (TYPE_STUB_DECL (type), id);
387
388   /* Lazily create pointer and reference types.  */
389   TYPE_POINTER_TO (new_tree) = NULL;
390   TYPE_REFERENCE_TO (new_tree) = NULL;
391
392   switch (TREE_CODE (new_tree))
393     {
394     case INTEGER_TYPE:
395     case REAL_TYPE:
396     case FIXED_POINT_TYPE:
397     case ENUMERAL_TYPE:
398     case BOOLEAN_TYPE:
399       t = TYPE_MIN_VALUE (new_tree);
400       if (t && TREE_CODE (t) != INTEGER_CST)
401         walk_tree (&TYPE_MIN_VALUE (new_tree), copy_tree_body_r, id, NULL);
402
403       t = TYPE_MAX_VALUE (new_tree);
404       if (t && TREE_CODE (t) != INTEGER_CST)
405         walk_tree (&TYPE_MAX_VALUE (new_tree), copy_tree_body_r, id, NULL);
406       return new_tree;
407
408     case FUNCTION_TYPE:
409       TREE_TYPE (new_tree) = remap_type (TREE_TYPE (new_tree), id);
410       walk_tree (&TYPE_ARG_TYPES (new_tree), copy_tree_body_r, id, NULL);
411       return new_tree;
412
413     case ARRAY_TYPE:
414       TREE_TYPE (new_tree) = remap_type (TREE_TYPE (new_tree), id);
415       TYPE_DOMAIN (new_tree) = remap_type (TYPE_DOMAIN (new_tree), id);
416       break;
417
418     case RECORD_TYPE:
419     case UNION_TYPE:
420     case QUAL_UNION_TYPE:
421       {
422         tree f, nf = NULL;
423
424         for (f = TYPE_FIELDS (new_tree); f ; f = TREE_CHAIN (f))
425           {
426             t = remap_decl (f, id);
427             DECL_CONTEXT (t) = new_tree;
428             TREE_CHAIN (t) = nf;
429             nf = t;
430           }
431         TYPE_FIELDS (new_tree) = nreverse (nf);
432       }
433       break;
434
435     case OFFSET_TYPE:
436     default:
437       /* Shouldn't have been thought variable sized.  */
438       gcc_unreachable ();
439     }
440
441   walk_tree (&TYPE_SIZE (new_tree), copy_tree_body_r, id, NULL);
442   walk_tree (&TYPE_SIZE_UNIT (new_tree), copy_tree_body_r, id, NULL);
443
444   return new_tree;
445 }
446
447 tree
448 remap_type (tree type, copy_body_data *id)
449 {
450   tree *node;
451   tree tmp;
452
453   if (type == NULL)
454     return type;
455
456   /* See if we have remapped this type.  */
457   node = (tree *) pointer_map_contains (id->decl_map, type);
458   if (node)
459     return *node;
460
461   /* The type only needs remapping if it's variably modified.  */
462   if (! variably_modified_type_p (type, id->src_fn))
463     {
464       insert_decl_map (id, type, type);
465       return type;
466     }
467
468   id->remapping_type_depth++;
469   tmp = remap_type_1 (type, id);
470   id->remapping_type_depth--;
471
472   return tmp;
473 }
474
475 /* Return previously remapped type of TYPE in ID.  Return NULL if TYPE
476    is NULL or TYPE has not been remapped before.  */
477
478 static tree
479 remapped_type (tree type, copy_body_data *id)
480 {
481   tree *node;
482
483   if (type == NULL)
484     return type;
485
486   /* See if we have remapped this type.  */
487   node = (tree *) pointer_map_contains (id->decl_map, type);
488   if (node)
489     return *node;
490   else
491     return NULL;
492 }
493
494   /* The type only needs remapping if it's variably modified.  */
495 /* Decide if DECL can be put into BLOCK_NONLOCAL_VARs.  */
496   
497 static bool
498 can_be_nonlocal (tree decl, copy_body_data *id)
499 {
500   /* We can not duplicate function decls.  */
501   if (TREE_CODE (decl) == FUNCTION_DECL)
502     return true;
503
504   /* Local static vars must be non-local or we get multiple declaration
505      problems.  */
506   if (TREE_CODE (decl) == VAR_DECL
507       && !auto_var_in_fn_p (decl, id->src_fn))
508     return true;
509
510   /* At the moment dwarf2out can handle only these types of nodes.  We
511      can support more later.  */
512   if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != PARM_DECL)
513     return false;
514
515   /* We must use global type.  We call remapped_type instead of
516      remap_type since we don't want to remap this type here if it
517      hasn't been remapped before.  */
518   if (TREE_TYPE (decl) != remapped_type (TREE_TYPE (decl), id))
519     return false;
520
521   /* Wihtout SSA we can't tell if variable is used.  */
522   if (!gimple_in_ssa_p (cfun))
523     return false;
524
525   /* Live variables must be copied so we can attach DECL_RTL.  */
526   if (var_ann (decl))
527     return false;
528
529   return true;
530 }
531
532 static tree
533 remap_decls (tree decls, VEC(tree,gc) **nonlocalized_list, copy_body_data *id)
534 {
535   tree old_var;
536   tree new_decls = NULL_TREE;
537
538   /* Remap its variables.  */
539   for (old_var = decls; old_var; old_var = TREE_CHAIN (old_var))
540     {
541       tree new_var;
542       tree origin_var = DECL_ORIGIN (old_var);
543
544       if (can_be_nonlocal (old_var, id))
545         {
546           if (TREE_CODE (old_var) == VAR_DECL
547               && ! DECL_EXTERNAL (old_var)
548               && (var_ann (old_var) || !gimple_in_ssa_p (cfun)))
549             cfun->local_decls = tree_cons (NULL_TREE, old_var,
550                                                    cfun->local_decls);
551           if ((!optimize || debug_info_level > DINFO_LEVEL_TERSE)
552               && !DECL_IGNORED_P (old_var)
553               && nonlocalized_list)
554             VEC_safe_push (tree, gc, *nonlocalized_list, origin_var);
555           continue;
556         }
557
558       /* Remap the variable.  */
559       new_var = remap_decl (old_var, id);
560
561       /* If we didn't remap this variable, we can't mess with its
562          TREE_CHAIN.  If we remapped this variable to the return slot, it's
563          already declared somewhere else, so don't declare it here.  */
564       
565       if (new_var == id->retvar)
566         ;
567       else if (!new_var)
568         {
569           if ((!optimize || debug_info_level > DINFO_LEVEL_TERSE)
570               && !DECL_IGNORED_P (old_var)
571               && nonlocalized_list)
572             VEC_safe_push (tree, gc, *nonlocalized_list, origin_var);
573         }
574       else
575         {
576           gcc_assert (DECL_P (new_var));
577           TREE_CHAIN (new_var) = new_decls;
578           new_decls = new_var;
579         }
580     }
581
582   return nreverse (new_decls);
583 }
584
585 /* Copy the BLOCK to contain remapped versions of the variables
586    therein.  And hook the new block into the block-tree.  */
587
588 static void
589 remap_block (tree *block, copy_body_data *id)
590 {
591   tree old_block;
592   tree new_block;
593   tree fn;
594
595   /* Make the new block.  */
596   old_block = *block;
597   new_block = make_node (BLOCK);
598   TREE_USED (new_block) = TREE_USED (old_block);
599   BLOCK_ABSTRACT_ORIGIN (new_block) = old_block;
600   BLOCK_SOURCE_LOCATION (new_block) = BLOCK_SOURCE_LOCATION (old_block);
601   BLOCK_NONLOCALIZED_VARS (new_block)
602     = VEC_copy (tree, gc, BLOCK_NONLOCALIZED_VARS (old_block));
603   *block = new_block;
604
605   /* Remap its variables.  */
606   BLOCK_VARS (new_block) = remap_decls (BLOCK_VARS (old_block),
607                                         &BLOCK_NONLOCALIZED_VARS (new_block),
608                                         id);
609
610   fn = id->dst_fn;
611
612   if (id->transform_lang_insert_block)
613     id->transform_lang_insert_block (new_block);
614
615   /* Remember the remapped block.  */
616   insert_decl_map (id, old_block, new_block);
617 }
618
619 /* Copy the whole block tree and root it in id->block.  */
620 static tree
621 remap_blocks (tree block, copy_body_data *id)
622 {
623   tree t;
624   tree new_tree = block;
625
626   if (!block)
627     return NULL;
628
629   remap_block (&new_tree, id);
630   gcc_assert (new_tree != block);
631   for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
632     prepend_lexical_block (new_tree, remap_blocks (t, id));
633   /* Blocks are in arbitrary order, but make things slightly prettier and do
634      not swap order when producing a copy.  */
635   BLOCK_SUBBLOCKS (new_tree) = blocks_nreverse (BLOCK_SUBBLOCKS (new_tree));
636   return new_tree;
637 }
638
639 static void
640 copy_statement_list (tree *tp)
641 {
642   tree_stmt_iterator oi, ni;
643   tree new_tree;
644
645   new_tree = alloc_stmt_list ();
646   ni = tsi_start (new_tree);
647   oi = tsi_start (*tp);
648   TREE_TYPE (new_tree) = TREE_TYPE (*tp);
649   *tp = new_tree;
650
651   for (; !tsi_end_p (oi); tsi_next (&oi))
652     {
653       tree stmt = tsi_stmt (oi);
654       if (TREE_CODE (stmt) == STATEMENT_LIST)
655         copy_statement_list (&stmt);
656       tsi_link_after (&ni, stmt, TSI_CONTINUE_LINKING);
657     }
658 }
659
660 static void
661 copy_bind_expr (tree *tp, int *walk_subtrees, copy_body_data *id)
662 {
663   tree block = BIND_EXPR_BLOCK (*tp);
664   /* Copy (and replace) the statement.  */
665   copy_tree_r (tp, walk_subtrees, NULL);
666   if (block)
667     {
668       remap_block (&block, id);
669       BIND_EXPR_BLOCK (*tp) = block;
670     }
671
672   if (BIND_EXPR_VARS (*tp))
673     /* This will remap a lot of the same decls again, but this should be
674        harmless.  */
675     BIND_EXPR_VARS (*tp) = remap_decls (BIND_EXPR_VARS (*tp), NULL, id);
676 }
677
678
679 /* Create a new gimple_seq by remapping all the statements in BODY
680    using the inlining information in ID.  */
681
682 gimple_seq
683 remap_gimple_seq (gimple_seq body, copy_body_data *id)
684 {
685   gimple_stmt_iterator si;
686   gimple_seq new_body = NULL;
687
688   for (si = gsi_start (body); !gsi_end_p (si); gsi_next (&si))
689     {
690       gimple new_stmt = remap_gimple_stmt (gsi_stmt (si), id);
691       gimple_seq_add_stmt (&new_body, new_stmt);
692     }
693
694   return new_body;
695 }
696
697
698 /* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its
699    block using the mapping information in ID.  */
700
701 static gimple
702 copy_gimple_bind (gimple stmt, copy_body_data *id)
703 {
704   gimple new_bind;
705   tree new_block, new_vars;
706   gimple_seq body, new_body;
707
708   /* Copy the statement.  Note that we purposely don't use copy_stmt
709      here because we need to remap statements as we copy.  */
710   body = gimple_bind_body (stmt);
711   new_body = remap_gimple_seq (body, id);
712
713   new_block = gimple_bind_block (stmt);
714   if (new_block)
715     remap_block (&new_block, id);
716
717   /* This will remap a lot of the same decls again, but this should be
718      harmless.  */
719   new_vars = gimple_bind_vars (stmt);
720   if (new_vars)
721     new_vars = remap_decls (new_vars, NULL, id);
722
723   new_bind = gimple_build_bind (new_vars, new_body, new_block);
724
725   return new_bind;
726 }
727
728
729 /* Remap the GIMPLE operand pointed to by *TP.  DATA is really a
730    'struct walk_stmt_info *'.  DATA->INFO is a 'copy_body_data *'.
731    WALK_SUBTREES is used to indicate walk_gimple_op whether to keep
732    recursing into the children nodes of *TP.  */
733
734 static tree
735 remap_gimple_op_r (tree *tp, int *walk_subtrees, void *data)
736 {
737   struct walk_stmt_info *wi_p = (struct walk_stmt_info *) data;
738   copy_body_data *id = (copy_body_data *) wi_p->info;
739   tree fn = id->src_fn;
740
741   if (TREE_CODE (*tp) == SSA_NAME)
742     {
743       *tp = remap_ssa_name (*tp, id);
744       *walk_subtrees = 0;
745       return NULL;
746     }
747   else if (auto_var_in_fn_p (*tp, fn))
748     {
749       /* Local variables and labels need to be replaced by equivalent
750          variables.  We don't want to copy static variables; there's
751          only one of those, no matter how many times we inline the
752          containing function.  Similarly for globals from an outer
753          function.  */
754       tree new_decl;
755
756       /* Remap the declaration.  */
757       new_decl = remap_decl (*tp, id);
758       gcc_assert (new_decl);
759       /* Replace this variable with the copy.  */
760       STRIP_TYPE_NOPS (new_decl);
761       /* ???  The C++ frontend uses void * pointer zero to initialize
762          any other type.  This confuses the middle-end type verification.
763          As cloned bodies do not go through gimplification again the fixup
764          there doesn't trigger.  */
765       if (TREE_CODE (new_decl) == INTEGER_CST
766           && !useless_type_conversion_p (TREE_TYPE (*tp), TREE_TYPE (new_decl)))
767         new_decl = fold_convert (TREE_TYPE (*tp), new_decl);
768       *tp = new_decl;
769       *walk_subtrees = 0;
770     }
771   else if (TREE_CODE (*tp) == STATEMENT_LIST)
772     gcc_unreachable ();
773   else if (TREE_CODE (*tp) == SAVE_EXPR)
774     gcc_unreachable ();
775   else if (TREE_CODE (*tp) == LABEL_DECL
776            && (!DECL_CONTEXT (*tp)
777                || decl_function_context (*tp) == id->src_fn))
778     /* These may need to be remapped for EH handling.  */
779     *tp = remap_decl (*tp, id);
780   else if (TYPE_P (*tp))
781     /* Types may need remapping as well.  */
782     *tp = remap_type (*tp, id);
783   else if (CONSTANT_CLASS_P (*tp))
784     {
785       /* If this is a constant, we have to copy the node iff the type
786          will be remapped.  copy_tree_r will not copy a constant.  */
787       tree new_type = remap_type (TREE_TYPE (*tp), id);
788
789       if (new_type == TREE_TYPE (*tp))
790         *walk_subtrees = 0;
791
792       else if (TREE_CODE (*tp) == INTEGER_CST)
793         *tp = build_int_cst_wide (new_type, TREE_INT_CST_LOW (*tp),
794                                   TREE_INT_CST_HIGH (*tp));
795       else
796         {
797           *tp = copy_node (*tp);
798           TREE_TYPE (*tp) = new_type;
799         }
800     }
801   else
802     {
803       /* Otherwise, just copy the node.  Note that copy_tree_r already
804          knows not to copy VAR_DECLs, etc., so this is safe.  */
805       if (TREE_CODE (*tp) == INDIRECT_REF)
806         {
807           /* Get rid of *& from inline substitutions that can happen when a
808              pointer argument is an ADDR_EXPR.  */
809           tree decl = TREE_OPERAND (*tp, 0);
810           tree *n;
811
812           n = (tree *) pointer_map_contains (id->decl_map, decl);
813           if (n)
814             {
815               tree type, new_tree, old;
816
817               /* If we happen to get an ADDR_EXPR in n->value, strip
818                  it manually here as we'll eventually get ADDR_EXPRs
819                  which lie about their types pointed to.  In this case
820                  build_fold_indirect_ref wouldn't strip the
821                  INDIRECT_REF, but we absolutely rely on that.  As
822                  fold_indirect_ref does other useful transformations,
823                  try that first, though.  */
824               type = TREE_TYPE (TREE_TYPE (*n));
825               new_tree = unshare_expr (*n);
826               old = *tp;
827               *tp = gimple_fold_indirect_ref (new_tree);
828               if (!*tp)
829                 {
830                   if (TREE_CODE (new_tree) == ADDR_EXPR)
831                     {
832                       *tp = fold_indirect_ref_1 (EXPR_LOCATION (new_tree),
833                                                  type, new_tree);
834                       /* ???  We should either assert here or build
835                          a VIEW_CONVERT_EXPR instead of blindly leaking
836                          incompatible types to our IL.  */
837                       if (! *tp)
838                         *tp = TREE_OPERAND (new_tree, 0);
839                     }
840                   else
841                     {
842                       *tp = build1 (INDIRECT_REF, type, new_tree);
843                       TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old);
844                       TREE_NO_WARNING (*tp) = TREE_NO_WARNING (old);
845                     }
846                 }
847               *walk_subtrees = 0;
848               return NULL;
849             }
850         }
851
852       /* Here is the "usual case".  Copy this tree node, and then
853          tweak some special cases.  */
854       copy_tree_r (tp, walk_subtrees, NULL);
855
856       /* Global variables we haven't seen yet need to go into referenced
857          vars.  If not referenced from types only.  */
858       if (gimple_in_ssa_p (cfun)
859           && TREE_CODE (*tp) == VAR_DECL
860           && id->remapping_type_depth == 0
861           && !processing_debug_stmt)
862         add_referenced_var (*tp);
863
864       /* We should never have TREE_BLOCK set on non-statements.  */
865       if (EXPR_P (*tp))
866         gcc_assert (!TREE_BLOCK (*tp));
867
868       if (TREE_CODE (*tp) != OMP_CLAUSE)
869         TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id);
870
871       if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3))
872         {
873           /* The copied TARGET_EXPR has never been expanded, even if the
874              original node was expanded already.  */
875           TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
876           TREE_OPERAND (*tp, 3) = NULL_TREE;
877         }
878       else if (TREE_CODE (*tp) == ADDR_EXPR)
879         {
880           /* Variable substitution need not be simple.  In particular,
881              the INDIRECT_REF substitution above.  Make sure that
882              TREE_CONSTANT and friends are up-to-date.  But make sure
883              to not improperly set TREE_BLOCK on some sub-expressions.  */
884           int invariant = is_gimple_min_invariant (*tp);
885           tree block = id->block;
886           id->block = NULL_TREE;
887           walk_tree (&TREE_OPERAND (*tp, 0), copy_tree_body_r, id, NULL);
888           id->block = block;
889
890           /* Handle the case where we substituted an INDIRECT_REF
891              into the operand of the ADDR_EXPR.  */
892           if (TREE_CODE (TREE_OPERAND (*tp, 0)) == INDIRECT_REF)
893             *tp = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0);
894           else
895             recompute_tree_invariant_for_addr_expr (*tp);
896
897           /* If this used to be invariant, but is not any longer,
898              then regimplification is probably needed.  */
899           if (invariant && !is_gimple_min_invariant (*tp))
900             id->regimplify = true;
901
902           *walk_subtrees = 0;
903         }
904     }
905
906   /* Keep iterating.  */
907   return NULL_TREE;
908 }
909
910
911 /* Called from copy_body_id via walk_tree.  DATA is really a
912    `copy_body_data *'.  */
913
914 tree
915 copy_tree_body_r (tree *tp, int *walk_subtrees, void *data)
916 {
917   copy_body_data *id = (copy_body_data *) data;
918   tree fn = id->src_fn;
919   tree new_block;
920
921   /* Begin by recognizing trees that we'll completely rewrite for the
922      inlining context.  Our output for these trees is completely
923      different from out input (e.g. RETURN_EXPR is deleted, and morphs
924      into an edge).  Further down, we'll handle trees that get
925      duplicated and/or tweaked.  */
926
927   /* When requested, RETURN_EXPRs should be transformed to just the
928      contained MODIFY_EXPR.  The branch semantics of the return will
929      be handled elsewhere by manipulating the CFG rather than a statement.  */
930   if (TREE_CODE (*tp) == RETURN_EXPR && id->transform_return_to_modify)
931     {
932       tree assignment = TREE_OPERAND (*tp, 0);
933
934       /* If we're returning something, just turn that into an
935          assignment into the equivalent of the original RESULT_DECL.
936          If the "assignment" is just the result decl, the result
937          decl has already been set (e.g. a recent "foo (&result_decl,
938          ...)"); just toss the entire RETURN_EXPR.  */
939       if (assignment && TREE_CODE (assignment) == MODIFY_EXPR)
940         {
941           /* Replace the RETURN_EXPR with (a copy of) the
942              MODIFY_EXPR hanging underneath.  */
943           *tp = copy_node (assignment);
944         }
945       else /* Else the RETURN_EXPR returns no value.  */
946         {
947           *tp = NULL;
948           return (tree) (void *)1;
949         }
950     }
951   else if (TREE_CODE (*tp) == SSA_NAME)
952     {
953       *tp = remap_ssa_name (*tp, id);
954       *walk_subtrees = 0;
955       return NULL;
956     }
957
958   /* Local variables and labels need to be replaced by equivalent
959      variables.  We don't want to copy static variables; there's only
960      one of those, no matter how many times we inline the containing
961      function.  Similarly for globals from an outer function.  */
962   else if (auto_var_in_fn_p (*tp, fn))
963     {
964       tree new_decl;
965
966       /* Remap the declaration.  */
967       new_decl = remap_decl (*tp, id);
968       gcc_assert (new_decl);
969       /* Replace this variable with the copy.  */
970       STRIP_TYPE_NOPS (new_decl);
971       *tp = new_decl;
972       *walk_subtrees = 0;
973     }
974   else if (TREE_CODE (*tp) == STATEMENT_LIST)
975     copy_statement_list (tp);
976   else if (TREE_CODE (*tp) == SAVE_EXPR
977            || TREE_CODE (*tp) == TARGET_EXPR)
978     remap_save_expr (tp, id->decl_map, walk_subtrees);
979   else if (TREE_CODE (*tp) == LABEL_DECL
980            && (! DECL_CONTEXT (*tp)
981                || decl_function_context (*tp) == id->src_fn))
982     /* These may need to be remapped for EH handling.  */
983     *tp = remap_decl (*tp, id);
984   else if (TREE_CODE (*tp) == BIND_EXPR)
985     copy_bind_expr (tp, walk_subtrees, id);
986   /* Types may need remapping as well.  */
987   else if (TYPE_P (*tp))
988     *tp = remap_type (*tp, id);
989
990   /* If this is a constant, we have to copy the node iff the type will be
991      remapped.  copy_tree_r will not copy a constant.  */
992   else if (CONSTANT_CLASS_P (*tp))
993     {
994       tree new_type = remap_type (TREE_TYPE (*tp), id);
995
996       if (new_type == TREE_TYPE (*tp))
997         *walk_subtrees = 0;
998
999       else if (TREE_CODE (*tp) == INTEGER_CST)
1000         *tp = build_int_cst_wide (new_type, TREE_INT_CST_LOW (*tp),
1001                                   TREE_INT_CST_HIGH (*tp));
1002       else
1003         {
1004           *tp = copy_node (*tp);
1005           TREE_TYPE (*tp) = new_type;
1006         }
1007     }
1008
1009   /* Otherwise, just copy the node.  Note that copy_tree_r already
1010      knows not to copy VAR_DECLs, etc., so this is safe.  */
1011   else
1012     {
1013       /* Here we handle trees that are not completely rewritten.
1014          First we detect some inlining-induced bogosities for
1015          discarding.  */
1016       if (TREE_CODE (*tp) == MODIFY_EXPR
1017           && TREE_OPERAND (*tp, 0) == TREE_OPERAND (*tp, 1)
1018           && (auto_var_in_fn_p (TREE_OPERAND (*tp, 0), fn)))
1019         {
1020           /* Some assignments VAR = VAR; don't generate any rtl code
1021              and thus don't count as variable modification.  Avoid
1022              keeping bogosities like 0 = 0.  */
1023           tree decl = TREE_OPERAND (*tp, 0), value;
1024           tree *n;
1025
1026           n = (tree *) pointer_map_contains (id->decl_map, decl);
1027           if (n)
1028             {
1029               value = *n;
1030               STRIP_TYPE_NOPS (value);
1031               if (TREE_CONSTANT (value) || TREE_READONLY (value))
1032                 {
1033                   *tp = build_empty_stmt (EXPR_LOCATION (*tp));
1034                   return copy_tree_body_r (tp, walk_subtrees, data);
1035                 }
1036             }
1037         }
1038       else if (TREE_CODE (*tp) == INDIRECT_REF)
1039         {
1040           /* Get rid of *& from inline substitutions that can happen when a
1041              pointer argument is an ADDR_EXPR.  */
1042           tree decl = TREE_OPERAND (*tp, 0);
1043           tree *n;
1044
1045           n = (tree *) pointer_map_contains (id->decl_map, decl);
1046           if (n)
1047             {
1048               tree new_tree;
1049               tree old;
1050               /* If we happen to get an ADDR_EXPR in n->value, strip
1051                  it manually here as we'll eventually get ADDR_EXPRs
1052                  which lie about their types pointed to.  In this case
1053                  build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
1054                  but we absolutely rely on that.  As fold_indirect_ref
1055                  does other useful transformations, try that first, though.  */
1056               tree type = TREE_TYPE (TREE_TYPE (*n));
1057               if (id->do_not_unshare)
1058                 new_tree = *n;
1059               else
1060                 new_tree = unshare_expr (*n);
1061               old = *tp;
1062               *tp = gimple_fold_indirect_ref (new_tree);
1063               if (! *tp)
1064                 {
1065                   if (TREE_CODE (new_tree) == ADDR_EXPR)
1066                     {
1067                       *tp = fold_indirect_ref_1 (EXPR_LOCATION (new_tree),
1068                                                  type, new_tree);
1069                       /* ???  We should either assert here or build
1070                          a VIEW_CONVERT_EXPR instead of blindly leaking
1071                          incompatible types to our IL.  */
1072                       if (! *tp)
1073                         *tp = TREE_OPERAND (new_tree, 0);
1074                     }
1075                   else
1076                     {
1077                       *tp = build1 (INDIRECT_REF, type, new_tree);
1078                       TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old);
1079                       TREE_SIDE_EFFECTS (*tp) = TREE_SIDE_EFFECTS (old);
1080                     }
1081                 }
1082               *walk_subtrees = 0;
1083               return NULL;
1084             }
1085         }
1086
1087       /* Here is the "usual case".  Copy this tree node, and then
1088          tweak some special cases.  */
1089       copy_tree_r (tp, walk_subtrees, NULL);
1090
1091       /* Global variables we haven't seen yet needs to go into referenced
1092          vars.  If not referenced from types or debug stmts only.  */
1093       if (gimple_in_ssa_p (cfun)
1094           && TREE_CODE (*tp) == VAR_DECL
1095           && id->remapping_type_depth == 0
1096           && !processing_debug_stmt)
1097         add_referenced_var (*tp);
1098        
1099       /* If EXPR has block defined, map it to newly constructed block.
1100          When inlining we want EXPRs without block appear in the block
1101          of function call.  */
1102       if (EXPR_P (*tp))
1103         {
1104           new_block = id->block;
1105           if (TREE_BLOCK (*tp))
1106             {
1107               tree *n;
1108               n = (tree *) pointer_map_contains (id->decl_map,
1109                                                  TREE_BLOCK (*tp));
1110               gcc_assert (n);
1111               new_block = *n;
1112             }
1113           TREE_BLOCK (*tp) = new_block;
1114         }
1115
1116       if (TREE_CODE (*tp) != OMP_CLAUSE)
1117         TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id);
1118
1119       /* The copied TARGET_EXPR has never been expanded, even if the
1120          original node was expanded already.  */
1121       if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3))
1122         {
1123           TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
1124           TREE_OPERAND (*tp, 3) = NULL_TREE;
1125         }
1126
1127       /* Variable substitution need not be simple.  In particular, the
1128          INDIRECT_REF substitution above.  Make sure that TREE_CONSTANT
1129          and friends are up-to-date.  */
1130       else if (TREE_CODE (*tp) == ADDR_EXPR)
1131         {
1132           int invariant = is_gimple_min_invariant (*tp);
1133           walk_tree (&TREE_OPERAND (*tp, 0), copy_tree_body_r, id, NULL);
1134
1135           /* Handle the case where we substituted an INDIRECT_REF
1136              into the operand of the ADDR_EXPR.  */
1137           if (TREE_CODE (TREE_OPERAND (*tp, 0)) == INDIRECT_REF)
1138             *tp = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0);
1139           else
1140             recompute_tree_invariant_for_addr_expr (*tp);
1141
1142           /* If this used to be invariant, but is not any longer,
1143              then regimplification is probably needed.  */
1144           if (invariant && !is_gimple_min_invariant (*tp))
1145             id->regimplify = true;
1146
1147           *walk_subtrees = 0;
1148         }
1149     }
1150
1151   /* Keep iterating.  */
1152   return NULL_TREE;
1153 }
1154
1155 /* Helper for remap_gimple_stmt.  Given an EH region number for the
1156    source function, map that to the duplicate EH region number in
1157    the destination function.  */
1158
1159 static int
1160 remap_eh_region_nr (int old_nr, copy_body_data *id)
1161 {
1162   eh_region old_r, new_r;
1163   void **slot;
1164
1165   old_r = get_eh_region_from_number_fn (id->src_cfun, old_nr);
1166   slot = pointer_map_contains (id->eh_map, old_r);
1167   new_r = (eh_region) *slot;
1168
1169   return new_r->index;
1170 }
1171
1172 /* Similar, but operate on INTEGER_CSTs.  */
1173
1174 static tree
1175 remap_eh_region_tree_nr (tree old_t_nr, copy_body_data *id)
1176 {
1177   int old_nr, new_nr;
1178
1179   old_nr = tree_low_cst (old_t_nr, 0);
1180   new_nr = remap_eh_region_nr (old_nr, id);
1181
1182   return build_int_cst (NULL, new_nr);
1183 }
1184
1185 /* Helper for copy_bb.  Remap statement STMT using the inlining
1186    information in ID.  Return the new statement copy.  */
1187
1188 static gimple
1189 remap_gimple_stmt (gimple stmt, copy_body_data *id)
1190 {
1191   gimple copy = NULL;
1192   struct walk_stmt_info wi;
1193   tree new_block;
1194   bool skip_first = false;
1195
1196   /* Begin by recognizing trees that we'll completely rewrite for the
1197      inlining context.  Our output for these trees is completely
1198      different from out input (e.g. RETURN_EXPR is deleted, and morphs
1199      into an edge).  Further down, we'll handle trees that get
1200      duplicated and/or tweaked.  */
1201
1202   /* When requested, GIMPLE_RETURNs should be transformed to just the
1203      contained GIMPLE_ASSIGN.  The branch semantics of the return will
1204      be handled elsewhere by manipulating the CFG rather than the
1205      statement.  */
1206   if (gimple_code (stmt) == GIMPLE_RETURN && id->transform_return_to_modify)
1207     {
1208       tree retval = gimple_return_retval (stmt);
1209
1210       /* If we're returning something, just turn that into an
1211          assignment into the equivalent of the original RESULT_DECL.
1212          If RETVAL is just the result decl, the result decl has
1213          already been set (e.g. a recent "foo (&result_decl, ...)");
1214          just toss the entire GIMPLE_RETURN.  */
1215       if (retval && TREE_CODE (retval) != RESULT_DECL)
1216         {
1217           copy = gimple_build_assign (id->retvar, retval);
1218           /* id->retvar is already substituted.  Skip it on later remapping.  */
1219           skip_first = true;
1220         }
1221       else
1222         return gimple_build_nop ();
1223     }
1224   else if (gimple_has_substatements (stmt))
1225     {
1226       gimple_seq s1, s2;
1227
1228       /* When cloning bodies from the C++ front end, we will be handed bodies
1229          in High GIMPLE form.  Handle here all the High GIMPLE statements that
1230          have embedded statements.  */
1231       switch (gimple_code (stmt))
1232         {
1233         case GIMPLE_BIND:
1234           copy = copy_gimple_bind (stmt, id);
1235           break;
1236
1237         case GIMPLE_CATCH:
1238           s1 = remap_gimple_seq (gimple_catch_handler (stmt), id);
1239           copy = gimple_build_catch (gimple_catch_types (stmt), s1);
1240           break;
1241
1242         case GIMPLE_EH_FILTER:
1243           s1 = remap_gimple_seq (gimple_eh_filter_failure (stmt), id);
1244           copy = gimple_build_eh_filter (gimple_eh_filter_types (stmt), s1);
1245           break;
1246
1247         case GIMPLE_TRY:
1248           s1 = remap_gimple_seq (gimple_try_eval (stmt), id);
1249           s2 = remap_gimple_seq (gimple_try_cleanup (stmt), id);
1250           copy = gimple_build_try (s1, s2, gimple_try_kind (stmt)); 
1251           break;
1252
1253         case GIMPLE_WITH_CLEANUP_EXPR:
1254           s1 = remap_gimple_seq (gimple_wce_cleanup (stmt), id);
1255           copy = gimple_build_wce (s1);
1256           break;
1257
1258         case GIMPLE_OMP_PARALLEL:
1259           s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1260           copy = gimple_build_omp_parallel
1261                    (s1,
1262                     gimple_omp_parallel_clauses (stmt),
1263                     gimple_omp_parallel_child_fn (stmt),
1264                     gimple_omp_parallel_data_arg (stmt));
1265           break;
1266
1267         case GIMPLE_OMP_TASK:
1268           s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1269           copy = gimple_build_omp_task
1270                    (s1,
1271                     gimple_omp_task_clauses (stmt),
1272                     gimple_omp_task_child_fn (stmt),
1273                     gimple_omp_task_data_arg (stmt),
1274                     gimple_omp_task_copy_fn (stmt),
1275                     gimple_omp_task_arg_size (stmt),
1276                     gimple_omp_task_arg_align (stmt));
1277           break;
1278
1279         case GIMPLE_OMP_FOR:
1280           s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1281           s2 = remap_gimple_seq (gimple_omp_for_pre_body (stmt), id);
1282           copy = gimple_build_omp_for (s1, gimple_omp_for_clauses (stmt),
1283                                        gimple_omp_for_collapse (stmt), s2);
1284           {
1285             size_t i;
1286             for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
1287               {
1288                 gimple_omp_for_set_index (copy, i,
1289                                           gimple_omp_for_index (stmt, i));
1290                 gimple_omp_for_set_initial (copy, i,
1291                                             gimple_omp_for_initial (stmt, i));
1292                 gimple_omp_for_set_final (copy, i,
1293                                           gimple_omp_for_final (stmt, i));
1294                 gimple_omp_for_set_incr (copy, i,
1295                                          gimple_omp_for_incr (stmt, i));
1296                 gimple_omp_for_set_cond (copy, i,
1297                                          gimple_omp_for_cond (stmt, i));
1298               }
1299           }
1300           break;
1301
1302         case GIMPLE_OMP_MASTER:
1303           s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1304           copy = gimple_build_omp_master (s1);
1305           break;
1306
1307         case GIMPLE_OMP_ORDERED:
1308           s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1309           copy = gimple_build_omp_ordered (s1);
1310           break;
1311
1312         case GIMPLE_OMP_SECTION:
1313           s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1314           copy = gimple_build_omp_section (s1);
1315           break;
1316
1317         case GIMPLE_OMP_SECTIONS:
1318           s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1319           copy = gimple_build_omp_sections
1320                    (s1, gimple_omp_sections_clauses (stmt));
1321           break;
1322
1323         case GIMPLE_OMP_SINGLE:
1324           s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1325           copy = gimple_build_omp_single
1326                    (s1, gimple_omp_single_clauses (stmt));
1327           break;
1328
1329         case GIMPLE_OMP_CRITICAL:
1330           s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1331           copy
1332             = gimple_build_omp_critical (s1, gimple_omp_critical_name (stmt));
1333           break;
1334
1335         default:
1336           gcc_unreachable ();
1337         }
1338     }
1339   else
1340     {
1341       if (gimple_assign_copy_p (stmt)
1342           && gimple_assign_lhs (stmt) == gimple_assign_rhs1 (stmt)
1343           && auto_var_in_fn_p (gimple_assign_lhs (stmt), id->src_fn))
1344         {
1345           /* Here we handle statements that are not completely rewritten.
1346              First we detect some inlining-induced bogosities for
1347              discarding.  */
1348
1349           /* Some assignments VAR = VAR; don't generate any rtl code
1350              and thus don't count as variable modification.  Avoid
1351              keeping bogosities like 0 = 0.  */
1352           tree decl = gimple_assign_lhs (stmt), value;
1353           tree *n;
1354
1355           n = (tree *) pointer_map_contains (id->decl_map, decl);
1356           if (n)
1357             {
1358               value = *n;
1359               STRIP_TYPE_NOPS (value);
1360               if (TREE_CONSTANT (value) || TREE_READONLY (value))
1361                 return gimple_build_nop ();
1362             }
1363         }
1364
1365       if (gimple_debug_bind_p (stmt))
1366         {
1367           copy = gimple_build_debug_bind (gimple_debug_bind_get_var (stmt),
1368                                           gimple_debug_bind_get_value (stmt),
1369                                           stmt);
1370           VEC_safe_push (gimple, heap, id->debug_stmts, copy);
1371           return copy;
1372         }
1373
1374       /* Create a new deep copy of the statement.  */
1375       copy = gimple_copy (stmt);
1376
1377       /* Remap the region numbers for __builtin_eh_{pointer,filter},
1378          RESX and EH_DISPATCH.  */
1379       if (id->eh_map)
1380         switch (gimple_code (copy))
1381           {
1382           case GIMPLE_CALL:
1383             {
1384               tree r, fndecl = gimple_call_fndecl (copy);
1385               if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
1386                 switch (DECL_FUNCTION_CODE (fndecl))
1387                   {
1388                   case BUILT_IN_EH_COPY_VALUES:
1389                     r = gimple_call_arg (copy, 1);
1390                     r = remap_eh_region_tree_nr (r, id);
1391                     gimple_call_set_arg (copy, 1, r);
1392                     /* FALLTHRU */
1393
1394                   case BUILT_IN_EH_POINTER:
1395                   case BUILT_IN_EH_FILTER:
1396                     r = gimple_call_arg (copy, 0);
1397                     r = remap_eh_region_tree_nr (r, id);
1398                     gimple_call_set_arg (copy, 0, r);
1399                     break;
1400
1401                   default:
1402                     break;
1403                   }
1404             }
1405             break;
1406
1407           case GIMPLE_RESX:
1408             {
1409               int r = gimple_resx_region (copy);
1410               r = remap_eh_region_nr (r, id);
1411               gimple_resx_set_region (copy, r);
1412             }
1413             break;
1414
1415           case GIMPLE_EH_DISPATCH:
1416             {
1417               int r = gimple_eh_dispatch_region (copy);
1418               r = remap_eh_region_nr (r, id);
1419               gimple_eh_dispatch_set_region (copy, r);
1420             }
1421             break;
1422
1423           default:
1424             break;
1425           }
1426     }
1427
1428   /* If STMT has a block defined, map it to the newly constructed
1429      block.  When inlining we want statements without a block to
1430      appear in the block of the function call.  */
1431   new_block = id->block;
1432   if (gimple_block (copy))
1433     {
1434       tree *n;
1435       n = (tree *) pointer_map_contains (id->decl_map, gimple_block (copy));
1436       gcc_assert (n);
1437       new_block = *n;
1438     }
1439
1440   gimple_set_block (copy, new_block);
1441
1442   if (gimple_debug_bind_p (copy))
1443     return copy;
1444
1445   /* Remap all the operands in COPY.  */
1446   memset (&wi, 0, sizeof (wi));
1447   wi.info = id;
1448   if (skip_first)
1449     walk_tree (gimple_op_ptr (copy, 1), remap_gimple_op_r, &wi, NULL);
1450   else
1451     walk_gimple_op (copy, remap_gimple_op_r, &wi); 
1452
1453   /* Clear the copied virtual operands.  We are not remapping them here
1454      but are going to recreate them from scratch.  */
1455   if (gimple_has_mem_ops (copy))
1456     {
1457       gimple_set_vdef (copy, NULL_TREE);
1458       gimple_set_vuse (copy, NULL_TREE);
1459     }
1460
1461   return copy;
1462 }
1463
1464
1465 /* Copy basic block, scale profile accordingly.  Edges will be taken care of
1466    later  */
1467
1468 static basic_block
1469 copy_bb (copy_body_data *id, basic_block bb, int frequency_scale,
1470          gcov_type count_scale)
1471 {
1472   gimple_stmt_iterator gsi, copy_gsi, seq_gsi;
1473   basic_block copy_basic_block;
1474   tree decl;
1475
1476   /* create_basic_block() will append every new block to
1477      basic_block_info automatically.  */
1478   copy_basic_block = create_basic_block (NULL, (void *) 0,
1479                                          (basic_block) bb->prev_bb->aux);
1480   copy_basic_block->count = bb->count * count_scale / REG_BR_PROB_BASE;
1481
1482   /* We are going to rebuild frequencies from scratch.  These values
1483      have just small importance to drive canonicalize_loop_headers.  */
1484   copy_basic_block->frequency = ((gcov_type)bb->frequency
1485                                  * frequency_scale / REG_BR_PROB_BASE);
1486
1487   if (copy_basic_block->frequency > BB_FREQ_MAX)
1488     copy_basic_block->frequency = BB_FREQ_MAX;
1489
1490   copy_gsi = gsi_start_bb (copy_basic_block);
1491
1492   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1493     {
1494       gimple stmt = gsi_stmt (gsi);
1495       gimple orig_stmt = stmt;
1496
1497       id->regimplify = false;
1498       stmt = remap_gimple_stmt (stmt, id);
1499       if (gimple_nop_p (stmt))
1500         continue;
1501
1502       gimple_duplicate_stmt_histograms (cfun, stmt, id->src_cfun, orig_stmt);
1503       seq_gsi = copy_gsi;
1504
1505       /* With return slot optimization we can end up with
1506          non-gimple (foo *)&this->m, fix that here.  */
1507       if (is_gimple_assign (stmt)
1508           && gimple_assign_rhs_code (stmt) == NOP_EXPR
1509           && !is_gimple_val (gimple_assign_rhs1 (stmt)))
1510         {
1511           tree new_rhs;
1512           new_rhs = force_gimple_operand_gsi (&seq_gsi,
1513                                               gimple_assign_rhs1 (stmt),
1514                                               true, NULL, false, GSI_NEW_STMT);
1515           gimple_assign_set_rhs1 (stmt, new_rhs);
1516           id->regimplify = false;
1517         }
1518
1519       gsi_insert_after (&seq_gsi, stmt, GSI_NEW_STMT);
1520
1521       if (id->regimplify)
1522         gimple_regimplify_operands (stmt, &seq_gsi);
1523
1524       /* If copy_basic_block has been empty at the start of this iteration,
1525          call gsi_start_bb again to get at the newly added statements.  */
1526       if (gsi_end_p (copy_gsi))
1527         copy_gsi = gsi_start_bb (copy_basic_block);
1528       else
1529         gsi_next (&copy_gsi);
1530
1531       /* Process the new statement.  The call to gimple_regimplify_operands
1532          possibly turned the statement into multiple statements, we
1533          need to process all of them.  */
1534       do
1535         {
1536           tree fn;
1537
1538           stmt = gsi_stmt (copy_gsi);
1539           if (is_gimple_call (stmt)
1540               && gimple_call_va_arg_pack_p (stmt)
1541               && id->gimple_call)
1542             {
1543               /* __builtin_va_arg_pack () should be replaced by
1544                  all arguments corresponding to ... in the caller.  */
1545               tree p;
1546               gimple new_call;
1547               VEC(tree, heap) *argarray;
1548               size_t nargs = gimple_call_num_args (id->gimple_call);
1549               size_t n;
1550
1551               for (p = DECL_ARGUMENTS (id->src_fn); p; p = TREE_CHAIN (p))
1552                 nargs--;
1553
1554               /* Create the new array of arguments.  */
1555               n = nargs + gimple_call_num_args (stmt);
1556               argarray = VEC_alloc (tree, heap, n);
1557               VEC_safe_grow (tree, heap, argarray, n);
1558
1559               /* Copy all the arguments before '...'  */
1560               memcpy (VEC_address (tree, argarray),
1561                       gimple_call_arg_ptr (stmt, 0),
1562                       gimple_call_num_args (stmt) * sizeof (tree));
1563
1564               /* Append the arguments passed in '...'  */
1565               memcpy (VEC_address(tree, argarray) + gimple_call_num_args (stmt),
1566                       gimple_call_arg_ptr (id->gimple_call, 0)
1567                         + (gimple_call_num_args (id->gimple_call) - nargs),
1568                       nargs * sizeof (tree));
1569
1570               new_call = gimple_build_call_vec (gimple_call_fn (stmt),
1571                                                 argarray);
1572
1573               VEC_free (tree, heap, argarray);
1574
1575               /* Copy all GIMPLE_CALL flags, location and block, except
1576                  GF_CALL_VA_ARG_PACK.  */
1577               gimple_call_copy_flags (new_call, stmt);
1578               gimple_call_set_va_arg_pack (new_call, false);
1579               gimple_set_location (new_call, gimple_location (stmt));
1580               gimple_set_block (new_call, gimple_block (stmt));
1581               gimple_call_set_lhs (new_call, gimple_call_lhs (stmt));
1582
1583               gsi_replace (&copy_gsi, new_call, false);
1584               gimple_set_bb (stmt, NULL);
1585               stmt = new_call;
1586             }
1587           else if (is_gimple_call (stmt)
1588                    && id->gimple_call
1589                    && (decl = gimple_call_fndecl (stmt))
1590                    && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
1591                    && DECL_FUNCTION_CODE (decl) == BUILT_IN_VA_ARG_PACK_LEN)
1592             {
1593               /* __builtin_va_arg_pack_len () should be replaced by
1594                  the number of anonymous arguments.  */
1595               size_t nargs = gimple_call_num_args (id->gimple_call);
1596               tree count, p;
1597               gimple new_stmt;
1598
1599               for (p = DECL_ARGUMENTS (id->src_fn); p; p = TREE_CHAIN (p))
1600                 nargs--;
1601
1602               count = build_int_cst (integer_type_node, nargs);
1603               new_stmt = gimple_build_assign (gimple_call_lhs (stmt), count);
1604               gsi_replace (&copy_gsi, new_stmt, false);
1605               stmt = new_stmt;
1606             }
1607
1608           /* Statements produced by inlining can be unfolded, especially
1609              when we constant propagated some operands.  We can't fold
1610              them right now for two reasons:
1611              1) folding require SSA_NAME_DEF_STMTs to be correct
1612              2) we can't change function calls to builtins.
1613              So we just mark statement for later folding.  We mark
1614              all new statements, instead just statements that has changed
1615              by some nontrivial substitution so even statements made
1616              foldable indirectly are updated.  If this turns out to be
1617              expensive, copy_body can be told to watch for nontrivial
1618              changes.  */
1619           if (id->statements_to_fold)
1620             pointer_set_insert (id->statements_to_fold, stmt);
1621
1622           /* We're duplicating a CALL_EXPR.  Find any corresponding
1623              callgraph edges and update or duplicate them.  */
1624           if (is_gimple_call (stmt))
1625             {
1626               struct cgraph_edge *edge;
1627               int flags;
1628
1629               switch (id->transform_call_graph_edges)
1630                 {
1631                 case CB_CGE_DUPLICATE:
1632                   edge = cgraph_edge (id->src_node, orig_stmt);
1633                   if (edge)
1634                     edge = cgraph_clone_edge (edge, id->dst_node, stmt,
1635                                               gimple_uid (stmt),
1636                                               REG_BR_PROB_BASE, 1,
1637                                               edge->frequency, true);
1638                   break;
1639
1640                 case CB_CGE_MOVE_CLONES:
1641                   cgraph_set_call_stmt_including_clones (id->dst_node,
1642                                                          orig_stmt, stmt);
1643                   edge = cgraph_edge (id->dst_node, stmt);
1644                   break;
1645
1646                 case CB_CGE_MOVE:
1647                   edge = cgraph_edge (id->dst_node, orig_stmt);
1648                   if (edge)
1649                     cgraph_set_call_stmt (edge, stmt);
1650                   break;
1651
1652                 default:
1653                   gcc_unreachable ();
1654                 }
1655
1656               /* Constant propagation on argument done during inlining
1657                  may create new direct call.  Produce an edge for it.  */
1658               if ((!edge 
1659                    || (edge->indirect_call
1660                        && id->transform_call_graph_edges == CB_CGE_MOVE_CLONES))
1661                   && is_gimple_call (stmt)
1662                   && (fn = gimple_call_fndecl (stmt)) != NULL)
1663                 {
1664                   struct cgraph_node *dest = cgraph_node (fn);
1665
1666                   /* We have missing edge in the callgraph.  This can happen
1667                      when previous inlining turned an indirect call into a
1668                      direct call by constant propagating arguments or we are
1669                      producing dead clone (for further clonning).  In all
1670                      other cases we hit a bug (incorrect node sharing is the
1671                      most common reason for missing edges).  */
1672                   gcc_assert (dest->needed || !dest->analyzed
1673                               || !id->src_node->analyzed);
1674                   if (id->transform_call_graph_edges == CB_CGE_MOVE_CLONES)
1675                     cgraph_create_edge_including_clones
1676                       (id->dst_node, dest, stmt, bb->count,
1677                        compute_call_stmt_bb_frequency (id->dst_node->decl, bb),
1678                        bb->loop_depth, CIF_ORIGINALLY_INDIRECT_CALL);
1679                   else
1680                     cgraph_create_edge (id->dst_node, dest, stmt,
1681                                         bb->count, CGRAPH_FREQ_BASE,
1682                                         bb->loop_depth)->inline_failed
1683                       = CIF_ORIGINALLY_INDIRECT_CALL;
1684                   if (dump_file)
1685                     {
1686                       fprintf (dump_file, "Created new direct edge to %s",
1687                                cgraph_node_name (dest));
1688                     }
1689                 }
1690
1691               flags = gimple_call_flags (stmt);
1692               if (flags & ECF_MAY_BE_ALLOCA)
1693                 cfun->calls_alloca = true;
1694               if (flags & ECF_RETURNS_TWICE)
1695                 cfun->calls_setjmp = true;
1696             }
1697
1698           maybe_duplicate_eh_stmt_fn (cfun, stmt, id->src_cfun, orig_stmt,
1699                                       id->eh_map, id->eh_lp_nr);
1700
1701           if (gimple_in_ssa_p (cfun) && !is_gimple_debug (stmt))
1702             {
1703               ssa_op_iter i;
1704               tree def;
1705
1706               find_new_referenced_vars (gsi_stmt (copy_gsi));
1707               FOR_EACH_SSA_TREE_OPERAND (def, stmt, i, SSA_OP_DEF)
1708                 if (TREE_CODE (def) == SSA_NAME)
1709                   SSA_NAME_DEF_STMT (def) = stmt;
1710             }
1711
1712           gsi_next (&copy_gsi);
1713         }
1714       while (!gsi_end_p (copy_gsi));
1715
1716       copy_gsi = gsi_last_bb (copy_basic_block);
1717     }
1718
1719   return copy_basic_block;
1720 }
1721
1722 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
1723    form is quite easy, since dominator relationship for old basic blocks does
1724    not change.
1725
1726    There is however exception where inlining might change dominator relation
1727    across EH edges from basic block within inlined functions destinating
1728    to landing pads in function we inline into.
1729
1730    The function fills in PHI_RESULTs of such PHI nodes if they refer
1731    to gimple regs.  Otherwise, the function mark PHI_RESULT of such
1732    PHI nodes for renaming.  For non-gimple regs, renaming is safe: the
1733    EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
1734    set, and this means that there will be no overlapping live ranges
1735    for the underlying symbol.
1736
1737    This might change in future if we allow redirecting of EH edges and
1738    we might want to change way build CFG pre-inlining to include
1739    all the possible edges then.  */
1740 static void
1741 update_ssa_across_abnormal_edges (basic_block bb, basic_block ret_bb,
1742                                   bool can_throw, bool nonlocal_goto)
1743 {
1744   edge e;
1745   edge_iterator ei;
1746
1747   FOR_EACH_EDGE (e, ei, bb->succs)
1748     if (!e->dest->aux
1749         || ((basic_block)e->dest->aux)->index == ENTRY_BLOCK)
1750       {
1751         gimple phi;
1752         gimple_stmt_iterator si;
1753
1754         if (!nonlocal_goto)
1755           gcc_assert (e->flags & EDGE_EH);
1756
1757         if (!can_throw)
1758           gcc_assert (!(e->flags & EDGE_EH));
1759
1760         for (si = gsi_start_phis (e->dest); !gsi_end_p (si); gsi_next (&si))
1761           {
1762             edge re;
1763
1764             phi = gsi_stmt (si);
1765
1766             /* There shouldn't be any PHI nodes in the ENTRY_BLOCK.  */
1767             gcc_assert (!e->dest->aux);
1768
1769             gcc_assert ((e->flags & EDGE_EH)
1770                         || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi)));
1771
1772             if (!is_gimple_reg (PHI_RESULT (phi)))
1773               {
1774                 mark_sym_for_renaming (SSA_NAME_VAR (PHI_RESULT (phi)));
1775                 continue;
1776               }
1777
1778             re = find_edge (ret_bb, e->dest);
1779             gcc_assert (re);
1780             gcc_assert ((re->flags & (EDGE_EH | EDGE_ABNORMAL))
1781                         == (e->flags & (EDGE_EH | EDGE_ABNORMAL)));
1782
1783             SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi, e),
1784                      USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi, re)));
1785           }
1786       }
1787 }
1788
1789
1790 /* Copy edges from BB into its copy constructed earlier, scale profile
1791    accordingly.  Edges will be taken care of later.  Assume aux
1792    pointers to point to the copies of each BB.  */
1793
1794 static void
1795 copy_edges_for_bb (basic_block bb, gcov_type count_scale, basic_block ret_bb)
1796 {
1797   basic_block new_bb = (basic_block) bb->aux;
1798   edge_iterator ei;
1799   edge old_edge;
1800   gimple_stmt_iterator si;
1801   int flags;
1802
1803   /* Use the indices from the original blocks to create edges for the
1804      new ones.  */
1805   FOR_EACH_EDGE (old_edge, ei, bb->succs)
1806     if (!(old_edge->flags & EDGE_EH))
1807       {
1808         edge new_edge;
1809
1810         flags = old_edge->flags;
1811
1812         /* Return edges do get a FALLTHRU flag when the get inlined.  */
1813         if (old_edge->dest->index == EXIT_BLOCK && !old_edge->flags
1814             && old_edge->dest->aux != EXIT_BLOCK_PTR)
1815           flags |= EDGE_FALLTHRU;
1816         new_edge = make_edge (new_bb, (basic_block) old_edge->dest->aux, flags);
1817         new_edge->count = old_edge->count * count_scale / REG_BR_PROB_BASE;
1818         new_edge->probability = old_edge->probability;
1819       }
1820
1821   if (bb->index == ENTRY_BLOCK || bb->index == EXIT_BLOCK)
1822     return;
1823
1824   for (si = gsi_start_bb (new_bb); !gsi_end_p (si);)
1825     {
1826       gimple copy_stmt;
1827       bool can_throw, nonlocal_goto;
1828
1829       copy_stmt = gsi_stmt (si);
1830       if (!is_gimple_debug (copy_stmt))
1831         {
1832           update_stmt (copy_stmt);
1833           if (gimple_in_ssa_p (cfun))
1834             mark_symbols_for_renaming (copy_stmt);
1835         }
1836
1837       /* Do this before the possible split_block.  */
1838       gsi_next (&si);
1839
1840       /* If this tree could throw an exception, there are two
1841          cases where we need to add abnormal edge(s): the
1842          tree wasn't in a region and there is a "current
1843          region" in the caller; or the original tree had
1844          EH edges.  In both cases split the block after the tree,
1845          and add abnormal edge(s) as needed; we need both
1846          those from the callee and the caller.
1847          We check whether the copy can throw, because the const
1848          propagation can change an INDIRECT_REF which throws
1849          into a COMPONENT_REF which doesn't.  If the copy
1850          can throw, the original could also throw.  */
1851       can_throw = stmt_can_throw_internal (copy_stmt);
1852       nonlocal_goto = stmt_can_make_abnormal_goto (copy_stmt);
1853
1854       if (can_throw || nonlocal_goto)
1855         {
1856           if (!gsi_end_p (si))
1857             /* Note that bb's predecessor edges aren't necessarily
1858                right at this point; split_block doesn't care.  */
1859             {
1860               edge e = split_block (new_bb, copy_stmt);
1861
1862               new_bb = e->dest;
1863               new_bb->aux = e->src->aux;
1864               si = gsi_start_bb (new_bb);
1865             }
1866         }
1867
1868       if (gimple_code (copy_stmt) == GIMPLE_EH_DISPATCH)
1869         make_eh_dispatch_edges (copy_stmt);
1870       else if (can_throw)
1871         make_eh_edges (copy_stmt);
1872
1873       if (nonlocal_goto)
1874         make_abnormal_goto_edges (gimple_bb (copy_stmt), true);
1875
1876       if ((can_throw || nonlocal_goto)
1877           && gimple_in_ssa_p (cfun))
1878         update_ssa_across_abnormal_edges (gimple_bb (copy_stmt), ret_bb,
1879                                           can_throw, nonlocal_goto);
1880     }
1881 }
1882
1883 /* Copy the PHIs.  All blocks and edges are copied, some blocks
1884    was possibly split and new outgoing EH edges inserted.
1885    BB points to the block of original function and AUX pointers links
1886    the original and newly copied blocks.  */
1887
1888 static void
1889 copy_phis_for_bb (basic_block bb, copy_body_data *id)
1890 {
1891   basic_block const new_bb = (basic_block) bb->aux;
1892   edge_iterator ei;
1893   gimple phi;
1894   gimple_stmt_iterator si;
1895
1896   for (si = gsi_start (phi_nodes (bb)); !gsi_end_p (si); gsi_next (&si))
1897     {
1898       tree res, new_res;
1899       gimple new_phi;
1900       edge new_edge;
1901
1902       phi = gsi_stmt (si);
1903       res = PHI_RESULT (phi);
1904       new_res = res;
1905       if (is_gimple_reg (res))
1906         {
1907           walk_tree (&new_res, copy_tree_body_r, id, NULL);
1908           SSA_NAME_DEF_STMT (new_res)
1909             = new_phi = create_phi_node (new_res, new_bb);
1910           FOR_EACH_EDGE (new_edge, ei, new_bb->preds)
1911             {
1912               edge const old_edge
1913                 = find_edge ((basic_block) new_edge->src->aux, bb);
1914               tree arg = PHI_ARG_DEF_FROM_EDGE (phi, old_edge);
1915               tree new_arg = arg;
1916               tree block = id->block;
1917               id->block = NULL_TREE;
1918               walk_tree (&new_arg, copy_tree_body_r, id, NULL);
1919               id->block = block;
1920               gcc_assert (new_arg);
1921               /* With return slot optimization we can end up with
1922                  non-gimple (foo *)&this->m, fix that here.  */
1923               if (TREE_CODE (new_arg) != SSA_NAME
1924                   && TREE_CODE (new_arg) != FUNCTION_DECL
1925                   && !is_gimple_val (new_arg))
1926                 {
1927                   gimple_seq stmts = NULL;
1928                   new_arg = force_gimple_operand (new_arg, &stmts, true, NULL);
1929                   gsi_insert_seq_on_edge_immediate (new_edge, stmts);
1930                 }
1931               add_phi_arg (new_phi, new_arg, new_edge, 
1932                            gimple_phi_arg_location_from_edge (phi, old_edge));
1933             }
1934         }
1935     }
1936 }
1937
1938
1939 /* Wrapper for remap_decl so it can be used as a callback.  */
1940
1941 static tree
1942 remap_decl_1 (tree decl, void *data)
1943 {
1944   return remap_decl (decl, (copy_body_data *) data);
1945 }
1946
1947 /* Build struct function and associated datastructures for the new clone
1948    NEW_FNDECL to be build.  CALLEE_FNDECL is the original */
1949
1950 static void
1951 initialize_cfun (tree new_fndecl, tree callee_fndecl, gcov_type count,
1952                  int frequency)
1953 {
1954   struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
1955   gcov_type count_scale, frequency_scale;
1956
1957   if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count)
1958     count_scale = (REG_BR_PROB_BASE * count
1959                    / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count);
1960   else
1961     count_scale = 1;
1962
1963   if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency)
1964     frequency_scale = (REG_BR_PROB_BASE * frequency
1965                        /
1966                        ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency);
1967   else
1968     frequency_scale = count_scale;
1969
1970   /* Register specific tree functions.  */
1971   gimple_register_cfg_hooks ();
1972
1973   /* Get clean struct function.  */
1974   push_struct_function (new_fndecl);
1975
1976   /* We will rebuild these, so just sanity check that they are empty.  */
1977   gcc_assert (VALUE_HISTOGRAMS (cfun) == NULL);
1978   gcc_assert (cfun->local_decls == NULL);
1979   gcc_assert (cfun->cfg == NULL);
1980   gcc_assert (cfun->decl == new_fndecl);
1981
1982   /* Copy items we preserve during clonning.  */
1983   cfun->static_chain_decl = src_cfun->static_chain_decl;
1984   cfun->nonlocal_goto_save_area = src_cfun->nonlocal_goto_save_area;
1985   cfun->function_end_locus = src_cfun->function_end_locus;
1986   cfun->curr_properties = src_cfun->curr_properties;
1987   cfun->last_verified = src_cfun->last_verified;
1988   cfun->va_list_gpr_size = src_cfun->va_list_gpr_size;
1989   cfun->va_list_fpr_size = src_cfun->va_list_fpr_size;
1990   cfun->function_frequency = src_cfun->function_frequency;
1991   cfun->has_nonlocal_label = src_cfun->has_nonlocal_label;
1992   cfun->stdarg = src_cfun->stdarg;
1993   cfun->dont_save_pending_sizes_p = src_cfun->dont_save_pending_sizes_p;
1994   cfun->after_inlining = src_cfun->after_inlining;
1995   cfun->returns_struct = src_cfun->returns_struct;
1996   cfun->returns_pcc_struct = src_cfun->returns_pcc_struct;
1997   cfun->after_tree_profile = src_cfun->after_tree_profile;
1998
1999   init_empty_tree_cfg ();
2000
2001   ENTRY_BLOCK_PTR->count =
2002     (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count * count_scale /
2003      REG_BR_PROB_BASE);
2004   ENTRY_BLOCK_PTR->frequency =
2005     (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency *
2006      frequency_scale / REG_BR_PROB_BASE);
2007   EXIT_BLOCK_PTR->count =
2008     (EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count * count_scale /
2009      REG_BR_PROB_BASE);
2010   EXIT_BLOCK_PTR->frequency =
2011     (EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency *
2012      frequency_scale / REG_BR_PROB_BASE);
2013   if (src_cfun->eh)
2014     init_eh_for_function ();
2015
2016   if (src_cfun->gimple_df)
2017     {
2018       init_tree_ssa (cfun);
2019       cfun->gimple_df->in_ssa_p = true;
2020       init_ssa_operands ();
2021     }
2022   pop_cfun ();
2023 }
2024
2025 /* Make a copy of the body of FN so that it can be inserted inline in
2026    another function.  Walks FN via CFG, returns new fndecl.  */
2027
2028 static tree
2029 copy_cfg_body (copy_body_data * id, gcov_type count, int frequency,
2030                basic_block entry_block_map, basic_block exit_block_map)
2031 {
2032   tree callee_fndecl = id->src_fn;
2033   /* Original cfun for the callee, doesn't change.  */
2034   struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
2035   struct function *cfun_to_copy;
2036   basic_block bb;
2037   tree new_fndecl = NULL;
2038   gcov_type count_scale, frequency_scale;
2039   int last;
2040
2041   if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count)
2042     count_scale = (REG_BR_PROB_BASE * count
2043                    / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count);
2044   else
2045     count_scale = 1;
2046
2047   if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency)
2048     frequency_scale = (REG_BR_PROB_BASE * frequency
2049                        /
2050                        ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency);
2051   else
2052     frequency_scale = count_scale;
2053
2054   /* Register specific tree functions.  */
2055   gimple_register_cfg_hooks ();
2056
2057   /* Must have a CFG here at this point.  */
2058   gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION
2059               (DECL_STRUCT_FUNCTION (callee_fndecl)));
2060
2061   cfun_to_copy = id->src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
2062
2063   ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy)->aux = entry_block_map;
2064   EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy)->aux = exit_block_map;
2065   entry_block_map->aux = ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy);
2066   exit_block_map->aux = EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy);
2067
2068   /* Duplicate any exception-handling regions.  */
2069   if (cfun->eh)
2070     id->eh_map = duplicate_eh_regions (cfun_to_copy, NULL, id->eh_lp_nr,
2071                                        remap_decl_1, id);
2072
2073   /* Use aux pointers to map the original blocks to copy.  */
2074   FOR_EACH_BB_FN (bb, cfun_to_copy)
2075     {
2076       basic_block new_bb = copy_bb (id, bb, frequency_scale, count_scale);
2077       bb->aux = new_bb;
2078       new_bb->aux = bb;
2079     }
2080
2081   last = last_basic_block;
2082
2083   /* Now that we've duplicated the blocks, duplicate their edges.  */
2084   FOR_ALL_BB_FN (bb, cfun_to_copy)
2085     copy_edges_for_bb (bb, count_scale, exit_block_map);
2086
2087   if (gimple_in_ssa_p (cfun))
2088     FOR_ALL_BB_FN (bb, cfun_to_copy)
2089       copy_phis_for_bb (bb, id);
2090
2091   FOR_ALL_BB_FN (bb, cfun_to_copy)
2092     {
2093       ((basic_block)bb->aux)->aux = NULL;
2094       bb->aux = NULL;
2095     }
2096
2097   /* Zero out AUX fields of newly created block during EH edge
2098      insertion. */
2099   for (; last < last_basic_block; last++)
2100     BASIC_BLOCK (last)->aux = NULL;
2101   entry_block_map->aux = NULL;
2102   exit_block_map->aux = NULL;
2103
2104   if (id->eh_map)
2105     {
2106       pointer_map_destroy (id->eh_map);
2107       id->eh_map = NULL;
2108     }
2109
2110   return new_fndecl;
2111 }
2112
2113 /* Copy the debug STMT using ID.  We deal with these statements in a
2114    special way: if any variable in their VALUE expression wasn't
2115    remapped yet, we won't remap it, because that would get decl uids
2116    out of sync, causing codegen differences between -g and -g0.  If
2117    this arises, we drop the VALUE expression altogether.  */
2118
2119 static void
2120 copy_debug_stmt (gimple stmt, copy_body_data *id)
2121 {
2122   tree t, *n;
2123   struct walk_stmt_info wi;
2124
2125   t = id->block;
2126   if (gimple_block (stmt))
2127     {
2128       tree *n;
2129       n = (tree *) pointer_map_contains (id->decl_map, gimple_block (stmt));
2130       if (n)
2131         t = *n;
2132     }
2133   gimple_set_block (stmt, t);
2134
2135   /* Remap all the operands in COPY.  */
2136   memset (&wi, 0, sizeof (wi));
2137   wi.info = id;
2138
2139   processing_debug_stmt = 1;
2140
2141   t = gimple_debug_bind_get_var (stmt);
2142
2143   if (TREE_CODE (t) == PARM_DECL && id->debug_map
2144       && (n = (tree *) pointer_map_contains (id->debug_map, t)))
2145     {
2146       gcc_assert (TREE_CODE (*n) == VAR_DECL);
2147       t = *n;
2148     }
2149   else
2150     walk_tree (&t, remap_gimple_op_r, &wi, NULL);
2151
2152   gimple_debug_bind_set_var (stmt, t);
2153
2154   if (gimple_debug_bind_has_value_p (stmt))
2155     walk_tree (gimple_debug_bind_get_value_ptr (stmt),
2156                remap_gimple_op_r, &wi, NULL);
2157
2158   /* Punt if any decl couldn't be remapped.  */
2159   if (processing_debug_stmt < 0)
2160     gimple_debug_bind_reset_value (stmt);
2161
2162   processing_debug_stmt = 0;
2163
2164   update_stmt (stmt);
2165   if (gimple_in_ssa_p (cfun))
2166     mark_symbols_for_renaming (stmt);
2167 }
2168
2169 /* Process deferred debug stmts.  In order to give values better odds
2170    of being successfully remapped, we delay the processing of debug
2171    stmts until all other stmts that might require remapping are
2172    processed.  */
2173
2174 static void
2175 copy_debug_stmts (copy_body_data *id)
2176 {
2177   size_t i;
2178   gimple stmt;
2179
2180   if (!id->debug_stmts)
2181     return;
2182
2183   for (i = 0; VEC_iterate (gimple, id->debug_stmts, i, stmt); i++)
2184     copy_debug_stmt (stmt, id);
2185
2186   VEC_free (gimple, heap, id->debug_stmts);
2187 }
2188
2189 /* Make a copy of the body of SRC_FN so that it can be inserted inline in
2190    another function.  */
2191
2192 static tree
2193 copy_tree_body (copy_body_data *id)
2194 {
2195   tree fndecl = id->src_fn;
2196   tree body = DECL_SAVED_TREE (fndecl);
2197
2198   walk_tree (&body, copy_tree_body_r, id, NULL);
2199
2200   return body;
2201 }
2202
2203 /* Make a copy of the body of FN so that it can be inserted inline in
2204    another function.  */
2205
2206 static tree
2207 copy_body (copy_body_data *id, gcov_type count, int frequency,
2208            basic_block entry_block_map, basic_block exit_block_map)
2209 {
2210   tree fndecl = id->src_fn;
2211   tree body;
2212
2213   /* If this body has a CFG, walk CFG and copy.  */
2214   gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (fndecl)));
2215   body = copy_cfg_body (id, count, frequency, entry_block_map, exit_block_map);
2216   copy_debug_stmts (id);
2217
2218   return body;
2219 }
2220
2221 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
2222    defined in function FN, or of a data member thereof.  */
2223
2224 static bool
2225 self_inlining_addr_expr (tree value, tree fn)
2226 {
2227   tree var;
2228
2229   if (TREE_CODE (value) != ADDR_EXPR)
2230     return false;
2231
2232   var = get_base_address (TREE_OPERAND (value, 0));
2233
2234   return var && auto_var_in_fn_p (var, fn);
2235 }
2236
2237 /* Append to BB a debug annotation that binds VAR to VALUE, inheriting
2238    lexical block and line number information from base_stmt, if given,
2239    or from the last stmt of the block otherwise.  */
2240
2241 static gimple
2242 insert_init_debug_bind (copy_body_data *id,
2243                         basic_block bb, tree var, tree value,
2244                         gimple base_stmt)
2245 {
2246   gimple note;
2247   gimple_stmt_iterator gsi;
2248   tree tracked_var;
2249
2250   if (!gimple_in_ssa_p (id->src_cfun))
2251     return NULL;
2252
2253   if (!MAY_HAVE_DEBUG_STMTS)
2254     return NULL;
2255
2256   tracked_var = target_for_debug_bind (var);
2257   if (!tracked_var)
2258     return NULL;
2259
2260   if (bb)
2261     {
2262       gsi = gsi_last_bb (bb);
2263       if (!base_stmt && !gsi_end_p (gsi))
2264         base_stmt = gsi_stmt (gsi);
2265     }
2266
2267   note = gimple_build_debug_bind (tracked_var, value, base_stmt);
2268
2269   if (bb)
2270     {
2271       if (!gsi_end_p (gsi))
2272         gsi_insert_after (&gsi, note, GSI_SAME_STMT);
2273       else
2274         gsi_insert_before (&gsi, note, GSI_SAME_STMT);
2275     }
2276
2277   return note;
2278 }
2279
2280 static void
2281 insert_init_stmt (copy_body_data *id, basic_block bb, gimple init_stmt)
2282 {
2283   /* If VAR represents a zero-sized variable, it's possible that the
2284      assignment statement may result in no gimple statements.  */
2285   if (init_stmt)
2286     {
2287       gimple_stmt_iterator si = gsi_last_bb (bb);
2288
2289       /* We can end up with init statements that store to a non-register
2290          from a rhs with a conversion.  Handle that here by forcing the
2291          rhs into a temporary.  gimple_regimplify_operands is not
2292          prepared to do this for us.  */
2293       if (!is_gimple_debug (init_stmt)
2294           && !is_gimple_reg (gimple_assign_lhs (init_stmt))
2295           && is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (init_stmt)))
2296           && gimple_assign_rhs_class (init_stmt) == GIMPLE_UNARY_RHS)
2297         {
2298           tree rhs = build1 (gimple_assign_rhs_code (init_stmt),
2299                              gimple_expr_type (init_stmt),
2300                              gimple_assign_rhs1 (init_stmt));
2301           rhs = force_gimple_operand_gsi (&si, rhs, true, NULL_TREE, false,
2302                                           GSI_NEW_STMT);
2303           gimple_assign_set_rhs_code (init_stmt, TREE_CODE (rhs));
2304           gimple_assign_set_rhs1 (init_stmt, rhs);
2305         }
2306       gsi_insert_after (&si, init_stmt, GSI_NEW_STMT);
2307       gimple_regimplify_operands (init_stmt, &si);
2308       mark_symbols_for_renaming (init_stmt);
2309
2310       if (!is_gimple_debug (init_stmt) && MAY_HAVE_DEBUG_STMTS)
2311         {
2312           tree var, def = gimple_assign_lhs (init_stmt);
2313
2314           if (TREE_CODE (def) == SSA_NAME)
2315             var = SSA_NAME_VAR (def);
2316           else
2317             var = def;
2318
2319           insert_init_debug_bind (id, bb, var, def, init_stmt);
2320         }
2321     }
2322 }
2323
2324 /* Initialize parameter P with VALUE.  If needed, produce init statement
2325    at the end of BB.  When BB is NULL, we return init statement to be
2326    output later.  */
2327 static gimple
2328 setup_one_parameter (copy_body_data *id, tree p, tree value, tree fn,
2329                      basic_block bb, tree *vars)
2330 {
2331   gimple init_stmt = NULL;
2332   tree var;
2333   tree rhs = value;
2334   tree def = (gimple_in_ssa_p (cfun)
2335               ? gimple_default_def (id->src_cfun, p) : NULL);
2336
2337   if (value
2338       && value != error_mark_node
2339       && !useless_type_conversion_p (TREE_TYPE (p), TREE_TYPE (value)))
2340     {
2341       if (fold_convertible_p (TREE_TYPE (p), value))
2342         rhs = fold_build1 (NOP_EXPR, TREE_TYPE (p), value);
2343       else
2344         /* ???  For valid (GIMPLE) programs we should not end up here.
2345            Still if something has gone wrong and we end up with truly
2346            mismatched types here, fall back to using a VIEW_CONVERT_EXPR
2347            to not leak invalid GIMPLE to the following passes.  */
2348         rhs = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (p), value);
2349     }
2350
2351   /* Make an equivalent VAR_DECL.  Note that we must NOT remap the type
2352      here since the type of this decl must be visible to the calling
2353      function.  */
2354   var = copy_decl_to_var (p, id);
2355
2356   /* We're actually using the newly-created var.  */
2357   if (gimple_in_ssa_p (cfun) && TREE_CODE (var) == VAR_DECL)
2358     {
2359       get_var_ann (var);
2360       add_referenced_var (var);
2361     }
2362
2363   /* Declare this new variable.  */
2364   TREE_CHAIN (var) = *vars;
2365   *vars = var;
2366
2367   /* Make gimplifier happy about this variable.  */
2368   DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
2369
2370   /* If the parameter is never assigned to, has no SSA_NAMEs created,
2371      we would not need to create a new variable here at all, if it
2372      weren't for debug info.  Still, we can just use the argument
2373      value.  */
2374   if (TREE_READONLY (p)
2375       && !TREE_ADDRESSABLE (p)
2376       && value && !TREE_SIDE_EFFECTS (value)
2377       && !def)
2378     {
2379       /* We may produce non-gimple trees by adding NOPs or introduce
2380          invalid sharing when operand is not really constant.
2381          It is not big deal to prohibit constant propagation here as
2382          we will constant propagate in DOM1 pass anyway.  */
2383       if (is_gimple_min_invariant (value)
2384           && useless_type_conversion_p (TREE_TYPE (p),
2385                                                  TREE_TYPE (value))
2386           /* We have to be very careful about ADDR_EXPR.  Make sure
2387              the base variable isn't a local variable of the inlined
2388              function, e.g., when doing recursive inlining, direct or
2389              mutually-recursive or whatever, which is why we don't
2390              just test whether fn == current_function_decl.  */
2391           && ! self_inlining_addr_expr (value, fn))
2392         {
2393           insert_decl_map (id, p, value);
2394           insert_debug_decl_map (id, p, var);
2395           return insert_init_debug_bind (id, bb, var, value, NULL);
2396         }
2397     }
2398
2399   /* Register the VAR_DECL as the equivalent for the PARM_DECL;
2400      that way, when the PARM_DECL is encountered, it will be
2401      automatically replaced by the VAR_DECL.  */
2402   insert_decl_map (id, p, var);
2403
2404   /* Even if P was TREE_READONLY, the new VAR should not be.
2405      In the original code, we would have constructed a
2406      temporary, and then the function body would have never
2407      changed the value of P.  However, now, we will be
2408      constructing VAR directly.  The constructor body may
2409      change its value multiple times as it is being
2410      constructed.  Therefore, it must not be TREE_READONLY;
2411      the back-end assumes that TREE_READONLY variable is
2412      assigned to only once.  */
2413   if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p)))
2414     TREE_READONLY (var) = 0;
2415
2416   /* If there is no setup required and we are in SSA, take the easy route
2417      replacing all SSA names representing the function parameter by the
2418      SSA name passed to function.
2419
2420      We need to construct map for the variable anyway as it might be used
2421      in different SSA names when parameter is set in function.
2422
2423      Do replacement at -O0 for const arguments replaced by constant.
2424      This is important for builtin_constant_p and other construct requiring
2425      constant argument to be visible in inlined function body.  */
2426   if (gimple_in_ssa_p (cfun) && rhs && def && is_gimple_reg (p)
2427       && (optimize
2428           || (TREE_READONLY (p)
2429               && is_gimple_min_invariant (rhs)))
2430       && (TREE_CODE (rhs) == SSA_NAME
2431           || is_gimple_min_invariant (rhs))
2432       && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def))
2433     {
2434       insert_decl_map (id, def, rhs);
2435       return insert_init_debug_bind (id, bb, var, rhs, NULL);
2436     }
2437
2438   /* If the value of argument is never used, don't care about initializing
2439      it.  */
2440   if (optimize && gimple_in_ssa_p (cfun) && !def && is_gimple_reg (p))
2441     {
2442       gcc_assert (!value || !TREE_SIDE_EFFECTS (value));
2443       return insert_init_debug_bind (id, bb, var, rhs, NULL);
2444     }
2445
2446   /* Initialize this VAR_DECL from the equivalent argument.  Convert
2447      the argument to the proper type in case it was promoted.  */
2448   if (value)
2449     {
2450       if (rhs == error_mark_node)
2451         {
2452           insert_decl_map (id, p, var);
2453           return insert_init_debug_bind (id, bb, var, rhs, NULL);
2454         }
2455
2456       STRIP_USELESS_TYPE_CONVERSION (rhs);
2457
2458       /* We want to use MODIFY_EXPR, not INIT_EXPR here so that we
2459          keep our trees in gimple form.  */
2460       if (def && gimple_in_ssa_p (cfun) && is_gimple_reg (p))
2461         {
2462           def = remap_ssa_name (def, id);
2463           init_stmt = gimple_build_assign (def, rhs);
2464           SSA_NAME_IS_DEFAULT_DEF (def) = 0;
2465           set_default_def (var, NULL);
2466         }
2467       else
2468         init_stmt = gimple_build_assign (var, rhs);
2469
2470       if (bb && init_stmt)
2471         insert_init_stmt (id, bb, init_stmt);
2472     }
2473   return init_stmt;
2474 }
2475
2476 /* Generate code to initialize the parameters of the function at the
2477    top of the stack in ID from the GIMPLE_CALL STMT.  */
2478
2479 static void
2480 initialize_inlined_parameters (copy_body_data *id, gimple stmt,
2481                                tree fn, basic_block bb)
2482 {
2483   tree parms;
2484   size_t i;
2485   tree p;
2486   tree vars = NULL_TREE;
2487   tree static_chain = gimple_call_chain (stmt);
2488
2489   /* Figure out what the parameters are.  */
2490   parms = DECL_ARGUMENTS (fn);
2491
2492   /* Loop through the parameter declarations, replacing each with an
2493      equivalent VAR_DECL, appropriately initialized.  */
2494   for (p = parms, i = 0; p; p = TREE_CHAIN (p), i++)
2495     {
2496       tree val;
2497       val = i < gimple_call_num_args (stmt) ? gimple_call_arg (stmt, i) : NULL;
2498       setup_one_parameter (id, p, val, fn, bb, &vars);
2499     }
2500
2501   /* Initialize the static chain.  */
2502   p = DECL_STRUCT_FUNCTION (fn)->static_chain_decl;
2503   gcc_assert (fn != current_function_decl);
2504   if (p)
2505     {
2506       /* No static chain?  Seems like a bug in tree-nested.c.  */
2507       gcc_assert (static_chain);
2508
2509       setup_one_parameter (id, p, static_chain, fn, bb, &vars);
2510     }
2511
2512   declare_inline_vars (id->block, vars);
2513 }
2514
2515
2516 /* Declare a return variable to replace the RESULT_DECL for the
2517    function we are calling.  An appropriate DECL_STMT is returned.
2518    The USE_STMT is filled to contain a use of the declaration to
2519    indicate the return value of the function.
2520
2521    RETURN_SLOT, if non-null is place where to store the result.  It
2522    is set only for CALL_EXPR_RETURN_SLOT_OPT.  MODIFY_DEST, if non-null,
2523    was the LHS of the MODIFY_EXPR to which this call is the RHS.
2524
2525    The return value is a (possibly null) value that is the result of the
2526    function as seen by the callee.  *USE_P is a (possibly null) value that
2527    holds the result as seen by the caller.  */
2528
2529 static tree
2530 declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest,
2531                          tree *use_p)
2532 {
2533   tree callee = id->src_fn;
2534   tree caller = id->dst_fn;
2535   tree result = DECL_RESULT (callee);
2536   tree callee_type = TREE_TYPE (result);
2537   tree caller_type = TREE_TYPE (TREE_TYPE (callee));
2538   tree var, use;
2539
2540   /* We don't need to do anything for functions that don't return
2541      anything.  */
2542   if (!result || VOID_TYPE_P (callee_type))
2543     {
2544       *use_p = NULL_TREE;
2545       return NULL_TREE;
2546     }
2547
2548   /* If there was a return slot, then the return value is the
2549      dereferenced address of that object.  */
2550   if (return_slot)
2551     {
2552       /* The front end shouldn't have used both return_slot and
2553          a modify expression.  */
2554       gcc_assert (!modify_dest);
2555       if (DECL_BY_REFERENCE (result))
2556         {
2557           tree return_slot_addr = build_fold_addr_expr (return_slot);
2558           STRIP_USELESS_TYPE_CONVERSION (return_slot_addr);
2559
2560           /* We are going to construct *&return_slot and we can't do that
2561              for variables believed to be not addressable. 
2562
2563              FIXME: This check possibly can match, because values returned
2564              via return slot optimization are not believed to have address
2565              taken by alias analysis.  */
2566           gcc_assert (TREE_CODE (return_slot) != SSA_NAME);
2567           if (gimple_in_ssa_p (cfun))
2568             {
2569               HOST_WIDE_INT bitsize;
2570               HOST_WIDE_INT bitpos;
2571               tree offset;
2572               enum machine_mode mode;
2573               int unsignedp;
2574               int volatilep;
2575               tree base;
2576               base = get_inner_reference (return_slot, &bitsize, &bitpos,
2577                                           &offset,
2578                                           &mode, &unsignedp, &volatilep,
2579                                           false);
2580               if (TREE_CODE (base) == INDIRECT_REF)
2581                 base = TREE_OPERAND (base, 0);
2582               if (TREE_CODE (base) == SSA_NAME)
2583                 base = SSA_NAME_VAR (base);
2584               mark_sym_for_renaming (base);
2585             }
2586           var = return_slot_addr;
2587         }
2588       else
2589         {
2590           var = return_slot;
2591           gcc_assert (TREE_CODE (var) != SSA_NAME);
2592           TREE_ADDRESSABLE (var) |= TREE_ADDRESSABLE (result);
2593         }
2594       if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
2595            || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
2596           && !DECL_GIMPLE_REG_P (result)
2597           && DECL_P (var))
2598         DECL_GIMPLE_REG_P (var) = 0;
2599       use = NULL;
2600       goto done;
2601     }
2602
2603   /* All types requiring non-trivial constructors should have been handled.  */
2604   gcc_assert (!TREE_ADDRESSABLE (callee_type));
2605
2606   /* Attempt to avoid creating a new temporary variable.  */
2607   if (modify_dest
2608       && TREE_CODE (modify_dest) != SSA_NAME)
2609     {
2610       bool use_it = false;
2611
2612       /* We can't use MODIFY_DEST if there's type promotion involved.  */
2613       if (!useless_type_conversion_p (callee_type, caller_type))
2614         use_it = false;
2615
2616       /* ??? If we're assigning to a variable sized type, then we must
2617          reuse the destination variable, because we've no good way to
2618          create variable sized temporaries at this point.  */
2619       else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type)) != INTEGER_CST)
2620         use_it = true;
2621
2622       /* If the callee cannot possibly modify MODIFY_DEST, then we can
2623          reuse it as the result of the call directly.  Don't do this if
2624          it would promote MODIFY_DEST to addressable.  */
2625       else if (TREE_ADDRESSABLE (result))
2626         use_it = false;
2627       else
2628         {
2629           tree base_m = get_base_address (modify_dest);
2630
2631           /* If the base isn't a decl, then it's a pointer, and we don't
2632              know where that's going to go.  */
2633           if (!DECL_P (base_m))
2634             use_it = false;
2635           else if (is_global_var (base_m))
2636             use_it = false;
2637           else if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
2638                     || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
2639                    && !DECL_GIMPLE_REG_P (result)
2640                    && DECL_GIMPLE_REG_P (base_m))
2641             use_it = false;
2642           else if (!TREE_ADDRESSABLE (base_m))
2643             use_it = true;
2644         }
2645
2646       if (use_it)
2647         {
2648           var = modify_dest;
2649           use = NULL;
2650           goto done;
2651         }
2652     }
2653
2654   gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type)) == INTEGER_CST);
2655
2656   var = copy_result_decl_to_var (result, id);
2657   if (gimple_in_ssa_p (cfun))
2658     {
2659       get_var_ann (var);
2660       add_referenced_var (var);
2661     }
2662
2663   DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
2664   DECL_STRUCT_FUNCTION (caller)->local_decls
2665     = tree_cons (NULL_TREE, var,
2666                  DECL_STRUCT_FUNCTION (caller)->local_decls);
2667
2668   /* Do not have the rest of GCC warn about this variable as it should
2669      not be visible to the user.  */
2670   TREE_NO_WARNING (var) = 1;
2671
2672   declare_inline_vars (id->block, var);
2673
2674   /* Build the use expr.  If the return type of the function was
2675      promoted, convert it back to the expected type.  */
2676   use = var;
2677   if (!useless_type_conversion_p (caller_type, TREE_TYPE (var)))
2678     use = fold_convert (caller_type, var);
2679     
2680   STRIP_USELESS_TYPE_CONVERSION (use);
2681
2682   if (DECL_BY_REFERENCE (result))
2683     {
2684       TREE_ADDRESSABLE (var) = 1;
2685       var = build_fold_addr_expr (var);
2686     }
2687
2688  done:
2689   /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
2690      way, when the RESULT_DECL is encountered, it will be
2691      automatically replaced by the VAR_DECL.  */
2692   insert_decl_map (id, result, var);
2693
2694   /* Remember this so we can ignore it in remap_decls.  */
2695   id->retvar = var;
2696
2697   *use_p = use;
2698   return var;
2699 }
2700
2701 /* Callback through walk_tree.  Determine if a DECL_INITIAL makes reference
2702    to a local label.  */
2703
2704 static tree
2705 has_label_address_in_static_1 (tree *nodep, int *walk_subtrees, void *fnp)
2706 {
2707   tree node = *nodep;
2708   tree fn = (tree) fnp;
2709
2710   if (TREE_CODE (node) == LABEL_DECL && DECL_CONTEXT (node) == fn)
2711     return node;
2712
2713   if (TYPE_P (node))
2714     *walk_subtrees = 0;
2715
2716   return NULL_TREE;
2717 }
2718
2719 /* Callback through walk_tree.  Determine if we've got an aggregate
2720    type that we can't support; return non-null if so.  */
2721
2722 static tree
2723 cannot_copy_type_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED,
2724                     void *data ATTRIBUTE_UNUSED)
2725 {
2726   tree t, node = *nodep;
2727
2728   if (TREE_CODE (node) == RECORD_TYPE || TREE_CODE (node) == UNION_TYPE)
2729     {
2730       /* We cannot inline a function of the form
2731
2732            void F (int i) { struct S { int ar[i]; } s; }
2733
2734          Attempting to do so produces a catch-22.
2735          If walk_tree examines the TYPE_FIELDS chain of RECORD_TYPE/
2736          UNION_TYPE nodes, then it goes into infinite recursion on a
2737          structure containing a pointer to its own type.  If it doesn't,
2738          then the type node for S doesn't get adjusted properly when
2739          F is inlined. 
2740
2741          ??? This is likely no longer true, but it's too late in the 4.0
2742          cycle to try to find out.  This should be checked for 4.1.  */
2743       for (t = TYPE_FIELDS (node); t; t = TREE_CHAIN (t))
2744         if (variably_modified_type_p (TREE_TYPE (t), NULL))
2745           return node;
2746     }
2747
2748   return NULL_TREE;
2749 }
2750
2751
2752 /* Determine if the function can be copied.  If so return NULL.  If
2753    not return a string describng the reason for failure.  */
2754
2755 static const char *
2756 copy_forbidden (struct function *fun, tree fndecl)
2757 {
2758   const char *reason = fun->cannot_be_copied_reason;
2759   tree step;
2760
2761   /* Only examine the function once.  */
2762   if (fun->cannot_be_copied_set)
2763     return reason;
2764
2765   /* We cannot copy a function that receives a non-local goto
2766      because we cannot remap the destination label used in the
2767      function that is performing the non-local goto.  */
2768   /* ??? Actually, this should be possible, if we work at it.
2769      No doubt there's just a handful of places that simply
2770      assume it doesn't happen and don't substitute properly.  */
2771   if (fun->has_nonlocal_label)
2772     {
2773       reason = G_("function %q+F can never be copied "
2774                   "because it receives a non-local goto");
2775       goto fail;
2776     }
2777
2778   for (step = fun->local_decls; step; step = TREE_CHAIN (step))
2779     {
2780       tree decl = TREE_VALUE (step);
2781
2782       if (TREE_CODE (decl) == VAR_DECL
2783           && TREE_STATIC (decl)
2784           && !DECL_EXTERNAL (decl)
2785           && DECL_INITIAL (decl)
2786           && walk_tree_without_duplicates (&DECL_INITIAL (decl),
2787                                            has_label_address_in_static_1,
2788                                            fndecl))
2789         {
2790           reason = G_("function %q+F can never be copied because it saves "
2791                       "address of local label in a static variable");
2792           goto fail;
2793         }
2794
2795       if (!TREE_STATIC (decl) && !DECL_EXTERNAL (decl)
2796           && variably_modified_type_p (TREE_TYPE (decl), NULL)
2797           && walk_tree_without_duplicates (&TREE_TYPE (decl),
2798                                            cannot_copy_type_1, NULL))
2799         {
2800           reason = G_("function %q+F can never be copied "
2801                       "because it uses variable sized variables");
2802           goto fail;
2803         }
2804     }
2805
2806  fail:
2807   fun->cannot_be_copied_reason = reason;
2808   fun->cannot_be_copied_set = true;
2809   return reason;
2810 }
2811
2812
2813 static const char *inline_forbidden_reason;
2814
2815 /* A callback for walk_gimple_seq to handle statements.  Returns non-null
2816    iff a function can not be inlined.  Also sets the reason why. */
2817
2818 static tree
2819 inline_forbidden_p_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
2820                          struct walk_stmt_info *wip)
2821 {
2822   tree fn = (tree) wip->info;
2823   tree t;
2824   gimple stmt = gsi_stmt (*gsi);
2825
2826   switch (gimple_code (stmt))
2827     {
2828     case GIMPLE_CALL:
2829       /* Refuse to inline alloca call unless user explicitly forced so as
2830          this may change program's memory overhead drastically when the
2831          function using alloca is called in loop.  In GCC present in
2832          SPEC2000 inlining into schedule_block cause it to require 2GB of
2833          RAM instead of 256MB.  */
2834       if (gimple_alloca_call_p (stmt)
2835           && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
2836         {
2837           inline_forbidden_reason
2838             = G_("function %q+F can never be inlined because it uses "
2839                  "alloca (override using the always_inline attribute)");
2840           *handled_ops_p = true;
2841           return fn;
2842         }
2843
2844       t = gimple_call_fndecl (stmt);
2845       if (t == NULL_TREE)
2846         break;
2847
2848       /* We cannot inline functions that call setjmp.  */
2849       if (setjmp_call_p (t))
2850         {
2851           inline_forbidden_reason
2852             = G_("function %q+F can never be inlined because it uses setjmp");
2853           *handled_ops_p = true;
2854           return t;
2855         }
2856
2857       if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL)
2858         switch (DECL_FUNCTION_CODE (t))
2859           {
2860             /* We cannot inline functions that take a variable number of
2861                arguments.  */
2862           case BUILT_IN_VA_START:
2863           case BUILT_IN_NEXT_ARG:
2864           case BUILT_IN_VA_END:
2865             inline_forbidden_reason
2866               = G_("function %q+F can never be inlined because it "
2867                    "uses variable argument lists");
2868             *handled_ops_p = true;
2869             return t;
2870
2871           case BUILT_IN_LONGJMP:
2872             /* We can't inline functions that call __builtin_longjmp at
2873                all.  The non-local goto machinery really requires the
2874                destination be in a different function.  If we allow the
2875                function calling __builtin_longjmp to be inlined into the
2876                function calling __builtin_setjmp, Things will Go Awry.  */
2877             inline_forbidden_reason
2878               = G_("function %q+F can never be inlined because "
2879                    "it uses setjmp-longjmp exception handling");
2880             *handled_ops_p = true;
2881             return t;
2882
2883           case BUILT_IN_NONLOCAL_GOTO:
2884             /* Similarly.  */
2885             inline_forbidden_reason
2886               = G_("function %q+F can never be inlined because "
2887                    "it uses non-local goto");
2888             *handled_ops_p = true;
2889             return t;
2890
2891           case BUILT_IN_RETURN:
2892           case BUILT_IN_APPLY_ARGS:
2893             /* If a __builtin_apply_args caller would be inlined,
2894                it would be saving arguments of the function it has
2895                been inlined into.  Similarly __builtin_return would
2896                return from the function the inline has been inlined into.  */
2897             inline_forbidden_reason
2898               = G_("function %q+F can never be inlined because "
2899                    "it uses __builtin_return or __builtin_apply_args");
2900             *handled_ops_p = true;
2901             return t;
2902
2903           default:
2904             break;
2905           }
2906       break;
2907
2908     case GIMPLE_GOTO:
2909       t = gimple_goto_dest (stmt);
2910
2911       /* We will not inline a function which uses computed goto.  The
2912          addresses of its local labels, which may be tucked into
2913          global storage, are of course not constant across
2914          instantiations, which causes unexpected behavior.  */
2915       if (TREE_CODE (t) != LABEL_DECL)
2916         {
2917           inline_forbidden_reason
2918             = G_("function %q+F can never be inlined "
2919                  "because it contains a computed goto");
2920           *handled_ops_p = true;
2921           return t;
2922         }
2923       break;
2924
2925     default:
2926       break;
2927     }
2928
2929   *handled_ops_p = false;
2930   return NULL_TREE;
2931 }
2932
2933 /* Return true if FNDECL is a function that cannot be inlined into
2934    another one.  */
2935
2936 static bool
2937 inline_forbidden_p (tree fndecl)
2938 {
2939   struct function *fun = DECL_STRUCT_FUNCTION (fndecl);
2940   struct walk_stmt_info wi;
2941   struct pointer_set_t *visited_nodes;
2942   basic_block bb;
2943   bool forbidden_p = false;
2944
2945   /* First check for shared reasons not to copy the code.  */
2946   inline_forbidden_reason = copy_forbidden (fun, fndecl);
2947   if (inline_forbidden_reason != NULL)
2948     return true;
2949
2950   /* Next, walk the statements of the function looking for
2951      constraucts we can't handle, or are non-optimal for inlining.  */
2952   visited_nodes = pointer_set_create ();
2953   memset (&wi, 0, sizeof (wi));
2954   wi.info = (void *) fndecl;
2955   wi.pset = visited_nodes;
2956
2957   FOR_EACH_BB_FN (bb, fun)
2958     {
2959       gimple ret;
2960       gimple_seq seq = bb_seq (bb);
2961       ret = walk_gimple_seq (seq, inline_forbidden_p_stmt, NULL, &wi);
2962       forbidden_p = (ret != NULL);
2963       if (forbidden_p)
2964         break;
2965     }
2966
2967   pointer_set_destroy (visited_nodes);
2968   return forbidden_p;
2969 }
2970
2971 /* Returns nonzero if FN is a function that does not have any
2972    fundamental inline blocking properties.  */
2973
2974 bool
2975 tree_inlinable_function_p (tree fn)
2976 {
2977   bool inlinable = true;
2978   bool do_warning;
2979   tree always_inline;
2980
2981   /* If we've already decided this function shouldn't be inlined,
2982      there's no need to check again.  */
2983   if (DECL_UNINLINABLE (fn))
2984     return false;
2985
2986   /* We only warn for functions declared `inline' by the user.  */
2987   do_warning = (warn_inline
2988                 && DECL_DECLARED_INLINE_P (fn)
2989                 && !DECL_NO_INLINE_WARNING_P (fn)
2990                 && !DECL_IN_SYSTEM_HEADER (fn));
2991
2992   always_inline = lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn));
2993
2994   if (flag_no_inline
2995       && always_inline == NULL)
2996     {
2997       if (do_warning)
2998         warning (OPT_Winline, "function %q+F can never be inlined because it "
2999                  "is suppressed using -fno-inline", fn);
3000       inlinable = false;
3001     }
3002
3003   /* Don't auto-inline anything that might not be bound within
3004      this unit of translation.  */
3005   else if (!DECL_DECLARED_INLINE_P (fn)
3006            && DECL_REPLACEABLE_P (fn))
3007     inlinable = false;
3008
3009   else if (!function_attribute_inlinable_p (fn))
3010     {
3011       if (do_warning)
3012         warning (OPT_Winline, "function %q+F can never be inlined because it "
3013                  "uses attributes conflicting with inlining", fn);
3014       inlinable = false;
3015     }
3016
3017   else if (inline_forbidden_p (fn))
3018     {
3019       /* See if we should warn about uninlinable functions.  Previously,
3020          some of these warnings would be issued while trying to expand
3021          the function inline, but that would cause multiple warnings
3022          about functions that would for example call alloca.  But since
3023          this a property of the function, just one warning is enough.
3024          As a bonus we can now give more details about the reason why a
3025          function is not inlinable.  */
3026       if (always_inline)
3027         sorry (inline_forbidden_reason, fn);
3028       else if (do_warning)
3029         warning (OPT_Winline, inline_forbidden_reason, fn);
3030
3031       inlinable = false;
3032     }
3033
3034   /* Squirrel away the result so that we don't have to check again.  */
3035   DECL_UNINLINABLE (fn) = !inlinable;
3036
3037   return inlinable;
3038 }
3039
3040 /* Estimate the cost of a memory move.  Use machine dependent
3041    word size and take possible memcpy call into account.  */
3042
3043 int
3044 estimate_move_cost (tree type)
3045 {
3046   HOST_WIDE_INT size;
3047
3048   gcc_assert (!VOID_TYPE_P (type));
3049
3050   size = int_size_in_bytes (type);
3051
3052   if (size < 0 || size > MOVE_MAX_PIECES * MOVE_RATIO (!optimize_size))
3053     /* Cost of a memcpy call, 3 arguments and the call.  */
3054     return 4;
3055   else
3056     return ((size + MOVE_MAX_PIECES - 1) / MOVE_MAX_PIECES);
3057 }
3058
3059 /* Returns cost of operation CODE, according to WEIGHTS  */
3060
3061 static int
3062 estimate_operator_cost (enum tree_code code, eni_weights *weights,
3063                         tree op1 ATTRIBUTE_UNUSED, tree op2)
3064 {
3065   switch (code)
3066     {
3067     /* These are "free" conversions, or their presumed cost
3068        is folded into other operations.  */
3069     case RANGE_EXPR:
3070     CASE_CONVERT:
3071     case COMPLEX_EXPR:
3072     case PAREN_EXPR:
3073       return 0;
3074
3075     /* Assign cost of 1 to usual operations.
3076        ??? We may consider mapping RTL costs to this.  */
3077     case COND_EXPR:
3078     case VEC_COND_EXPR:
3079
3080     case PLUS_EXPR:
3081     case POINTER_PLUS_EXPR:
3082     case MINUS_EXPR:
3083     case MULT_EXPR:
3084
3085     case ADDR_SPACE_CONVERT_EXPR:
3086     case FIXED_CONVERT_EXPR:
3087     case FIX_TRUNC_EXPR:
3088
3089     case NEGATE_EXPR:
3090     case FLOAT_EXPR:
3091     case MIN_EXPR:
3092     case MAX_EXPR:
3093     case ABS_EXPR:
3094
3095     case LSHIFT_EXPR:
3096     case RSHIFT_EXPR:
3097     case LROTATE_EXPR:
3098     case RROTATE_EXPR:
3099     case VEC_LSHIFT_EXPR:
3100     case VEC_RSHIFT_EXPR:
3101
3102     case BIT_IOR_EXPR:
3103     case BIT_XOR_EXPR:
3104     case BIT_AND_EXPR:
3105     case BIT_NOT_EXPR:
3106
3107     case TRUTH_ANDIF_EXPR:
3108     case TRUTH_ORIF_EXPR:
3109     case TRUTH_AND_EXPR:
3110     case TRUTH_OR_EXPR:
3111     case TRUTH_XOR_EXPR:
3112     case TRUTH_NOT_EXPR:
3113
3114     case LT_EXPR:
3115     case LE_EXPR:
3116     case GT_EXPR:
3117     case GE_EXPR:
3118     case EQ_EXPR:
3119     case NE_EXPR:
3120     case ORDERED_EXPR:
3121     case UNORDERED_EXPR:
3122
3123     case UNLT_EXPR:
3124     case UNLE_EXPR:
3125     case UNGT_EXPR:
3126     case UNGE_EXPR:
3127     case UNEQ_EXPR:
3128     case LTGT_EXPR:
3129
3130     case CONJ_EXPR:
3131
3132     case PREDECREMENT_EXPR:
3133     case PREINCREMENT_EXPR:
3134     case POSTDECREMENT_EXPR:
3135     case POSTINCREMENT_EXPR:
3136
3137     case REALIGN_LOAD_EXPR:
3138
3139     case REDUC_MAX_EXPR:
3140     case REDUC_MIN_EXPR:
3141     case REDUC_PLUS_EXPR:
3142     case WIDEN_SUM_EXPR:
3143     case WIDEN_MULT_EXPR:
3144     case DOT_PROD_EXPR:
3145
3146     case VEC_WIDEN_MULT_HI_EXPR:
3147     case VEC_WIDEN_MULT_LO_EXPR:
3148     case VEC_UNPACK_HI_EXPR:
3149     case VEC_UNPACK_LO_EXPR:
3150     case VEC_UNPACK_FLOAT_HI_EXPR:
3151     case VEC_UNPACK_FLOAT_LO_EXPR:
3152     case VEC_PACK_TRUNC_EXPR:
3153     case VEC_PACK_SAT_EXPR:
3154     case VEC_PACK_FIX_TRUNC_EXPR:
3155     case VEC_EXTRACT_EVEN_EXPR:
3156     case VEC_EXTRACT_ODD_EXPR:
3157     case VEC_INTERLEAVE_HIGH_EXPR:
3158     case VEC_INTERLEAVE_LOW_EXPR:
3159
3160       return 1;
3161
3162     /* Few special cases of expensive operations.  This is useful
3163        to avoid inlining on functions having too many of these.  */
3164     case TRUNC_DIV_EXPR:
3165     case CEIL_DIV_EXPR:
3166     case FLOOR_DIV_EXPR:
3167     case ROUND_DIV_EXPR:
3168     case EXACT_DIV_EXPR:
3169     case TRUNC_MOD_EXPR:
3170     case CEIL_MOD_EXPR:
3171     case FLOOR_MOD_EXPR:
3172     case ROUND_MOD_EXPR:
3173     case RDIV_EXPR:
3174       if (TREE_CODE (op2) != INTEGER_CST)
3175         return weights->div_mod_cost;
3176       return 1;
3177
3178     default:
3179       /* We expect a copy assignment with no operator.  */
3180       gcc_assert (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS);
3181       return 0;
3182     }
3183 }
3184
3185
3186 /* Estimate number of instructions that will be created by expanding
3187    the statements in the statement sequence STMTS.
3188    WEIGHTS contains weights attributed to various constructs.  */
3189
3190 static
3191 int estimate_num_insns_seq (gimple_seq stmts, eni_weights *weights)
3192 {
3193   int cost;
3194   gimple_stmt_iterator gsi;
3195
3196   cost = 0;
3197   for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
3198     cost += estimate_num_insns (gsi_stmt (gsi), weights);
3199
3200   return cost;
3201 }
3202
3203
3204 /* Estimate number of instructions that will be created by expanding STMT.
3205    WEIGHTS contains weights attributed to various constructs.  */
3206
3207 int
3208 estimate_num_insns (gimple stmt, eni_weights *weights)
3209 {
3210   unsigned cost, i;
3211   enum gimple_code code = gimple_code (stmt);
3212   tree lhs;
3213   tree rhs;
3214
3215   switch (code)
3216     {
3217     case GIMPLE_ASSIGN:
3218       /* Try to estimate the cost of assignments.  We have three cases to
3219          deal with:
3220          1) Simple assignments to registers;
3221          2) Stores to things that must live in memory.  This includes
3222             "normal" stores to scalars, but also assignments of large
3223             structures, or constructors of big arrays;
3224
3225          Let us look at the first two cases, assuming we have "a = b + C":
3226          <GIMPLE_ASSIGN <var_decl "a">
3227                 <plus_expr <var_decl "b"> <constant C>>
3228          If "a" is a GIMPLE register, the assignment to it is free on almost
3229          any target, because "a" usually ends up in a real register.  Hence
3230          the only cost of this expression comes from the PLUS_EXPR, and we
3231          can ignore the GIMPLE_ASSIGN.
3232          If "a" is not a GIMPLE register, the assignment to "a" will most
3233          likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost
3234          of moving something into "a", which we compute using the function
3235          estimate_move_cost.  */
3236       lhs = gimple_assign_lhs (stmt);
3237       rhs = gimple_assign_rhs1 (stmt);
3238
3239       if (is_gimple_reg (lhs))
3240         cost = 0;
3241       else
3242         cost = estimate_move_cost (TREE_TYPE (lhs));
3243
3244       if (!is_gimple_reg (rhs) && !is_gimple_min_invariant (rhs))
3245         cost += estimate_move_cost (TREE_TYPE (rhs));
3246
3247       cost += estimate_operator_cost (gimple_assign_rhs_code (stmt), weights,
3248                                       gimple_assign_rhs1 (stmt),
3249                                       get_gimple_rhs_class (gimple_assign_rhs_code (stmt))
3250                                       == GIMPLE_BINARY_RHS
3251                                       ? gimple_assign_rhs2 (stmt) : NULL);
3252       break;
3253
3254     case GIMPLE_COND:
3255       cost = 1 + estimate_operator_cost (gimple_cond_code (stmt), weights,
3256                                          gimple_op (stmt, 0),
3257                                          gimple_op (stmt, 1));
3258       break;
3259
3260     case GIMPLE_SWITCH:
3261       /* Take into account cost of the switch + guess 2 conditional jumps for
3262          each case label.  
3263
3264          TODO: once the switch expansion logic is sufficiently separated, we can
3265          do better job on estimating cost of the switch.  */
3266       if (weights->time_based)
3267         cost = floor_log2 (gimple_switch_num_labels (stmt)) * 2;
3268       else
3269         cost = gimple_switch_num_labels (stmt) * 2;
3270       break;
3271
3272     case GIMPLE_CALL:
3273       {
3274         tree decl = gimple_call_fndecl (stmt);
3275         tree addr = gimple_call_fn (stmt);
3276         tree funtype = TREE_TYPE (addr);
3277
3278         if (POINTER_TYPE_P (funtype))
3279           funtype = TREE_TYPE (funtype);
3280
3281         if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD)
3282           cost = weights->target_builtin_call_cost;
3283         else
3284           cost = weights->call_cost;
3285         
3286         if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
3287           switch (DECL_FUNCTION_CODE (decl))
3288             {
3289             case BUILT_IN_CONSTANT_P:
3290               return 0;
3291             case BUILT_IN_EXPECT:
3292               return 0;
3293
3294             /* Prefetch instruction is not expensive.  */
3295             case BUILT_IN_PREFETCH:
3296               cost = weights->target_builtin_call_cost;
3297               break;
3298
3299             default:
3300               break;
3301             }
3302
3303         if (decl)
3304           funtype = TREE_TYPE (decl);
3305
3306         if (!VOID_TYPE_P (TREE_TYPE (funtype)))
3307           cost += estimate_move_cost (TREE_TYPE (funtype));
3308         /* Our cost must be kept in sync with
3309            cgraph_estimate_size_after_inlining that does use function
3310            declaration to figure out the arguments.  */
3311         if (decl && DECL_ARGUMENTS (decl))
3312           {
3313             tree arg;
3314             for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg))
3315               if (!VOID_TYPE_P (TREE_TYPE (arg)))
3316                 cost += estimate_move_cost (TREE_TYPE (arg));
3317           }
3318         else if (funtype && prototype_p (funtype))
3319           {
3320             tree t;
3321             for (t = TYPE_ARG_TYPES (funtype); t && t != void_list_node;
3322                  t = TREE_CHAIN (t))
3323               if (!VOID_TYPE_P (TREE_VALUE (t)))
3324                 cost += estimate_move_cost (TREE_VALUE (t));
3325           }
3326         else
3327           {
3328             for (i = 0; i < gimple_call_num_args (stmt); i++)
3329               {
3330                 tree arg = gimple_call_arg (stmt, i);
3331                 if (!VOID_TYPE_P (TREE_TYPE (arg)))
3332                   cost += estimate_move_cost (TREE_TYPE (arg));
3333               }
3334           }
3335
3336         break;
3337       }
3338
3339     case GIMPLE_GOTO:
3340     case GIMPLE_LABEL:
3341     case GIMPLE_NOP:
3342     case GIMPLE_PHI:
3343     case GIMPLE_RETURN:
3344     case GIMPLE_PREDICT:
3345     case GIMPLE_DEBUG:
3346       return 0;
3347
3348     case GIMPLE_ASM:
3349       return asm_str_count (gimple_asm_string (stmt));
3350
3351     case GIMPLE_RESX:
3352       /* This is either going to be an external function call with one
3353          argument, or two register copy statements plus a goto.  */
3354       return 2;
3355
3356     case GIMPLE_EH_DISPATCH:
3357       /* ??? This is going to turn into a switch statement.  Ideally
3358          we'd have a look at the eh region and estimate the number of
3359          edges involved.  */
3360       return 10;
3361
3362     case GIMPLE_BIND:
3363       return estimate_num_insns_seq (gimple_bind_body (stmt), weights);
3364
3365     case GIMPLE_EH_FILTER:
3366       return estimate_num_insns_seq (gimple_eh_filter_failure (stmt), weights);
3367
3368     case GIMPLE_CATCH:
3369       return estimate_num_insns_seq (gimple_catch_handler (stmt), weights);
3370
3371     case GIMPLE_TRY:
3372       return (estimate_num_insns_seq (gimple_try_eval (stmt), weights)
3373               + estimate_num_insns_seq (gimple_try_cleanup (stmt), weights));
3374
3375     /* OpenMP directives are generally very expensive.  */
3376
3377     case GIMPLE_OMP_RETURN:
3378     case GIMPLE_OMP_SECTIONS_SWITCH:
3379     case GIMPLE_OMP_ATOMIC_STORE:
3380     case GIMPLE_OMP_CONTINUE:
3381       /* ...except these, which are cheap.  */
3382       return 0;
3383
3384     case GIMPLE_OMP_ATOMIC_LOAD:
3385       return weights->omp_cost;
3386
3387     case GIMPLE_OMP_FOR:
3388       return (weights->omp_cost
3389               + estimate_num_insns_seq (gimple_omp_body (stmt), weights)
3390               + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt), weights));
3391
3392     case GIMPLE_OMP_PARALLEL:
3393     case GIMPLE_OMP_TASK:
3394     case GIMPLE_OMP_CRITICAL:
3395     case GIMPLE_OMP_MASTER:
3396     case GIMPLE_OMP_ORDERED:
3397     case GIMPLE_OMP_SECTION:
3398     case GIMPLE_OMP_SECTIONS:
3399     case GIMPLE_OMP_SINGLE:
3400       return (weights->omp_cost
3401               + estimate_num_insns_seq (gimple_omp_body (stmt), weights));
3402
3403     default:
3404       gcc_unreachable ();
3405     }
3406
3407   return cost;
3408 }
3409
3410 /* Estimate number of instructions that will be created by expanding
3411    function FNDECL.  WEIGHTS contains weights attributed to various
3412    constructs.  */
3413
3414 int
3415 estimate_num_insns_fn (tree fndecl, eni_weights *weights)
3416 {
3417   struct function *my_function = DECL_STRUCT_FUNCTION (fndecl);
3418   gimple_stmt_iterator bsi;
3419   basic_block bb;
3420   int n = 0;
3421
3422   gcc_assert (my_function && my_function->cfg);
3423   FOR_EACH_BB_FN (bb, my_function)
3424     {
3425       for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
3426         n += estimate_num_insns (gsi_stmt (bsi), weights);
3427     }
3428
3429   return n;
3430 }
3431
3432
3433 /* Initializes weights used by estimate_num_insns.  */
3434
3435 void
3436 init_inline_once (void)
3437 {
3438   eni_size_weights.call_cost = 1;
3439   eni_size_weights.target_builtin_call_cost = 1;
3440   eni_size_weights.div_mod_cost = 1;
3441   eni_size_weights.omp_cost = 40;
3442   eni_size_weights.time_based = false;
3443
3444   /* Estimating time for call is difficult, since we have no idea what the
3445      called function does.  In the current uses of eni_time_weights,
3446      underestimating the cost does less harm than overestimating it, so
3447      we choose a rather small value here.  */
3448   eni_time_weights.call_cost = 10;
3449   eni_time_weights.target_builtin_call_cost = 10;
3450   eni_time_weights.div_mod_cost = 10;
3451   eni_time_weights.omp_cost = 40;
3452   eni_time_weights.time_based = true;
3453 }
3454
3455 /* Estimate the number of instructions in a gimple_seq. */
3456