OSDN Git Service

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