OSDN Git Service

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