OSDN Git Service

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