2 Copyright (C) 2001-2014 Free Software Foundation, Inc.
3 Contributed by Alexandre Oliva <aoliva@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
25 #include "diagnostic-core.h"
27 #include "stor-layout.h"
29 #include "tree-inline.h"
33 #include "insn-config.h"
35 #include "langhooks.h"
36 #include "basic-block.h"
37 #include "tree-iterator.h"
39 #include "pointer-set.h"
40 #include "tree-ssa-alias.h"
41 #include "internal-fn.h"
42 #include "gimple-fold.h"
44 #include "gimple-expr.h"
48 #include "gimple-iterator.h"
49 #include "gimplify-me.h"
50 #include "gimple-walk.h"
51 #include "gimple-ssa.h"
53 #include "tree-phinodes.h"
54 #include "ssa-iterators.h"
55 #include "stringpool.h"
56 #include "tree-ssanames.h"
57 #include "tree-into-ssa.h"
62 #include "tree-pretty-print.h"
66 #include "value-prof.h"
67 #include "tree-pass.h"
72 #include "rtl.h" /* FIXME: For asm_str_count. */
74 /* I'm not real happy about this, but we need to handle gimple and
77 /* Inlining, Cloning, Versioning, Parallelization
79 Inlining: a function body is duplicated, but the PARM_DECLs are
80 remapped into VAR_DECLs, and non-void RETURN_EXPRs become
81 MODIFY_EXPRs that store to a dedicated returned-value variable.
82 The duplicated eh_region info of the copy will later be appended
83 to the info for the caller; the eh_region info in copied throwing
84 statements and RESX statements are adjusted accordingly.
86 Cloning: (only in C++) We have one body for a con/de/structor, and
87 multiple function decls, each with a unique parameter list.
88 Duplicate the body, using the given splay tree; some parameters
89 will become constants (like 0 or 1).
91 Versioning: a function body is duplicated and the result is a new
92 function rather than into blocks of an existing function as with
93 inlining. Some parameters will become constants.
95 Parallelization: a region of a function is duplicated resulting in
96 a new function. Variables may be replaced with complex expressions
97 to enable shared variable semantics.
99 All of these will simultaneously lookup any callgraph edges. If
100 we're going to inline the duplicated function body, and the given
101 function has some cloned callgraph nodes (one for each place this
102 function will be inlined) those callgraph edges will be duplicated.
103 If we're cloning the body, those callgraph edges will be
104 updated to point into the new body. (Note that the original
105 callgraph node and edge list will not be altered.)
107 See the CALL_EXPR handling case in copy_tree_body_r (). */
111 o In order to make inlining-on-trees work, we pessimized
112 function-local static constants. In particular, they are now
113 always output, even when not addressed. Fix this by treating
114 function-local static constants just like global static
115 constants; the back-end already knows not to output them if they
118 o Provide heuristics to clamp inlining of recursive template
122 /* Weights that estimate_num_insns uses to estimate the size of the
125 eni_weights eni_size_weights
;
127 /* Weights that estimate_num_insns uses to estimate the time necessary
128 to execute the produced code. */
130 eni_weights eni_time_weights
;
134 static tree
declare_return_variable (copy_body_data
*, tree
, tree
, basic_block
);
135 static void remap_block (tree
*, copy_body_data
*);
136 static void copy_bind_expr (tree
*, int *, copy_body_data
*);
137 static void declare_inline_vars (tree
, tree
);
138 static void remap_save_expr (tree
*, void *, int *);
139 static void prepend_lexical_block (tree current_block
, tree new_block
);
140 static tree
copy_decl_to_var (tree
, copy_body_data
*);
141 static tree
copy_result_decl_to_var (tree
, copy_body_data
*);
142 static tree
copy_decl_maybe_to_var (tree
, copy_body_data
*);
143 static gimple
remap_gimple_stmt (gimple
, copy_body_data
*);
144 static bool delete_unreachable_blocks_update_callgraph (copy_body_data
*id
);
146 /* Insert a tree->tree mapping for ID. Despite the name suggests
147 that the trees should be variables, it is used for more than that. */
150 insert_decl_map (copy_body_data
*id
, tree key
, tree value
)
152 *pointer_map_insert (id
->decl_map
, key
) = value
;
154 /* Always insert an identity map as well. If we see this same new
155 node again, we won't want to duplicate it a second time. */
157 *pointer_map_insert (id
->decl_map
, value
) = value
;
160 /* Insert a tree->tree mapping for ID. This is only used for
164 insert_debug_decl_map (copy_body_data
*id
, tree key
, tree value
)
166 if (!gimple_in_ssa_p (id
->src_cfun
))
169 if (!MAY_HAVE_DEBUG_STMTS
)
172 if (!target_for_debug_bind (key
))
175 gcc_assert (TREE_CODE (key
) == PARM_DECL
);
176 gcc_assert (TREE_CODE (value
) == VAR_DECL
);
179 id
->debug_map
= pointer_map_create ();
181 *pointer_map_insert (id
->debug_map
, key
) = value
;
184 /* If nonzero, we're remapping the contents of inlined debug
185 statements. If negative, an error has occurred, such as a
186 reference to a variable that isn't available in the inlined
188 static int processing_debug_stmt
= 0;
190 /* Construct new SSA name for old NAME. ID is the inline context. */
193 remap_ssa_name (tree name
, copy_body_data
*id
)
198 gcc_assert (TREE_CODE (name
) == SSA_NAME
);
200 n
= (tree
*) pointer_map_contains (id
->decl_map
, name
);
202 return unshare_expr (*n
);
204 if (processing_debug_stmt
)
206 if (SSA_NAME_IS_DEFAULT_DEF (name
)
207 && TREE_CODE (SSA_NAME_VAR (name
)) == PARM_DECL
208 && id
->entry_bb
== NULL
209 && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (cfun
)))
211 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
213 gimple_stmt_iterator gsi
;
214 tree val
= SSA_NAME_VAR (name
);
216 n
= (tree
*) pointer_map_contains (id
->decl_map
, val
);
219 if (TREE_CODE (val
) != PARM_DECL
)
221 processing_debug_stmt
= -1;
224 def_temp
= gimple_build_debug_source_bind (vexpr
, val
, NULL
);
225 DECL_ARTIFICIAL (vexpr
) = 1;
226 TREE_TYPE (vexpr
) = TREE_TYPE (name
);
227 DECL_MODE (vexpr
) = DECL_MODE (SSA_NAME_VAR (name
));
228 gsi
= gsi_after_labels (single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
229 gsi_insert_before (&gsi
, def_temp
, GSI_SAME_STMT
);
233 processing_debug_stmt
= -1;
237 /* Remap anonymous SSA names or SSA names of anonymous decls. */
238 var
= SSA_NAME_VAR (name
);
240 || (!SSA_NAME_IS_DEFAULT_DEF (name
)
241 && TREE_CODE (var
) == VAR_DECL
242 && !VAR_DECL_IS_VIRTUAL_OPERAND (var
)
243 && DECL_ARTIFICIAL (var
)
244 && DECL_IGNORED_P (var
)
245 && !DECL_NAME (var
)))
247 struct ptr_info_def
*pi
;
248 new_tree
= make_ssa_name (remap_type (TREE_TYPE (name
), id
), NULL
);
249 if (!var
&& SSA_NAME_IDENTIFIER (name
))
250 SET_SSA_NAME_VAR_OR_IDENTIFIER (new_tree
, SSA_NAME_IDENTIFIER (name
));
251 insert_decl_map (id
, name
, new_tree
);
252 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
253 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
254 /* At least IPA points-to info can be directly transferred. */
255 if (id
->src_cfun
->gimple_df
256 && id
->src_cfun
->gimple_df
->ipa_pta
257 && (pi
= SSA_NAME_PTR_INFO (name
))
260 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
266 /* Do not set DEF_STMT yet as statement is not copied yet. We do that
268 new_tree
= remap_decl (var
, id
);
270 /* We might've substituted constant or another SSA_NAME for
273 Replace the SSA name representing RESULT_DECL by variable during
274 inlining: this saves us from need to introduce PHI node in a case
275 return value is just partly initialized. */
276 if ((TREE_CODE (new_tree
) == VAR_DECL
|| TREE_CODE (new_tree
) == PARM_DECL
)
277 && (!SSA_NAME_VAR (name
)
278 || TREE_CODE (SSA_NAME_VAR (name
)) != RESULT_DECL
279 || !id
->transform_return_to_modify
))
281 struct ptr_info_def
*pi
;
282 new_tree
= make_ssa_name (new_tree
, NULL
);
283 insert_decl_map (id
, name
, new_tree
);
284 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
285 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
286 /* At least IPA points-to info can be directly transferred. */
287 if (id
->src_cfun
->gimple_df
288 && id
->src_cfun
->gimple_df
->ipa_pta
289 && (pi
= SSA_NAME_PTR_INFO (name
))
292 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
295 if (SSA_NAME_IS_DEFAULT_DEF (name
))
297 /* By inlining function having uninitialized variable, we might
298 extend the lifetime (variable might get reused). This cause
299 ICE in the case we end up extending lifetime of SSA name across
300 abnormal edge, but also increase register pressure.
302 We simply initialize all uninitialized vars by 0 except
303 for case we are inlining to very first BB. We can avoid
304 this for all BBs that are not inside strongly connected
305 regions of the CFG, but this is expensive to test. */
307 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
)
308 && (!SSA_NAME_VAR (name
)
309 || TREE_CODE (SSA_NAME_VAR (name
)) != PARM_DECL
)
310 && (id
->entry_bb
!= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
),
312 || EDGE_COUNT (id
->entry_bb
->preds
) != 1))
314 gimple_stmt_iterator gsi
= gsi_last_bb (id
->entry_bb
);
316 tree zero
= build_zero_cst (TREE_TYPE (new_tree
));
318 init_stmt
= gimple_build_assign (new_tree
, zero
);
319 gsi_insert_after (&gsi
, init_stmt
, GSI_NEW_STMT
);
320 SSA_NAME_IS_DEFAULT_DEF (new_tree
) = 0;
324 SSA_NAME_DEF_STMT (new_tree
) = gimple_build_nop ();
325 set_ssa_default_def (cfun
, SSA_NAME_VAR (new_tree
), new_tree
);
330 insert_decl_map (id
, name
, new_tree
);
334 /* Remap DECL during the copying of the BLOCK tree for the function. */
337 remap_decl (tree decl
, copy_body_data
*id
)
341 /* We only remap local variables in the current function. */
343 /* See if we have remapped this declaration. */
345 n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
347 if (!n
&& processing_debug_stmt
)
349 processing_debug_stmt
= -1;
353 /* If we didn't already have an equivalent for this declaration,
357 /* Make a copy of the variable or label. */
358 tree t
= id
->copy_decl (decl
, id
);
360 /* Remember it, so that if we encounter this local entity again
361 we can reuse this copy. Do this early because remap_type may
362 need this decl for TYPE_STUB_DECL. */
363 insert_decl_map (id
, decl
, t
);
368 /* Remap types, if necessary. */
369 TREE_TYPE (t
) = remap_type (TREE_TYPE (t
), id
);
370 if (TREE_CODE (t
) == TYPE_DECL
)
371 DECL_ORIGINAL_TYPE (t
) = remap_type (DECL_ORIGINAL_TYPE (t
), id
);
373 /* Remap sizes as necessary. */
374 walk_tree (&DECL_SIZE (t
), copy_tree_body_r
, id
, NULL
);
375 walk_tree (&DECL_SIZE_UNIT (t
), copy_tree_body_r
, id
, NULL
);
377 /* If fields, do likewise for offset and qualifier. */
378 if (TREE_CODE (t
) == FIELD_DECL
)
380 walk_tree (&DECL_FIELD_OFFSET (t
), copy_tree_body_r
, id
, NULL
);
381 if (TREE_CODE (DECL_CONTEXT (t
)) == QUAL_UNION_TYPE
)
382 walk_tree (&DECL_QUALIFIER (t
), copy_tree_body_r
, id
, NULL
);
388 if (id
->do_not_unshare
)
391 return unshare_expr (*n
);
395 remap_type_1 (tree type
, copy_body_data
*id
)
399 /* We do need a copy. build and register it now. If this is a pointer or
400 reference type, remap the designated type and make a new pointer or
402 if (TREE_CODE (type
) == POINTER_TYPE
)
404 new_tree
= build_pointer_type_for_mode (remap_type (TREE_TYPE (type
), id
),
406 TYPE_REF_CAN_ALIAS_ALL (type
));
407 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
408 new_tree
= build_type_attribute_qual_variant (new_tree
,
409 TYPE_ATTRIBUTES (type
),
411 insert_decl_map (id
, type
, new_tree
);
414 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
416 new_tree
= build_reference_type_for_mode (remap_type (TREE_TYPE (type
), id
),
418 TYPE_REF_CAN_ALIAS_ALL (type
));
419 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
420 new_tree
= build_type_attribute_qual_variant (new_tree
,
421 TYPE_ATTRIBUTES (type
),
423 insert_decl_map (id
, type
, new_tree
);
427 new_tree
= copy_node (type
);
429 insert_decl_map (id
, type
, new_tree
);
431 /* This is a new type, not a copy of an old type. Need to reassociate
432 variants. We can handle everything except the main variant lazily. */
433 t
= TYPE_MAIN_VARIANT (type
);
436 t
= remap_type (t
, id
);
437 TYPE_MAIN_VARIANT (new_tree
) = t
;
438 TYPE_NEXT_VARIANT (new_tree
) = TYPE_NEXT_VARIANT (t
);
439 TYPE_NEXT_VARIANT (t
) = new_tree
;
443 TYPE_MAIN_VARIANT (new_tree
) = new_tree
;
444 TYPE_NEXT_VARIANT (new_tree
) = NULL
;
447 if (TYPE_STUB_DECL (type
))
448 TYPE_STUB_DECL (new_tree
) = remap_decl (TYPE_STUB_DECL (type
), id
);
450 /* Lazily create pointer and reference types. */
451 TYPE_POINTER_TO (new_tree
) = NULL
;
452 TYPE_REFERENCE_TO (new_tree
) = NULL
;
454 /* Copy all types that may contain references to local variables; be sure to
455 preserve sharing in between type and its main variant when possible. */
456 switch (TREE_CODE (new_tree
))
460 case FIXED_POINT_TYPE
:
463 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
465 gcc_checking_assert (TYPE_MIN_VALUE (type
) == TYPE_MIN_VALUE (TYPE_MAIN_VARIANT (type
)));
466 gcc_checking_assert (TYPE_MAX_VALUE (type
) == TYPE_MAX_VALUE (TYPE_MAIN_VARIANT (type
)));
468 TYPE_MIN_VALUE (new_tree
) = TYPE_MIN_VALUE (TYPE_MAIN_VARIANT (new_tree
));
469 TYPE_MAX_VALUE (new_tree
) = TYPE_MAX_VALUE (TYPE_MAIN_VARIANT (new_tree
));
473 t
= TYPE_MIN_VALUE (new_tree
);
474 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
475 walk_tree (&TYPE_MIN_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
477 t
= TYPE_MAX_VALUE (new_tree
);
478 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
479 walk_tree (&TYPE_MAX_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
484 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
485 && TREE_TYPE (type
) == TREE_TYPE (TYPE_MAIN_VARIANT (type
)))
486 TREE_TYPE (new_tree
) = TREE_TYPE (TYPE_MAIN_VARIANT (new_tree
));
488 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
489 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
490 && TYPE_ARG_TYPES (type
) == TYPE_ARG_TYPES (TYPE_MAIN_VARIANT (type
)))
491 TYPE_ARG_TYPES (new_tree
) = TYPE_ARG_TYPES (TYPE_MAIN_VARIANT (new_tree
));
493 walk_tree (&TYPE_ARG_TYPES (new_tree
), copy_tree_body_r
, id
, NULL
);
497 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
498 && TREE_TYPE (type
) == TREE_TYPE (TYPE_MAIN_VARIANT (type
)))
499 TREE_TYPE (new_tree
) = TREE_TYPE (TYPE_MAIN_VARIANT (new_tree
));
501 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
503 gcc_checking_assert (TYPE_DOMAIN (type
) == TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)));
504 TYPE_DOMAIN (new_tree
) = TYPE_DOMAIN (TYPE_MAIN_VARIANT (new_tree
));
507 TYPE_DOMAIN (new_tree
) = remap_type (TYPE_DOMAIN (new_tree
), id
);
512 case QUAL_UNION_TYPE
:
513 if (TYPE_MAIN_VARIANT (type
) != type
514 && TYPE_FIELDS (type
) == TYPE_FIELDS (TYPE_MAIN_VARIANT (type
)))
515 TYPE_FIELDS (new_tree
) = TYPE_FIELDS (TYPE_MAIN_VARIANT (new_tree
));
520 for (f
= TYPE_FIELDS (new_tree
); f
; f
= DECL_CHAIN (f
))
522 t
= remap_decl (f
, id
);
523 DECL_CONTEXT (t
) = new_tree
;
527 TYPE_FIELDS (new_tree
) = nreverse (nf
);
533 /* Shouldn't have been thought variable sized. */
537 /* All variants of type share the same size, so use the already remaped data. */
538 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
540 gcc_checking_assert (TYPE_SIZE (type
) == TYPE_SIZE (TYPE_MAIN_VARIANT (type
)));
541 gcc_checking_assert (TYPE_SIZE_UNIT (type
) == TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type
)));
543 TYPE_SIZE (new_tree
) = TYPE_SIZE (TYPE_MAIN_VARIANT (new_tree
));
544 TYPE_SIZE_UNIT (new_tree
) = TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (new_tree
));
548 walk_tree (&TYPE_SIZE (new_tree
), copy_tree_body_r
, id
, NULL
);
549 walk_tree (&TYPE_SIZE_UNIT (new_tree
), copy_tree_body_r
, id
, NULL
);
556 remap_type (tree type
, copy_body_data
*id
)
564 /* See if we have remapped this type. */
565 node
= (tree
*) pointer_map_contains (id
->decl_map
, type
);
569 /* The type only needs remapping if it's variably modified. */
570 if (! variably_modified_type_p (type
, id
->src_fn
))
572 insert_decl_map (id
, type
, type
);
576 id
->remapping_type_depth
++;
577 tmp
= remap_type_1 (type
, id
);
578 id
->remapping_type_depth
--;
583 /* Decide if DECL can be put into BLOCK_NONLOCAL_VARs. */
586 can_be_nonlocal (tree decl
, copy_body_data
*id
)
588 /* We can not duplicate function decls. */
589 if (TREE_CODE (decl
) == FUNCTION_DECL
)
592 /* Local static vars must be non-local or we get multiple declaration
594 if (TREE_CODE (decl
) == VAR_DECL
595 && !auto_var_in_fn_p (decl
, id
->src_fn
))
602 remap_decls (tree decls
, vec
<tree
, va_gc
> **nonlocalized_list
,
606 tree new_decls
= NULL_TREE
;
608 /* Remap its variables. */
609 for (old_var
= decls
; old_var
; old_var
= DECL_CHAIN (old_var
))
613 if (can_be_nonlocal (old_var
, id
))
615 /* We need to add this variable to the local decls as otherwise
616 nothing else will do so. */
617 if (TREE_CODE (old_var
) == VAR_DECL
618 && ! DECL_EXTERNAL (old_var
))
619 add_local_decl (cfun
, old_var
);
620 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
621 && !DECL_IGNORED_P (old_var
)
622 && nonlocalized_list
)
623 vec_safe_push (*nonlocalized_list
, old_var
);
627 /* Remap the variable. */
628 new_var
= remap_decl (old_var
, id
);
630 /* If we didn't remap this variable, we can't mess with its
631 TREE_CHAIN. If we remapped this variable to the return slot, it's
632 already declared somewhere else, so don't declare it here. */
634 if (new_var
== id
->retvar
)
638 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
639 && !DECL_IGNORED_P (old_var
)
640 && nonlocalized_list
)
641 vec_safe_push (*nonlocalized_list
, old_var
);
645 gcc_assert (DECL_P (new_var
));
646 DECL_CHAIN (new_var
) = new_decls
;
649 /* Also copy value-expressions. */
650 if (TREE_CODE (new_var
) == VAR_DECL
651 && DECL_HAS_VALUE_EXPR_P (new_var
))
653 tree tem
= DECL_VALUE_EXPR (new_var
);
654 bool old_regimplify
= id
->regimplify
;
655 id
->remapping_type_depth
++;
656 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
657 id
->remapping_type_depth
--;
658 id
->regimplify
= old_regimplify
;
659 SET_DECL_VALUE_EXPR (new_var
, tem
);
664 return nreverse (new_decls
);
667 /* Copy the BLOCK to contain remapped versions of the variables
668 therein. And hook the new block into the block-tree. */
671 remap_block (tree
*block
, copy_body_data
*id
)
676 /* Make the new block. */
678 new_block
= make_node (BLOCK
);
679 TREE_USED (new_block
) = TREE_USED (old_block
);
680 BLOCK_ABSTRACT_ORIGIN (new_block
) = old_block
;
681 BLOCK_SOURCE_LOCATION (new_block
) = BLOCK_SOURCE_LOCATION (old_block
);
682 BLOCK_NONLOCALIZED_VARS (new_block
)
683 = vec_safe_copy (BLOCK_NONLOCALIZED_VARS (old_block
));
686 /* Remap its variables. */
687 BLOCK_VARS (new_block
) = remap_decls (BLOCK_VARS (old_block
),
688 &BLOCK_NONLOCALIZED_VARS (new_block
),
691 if (id
->transform_lang_insert_block
)
692 id
->transform_lang_insert_block (new_block
);
694 /* Remember the remapped block. */
695 insert_decl_map (id
, old_block
, new_block
);
698 /* Copy the whole block tree and root it in id->block. */
700 remap_blocks (tree block
, copy_body_data
*id
)
703 tree new_tree
= block
;
708 remap_block (&new_tree
, id
);
709 gcc_assert (new_tree
!= block
);
710 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
711 prepend_lexical_block (new_tree
, remap_blocks (t
, id
));
712 /* Blocks are in arbitrary order, but make things slightly prettier and do
713 not swap order when producing a copy. */
714 BLOCK_SUBBLOCKS (new_tree
) = blocks_nreverse (BLOCK_SUBBLOCKS (new_tree
));
718 /* Remap the block tree rooted at BLOCK to nothing. */
720 remap_blocks_to_null (tree block
, copy_body_data
*id
)
723 insert_decl_map (id
, block
, NULL_TREE
);
724 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
725 remap_blocks_to_null (t
, id
);
729 copy_statement_list (tree
*tp
)
731 tree_stmt_iterator oi
, ni
;
734 new_tree
= alloc_stmt_list ();
735 ni
= tsi_start (new_tree
);
736 oi
= tsi_start (*tp
);
737 TREE_TYPE (new_tree
) = TREE_TYPE (*tp
);
740 for (; !tsi_end_p (oi
); tsi_next (&oi
))
742 tree stmt
= tsi_stmt (oi
);
743 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
744 /* This copy is not redundant; tsi_link_after will smash this
745 STATEMENT_LIST into the end of the one we're building, and we
746 don't want to do that with the original. */
747 copy_statement_list (&stmt
);
748 tsi_link_after (&ni
, stmt
, TSI_CONTINUE_LINKING
);
753 copy_bind_expr (tree
*tp
, int *walk_subtrees
, copy_body_data
*id
)
755 tree block
= BIND_EXPR_BLOCK (*tp
);
756 /* Copy (and replace) the statement. */
757 copy_tree_r (tp
, walk_subtrees
, NULL
);
760 remap_block (&block
, id
);
761 BIND_EXPR_BLOCK (*tp
) = block
;
764 if (BIND_EXPR_VARS (*tp
))
765 /* This will remap a lot of the same decls again, but this should be
767 BIND_EXPR_VARS (*tp
) = remap_decls (BIND_EXPR_VARS (*tp
), NULL
, id
);
771 /* Create a new gimple_seq by remapping all the statements in BODY
772 using the inlining information in ID. */
775 remap_gimple_seq (gimple_seq body
, copy_body_data
*id
)
777 gimple_stmt_iterator si
;
778 gimple_seq new_body
= NULL
;
780 for (si
= gsi_start (body
); !gsi_end_p (si
); gsi_next (&si
))
782 gimple new_stmt
= remap_gimple_stmt (gsi_stmt (si
), id
);
783 gimple_seq_add_stmt (&new_body
, new_stmt
);
790 /* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its
791 block using the mapping information in ID. */
794 copy_gimple_bind (gimple stmt
, copy_body_data
*id
)
797 tree new_block
, new_vars
;
798 gimple_seq body
, new_body
;
800 /* Copy the statement. Note that we purposely don't use copy_stmt
801 here because we need to remap statements as we copy. */
802 body
= gimple_bind_body (stmt
);
803 new_body
= remap_gimple_seq (body
, id
);
805 new_block
= gimple_bind_block (stmt
);
807 remap_block (&new_block
, id
);
809 /* This will remap a lot of the same decls again, but this should be
811 new_vars
= gimple_bind_vars (stmt
);
813 new_vars
= remap_decls (new_vars
, NULL
, id
);
815 new_bind
= gimple_build_bind (new_vars
, new_body
, new_block
);
820 /* Return true if DECL is a parameter or a SSA_NAME for a parameter. */
825 if (TREE_CODE (decl
) == SSA_NAME
)
827 decl
= SSA_NAME_VAR (decl
);
832 return (TREE_CODE (decl
) == PARM_DECL
);
835 /* Remap the GIMPLE operand pointed to by *TP. DATA is really a
836 'struct walk_stmt_info *'. DATA->INFO is a 'copy_body_data *'.
837 WALK_SUBTREES is used to indicate walk_gimple_op whether to keep
838 recursing into the children nodes of *TP. */
841 remap_gimple_op_r (tree
*tp
, int *walk_subtrees
, void *data
)
843 struct walk_stmt_info
*wi_p
= (struct walk_stmt_info
*) data
;
844 copy_body_data
*id
= (copy_body_data
*) wi_p
->info
;
845 tree fn
= id
->src_fn
;
847 if (TREE_CODE (*tp
) == SSA_NAME
)
849 *tp
= remap_ssa_name (*tp
, id
);
853 else if (auto_var_in_fn_p (*tp
, fn
))
855 /* Local variables and labels need to be replaced by equivalent
856 variables. We don't want to copy static variables; there's
857 only one of those, no matter how many times we inline the
858 containing function. Similarly for globals from an outer
862 /* Remap the declaration. */
863 new_decl
= remap_decl (*tp
, id
);
864 gcc_assert (new_decl
);
865 /* Replace this variable with the copy. */
866 STRIP_TYPE_NOPS (new_decl
);
867 /* ??? The C++ frontend uses void * pointer zero to initialize
868 any other type. This confuses the middle-end type verification.
869 As cloned bodies do not go through gimplification again the fixup
870 there doesn't trigger. */
871 if (TREE_CODE (new_decl
) == INTEGER_CST
872 && !useless_type_conversion_p (TREE_TYPE (*tp
), TREE_TYPE (new_decl
)))
873 new_decl
= fold_convert (TREE_TYPE (*tp
), new_decl
);
877 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
879 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
881 else if (TREE_CODE (*tp
) == LABEL_DECL
882 && (!DECL_CONTEXT (*tp
)
883 || decl_function_context (*tp
) == id
->src_fn
))
884 /* These may need to be remapped for EH handling. */
885 *tp
= remap_decl (*tp
, id
);
886 else if (TREE_CODE (*tp
) == FIELD_DECL
)
888 /* If the enclosing record type is variably_modified_type_p, the field
889 has already been remapped. Otherwise, it need not be. */
890 tree
*n
= (tree
*) pointer_map_contains (id
->decl_map
, *tp
);
895 else if (TYPE_P (*tp
))
896 /* Types may need remapping as well. */
897 *tp
= remap_type (*tp
, id
);
898 else if (CONSTANT_CLASS_P (*tp
))
900 /* If this is a constant, we have to copy the node iff the type
901 will be remapped. copy_tree_r will not copy a constant. */
902 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
904 if (new_type
== TREE_TYPE (*tp
))
907 else if (TREE_CODE (*tp
) == INTEGER_CST
)
908 *tp
= wide_int_to_tree (new_type
, *tp
);
911 *tp
= copy_node (*tp
);
912 TREE_TYPE (*tp
) = new_type
;
917 /* Otherwise, just copy the node. Note that copy_tree_r already
918 knows not to copy VAR_DECLs, etc., so this is safe. */
920 if (TREE_CODE (*tp
) == MEM_REF
)
922 /* We need to re-canonicalize MEM_REFs from inline substitutions
923 that can happen when a pointer argument is an ADDR_EXPR.
924 Recurse here manually to allow that. */
925 tree ptr
= TREE_OPERAND (*tp
, 0);
926 tree type
= remap_type (TREE_TYPE (*tp
), id
);
928 walk_tree (&ptr
, remap_gimple_op_r
, data
, NULL
);
929 *tp
= fold_build2 (MEM_REF
, type
, ptr
, TREE_OPERAND (*tp
, 1));
930 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
931 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
932 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
933 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
934 remapped a parameter as the property might be valid only
935 for the parameter itself. */
936 if (TREE_THIS_NOTRAP (old
)
937 && (!is_parm (TREE_OPERAND (old
, 0))
938 || (!id
->transform_parameter
&& is_parm (ptr
))))
939 TREE_THIS_NOTRAP (*tp
) = 1;
944 /* Here is the "usual case". Copy this tree node, and then
945 tweak some special cases. */
946 copy_tree_r (tp
, walk_subtrees
, NULL
);
948 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
949 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
951 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
953 /* The copied TARGET_EXPR has never been expanded, even if the
954 original node was expanded already. */
955 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
956 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
958 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
960 /* Variable substitution need not be simple. In particular,
961 the MEM_REF substitution above. Make sure that
962 TREE_CONSTANT and friends are up-to-date. */
963 int invariant
= is_gimple_min_invariant (*tp
);
964 walk_tree (&TREE_OPERAND (*tp
, 0), remap_gimple_op_r
, data
, NULL
);
965 recompute_tree_invariant_for_addr_expr (*tp
);
967 /* If this used to be invariant, but is not any longer,
968 then regimplification is probably needed. */
969 if (invariant
&& !is_gimple_min_invariant (*tp
))
970 id
->regimplify
= true;
976 /* Update the TREE_BLOCK for the cloned expr. */
979 tree new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
980 tree old_block
= TREE_BLOCK (*tp
);
984 n
= (tree
*) pointer_map_contains (id
->decl_map
,
989 TREE_SET_BLOCK (*tp
, new_block
);
992 /* Keep iterating. */
997 /* Called from copy_body_id via walk_tree. DATA is really a
998 `copy_body_data *'. */
1001 copy_tree_body_r (tree
*tp
, int *walk_subtrees
, void *data
)
1003 copy_body_data
*id
= (copy_body_data
*) data
;
1004 tree fn
= id
->src_fn
;
1007 /* Begin by recognizing trees that we'll completely rewrite for the
1008 inlining context. Our output for these trees is completely
1009 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1010 into an edge). Further down, we'll handle trees that get
1011 duplicated and/or tweaked. */
1013 /* When requested, RETURN_EXPRs should be transformed to just the
1014 contained MODIFY_EXPR. The branch semantics of the return will
1015 be handled elsewhere by manipulating the CFG rather than a statement. */
1016 if (TREE_CODE (*tp
) == RETURN_EXPR
&& id
->transform_return_to_modify
)
1018 tree assignment
= TREE_OPERAND (*tp
, 0);
1020 /* If we're returning something, just turn that into an
1021 assignment into the equivalent of the original RESULT_DECL.
1022 If the "assignment" is just the result decl, the result
1023 decl has already been set (e.g. a recent "foo (&result_decl,
1024 ...)"); just toss the entire RETURN_EXPR. */
1025 if (assignment
&& TREE_CODE (assignment
) == MODIFY_EXPR
)
1027 /* Replace the RETURN_EXPR with (a copy of) the
1028 MODIFY_EXPR hanging underneath. */
1029 *tp
= copy_node (assignment
);
1031 else /* Else the RETURN_EXPR returns no value. */
1034 return (tree
) (void *)1;
1037 else if (TREE_CODE (*tp
) == SSA_NAME
)
1039 *tp
= remap_ssa_name (*tp
, id
);
1044 /* Local variables and labels need to be replaced by equivalent
1045 variables. We don't want to copy static variables; there's only
1046 one of those, no matter how many times we inline the containing
1047 function. Similarly for globals from an outer function. */
1048 else if (auto_var_in_fn_p (*tp
, fn
))
1052 /* Remap the declaration. */
1053 new_decl
= remap_decl (*tp
, id
);
1054 gcc_assert (new_decl
);
1055 /* Replace this variable with the copy. */
1056 STRIP_TYPE_NOPS (new_decl
);
1060 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
1061 copy_statement_list (tp
);
1062 else if (TREE_CODE (*tp
) == SAVE_EXPR
1063 || TREE_CODE (*tp
) == TARGET_EXPR
)
1064 remap_save_expr (tp
, id
->decl_map
, walk_subtrees
);
1065 else if (TREE_CODE (*tp
) == LABEL_DECL
1066 && (! DECL_CONTEXT (*tp
)
1067 || decl_function_context (*tp
) == id
->src_fn
))
1068 /* These may need to be remapped for EH handling. */
1069 *tp
= remap_decl (*tp
, id
);
1070 else if (TREE_CODE (*tp
) == BIND_EXPR
)
1071 copy_bind_expr (tp
, walk_subtrees
, id
);
1072 /* Types may need remapping as well. */
1073 else if (TYPE_P (*tp
))
1074 *tp
= remap_type (*tp
, id
);
1076 /* If this is a constant, we have to copy the node iff the type will be
1077 remapped. copy_tree_r will not copy a constant. */
1078 else if (CONSTANT_CLASS_P (*tp
))
1080 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
1082 if (new_type
== TREE_TYPE (*tp
))
1085 else if (TREE_CODE (*tp
) == INTEGER_CST
)
1086 *tp
= wide_int_to_tree (new_type
, *tp
);
1089 *tp
= copy_node (*tp
);
1090 TREE_TYPE (*tp
) = new_type
;
1094 /* Otherwise, just copy the node. Note that copy_tree_r already
1095 knows not to copy VAR_DECLs, etc., so this is safe. */
1098 /* Here we handle trees that are not completely rewritten.
1099 First we detect some inlining-induced bogosities for
1101 if (TREE_CODE (*tp
) == MODIFY_EXPR
1102 && TREE_OPERAND (*tp
, 0) == TREE_OPERAND (*tp
, 1)
1103 && (auto_var_in_fn_p (TREE_OPERAND (*tp
, 0), fn
)))
1105 /* Some assignments VAR = VAR; don't generate any rtl code
1106 and thus don't count as variable modification. Avoid
1107 keeping bogosities like 0 = 0. */
1108 tree decl
= TREE_OPERAND (*tp
, 0), value
;
1111 n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
1115 STRIP_TYPE_NOPS (value
);
1116 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1118 *tp
= build_empty_stmt (EXPR_LOCATION (*tp
));
1119 return copy_tree_body_r (tp
, walk_subtrees
, data
);
1123 else if (TREE_CODE (*tp
) == INDIRECT_REF
)
1125 /* Get rid of *& from inline substitutions that can happen when a
1126 pointer argument is an ADDR_EXPR. */
1127 tree decl
= TREE_OPERAND (*tp
, 0);
1128 tree
*n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
1131 /* If we happen to get an ADDR_EXPR in n->value, strip
1132 it manually here as we'll eventually get ADDR_EXPRs
1133 which lie about their types pointed to. In this case
1134 build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
1135 but we absolutely rely on that. As fold_indirect_ref
1136 does other useful transformations, try that first, though. */
1137 tree type
= TREE_TYPE (*tp
);
1138 tree ptr
= id
->do_not_unshare
? *n
: unshare_expr (*n
);
1140 *tp
= gimple_fold_indirect_ref (ptr
);
1143 if (TREE_CODE (ptr
) == ADDR_EXPR
)
1146 = fold_indirect_ref_1 (EXPR_LOCATION (ptr
), type
, ptr
);
1147 /* ??? We should either assert here or build
1148 a VIEW_CONVERT_EXPR instead of blindly leaking
1149 incompatible types to our IL. */
1151 *tp
= TREE_OPERAND (ptr
, 0);
1155 *tp
= build1 (INDIRECT_REF
, type
, ptr
);
1156 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1157 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1158 TREE_READONLY (*tp
) = TREE_READONLY (old
);
1159 /* We cannot propagate the TREE_THIS_NOTRAP flag if we
1160 have remapped a parameter as the property might be
1161 valid only for the parameter itself. */
1162 if (TREE_THIS_NOTRAP (old
)
1163 && (!is_parm (TREE_OPERAND (old
, 0))
1164 || (!id
->transform_parameter
&& is_parm (ptr
))))
1165 TREE_THIS_NOTRAP (*tp
) = 1;
1172 else if (TREE_CODE (*tp
) == MEM_REF
)
1174 /* We need to re-canonicalize MEM_REFs from inline substitutions
1175 that can happen when a pointer argument is an ADDR_EXPR.
1176 Recurse here manually to allow that. */
1177 tree ptr
= TREE_OPERAND (*tp
, 0);
1178 tree type
= remap_type (TREE_TYPE (*tp
), id
);
1180 walk_tree (&ptr
, copy_tree_body_r
, data
, NULL
);
1181 *tp
= fold_build2 (MEM_REF
, type
, ptr
, TREE_OPERAND (*tp
, 1));
1182 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1183 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1184 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
1185 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
1186 remapped a parameter as the property might be valid only
1187 for the parameter itself. */
1188 if (TREE_THIS_NOTRAP (old
)
1189 && (!is_parm (TREE_OPERAND (old
, 0))
1190 || (!id
->transform_parameter
&& is_parm (ptr
))))
1191 TREE_THIS_NOTRAP (*tp
) = 1;
1196 /* Here is the "usual case". Copy this tree node, and then
1197 tweak some special cases. */
1198 copy_tree_r (tp
, walk_subtrees
, NULL
);
1200 /* If EXPR has block defined, map it to newly constructed block.
1201 When inlining we want EXPRs without block appear in the block
1202 of function call if we are not remapping a type. */
1205 new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
1206 if (TREE_BLOCK (*tp
))
1209 n
= (tree
*) pointer_map_contains (id
->decl_map
,
1214 TREE_SET_BLOCK (*tp
, new_block
);
1217 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
1218 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
1220 /* The copied TARGET_EXPR has never been expanded, even if the
1221 original node was expanded already. */
1222 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
1224 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
1225 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
1228 /* Variable substitution need not be simple. In particular, the
1229 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
1230 and friends are up-to-date. */
1231 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
1233 int invariant
= is_gimple_min_invariant (*tp
);
1234 walk_tree (&TREE_OPERAND (*tp
, 0), copy_tree_body_r
, id
, NULL
);
1236 /* Handle the case where we substituted an INDIRECT_REF
1237 into the operand of the ADDR_EXPR. */
1238 if (TREE_CODE (TREE_OPERAND (*tp
, 0)) == INDIRECT_REF
)
1239 *tp
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0);
1241 recompute_tree_invariant_for_addr_expr (*tp
);
1243 /* If this used to be invariant, but is not any longer,
1244 then regimplification is probably needed. */
1245 if (invariant
&& !is_gimple_min_invariant (*tp
))
1246 id
->regimplify
= true;
1252 /* Keep iterating. */
1256 /* Helper for remap_gimple_stmt. Given an EH region number for the
1257 source function, map that to the duplicate EH region number in
1258 the destination function. */
1261 remap_eh_region_nr (int old_nr
, copy_body_data
*id
)
1263 eh_region old_r
, new_r
;
1266 old_r
= get_eh_region_from_number_fn (id
->src_cfun
, old_nr
);
1267 slot
= pointer_map_contains (id
->eh_map
, old_r
);
1268 new_r
= (eh_region
) *slot
;
1270 return new_r
->index
;
1273 /* Similar, but operate on INTEGER_CSTs. */
1276 remap_eh_region_tree_nr (tree old_t_nr
, copy_body_data
*id
)
1280 old_nr
= tree_to_shwi (old_t_nr
);
1281 new_nr
= remap_eh_region_nr (old_nr
, id
);
1283 return build_int_cst (integer_type_node
, new_nr
);
1286 /* Helper for copy_bb. Remap statement STMT using the inlining
1287 information in ID. Return the new statement copy. */
1290 remap_gimple_stmt (gimple stmt
, copy_body_data
*id
)
1293 struct walk_stmt_info wi
;
1294 bool skip_first
= false;
1296 /* Begin by recognizing trees that we'll completely rewrite for the
1297 inlining context. Our output for these trees is completely
1298 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1299 into an edge). Further down, we'll handle trees that get
1300 duplicated and/or tweaked. */
1302 /* When requested, GIMPLE_RETURNs should be transformed to just the
1303 contained GIMPLE_ASSIGN. The branch semantics of the return will
1304 be handled elsewhere by manipulating the CFG rather than the
1306 if (gimple_code (stmt
) == GIMPLE_RETURN
&& id
->transform_return_to_modify
)
1308 tree retval
= gimple_return_retval (stmt
);
1310 /* If we're returning something, just turn that into an
1311 assignment into the equivalent of the original RESULT_DECL.
1312 If RETVAL is just the result decl, the result decl has
1313 already been set (e.g. a recent "foo (&result_decl, ...)");
1314 just toss the entire GIMPLE_RETURN. */
1316 && (TREE_CODE (retval
) != RESULT_DECL
1317 && (TREE_CODE (retval
) != SSA_NAME
1318 || ! SSA_NAME_VAR (retval
)
1319 || TREE_CODE (SSA_NAME_VAR (retval
)) != RESULT_DECL
)))
1321 copy
= gimple_build_assign (id
->do_not_unshare
1322 ? id
->retvar
: unshare_expr (id
->retvar
),
1324 /* id->retvar is already substituted. Skip it on later remapping. */
1328 return gimple_build_nop ();
1330 else if (gimple_has_substatements (stmt
))
1334 /* When cloning bodies from the C++ front end, we will be handed bodies
1335 in High GIMPLE form. Handle here all the High GIMPLE statements that
1336 have embedded statements. */
1337 switch (gimple_code (stmt
))
1340 copy
= copy_gimple_bind (stmt
, id
);
1344 s1
= remap_gimple_seq (gimple_catch_handler (stmt
), id
);
1345 copy
= gimple_build_catch (gimple_catch_types (stmt
), s1
);
1348 case GIMPLE_EH_FILTER
:
1349 s1
= remap_gimple_seq (gimple_eh_filter_failure (stmt
), id
);
1350 copy
= gimple_build_eh_filter (gimple_eh_filter_types (stmt
), s1
);
1354 s1
= remap_gimple_seq (gimple_try_eval (stmt
), id
);
1355 s2
= remap_gimple_seq (gimple_try_cleanup (stmt
), id
);
1356 copy
= gimple_build_try (s1
, s2
, gimple_try_kind (stmt
));
1359 case GIMPLE_WITH_CLEANUP_EXPR
:
1360 s1
= remap_gimple_seq (gimple_wce_cleanup (stmt
), id
);
1361 copy
= gimple_build_wce (s1
);
1364 case GIMPLE_OMP_PARALLEL
:
1365 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1366 copy
= gimple_build_omp_parallel
1368 gimple_omp_parallel_clauses (stmt
),
1369 gimple_omp_parallel_child_fn (stmt
),
1370 gimple_omp_parallel_data_arg (stmt
));
1373 case GIMPLE_OMP_TASK
:
1374 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1375 copy
= gimple_build_omp_task
1377 gimple_omp_task_clauses (stmt
),
1378 gimple_omp_task_child_fn (stmt
),
1379 gimple_omp_task_data_arg (stmt
),
1380 gimple_omp_task_copy_fn (stmt
),
1381 gimple_omp_task_arg_size (stmt
),
1382 gimple_omp_task_arg_align (stmt
));
1385 case GIMPLE_OMP_FOR
:
1386 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1387 s2
= remap_gimple_seq (gimple_omp_for_pre_body (stmt
), id
);
1388 copy
= gimple_build_omp_for (s1
, gimple_omp_for_kind (stmt
),
1389 gimple_omp_for_clauses (stmt
),
1390 gimple_omp_for_collapse (stmt
), s2
);
1393 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1395 gimple_omp_for_set_index (copy
, i
,
1396 gimple_omp_for_index (stmt
, i
));
1397 gimple_omp_for_set_initial (copy
, i
,
1398 gimple_omp_for_initial (stmt
, i
));
1399 gimple_omp_for_set_final (copy
, i
,
1400 gimple_omp_for_final (stmt
, i
));
1401 gimple_omp_for_set_incr (copy
, i
,
1402 gimple_omp_for_incr (stmt
, i
));
1403 gimple_omp_for_set_cond (copy
, i
,
1404 gimple_omp_for_cond (stmt
, i
));
1409 case GIMPLE_OMP_MASTER
:
1410 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1411 copy
= gimple_build_omp_master (s1
);
1414 case GIMPLE_OMP_TASKGROUP
:
1415 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1416 copy
= gimple_build_omp_taskgroup (s1
);
1419 case GIMPLE_OMP_ORDERED
:
1420 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1421 copy
= gimple_build_omp_ordered (s1
);
1424 case GIMPLE_OMP_SECTION
:
1425 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1426 copy
= gimple_build_omp_section (s1
);
1429 case GIMPLE_OMP_SECTIONS
:
1430 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1431 copy
= gimple_build_omp_sections
1432 (s1
, gimple_omp_sections_clauses (stmt
));
1435 case GIMPLE_OMP_SINGLE
:
1436 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1437 copy
= gimple_build_omp_single
1438 (s1
, gimple_omp_single_clauses (stmt
));
1441 case GIMPLE_OMP_TARGET
:
1442 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1443 copy
= gimple_build_omp_target
1444 (s1
, gimple_omp_target_kind (stmt
),
1445 gimple_omp_target_clauses (stmt
));
1448 case GIMPLE_OMP_TEAMS
:
1449 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1450 copy
= gimple_build_omp_teams
1451 (s1
, gimple_omp_teams_clauses (stmt
));
1454 case GIMPLE_OMP_CRITICAL
:
1455 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1457 = gimple_build_omp_critical (s1
, gimple_omp_critical_name (stmt
));
1460 case GIMPLE_TRANSACTION
:
1461 s1
= remap_gimple_seq (gimple_transaction_body (stmt
), id
);
1462 copy
= gimple_build_transaction (s1
, gimple_transaction_label (stmt
));
1463 gimple_transaction_set_subcode (copy
, gimple_transaction_subcode (stmt
));
1472 if (gimple_assign_copy_p (stmt
)
1473 && gimple_assign_lhs (stmt
) == gimple_assign_rhs1 (stmt
)
1474 && auto_var_in_fn_p (gimple_assign_lhs (stmt
), id
->src_fn
))
1476 /* Here we handle statements that are not completely rewritten.
1477 First we detect some inlining-induced bogosities for
1480 /* Some assignments VAR = VAR; don't generate any rtl code
1481 and thus don't count as variable modification. Avoid
1482 keeping bogosities like 0 = 0. */
1483 tree decl
= gimple_assign_lhs (stmt
), value
;
1486 n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
1490 STRIP_TYPE_NOPS (value
);
1491 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1492 return gimple_build_nop ();
1496 /* For *ptr_N ={v} {CLOBBER}, if ptr_N is SSA_NAME defined
1497 in a block that we aren't copying during tree_function_versioning,
1498 just drop the clobber stmt. */
1499 if (id
->blocks_to_copy
&& gimple_clobber_p (stmt
))
1501 tree lhs
= gimple_assign_lhs (stmt
);
1502 if (TREE_CODE (lhs
) == MEM_REF
1503 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == SSA_NAME
)
1505 gimple def_stmt
= SSA_NAME_DEF_STMT (TREE_OPERAND (lhs
, 0));
1506 if (gimple_bb (def_stmt
)
1507 && !bitmap_bit_p (id
->blocks_to_copy
,
1508 gimple_bb (def_stmt
)->index
))
1509 return gimple_build_nop ();
1513 if (gimple_debug_bind_p (stmt
))
1515 copy
= gimple_build_debug_bind (gimple_debug_bind_get_var (stmt
),
1516 gimple_debug_bind_get_value (stmt
),
1518 id
->debug_stmts
.safe_push (copy
);
1521 if (gimple_debug_source_bind_p (stmt
))
1523 copy
= gimple_build_debug_source_bind
1524 (gimple_debug_source_bind_get_var (stmt
),
1525 gimple_debug_source_bind_get_value (stmt
), stmt
);
1526 id
->debug_stmts
.safe_push (copy
);
1530 /* Create a new deep copy of the statement. */
1531 copy
= gimple_copy (stmt
);
1533 /* Clear flags that need revisiting. */
1534 if (is_gimple_call (copy
)
1535 && gimple_call_tail_p (copy
))
1536 gimple_call_set_tail (copy
, false);
1538 /* Remap the region numbers for __builtin_eh_{pointer,filter},
1539 RESX and EH_DISPATCH. */
1541 switch (gimple_code (copy
))
1545 tree r
, fndecl
= gimple_call_fndecl (copy
);
1546 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
1547 switch (DECL_FUNCTION_CODE (fndecl
))
1549 case BUILT_IN_EH_COPY_VALUES
:
1550 r
= gimple_call_arg (copy
, 1);
1551 r
= remap_eh_region_tree_nr (r
, id
);
1552 gimple_call_set_arg (copy
, 1, r
);
1555 case BUILT_IN_EH_POINTER
:
1556 case BUILT_IN_EH_FILTER
:
1557 r
= gimple_call_arg (copy
, 0);
1558 r
= remap_eh_region_tree_nr (r
, id
);
1559 gimple_call_set_arg (copy
, 0, r
);
1566 /* Reset alias info if we didn't apply measures to
1567 keep it valid over inlining by setting DECL_PT_UID. */
1568 if (!id
->src_cfun
->gimple_df
1569 || !id
->src_cfun
->gimple_df
->ipa_pta
)
1570 gimple_call_reset_alias_info (copy
);
1576 int r
= gimple_resx_region (copy
);
1577 r
= remap_eh_region_nr (r
, id
);
1578 gimple_resx_set_region (copy
, r
);
1582 case GIMPLE_EH_DISPATCH
:
1584 int r
= gimple_eh_dispatch_region (copy
);
1585 r
= remap_eh_region_nr (r
, id
);
1586 gimple_eh_dispatch_set_region (copy
, r
);
1595 /* If STMT has a block defined, map it to the newly constructed
1597 if (gimple_block (copy
))
1600 n
= (tree
*) pointer_map_contains (id
->decl_map
, gimple_block (copy
));
1602 gimple_set_block (copy
, *n
);
1605 if (gimple_debug_bind_p (copy
) || gimple_debug_source_bind_p (copy
))
1608 /* Remap all the operands in COPY. */
1609 memset (&wi
, 0, sizeof (wi
));
1612 walk_tree (gimple_op_ptr (copy
, 1), remap_gimple_op_r
, &wi
, NULL
);
1614 walk_gimple_op (copy
, remap_gimple_op_r
, &wi
);
1616 /* Clear the copied virtual operands. We are not remapping them here
1617 but are going to recreate them from scratch. */
1618 if (gimple_has_mem_ops (copy
))
1620 gimple_set_vdef (copy
, NULL_TREE
);
1621 gimple_set_vuse (copy
, NULL_TREE
);
1628 /* Copy basic block, scale profile accordingly. Edges will be taken care of
1632 copy_bb (copy_body_data
*id
, basic_block bb
, int frequency_scale
,
1633 gcov_type count_scale
)
1635 gimple_stmt_iterator gsi
, copy_gsi
, seq_gsi
;
1636 basic_block copy_basic_block
;
1641 /* Search for previous copied basic block. */
1644 prev
= prev
->prev_bb
;
1646 /* create_basic_block() will append every new block to
1647 basic_block_info automatically. */
1648 copy_basic_block
= create_basic_block (NULL
, (void *) 0,
1649 (basic_block
) prev
->aux
);
1650 copy_basic_block
->count
= apply_scale (bb
->count
, count_scale
);
1652 /* We are going to rebuild frequencies from scratch. These values
1653 have just small importance to drive canonicalize_loop_headers. */
1654 freq
= apply_scale ((gcov_type
)bb
->frequency
, frequency_scale
);
1656 /* We recompute frequencies after inlining, so this is quite safe. */
1657 if (freq
> BB_FREQ_MAX
)
1659 copy_basic_block
->frequency
= freq
;
1661 copy_gsi
= gsi_start_bb (copy_basic_block
);
1663 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1665 gimple stmt
= gsi_stmt (gsi
);
1666 gimple orig_stmt
= stmt
;
1668 id
->regimplify
= false;
1669 stmt
= remap_gimple_stmt (stmt
, id
);
1670 if (gimple_nop_p (stmt
))
1673 gimple_duplicate_stmt_histograms (cfun
, stmt
, id
->src_cfun
, orig_stmt
);
1676 /* With return slot optimization we can end up with
1677 non-gimple (foo *)&this->m, fix that here. */
1678 if (is_gimple_assign (stmt
)
1679 && gimple_assign_rhs_code (stmt
) == NOP_EXPR
1680 && !is_gimple_val (gimple_assign_rhs1 (stmt
)))
1683 new_rhs
= force_gimple_operand_gsi (&seq_gsi
,
1684 gimple_assign_rhs1 (stmt
),
1686 GSI_CONTINUE_LINKING
);
1687 gimple_assign_set_rhs1 (stmt
, new_rhs
);
1688 id
->regimplify
= false;
1691 gsi_insert_after (&seq_gsi
, stmt
, GSI_NEW_STMT
);
1694 gimple_regimplify_operands (stmt
, &seq_gsi
);
1696 /* If copy_basic_block has been empty at the start of this iteration,
1697 call gsi_start_bb again to get at the newly added statements. */
1698 if (gsi_end_p (copy_gsi
))
1699 copy_gsi
= gsi_start_bb (copy_basic_block
);
1701 gsi_next (©_gsi
);
1703 /* Process the new statement. The call to gimple_regimplify_operands
1704 possibly turned the statement into multiple statements, we
1705 need to process all of them. */
1710 stmt
= gsi_stmt (copy_gsi
);
1711 if (is_gimple_call (stmt
)
1712 && gimple_call_va_arg_pack_p (stmt
)
1715 /* __builtin_va_arg_pack () should be replaced by
1716 all arguments corresponding to ... in the caller. */
1720 size_t nargs
= gimple_call_num_args (id
->gimple_call
);
1723 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1726 /* Create the new array of arguments. */
1727 n
= nargs
+ gimple_call_num_args (stmt
);
1728 argarray
.create (n
);
1729 argarray
.safe_grow_cleared (n
);
1731 /* Copy all the arguments before '...' */
1732 memcpy (argarray
.address (),
1733 gimple_call_arg_ptr (stmt
, 0),
1734 gimple_call_num_args (stmt
) * sizeof (tree
));
1736 /* Append the arguments passed in '...' */
1737 memcpy (argarray
.address () + gimple_call_num_args (stmt
),
1738 gimple_call_arg_ptr (id
->gimple_call
, 0)
1739 + (gimple_call_num_args (id
->gimple_call
) - nargs
),
1740 nargs
* sizeof (tree
));
1742 new_call
= gimple_build_call_vec (gimple_call_fn (stmt
),
1745 argarray
.release ();
1747 /* Copy all GIMPLE_CALL flags, location and block, except
1748 GF_CALL_VA_ARG_PACK. */
1749 gimple_call_copy_flags (new_call
, stmt
);
1750 gimple_call_set_va_arg_pack (new_call
, false);
1751 gimple_set_location (new_call
, gimple_location (stmt
));
1752 gimple_set_block (new_call
, gimple_block (stmt
));
1753 gimple_call_set_lhs (new_call
, gimple_call_lhs (stmt
));
1755 gsi_replace (©_gsi
, new_call
, false);
1758 else if (is_gimple_call (stmt
)
1760 && (decl
= gimple_call_fndecl (stmt
))
1761 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
1762 && DECL_FUNCTION_CODE (decl
) == BUILT_IN_VA_ARG_PACK_LEN
)
1764 /* __builtin_va_arg_pack_len () should be replaced by
1765 the number of anonymous arguments. */
1766 size_t nargs
= gimple_call_num_args (id
->gimple_call
);
1770 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1773 count
= build_int_cst (integer_type_node
, nargs
);
1774 new_stmt
= gimple_build_assign (gimple_call_lhs (stmt
), count
);
1775 gsi_replace (©_gsi
, new_stmt
, false);
1779 /* Statements produced by inlining can be unfolded, especially
1780 when we constant propagated some operands. We can't fold
1781 them right now for two reasons:
1782 1) folding require SSA_NAME_DEF_STMTs to be correct
1783 2) we can't change function calls to builtins.
1784 So we just mark statement for later folding. We mark
1785 all new statements, instead just statements that has changed
1786 by some nontrivial substitution so even statements made
1787 foldable indirectly are updated. If this turns out to be
1788 expensive, copy_body can be told to watch for nontrivial
1790 if (id
->statements_to_fold
)
1791 id
->statements_to_fold
->add (stmt
);
1793 /* We're duplicating a CALL_EXPR. Find any corresponding
1794 callgraph edges and update or duplicate them. */
1795 if (is_gimple_call (stmt
))
1797 struct cgraph_edge
*edge
;
1799 switch (id
->transform_call_graph_edges
)
1801 case CB_CGE_DUPLICATE
:
1802 edge
= id
->src_node
->get_edge (orig_stmt
);
1805 int edge_freq
= edge
->frequency
;
1807 struct cgraph_edge
*old_edge
= edge
;
1808 edge
= cgraph_clone_edge (edge
, id
->dst_node
, stmt
,
1810 REG_BR_PROB_BASE
, CGRAPH_FREQ_BASE
,
1812 /* We could also just rescale the frequency, but
1813 doing so would introduce roundoff errors and make
1814 verifier unhappy. */
1815 new_freq
= compute_call_stmt_bb_frequency (id
->dst_node
->decl
,
1818 /* Speculative calls consist of two edges - direct and indirect.
1819 Duplicate the whole thing and distribute frequencies accordingly. */
1820 if (edge
->speculative
)
1822 struct cgraph_edge
*direct
, *indirect
;
1823 struct ipa_ref
*ref
;
1825 gcc_assert (!edge
->indirect_unknown_callee
);
1826 cgraph_speculative_call_info (old_edge
, direct
, indirect
, ref
);
1827 indirect
= cgraph_clone_edge (indirect
, id
->dst_node
, stmt
,
1829 REG_BR_PROB_BASE
, CGRAPH_FREQ_BASE
,
1831 if (old_edge
->frequency
+ indirect
->frequency
)
1833 edge
->frequency
= MIN (RDIV ((gcov_type
)new_freq
* old_edge
->frequency
,
1834 (old_edge
->frequency
+ indirect
->frequency
)),
1836 indirect
->frequency
= MIN (RDIV ((gcov_type
)new_freq
* indirect
->frequency
,
1837 (old_edge
->frequency
+ indirect
->frequency
)),
1840 id
->dst_node
->clone_reference (ref
, stmt
);
1844 edge
->frequency
= new_freq
;
1846 && profile_status_for_fn (cfun
) != PROFILE_ABSENT
1847 && (edge_freq
> edge
->frequency
+ 10
1848 || edge_freq
< edge
->frequency
- 10))
1850 fprintf (dump_file
, "Edge frequency estimated by "
1851 "cgraph %i diverge from inliner's estimate %i\n",
1855 "Orig bb: %i, orig bb freq %i, new bb freq %i\n",
1858 copy_basic_block
->frequency
);
1864 case CB_CGE_MOVE_CLONES
:
1865 id
->dst_node
->set_call_stmt_including_clones (orig_stmt
,
1867 edge
= id
->dst_node
->get_edge (stmt
);
1871 edge
= id
->dst_node
->get_edge (orig_stmt
);
1873 cgraph_set_call_stmt (edge
, stmt
);
1880 /* Constant propagation on argument done during inlining
1881 may create new direct call. Produce an edge for it. */
1883 || (edge
->indirect_inlining_edge
1884 && id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
))
1885 && id
->dst_node
->definition
1886 && (fn
= gimple_call_fndecl (stmt
)) != NULL
)
1888 struct cgraph_node
*dest
= cgraph_node::get (fn
);
1890 /* We have missing edge in the callgraph. This can happen
1891 when previous inlining turned an indirect call into a
1892 direct call by constant propagating arguments or we are
1893 producing dead clone (for further cloning). In all
1894 other cases we hit a bug (incorrect node sharing is the
1895 most common reason for missing edges). */
1896 gcc_assert (!dest
->definition
1897 || dest
->address_taken
1898 || !id
->src_node
->definition
1899 || !id
->dst_node
->definition
);
1900 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
)
1901 id
->dst_node
->create_edge_including_clones
1902 (dest
, orig_stmt
, stmt
, bb
->count
,
1903 compute_call_stmt_bb_frequency (id
->dst_node
->decl
,
1905 CIF_ORIGINALLY_INDIRECT_CALL
);
1907 id
->dst_node
->create_edge (dest
, stmt
,
1909 compute_call_stmt_bb_frequency
1910 (id
->dst_node
->decl
,
1911 copy_basic_block
))->inline_failed
1912 = CIF_ORIGINALLY_INDIRECT_CALL
;
1915 fprintf (dump_file
, "Created new direct edge to %s\n",
1920 notice_special_calls (stmt
);
1923 maybe_duplicate_eh_stmt_fn (cfun
, stmt
, id
->src_cfun
, orig_stmt
,
1924 id
->eh_map
, id
->eh_lp_nr
);
1926 if (gimple_in_ssa_p (cfun
) && !is_gimple_debug (stmt
))
1931 FOR_EACH_SSA_TREE_OPERAND (def
, stmt
, i
, SSA_OP_DEF
)
1932 if (TREE_CODE (def
) == SSA_NAME
)
1933 SSA_NAME_DEF_STMT (def
) = stmt
;
1936 gsi_next (©_gsi
);
1938 while (!gsi_end_p (copy_gsi
));
1940 copy_gsi
= gsi_last_bb (copy_basic_block
);
1943 return copy_basic_block
;
1946 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
1947 form is quite easy, since dominator relationship for old basic blocks does
1950 There is however exception where inlining might change dominator relation
1951 across EH edges from basic block within inlined functions destinating
1952 to landing pads in function we inline into.
1954 The function fills in PHI_RESULTs of such PHI nodes if they refer
1955 to gimple regs. Otherwise, the function mark PHI_RESULT of such
1956 PHI nodes for renaming. For non-gimple regs, renaming is safe: the
1957 EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
1958 set, and this means that there will be no overlapping live ranges
1959 for the underlying symbol.
1961 This might change in future if we allow redirecting of EH edges and
1962 we might want to change way build CFG pre-inlining to include
1963 all the possible edges then. */
1965 update_ssa_across_abnormal_edges (basic_block bb
, basic_block ret_bb
,
1966 bool can_throw
, bool nonlocal_goto
)
1971 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1973 || ((basic_block
)e
->dest
->aux
)->index
== ENTRY_BLOCK
)
1976 gimple_stmt_iterator si
;
1979 gcc_assert (e
->flags
& EDGE_EH
);
1982 gcc_assert (!(e
->flags
& EDGE_EH
));
1984 for (si
= gsi_start_phis (e
->dest
); !gsi_end_p (si
); gsi_next (&si
))
1988 phi
= gsi_stmt (si
);
1990 /* For abnormal goto/call edges the receiver can be the
1991 ENTRY_BLOCK. Do not assert this cannot happen. */
1993 gcc_assert ((e
->flags
& EDGE_EH
)
1994 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi
)));
1996 re
= find_edge (ret_bb
, e
->dest
);
1997 gcc_checking_assert (re
);
1998 gcc_assert ((re
->flags
& (EDGE_EH
| EDGE_ABNORMAL
))
1999 == (e
->flags
& (EDGE_EH
| EDGE_ABNORMAL
)));
2001 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, e
),
2002 USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, re
)));
2008 /* Copy edges from BB into its copy constructed earlier, scale profile
2009 accordingly. Edges will be taken care of later. Assume aux
2010 pointers to point to the copies of each BB. Return true if any
2011 debug stmts are left after a statement that must end the basic block. */
2014 copy_edges_for_bb (basic_block bb
, gcov_type count_scale
, basic_block ret_bb
,
2015 basic_block abnormal_goto_dest
)
2017 basic_block new_bb
= (basic_block
) bb
->aux
;
2020 gimple_stmt_iterator si
;
2022 bool need_debug_cleanup
= false;
2024 /* Use the indices from the original blocks to create edges for the
2026 FOR_EACH_EDGE (old_edge
, ei
, bb
->succs
)
2027 if (!(old_edge
->flags
& EDGE_EH
))
2031 flags
= old_edge
->flags
;
2033 /* Return edges do get a FALLTHRU flag when the get inlined. */
2034 if (old_edge
->dest
->index
== EXIT_BLOCK
2035 && !(old_edge
->flags
& (EDGE_TRUE_VALUE
|EDGE_FALSE_VALUE
|EDGE_FAKE
))
2036 && old_edge
->dest
->aux
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
2037 flags
|= EDGE_FALLTHRU
;
2038 new_edge
= make_edge (new_bb
, (basic_block
) old_edge
->dest
->aux
, flags
);
2039 new_edge
->count
= apply_scale (old_edge
->count
, count_scale
);
2040 new_edge
->probability
= old_edge
->probability
;
2043 if (bb
->index
== ENTRY_BLOCK
|| bb
->index
== EXIT_BLOCK
)
2046 for (si
= gsi_start_bb (new_bb
); !gsi_end_p (si
);)
2049 bool can_throw
, nonlocal_goto
;
2051 copy_stmt
= gsi_stmt (si
);
2052 if (!is_gimple_debug (copy_stmt
))
2053 update_stmt (copy_stmt
);
2055 /* Do this before the possible split_block. */
2058 /* If this tree could throw an exception, there are two
2059 cases where we need to add abnormal edge(s): the
2060 tree wasn't in a region and there is a "current
2061 region" in the caller; or the original tree had
2062 EH edges. In both cases split the block after the tree,
2063 and add abnormal edge(s) as needed; we need both
2064 those from the callee and the caller.
2065 We check whether the copy can throw, because the const
2066 propagation can change an INDIRECT_REF which throws
2067 into a COMPONENT_REF which doesn't. If the copy
2068 can throw, the original could also throw. */
2069 can_throw
= stmt_can_throw_internal (copy_stmt
);
2071 = (stmt_can_make_abnormal_goto (copy_stmt
)
2072 && !computed_goto_p (copy_stmt
));
2074 if (can_throw
|| nonlocal_goto
)
2076 if (!gsi_end_p (si
))
2078 while (!gsi_end_p (si
) && is_gimple_debug (gsi_stmt (si
)))
2081 need_debug_cleanup
= true;
2083 if (!gsi_end_p (si
))
2084 /* Note that bb's predecessor edges aren't necessarily
2085 right at this point; split_block doesn't care. */
2087 edge e
= split_block (new_bb
, copy_stmt
);
2090 new_bb
->aux
= e
->src
->aux
;
2091 si
= gsi_start_bb (new_bb
);
2095 if (gimple_code (copy_stmt
) == GIMPLE_EH_DISPATCH
)
2096 make_eh_dispatch_edges (copy_stmt
);
2098 make_eh_edges (copy_stmt
);
2100 /* If the call we inline cannot make abnormal goto do not add
2101 additional abnormal edges but only retain those already present
2102 in the original function body. */
2103 if (abnormal_goto_dest
== NULL
)
2104 nonlocal_goto
= false;
2107 basic_block copy_stmt_bb
= gimple_bb (copy_stmt
);
2109 if (get_abnormal_succ_dispatcher (copy_stmt_bb
))
2110 nonlocal_goto
= false;
2111 /* ABNORMAL_DISPATCHER (1) is for longjmp/setjmp or nonlocal gotos
2112 in OpenMP regions which aren't allowed to be left abnormally.
2113 So, no need to add abnormal edge in that case. */
2114 else if (is_gimple_call (copy_stmt
)
2115 && gimple_call_internal_p (copy_stmt
)
2116 && (gimple_call_internal_fn (copy_stmt
)
2117 == IFN_ABNORMAL_DISPATCHER
)
2118 && gimple_call_arg (copy_stmt
, 0) == boolean_true_node
)
2119 nonlocal_goto
= false;
2121 make_edge (copy_stmt_bb
, abnormal_goto_dest
, EDGE_ABNORMAL
);
2124 if ((can_throw
|| nonlocal_goto
)
2125 && gimple_in_ssa_p (cfun
))
2126 update_ssa_across_abnormal_edges (gimple_bb (copy_stmt
), ret_bb
,
2127 can_throw
, nonlocal_goto
);
2129 return need_debug_cleanup
;
2132 /* Copy the PHIs. All blocks and edges are copied, some blocks
2133 was possibly split and new outgoing EH edges inserted.
2134 BB points to the block of original function and AUX pointers links
2135 the original and newly copied blocks. */
2138 copy_phis_for_bb (basic_block bb
, copy_body_data
*id
)
2140 basic_block
const new_bb
= (basic_block
) bb
->aux
;
2143 gimple_stmt_iterator si
;
2145 bool inserted
= false;
2147 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
2152 phi
= gsi_stmt (si
);
2153 res
= PHI_RESULT (phi
);
2155 if (!virtual_operand_p (res
))
2157 walk_tree (&new_res
, copy_tree_body_r
, id
, NULL
);
2158 new_phi
= create_phi_node (new_res
, new_bb
);
2159 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2161 edge old_edge
= find_edge ((basic_block
) new_edge
->src
->aux
, bb
);
2167 /* When doing partial cloning, we allow PHIs on the entry block
2168 as long as all the arguments are the same. Find any input
2169 edge to see argument to copy. */
2171 FOR_EACH_EDGE (old_edge
, ei2
, bb
->preds
)
2172 if (!old_edge
->src
->aux
)
2175 arg
= PHI_ARG_DEF_FROM_EDGE (phi
, old_edge
);
2177 walk_tree (&new_arg
, copy_tree_body_r
, id
, NULL
);
2178 gcc_assert (new_arg
);
2179 /* With return slot optimization we can end up with
2180 non-gimple (foo *)&this->m, fix that here. */
2181 if (TREE_CODE (new_arg
) != SSA_NAME
2182 && TREE_CODE (new_arg
) != FUNCTION_DECL
2183 && !is_gimple_val (new_arg
))
2185 gimple_seq stmts
= NULL
;
2186 new_arg
= force_gimple_operand (new_arg
, &stmts
, true, NULL
);
2187 gsi_insert_seq_on_edge (new_edge
, stmts
);
2190 locus
= gimple_phi_arg_location_from_edge (phi
, old_edge
);
2191 if (LOCATION_BLOCK (locus
))
2194 n
= (tree
*) pointer_map_contains (id
->decl_map
,
2195 LOCATION_BLOCK (locus
));
2198 locus
= COMBINE_LOCATION_DATA (line_table
, locus
, *n
);
2200 locus
= LOCATION_LOCUS (locus
);
2203 locus
= LOCATION_LOCUS (locus
);
2205 add_phi_arg (new_phi
, new_arg
, new_edge
, locus
);
2210 /* Commit the delayed edge insertions. */
2212 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2213 gsi_commit_one_edge_insert (new_edge
, NULL
);
2217 /* Wrapper for remap_decl so it can be used as a callback. */
2220 remap_decl_1 (tree decl
, void *data
)
2222 return remap_decl (decl
, (copy_body_data
*) data
);
2225 /* Build struct function and associated datastructures for the new clone
2226 NEW_FNDECL to be build. CALLEE_FNDECL is the original. Function changes
2227 the cfun to the function of new_fndecl (and current_function_decl too). */
2230 initialize_cfun (tree new_fndecl
, tree callee_fndecl
, gcov_type count
)
2232 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2233 gcov_type count_scale
;
2235 if (!DECL_ARGUMENTS (new_fndecl
))
2236 DECL_ARGUMENTS (new_fndecl
) = DECL_ARGUMENTS (callee_fndecl
);
2237 if (!DECL_RESULT (new_fndecl
))
2238 DECL_RESULT (new_fndecl
) = DECL_RESULT (callee_fndecl
);
2240 if (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
)
2242 = GCOV_COMPUTE_SCALE (count
,
2243 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
);
2245 count_scale
= REG_BR_PROB_BASE
;
2247 /* Register specific tree functions. */
2248 gimple_register_cfg_hooks ();
2250 /* Get clean struct function. */
2251 push_struct_function (new_fndecl
);
2253 /* We will rebuild these, so just sanity check that they are empty. */
2254 gcc_assert (VALUE_HISTOGRAMS (cfun
) == NULL
);
2255 gcc_assert (cfun
->local_decls
== NULL
);
2256 gcc_assert (cfun
->cfg
== NULL
);
2257 gcc_assert (cfun
->decl
== new_fndecl
);
2259 /* Copy items we preserve during cloning. */
2260 cfun
->static_chain_decl
= src_cfun
->static_chain_decl
;
2261 cfun
->nonlocal_goto_save_area
= src_cfun
->nonlocal_goto_save_area
;
2262 cfun
->function_end_locus
= src_cfun
->function_end_locus
;
2263 cfun
->curr_properties
= src_cfun
->curr_properties
;
2264 cfun
->last_verified
= src_cfun
->last_verified
;
2265 cfun
->va_list_gpr_size
= src_cfun
->va_list_gpr_size
;
2266 cfun
->va_list_fpr_size
= src_cfun
->va_list_fpr_size
;
2267 cfun
->has_nonlocal_label
= src_cfun
->has_nonlocal_label
;
2268 cfun
->stdarg
= src_cfun
->stdarg
;
2269 cfun
->after_inlining
= src_cfun
->after_inlining
;
2270 cfun
->can_throw_non_call_exceptions
2271 = src_cfun
->can_throw_non_call_exceptions
;
2272 cfun
->can_delete_dead_exceptions
= src_cfun
->can_delete_dead_exceptions
;
2273 cfun
->returns_struct
= src_cfun
->returns_struct
;
2274 cfun
->returns_pcc_struct
= src_cfun
->returns_pcc_struct
;
2276 init_empty_tree_cfg ();
2278 profile_status_for_fn (cfun
) = profile_status_for_fn (src_cfun
);
2279 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
=
2280 (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
* count_scale
/
2282 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
2283 = ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->frequency
;
2284 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
=
2285 (EXIT_BLOCK_PTR_FOR_FN (src_cfun
)->count
* count_scale
/
2287 EXIT_BLOCK_PTR_FOR_FN (cfun
)->frequency
=
2288 EXIT_BLOCK_PTR_FOR_FN (src_cfun
)->frequency
;
2290 init_eh_for_function ();
2292 if (src_cfun
->gimple_df
)
2294 init_tree_ssa (cfun
);
2295 cfun
->gimple_df
->in_ssa_p
= true;
2296 init_ssa_operands (cfun
);
2300 /* Helper function for copy_cfg_body. Move debug stmts from the end
2301 of NEW_BB to the beginning of successor basic blocks when needed. If the
2302 successor has multiple predecessors, reset them, otherwise keep
2306 maybe_move_debug_stmts_to_successors (copy_body_data
*id
, basic_block new_bb
)
2310 gimple_stmt_iterator si
= gsi_last_nondebug_bb (new_bb
);
2313 || gsi_one_before_end_p (si
)
2314 || !(stmt_can_throw_internal (gsi_stmt (si
))
2315 || stmt_can_make_abnormal_goto (gsi_stmt (si
))))
2318 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
2320 gimple_stmt_iterator ssi
= gsi_last_bb (new_bb
);
2321 gimple_stmt_iterator dsi
= gsi_after_labels (e
->dest
);
2322 while (is_gimple_debug (gsi_stmt (ssi
)))
2324 gimple stmt
= gsi_stmt (ssi
), new_stmt
;
2328 /* For the last edge move the debug stmts instead of copying
2330 if (ei_one_before_end_p (ei
))
2334 if (!single_pred_p (e
->dest
) && gimple_debug_bind_p (stmt
))
2335 gimple_debug_bind_reset_value (stmt
);
2336 gsi_remove (&si
, false);
2337 gsi_insert_before (&dsi
, stmt
, GSI_SAME_STMT
);
2341 if (gimple_debug_bind_p (stmt
))
2343 var
= gimple_debug_bind_get_var (stmt
);
2344 if (single_pred_p (e
->dest
))
2346 value
= gimple_debug_bind_get_value (stmt
);
2347 value
= unshare_expr (value
);
2351 new_stmt
= gimple_build_debug_bind (var
, value
, stmt
);
2353 else if (gimple_debug_source_bind_p (stmt
))
2355 var
= gimple_debug_source_bind_get_var (stmt
);
2356 value
= gimple_debug_source_bind_get_value (stmt
);
2357 new_stmt
= gimple_build_debug_source_bind (var
, value
, stmt
);
2361 gsi_insert_before (&dsi
, new_stmt
, GSI_SAME_STMT
);
2362 id
->debug_stmts
.safe_push (new_stmt
);
2368 /* Make a copy of the sub-loops of SRC_PARENT and place them
2369 as siblings of DEST_PARENT. */
2372 copy_loops (copy_body_data
*id
,
2373 struct loop
*dest_parent
, struct loop
*src_parent
)
2375 struct loop
*src_loop
= src_parent
->inner
;
2378 if (!id
->blocks_to_copy
2379 || bitmap_bit_p (id
->blocks_to_copy
, src_loop
->header
->index
))
2381 struct loop
*dest_loop
= alloc_loop ();
2383 /* Assign the new loop its header and latch and associate
2384 those with the new loop. */
2385 if (src_loop
->header
!= NULL
)
2387 dest_loop
->header
= (basic_block
)src_loop
->header
->aux
;
2388 dest_loop
->header
->loop_father
= dest_loop
;
2390 if (src_loop
->latch
!= NULL
)
2392 dest_loop
->latch
= (basic_block
)src_loop
->latch
->aux
;
2393 dest_loop
->latch
->loop_father
= dest_loop
;
2396 /* Copy loop meta-data. */
2397 copy_loop_info (src_loop
, dest_loop
);
2399 /* Finally place it into the loop array and the loop tree. */
2400 place_new_loop (cfun
, dest_loop
);
2401 flow_loop_tree_node_add (dest_parent
, dest_loop
);
2403 dest_loop
->safelen
= src_loop
->safelen
;
2404 dest_loop
->dont_vectorize
= src_loop
->dont_vectorize
;
2405 if (src_loop
->force_vectorize
)
2407 dest_loop
->force_vectorize
= true;
2408 cfun
->has_force_vectorize_loops
= true;
2410 if (src_loop
->simduid
)
2412 dest_loop
->simduid
= remap_decl (src_loop
->simduid
, id
);
2413 cfun
->has_simduid_loops
= true;
2417 copy_loops (id
, dest_loop
, src_loop
);
2419 src_loop
= src_loop
->next
;
2423 /* Call cgraph_redirect_edge_call_stmt_to_callee on all calls in BB */
2426 redirect_all_calls (copy_body_data
* id
, basic_block bb
)
2428 gimple_stmt_iterator si
;
2429 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
2431 if (is_gimple_call (gsi_stmt (si
)))
2433 struct cgraph_edge
*edge
= id
->dst_node
->get_edge (gsi_stmt (si
));
2435 cgraph_redirect_edge_call_stmt_to_callee (edge
);
2440 /* Convert estimated frequencies into counts for NODE, scaling COUNT
2441 with each bb's frequency. Used when NODE has a 0-weight entry
2442 but we are about to inline it into a non-zero count call bb.
2443 See the comments for handle_missing_profiles() in predict.c for
2444 when this can happen for COMDATs. */
2447 freqs_to_counts (struct cgraph_node
*node
, gcov_type count
)
2452 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
2454 FOR_ALL_BB_FN(bb
, fn
)
2456 bb
->count
= apply_scale (count
,
2457 GCOV_COMPUTE_SCALE (bb
->frequency
, BB_FREQ_MAX
));
2458 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
2459 e
->count
= apply_probability (e
->src
->count
, e
->probability
);
2463 /* Make a copy of the body of FN so that it can be inserted inline in
2464 another function. Walks FN via CFG, returns new fndecl. */
2467 copy_cfg_body (copy_body_data
* id
, gcov_type count
, int frequency_scale
,
2468 basic_block entry_block_map
, basic_block exit_block_map
,
2469 basic_block new_entry
)
2471 tree callee_fndecl
= id
->src_fn
;
2472 /* Original cfun for the callee, doesn't change. */
2473 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2474 struct function
*cfun_to_copy
;
2476 tree new_fndecl
= NULL
;
2477 bool need_debug_cleanup
= false;
2478 gcov_type count_scale
;
2480 int incoming_frequency
= 0;
2481 gcov_type incoming_count
= 0;
2483 /* This can happen for COMDAT routines that end up with 0 counts
2484 despite being called (see the comments for handle_missing_profiles()
2485 in predict.c as to why). Apply counts to the blocks in the callee
2486 before inlining, using the guessed edge frequencies, so that we don't
2487 end up with a 0-count inline body which can confuse downstream
2488 optimizations such as function splitting. */
2489 if (!ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
&& count
)
2491 /* Apply the larger of the call bb count and the total incoming
2492 call edge count to the callee. */
2493 gcov_type in_count
= 0;
2494 struct cgraph_edge
*in_edge
;
2495 for (in_edge
= id
->src_node
->callers
; in_edge
;
2496 in_edge
= in_edge
->next_caller
)
2497 in_count
+= in_edge
->count
;
2498 freqs_to_counts (id
->src_node
, count
> in_count
? count
: in_count
);
2501 if (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
)
2503 = GCOV_COMPUTE_SCALE (count
,
2504 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
);
2506 count_scale
= REG_BR_PROB_BASE
;
2508 /* Register specific tree functions. */
2509 gimple_register_cfg_hooks ();
2511 /* If we are inlining just region of the function, make sure to connect
2512 new entry to ENTRY_BLOCK_PTR_FOR_FN (cfun). Since new entry can be
2513 part of loop, we must compute frequency and probability of
2514 ENTRY_BLOCK_PTR_FOR_FN (cfun) based on the frequencies and
2515 probabilities of edges incoming from nonduplicated region. */
2521 FOR_EACH_EDGE (e
, ei
, new_entry
->preds
)
2524 incoming_frequency
+= EDGE_FREQUENCY (e
);
2525 incoming_count
+= e
->count
;
2527 incoming_count
= apply_scale (incoming_count
, count_scale
);
2529 = apply_scale ((gcov_type
)incoming_frequency
, frequency_scale
);
2530 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= incoming_count
;
2531 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
= incoming_frequency
;
2534 /* Must have a CFG here at this point. */
2535 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN
2536 (DECL_STRUCT_FUNCTION (callee_fndecl
)));
2538 cfun_to_copy
= id
->src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2540 ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy
)->aux
= entry_block_map
;
2541 EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy
)->aux
= exit_block_map
;
2542 entry_block_map
->aux
= ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy
);
2543 exit_block_map
->aux
= EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy
);
2545 /* Duplicate any exception-handling regions. */
2547 id
->eh_map
= duplicate_eh_regions (cfun_to_copy
, NULL
, id
->eh_lp_nr
,
2550 /* Use aux pointers to map the original blocks to copy. */
2551 FOR_EACH_BB_FN (bb
, cfun_to_copy
)
2552 if (!id
->blocks_to_copy
|| bitmap_bit_p (id
->blocks_to_copy
, bb
->index
))
2554 basic_block new_bb
= copy_bb (id
, bb
, frequency_scale
, count_scale
);
2557 new_bb
->loop_father
= entry_block_map
->loop_father
;
2560 last
= last_basic_block_for_fn (cfun
);
2562 /* Now that we've duplicated the blocks, duplicate their edges. */
2563 basic_block abnormal_goto_dest
= NULL
;
2565 && stmt_can_make_abnormal_goto (id
->gimple_call
))
2567 gimple_stmt_iterator gsi
= gsi_for_stmt (id
->gimple_call
);
2569 bb
= gimple_bb (id
->gimple_call
);
2571 if (gsi_end_p (gsi
))
2572 abnormal_goto_dest
= get_abnormal_succ_dispatcher (bb
);
2574 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2575 if (!id
->blocks_to_copy
2576 || (bb
->index
> 0 && bitmap_bit_p (id
->blocks_to_copy
, bb
->index
)))
2577 need_debug_cleanup
|= copy_edges_for_bb (bb
, count_scale
, exit_block_map
,
2578 abnormal_goto_dest
);
2582 edge e
= make_edge (entry_block_map
, (basic_block
)new_entry
->aux
, EDGE_FALLTHRU
);
2583 e
->probability
= REG_BR_PROB_BASE
;
2584 e
->count
= incoming_count
;
2587 /* Duplicate the loop tree, if available and wanted. */
2588 if (loops_for_fn (src_cfun
) != NULL
2589 && current_loops
!= NULL
)
2591 copy_loops (id
, entry_block_map
->loop_father
,
2592 get_loop (src_cfun
, 0));
2593 /* Defer to cfgcleanup to update loop-father fields of basic-blocks. */
2594 loops_state_set (LOOPS_NEED_FIXUP
);
2597 /* If the loop tree in the source function needed fixup, mark the
2598 destination loop tree for fixup, too. */
2599 if (loops_for_fn (src_cfun
)->state
& LOOPS_NEED_FIXUP
)
2600 loops_state_set (LOOPS_NEED_FIXUP
);
2602 if (gimple_in_ssa_p (cfun
))
2603 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2604 if (!id
->blocks_to_copy
2605 || (bb
->index
> 0 && bitmap_bit_p (id
->blocks_to_copy
, bb
->index
)))
2606 copy_phis_for_bb (bb
, id
);
2608 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2611 if (need_debug_cleanup
2612 && bb
->index
!= ENTRY_BLOCK
2613 && bb
->index
!= EXIT_BLOCK
)
2614 maybe_move_debug_stmts_to_successors (id
, (basic_block
) bb
->aux
);
2615 /* Update call edge destinations. This can not be done before loop
2616 info is updated, because we may split basic blocks. */
2617 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
)
2618 redirect_all_calls (id
, (basic_block
)bb
->aux
);
2619 ((basic_block
)bb
->aux
)->aux
= NULL
;
2623 /* Zero out AUX fields of newly created block during EH edge
2625 for (; last
< last_basic_block_for_fn (cfun
); last
++)
2627 if (need_debug_cleanup
)
2628 maybe_move_debug_stmts_to_successors (id
,
2629 BASIC_BLOCK_FOR_FN (cfun
, last
));
2630 BASIC_BLOCK_FOR_FN (cfun
, last
)->aux
= NULL
;
2631 /* Update call edge destinations. This can not be done before loop
2632 info is updated, because we may split basic blocks. */
2633 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
)
2634 redirect_all_calls (id
, BASIC_BLOCK_FOR_FN (cfun
, last
));
2636 entry_block_map
->aux
= NULL
;
2637 exit_block_map
->aux
= NULL
;
2641 pointer_map_destroy (id
->eh_map
);
2648 /* Copy the debug STMT using ID. We deal with these statements in a
2649 special way: if any variable in their VALUE expression wasn't
2650 remapped yet, we won't remap it, because that would get decl uids
2651 out of sync, causing codegen differences between -g and -g0. If
2652 this arises, we drop the VALUE expression altogether. */
2655 copy_debug_stmt (gimple stmt
, copy_body_data
*id
)
2658 struct walk_stmt_info wi
;
2660 if (gimple_block (stmt
))
2662 n
= (tree
*) pointer_map_contains (id
->decl_map
, gimple_block (stmt
));
2663 gimple_set_block (stmt
, n
? *n
: id
->block
);
2666 /* Remap all the operands in COPY. */
2667 memset (&wi
, 0, sizeof (wi
));
2670 processing_debug_stmt
= 1;
2672 if (gimple_debug_source_bind_p (stmt
))
2673 t
= gimple_debug_source_bind_get_var (stmt
);
2675 t
= gimple_debug_bind_get_var (stmt
);
2677 if (TREE_CODE (t
) == PARM_DECL
&& id
->debug_map
2678 && (n
= (tree
*) pointer_map_contains (id
->debug_map
, t
)))
2680 gcc_assert (TREE_CODE (*n
) == VAR_DECL
);
2683 else if (TREE_CODE (t
) == VAR_DECL
2684 && !is_global_var (t
)
2685 && !pointer_map_contains (id
->decl_map
, t
))
2686 /* T is a non-localized variable. */;
2688 walk_tree (&t
, remap_gimple_op_r
, &wi
, NULL
);
2690 if (gimple_debug_bind_p (stmt
))
2692 gimple_debug_bind_set_var (stmt
, t
);
2694 if (gimple_debug_bind_has_value_p (stmt
))
2695 walk_tree (gimple_debug_bind_get_value_ptr (stmt
),
2696 remap_gimple_op_r
, &wi
, NULL
);
2698 /* Punt if any decl couldn't be remapped. */
2699 if (processing_debug_stmt
< 0)
2700 gimple_debug_bind_reset_value (stmt
);
2702 else if (gimple_debug_source_bind_p (stmt
))
2704 gimple_debug_source_bind_set_var (stmt
, t
);
2705 walk_tree (gimple_debug_source_bind_get_value_ptr (stmt
),
2706 remap_gimple_op_r
, &wi
, NULL
);
2707 /* When inlining and source bind refers to one of the optimized
2708 away parameters, change the source bind into normal debug bind
2709 referring to the corresponding DEBUG_EXPR_DECL that should have
2710 been bound before the call stmt. */
2711 t
= gimple_debug_source_bind_get_value (stmt
);
2713 && TREE_CODE (t
) == PARM_DECL
2716 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (id
->src_fn
);
2718 if (debug_args
!= NULL
)
2720 for (i
= 0; i
< vec_safe_length (*debug_args
); i
+= 2)
2721 if ((**debug_args
)[i
] == DECL_ORIGIN (t
)
2722 && TREE_CODE ((**debug_args
)[i
+ 1]) == DEBUG_EXPR_DECL
)
2724 t
= (**debug_args
)[i
+ 1];
2725 stmt
->subcode
= GIMPLE_DEBUG_BIND
;
2726 gimple_debug_bind_set_value (stmt
, t
);
2733 processing_debug_stmt
= 0;
2738 /* Process deferred debug stmts. In order to give values better odds
2739 of being successfully remapped, we delay the processing of debug
2740 stmts until all other stmts that might require remapping are
2744 copy_debug_stmts (copy_body_data
*id
)
2749 if (!id
->debug_stmts
.exists ())
2752 FOR_EACH_VEC_ELT (id
->debug_stmts
, i
, stmt
)
2753 copy_debug_stmt (stmt
, id
);
2755 id
->debug_stmts
.release ();
2758 /* Make a copy of the body of SRC_FN so that it can be inserted inline in
2759 another function. */
2762 copy_tree_body (copy_body_data
*id
)
2764 tree fndecl
= id
->src_fn
;
2765 tree body
= DECL_SAVED_TREE (fndecl
);
2767 walk_tree (&body
, copy_tree_body_r
, id
, NULL
);
2772 /* Make a copy of the body of FN so that it can be inserted inline in
2773 another function. */
2776 copy_body (copy_body_data
*id
, gcov_type count
, int frequency_scale
,
2777 basic_block entry_block_map
, basic_block exit_block_map
,
2778 basic_block new_entry
)
2780 tree fndecl
= id
->src_fn
;
2783 /* If this body has a CFG, walk CFG and copy. */
2784 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (fndecl
)));
2785 body
= copy_cfg_body (id
, count
, frequency_scale
, entry_block_map
, exit_block_map
,
2787 copy_debug_stmts (id
);
2792 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
2793 defined in function FN, or of a data member thereof. */
2796 self_inlining_addr_expr (tree value
, tree fn
)
2800 if (TREE_CODE (value
) != ADDR_EXPR
)
2803 var
= get_base_address (TREE_OPERAND (value
, 0));
2805 return var
&& auto_var_in_fn_p (var
, fn
);
2808 /* Append to BB a debug annotation that binds VAR to VALUE, inheriting
2809 lexical block and line number information from base_stmt, if given,
2810 or from the last stmt of the block otherwise. */
2813 insert_init_debug_bind (copy_body_data
*id
,
2814 basic_block bb
, tree var
, tree value
,
2818 gimple_stmt_iterator gsi
;
2821 if (!gimple_in_ssa_p (id
->src_cfun
))
2824 if (!MAY_HAVE_DEBUG_STMTS
)
2827 tracked_var
= target_for_debug_bind (var
);
2833 gsi
= gsi_last_bb (bb
);
2834 if (!base_stmt
&& !gsi_end_p (gsi
))
2835 base_stmt
= gsi_stmt (gsi
);
2838 note
= gimple_build_debug_bind (tracked_var
, value
, base_stmt
);
2842 if (!gsi_end_p (gsi
))
2843 gsi_insert_after (&gsi
, note
, GSI_SAME_STMT
);
2845 gsi_insert_before (&gsi
, note
, GSI_SAME_STMT
);
2852 insert_init_stmt (copy_body_data
*id
, basic_block bb
, gimple init_stmt
)
2854 /* If VAR represents a zero-sized variable, it's possible that the
2855 assignment statement may result in no gimple statements. */
2858 gimple_stmt_iterator si
= gsi_last_bb (bb
);
2860 /* We can end up with init statements that store to a non-register
2861 from a rhs with a conversion. Handle that here by forcing the
2862 rhs into a temporary. gimple_regimplify_operands is not
2863 prepared to do this for us. */
2864 if (!is_gimple_debug (init_stmt
)
2865 && !is_gimple_reg (gimple_assign_lhs (init_stmt
))
2866 && is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (init_stmt
)))
2867 && gimple_assign_rhs_class (init_stmt
) == GIMPLE_UNARY_RHS
)
2869 tree rhs
= build1 (gimple_assign_rhs_code (init_stmt
),
2870 gimple_expr_type (init_stmt
),
2871 gimple_assign_rhs1 (init_stmt
));
2872 rhs
= force_gimple_operand_gsi (&si
, rhs
, true, NULL_TREE
, false,
2874 gimple_assign_set_rhs_code (init_stmt
, TREE_CODE (rhs
));
2875 gimple_assign_set_rhs1 (init_stmt
, rhs
);
2877 gsi_insert_after (&si
, init_stmt
, GSI_NEW_STMT
);
2878 gimple_regimplify_operands (init_stmt
, &si
);
2880 if (!is_gimple_debug (init_stmt
) && MAY_HAVE_DEBUG_STMTS
)
2882 tree def
= gimple_assign_lhs (init_stmt
);
2883 insert_init_debug_bind (id
, bb
, def
, def
, init_stmt
);
2888 /* Initialize parameter P with VALUE. If needed, produce init statement
2889 at the end of BB. When BB is NULL, we return init statement to be
2892 setup_one_parameter (copy_body_data
*id
, tree p
, tree value
, tree fn
,
2893 basic_block bb
, tree
*vars
)
2895 gimple init_stmt
= NULL
;
2898 tree def
= (gimple_in_ssa_p (cfun
)
2899 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
2902 && value
!= error_mark_node
2903 && !useless_type_conversion_p (TREE_TYPE (p
), TREE_TYPE (value
)))
2905 /* If we can match up types by promotion/demotion do so. */
2906 if (fold_convertible_p (TREE_TYPE (p
), value
))
2907 rhs
= fold_convert (TREE_TYPE (p
), value
);
2910 /* ??? For valid programs we should not end up here.
2911 Still if we end up with truly mismatched types here, fall back
2912 to using a VIEW_CONVERT_EXPR or a literal zero to not leak invalid
2913 GIMPLE to the following passes. */
2914 if (!is_gimple_reg_type (TREE_TYPE (value
))
2915 || TYPE_SIZE (TREE_TYPE (p
)) == TYPE_SIZE (TREE_TYPE (value
)))
2916 rhs
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (p
), value
);
2918 rhs
= build_zero_cst (TREE_TYPE (p
));
2922 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
2923 here since the type of this decl must be visible to the calling
2925 var
= copy_decl_to_var (p
, id
);
2927 /* Declare this new variable. */
2928 DECL_CHAIN (var
) = *vars
;
2931 /* Make gimplifier happy about this variable. */
2932 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
2934 /* If the parameter is never assigned to, has no SSA_NAMEs created,
2935 we would not need to create a new variable here at all, if it
2936 weren't for debug info. Still, we can just use the argument
2938 if (TREE_READONLY (p
)
2939 && !TREE_ADDRESSABLE (p
)
2940 && value
&& !TREE_SIDE_EFFECTS (value
)
2943 /* We may produce non-gimple trees by adding NOPs or introduce
2944 invalid sharing when operand is not really constant.
2945 It is not big deal to prohibit constant propagation here as
2946 we will constant propagate in DOM1 pass anyway. */
2947 if (is_gimple_min_invariant (value
)
2948 && useless_type_conversion_p (TREE_TYPE (p
),
2950 /* We have to be very careful about ADDR_EXPR. Make sure
2951 the base variable isn't a local variable of the inlined
2952 function, e.g., when doing recursive inlining, direct or
2953 mutually-recursive or whatever, which is why we don't
2954 just test whether fn == current_function_decl. */
2955 && ! self_inlining_addr_expr (value
, fn
))
2957 insert_decl_map (id
, p
, value
);
2958 insert_debug_decl_map (id
, p
, var
);
2959 return insert_init_debug_bind (id
, bb
, var
, value
, NULL
);
2963 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
2964 that way, when the PARM_DECL is encountered, it will be
2965 automatically replaced by the VAR_DECL. */
2966 insert_decl_map (id
, p
, var
);
2968 /* Even if P was TREE_READONLY, the new VAR should not be.
2969 In the original code, we would have constructed a
2970 temporary, and then the function body would have never
2971 changed the value of P. However, now, we will be
2972 constructing VAR directly. The constructor body may
2973 change its value multiple times as it is being
2974 constructed. Therefore, it must not be TREE_READONLY;
2975 the back-end assumes that TREE_READONLY variable is
2976 assigned to only once. */
2977 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p
)))
2978 TREE_READONLY (var
) = 0;
2980 /* If there is no setup required and we are in SSA, take the easy route
2981 replacing all SSA names representing the function parameter by the
2982 SSA name passed to function.
2984 We need to construct map for the variable anyway as it might be used
2985 in different SSA names when parameter is set in function.
2987 Do replacement at -O0 for const arguments replaced by constant.
2988 This is important for builtin_constant_p and other construct requiring
2989 constant argument to be visible in inlined function body. */
2990 if (gimple_in_ssa_p (cfun
) && rhs
&& def
&& is_gimple_reg (p
)
2992 || (TREE_READONLY (p
)
2993 && is_gimple_min_invariant (rhs
)))
2994 && (TREE_CODE (rhs
) == SSA_NAME
2995 || is_gimple_min_invariant (rhs
))
2996 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
2998 insert_decl_map (id
, def
, rhs
);
2999 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3002 /* If the value of argument is never used, don't care about initializing
3004 if (optimize
&& gimple_in_ssa_p (cfun
) && !def
&& is_gimple_reg (p
))
3006 gcc_assert (!value
|| !TREE_SIDE_EFFECTS (value
));
3007 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3010 /* Initialize this VAR_DECL from the equivalent argument. Convert
3011 the argument to the proper type in case it was promoted. */
3014 if (rhs
== error_mark_node
)
3016 insert_decl_map (id
, p
, var
);
3017 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3020 STRIP_USELESS_TYPE_CONVERSION (rhs
);
3022 /* If we are in SSA form properly remap the default definition
3023 or assign to a dummy SSA name if the parameter is unused and
3024 we are not optimizing. */
3025 if (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
))
3029 def
= remap_ssa_name (def
, id
);
3030 init_stmt
= gimple_build_assign (def
, rhs
);
3031 SSA_NAME_IS_DEFAULT_DEF (def
) = 0;
3032 set_ssa_default_def (cfun
, var
, NULL
);
3036 def
= make_ssa_name (var
, NULL
);
3037 init_stmt
= gimple_build_assign (def
, rhs
);
3041 init_stmt
= gimple_build_assign (var
, rhs
);
3043 if (bb
&& init_stmt
)
3044 insert_init_stmt (id
, bb
, init_stmt
);
3049 /* Generate code to initialize the parameters of the function at the
3050 top of the stack in ID from the GIMPLE_CALL STMT. */
3053 initialize_inlined_parameters (copy_body_data
*id
, gimple stmt
,
3054 tree fn
, basic_block bb
)
3059 tree vars
= NULL_TREE
;
3060 tree static_chain
= gimple_call_chain (stmt
);
3062 /* Figure out what the parameters are. */
3063 parms
= DECL_ARGUMENTS (fn
);
3065 /* Loop through the parameter declarations, replacing each with an
3066 equivalent VAR_DECL, appropriately initialized. */
3067 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
3070 val
= i
< gimple_call_num_args (stmt
) ? gimple_call_arg (stmt
, i
) : NULL
;
3071 setup_one_parameter (id
, p
, val
, fn
, bb
, &vars
);
3073 /* After remapping parameters remap their types. This has to be done
3074 in a second loop over all parameters to appropriately remap
3075 variable sized arrays when the size is specified in a
3076 parameter following the array. */
3077 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
3079 tree
*varp
= (tree
*) pointer_map_contains (id
->decl_map
, p
);
3081 && TREE_CODE (*varp
) == VAR_DECL
)
3083 tree def
= (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
)
3084 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
3086 TREE_TYPE (var
) = remap_type (TREE_TYPE (var
), id
);
3087 /* Also remap the default definition if it was remapped
3088 to the default definition of the parameter replacement
3089 by the parameter setup. */
3092 tree
*defp
= (tree
*) pointer_map_contains (id
->decl_map
, def
);
3094 && TREE_CODE (*defp
) == SSA_NAME
3095 && SSA_NAME_VAR (*defp
) == var
)
3096 TREE_TYPE (*defp
) = TREE_TYPE (var
);
3101 /* Initialize the static chain. */
3102 p
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
3103 gcc_assert (fn
!= current_function_decl
);
3106 /* No static chain? Seems like a bug in tree-nested.c. */
3107 gcc_assert (static_chain
);
3109 setup_one_parameter (id
, p
, static_chain
, fn
, bb
, &vars
);
3112 declare_inline_vars (id
->block
, vars
);
3116 /* Declare a return variable to replace the RESULT_DECL for the
3117 function we are calling. An appropriate DECL_STMT is returned.
3118 The USE_STMT is filled to contain a use of the declaration to
3119 indicate the return value of the function.
3121 RETURN_SLOT, if non-null is place where to store the result. It
3122 is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null,
3123 was the LHS of the MODIFY_EXPR to which this call is the RHS.
3125 The return value is a (possibly null) value that holds the result
3126 as seen by the caller. */
3129 declare_return_variable (copy_body_data
*id
, tree return_slot
, tree modify_dest
,
3130 basic_block entry_bb
)
3132 tree callee
= id
->src_fn
;
3133 tree result
= DECL_RESULT (callee
);
3134 tree callee_type
= TREE_TYPE (result
);
3138 /* Handle type-mismatches in the function declaration return type
3139 vs. the call expression. */
3141 caller_type
= TREE_TYPE (modify_dest
);
3143 caller_type
= TREE_TYPE (TREE_TYPE (callee
));
3145 /* We don't need to do anything for functions that don't return anything. */
3146 if (VOID_TYPE_P (callee_type
))
3149 /* If there was a return slot, then the return value is the
3150 dereferenced address of that object. */
3153 /* The front end shouldn't have used both return_slot and
3154 a modify expression. */
3155 gcc_assert (!modify_dest
);
3156 if (DECL_BY_REFERENCE (result
))
3158 tree return_slot_addr
= build_fold_addr_expr (return_slot
);
3159 STRIP_USELESS_TYPE_CONVERSION (return_slot_addr
);
3161 /* We are going to construct *&return_slot and we can't do that
3162 for variables believed to be not addressable.
3164 FIXME: This check possibly can match, because values returned
3165 via return slot optimization are not believed to have address
3166 taken by alias analysis. */
3167 gcc_assert (TREE_CODE (return_slot
) != SSA_NAME
);
3168 var
= return_slot_addr
;
3173 gcc_assert (TREE_CODE (var
) != SSA_NAME
);
3174 if (TREE_ADDRESSABLE (result
))
3175 mark_addressable (var
);
3177 if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
3178 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
3179 && !DECL_GIMPLE_REG_P (result
)
3181 DECL_GIMPLE_REG_P (var
) = 0;
3186 /* All types requiring non-trivial constructors should have been handled. */
3187 gcc_assert (!TREE_ADDRESSABLE (callee_type
));
3189 /* Attempt to avoid creating a new temporary variable. */
3191 && TREE_CODE (modify_dest
) != SSA_NAME
)
3193 bool use_it
= false;
3195 /* We can't use MODIFY_DEST if there's type promotion involved. */
3196 if (!useless_type_conversion_p (callee_type
, caller_type
))
3199 /* ??? If we're assigning to a variable sized type, then we must
3200 reuse the destination variable, because we've no good way to
3201 create variable sized temporaries at this point. */
3202 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type
)) != INTEGER_CST
)
3205 /* If the callee cannot possibly modify MODIFY_DEST, then we can
3206 reuse it as the result of the call directly. Don't do this if
3207 it would promote MODIFY_DEST to addressable. */
3208 else if (TREE_ADDRESSABLE (result
))
3212 tree base_m
= get_base_address (modify_dest
);
3214 /* If the base isn't a decl, then it's a pointer, and we don't
3215 know where that's going to go. */
3216 if (!DECL_P (base_m
))
3218 else if (is_global_var (base_m
))
3220 else if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
3221 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
3222 && !DECL_GIMPLE_REG_P (result
)
3223 && DECL_GIMPLE_REG_P (base_m
))
3225 else if (!TREE_ADDRESSABLE (base_m
))
3237 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type
)) == INTEGER_CST
);
3239 var
= copy_result_decl_to_var (result
, id
);
3240 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
3242 /* Do not have the rest of GCC warn about this variable as it should
3243 not be visible to the user. */
3244 TREE_NO_WARNING (var
) = 1;
3246 declare_inline_vars (id
->block
, var
);
3248 /* Build the use expr. If the return type of the function was
3249 promoted, convert it back to the expected type. */
3251 if (!useless_type_conversion_p (caller_type
, TREE_TYPE (var
)))
3253 /* If we can match up types by promotion/demotion do so. */
3254 if (fold_convertible_p (caller_type
, var
))
3255 use
= fold_convert (caller_type
, var
);
3258 /* ??? For valid programs we should not end up here.
3259 Still if we end up with truly mismatched types here, fall back
3260 to using a MEM_REF to not leak invalid GIMPLE to the following
3262 /* Prevent var from being written into SSA form. */
3263 if (TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
3264 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
)
3265 DECL_GIMPLE_REG_P (var
) = false;
3266 else if (is_gimple_reg_type (TREE_TYPE (var
)))
3267 TREE_ADDRESSABLE (var
) = true;
3268 use
= fold_build2 (MEM_REF
, caller_type
,
3269 build_fold_addr_expr (var
),
3270 build_int_cst (ptr_type_node
, 0));
3274 STRIP_USELESS_TYPE_CONVERSION (use
);
3276 if (DECL_BY_REFERENCE (result
))
3278 TREE_ADDRESSABLE (var
) = 1;
3279 var
= build_fold_addr_expr (var
);
3283 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
3284 way, when the RESULT_DECL is encountered, it will be
3285 automatically replaced by the VAR_DECL.
3287 When returning by reference, ensure that RESULT_DECL remaps to
3289 if (DECL_BY_REFERENCE (result
)
3290 && !is_gimple_val (var
))
3292 tree temp
= create_tmp_var (TREE_TYPE (result
), "retvalptr");
3293 insert_decl_map (id
, result
, temp
);
3294 /* When RESULT_DECL is in SSA form, we need to remap and initialize
3295 it's default_def SSA_NAME. */
3296 if (gimple_in_ssa_p (id
->src_cfun
)
3297 && is_gimple_reg (result
))
3299 temp
= make_ssa_name (temp
, NULL
);
3300 insert_decl_map (id
, ssa_default_def (id
->src_cfun
, result
), temp
);
3302 insert_init_stmt (id
, entry_bb
, gimple_build_assign (temp
, var
));
3305 insert_decl_map (id
, result
, var
);
3307 /* Remember this so we can ignore it in remap_decls. */
3313 /* Callback through walk_tree. Determine if a DECL_INITIAL makes reference
3314 to a local label. */
3317 has_label_address_in_static_1 (tree
*nodep
, int *walk_subtrees
, void *fnp
)
3320 tree fn
= (tree
) fnp
;
3322 if (TREE_CODE (node
) == LABEL_DECL
&& DECL_CONTEXT (node
) == fn
)
3331 /* Determine if the function can be copied. If so return NULL. If
3332 not return a string describng the reason for failure. */
3335 copy_forbidden (struct function
*fun
, tree fndecl
)
3337 const char *reason
= fun
->cannot_be_copied_reason
;
3341 /* Only examine the function once. */
3342 if (fun
->cannot_be_copied_set
)
3345 /* We cannot copy a function that receives a non-local goto
3346 because we cannot remap the destination label used in the
3347 function that is performing the non-local goto. */
3348 /* ??? Actually, this should be possible, if we work at it.
3349 No doubt there's just a handful of places that simply
3350 assume it doesn't happen and don't substitute properly. */
3351 if (fun
->has_nonlocal_label
)
3353 reason
= G_("function %q+F can never be copied "
3354 "because it receives a non-local goto");
3358 FOR_EACH_LOCAL_DECL (fun
, ix
, decl
)
3359 if (TREE_CODE (decl
) == VAR_DECL
3360 && TREE_STATIC (decl
)
3361 && !DECL_EXTERNAL (decl
)
3362 && DECL_INITIAL (decl
)
3363 && walk_tree_without_duplicates (&DECL_INITIAL (decl
),
3364 has_label_address_in_static_1
,
3367 reason
= G_("function %q+F can never be copied because it saves "
3368 "address of local label in a static variable");
3373 fun
->cannot_be_copied_reason
= reason
;
3374 fun
->cannot_be_copied_set
= true;
3379 static const char *inline_forbidden_reason
;
3381 /* A callback for walk_gimple_seq to handle statements. Returns non-null
3382 iff a function can not be inlined. Also sets the reason why. */
3385 inline_forbidden_p_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
3386 struct walk_stmt_info
*wip
)
3388 tree fn
= (tree
) wip
->info
;
3390 gimple stmt
= gsi_stmt (*gsi
);
3392 switch (gimple_code (stmt
))
3395 /* Refuse to inline alloca call unless user explicitly forced so as
3396 this may change program's memory overhead drastically when the
3397 function using alloca is called in loop. In GCC present in
3398 SPEC2000 inlining into schedule_block cause it to require 2GB of
3399 RAM instead of 256MB. Don't do so for alloca calls emitted for
3400 VLA objects as those can't cause unbounded growth (they're always
3401 wrapped inside stack_save/stack_restore regions. */
3402 if (gimple_alloca_call_p (stmt
)
3403 && !gimple_call_alloca_for_var_p (stmt
)
3404 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
3406 inline_forbidden_reason
3407 = G_("function %q+F can never be inlined because it uses "
3408 "alloca (override using the always_inline attribute)");
3409 *handled_ops_p
= true;
3413 t
= gimple_call_fndecl (stmt
);
3417 /* We cannot inline functions that call setjmp. */
3418 if (setjmp_call_p (t
))
3420 inline_forbidden_reason
3421 = G_("function %q+F can never be inlined because it uses setjmp");
3422 *handled_ops_p
= true;
3426 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
3427 switch (DECL_FUNCTION_CODE (t
))
3429 /* We cannot inline functions that take a variable number of
3431 case BUILT_IN_VA_START
:
3432 case BUILT_IN_NEXT_ARG
:
3433 case BUILT_IN_VA_END
:
3434 inline_forbidden_reason
3435 = G_("function %q+F can never be inlined because it "
3436 "uses variable argument lists");
3437 *handled_ops_p
= true;
3440 case BUILT_IN_LONGJMP
:
3441 /* We can't inline functions that call __builtin_longjmp at
3442 all. The non-local goto machinery really requires the
3443 destination be in a different function. If we allow the
3444 function calling __builtin_longjmp to be inlined into the
3445 function calling __builtin_setjmp, Things will Go Awry. */
3446 inline_forbidden_reason
3447 = G_("function %q+F can never be inlined because "
3448 "it uses setjmp-longjmp exception handling");
3449 *handled_ops_p
= true;
3452 case BUILT_IN_NONLOCAL_GOTO
:
3454 inline_forbidden_reason
3455 = G_("function %q+F can never be inlined because "
3456 "it uses non-local goto");
3457 *handled_ops_p
= true;
3460 case BUILT_IN_RETURN
:
3461 case BUILT_IN_APPLY_ARGS
:
3462 /* If a __builtin_apply_args caller would be inlined,
3463 it would be saving arguments of the function it has
3464 been inlined into. Similarly __builtin_return would
3465 return from the function the inline has been inlined into. */
3466 inline_forbidden_reason
3467 = G_("function %q+F can never be inlined because "
3468 "it uses __builtin_return or __builtin_apply_args");
3469 *handled_ops_p
= true;
3478 t
= gimple_goto_dest (stmt
);
3480 /* We will not inline a function which uses computed goto. The
3481 addresses of its local labels, which may be tucked into
3482 global storage, are of course not constant across
3483 instantiations, which causes unexpected behavior. */
3484 if (TREE_CODE (t
) != LABEL_DECL
)
3486 inline_forbidden_reason
3487 = G_("function %q+F can never be inlined "
3488 "because it contains a computed goto");
3489 *handled_ops_p
= true;
3498 *handled_ops_p
= false;
3502 /* Return true if FNDECL is a function that cannot be inlined into
3506 inline_forbidden_p (tree fndecl
)
3508 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
3509 struct walk_stmt_info wi
;
3511 bool forbidden_p
= false;
3513 /* First check for shared reasons not to copy the code. */
3514 inline_forbidden_reason
= copy_forbidden (fun
, fndecl
);
3515 if (inline_forbidden_reason
!= NULL
)
3518 /* Next, walk the statements of the function looking for
3519 constraucts we can't handle, or are non-optimal for inlining. */
3520 hash_set
<tree
> visited_nodes
;
3521 memset (&wi
, 0, sizeof (wi
));
3522 wi
.info
= (void *) fndecl
;
3523 wi
.pset
= &visited_nodes
;
3525 FOR_EACH_BB_FN (bb
, fun
)
3528 gimple_seq seq
= bb_seq (bb
);
3529 ret
= walk_gimple_seq (seq
, inline_forbidden_p_stmt
, NULL
, &wi
);
3530 forbidden_p
= (ret
!= NULL
);
3538 /* Return false if the function FNDECL cannot be inlined on account of its
3539 attributes, true otherwise. */
3541 function_attribute_inlinable_p (const_tree fndecl
)
3543 if (targetm
.attribute_table
)
3547 for (a
= DECL_ATTRIBUTES (fndecl
); a
; a
= TREE_CHAIN (a
))
3549 const_tree name
= TREE_PURPOSE (a
);
3552 for (i
= 0; targetm
.attribute_table
[i
].name
!= NULL
; i
++)
3553 if (is_attribute_p (targetm
.attribute_table
[i
].name
, name
))
3554 return targetm
.function_attribute_inlinable_p (fndecl
);
3561 /* Returns nonzero if FN is a function that does not have any
3562 fundamental inline blocking properties. */
3565 tree_inlinable_function_p (tree fn
)
3567 bool inlinable
= true;
3571 /* If we've already decided this function shouldn't be inlined,
3572 there's no need to check again. */
3573 if (DECL_UNINLINABLE (fn
))
3576 /* We only warn for functions declared `inline' by the user. */
3577 do_warning
= (warn_inline
3578 && DECL_DECLARED_INLINE_P (fn
)
3579 && !DECL_NO_INLINE_WARNING_P (fn
)
3580 && !DECL_IN_SYSTEM_HEADER (fn
));
3582 always_inline
= lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
));
3585 && always_inline
== NULL
)
3588 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3589 "is suppressed using -fno-inline", fn
);
3593 else if (!function_attribute_inlinable_p (fn
))
3596 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3597 "uses attributes conflicting with inlining", fn
);
3601 else if (inline_forbidden_p (fn
))
3603 /* See if we should warn about uninlinable functions. Previously,
3604 some of these warnings would be issued while trying to expand
3605 the function inline, but that would cause multiple warnings
3606 about functions that would for example call alloca. But since
3607 this a property of the function, just one warning is enough.
3608 As a bonus we can now give more details about the reason why a
3609 function is not inlinable. */
3611 error (inline_forbidden_reason
, fn
);
3612 else if (do_warning
)
3613 warning (OPT_Winline
, inline_forbidden_reason
, fn
);
3618 /* Squirrel away the result so that we don't have to check again. */
3619 DECL_UNINLINABLE (fn
) = !inlinable
;
3624 /* Estimate the cost of a memory move of type TYPE. Use machine dependent
3625 word size and take possible memcpy call into account and return
3626 cost based on whether optimizing for size or speed according to SPEED_P. */
3629 estimate_move_cost (tree type
, bool ARG_UNUSED (speed_p
))
3633 gcc_assert (!VOID_TYPE_P (type
));
3635 if (TREE_CODE (type
) == VECTOR_TYPE
)
3637 enum machine_mode inner
= TYPE_MODE (TREE_TYPE (type
));
3638 enum machine_mode simd
3639 = targetm
.vectorize
.preferred_simd_mode (inner
);
3640 int simd_mode_size
= GET_MODE_SIZE (simd
);
3641 return ((GET_MODE_SIZE (TYPE_MODE (type
)) + simd_mode_size
- 1)
3645 size
= int_size_in_bytes (type
);
3647 if (size
< 0 || size
> MOVE_MAX_PIECES
* MOVE_RATIO (speed_p
))
3648 /* Cost of a memcpy call, 3 arguments and the call. */
3651 return ((size
+ MOVE_MAX_PIECES
- 1) / MOVE_MAX_PIECES
);
3654 /* Returns cost of operation CODE, according to WEIGHTS */
3657 estimate_operator_cost (enum tree_code code
, eni_weights
*weights
,
3658 tree op1 ATTRIBUTE_UNUSED
, tree op2
)
3662 /* These are "free" conversions, or their presumed cost
3663 is folded into other operations. */
3668 case VIEW_CONVERT_EXPR
:
3671 /* Assign cost of 1 to usual operations.
3672 ??? We may consider mapping RTL costs to this. */
3678 case POINTER_PLUS_EXPR
:
3681 case MULT_HIGHPART_EXPR
:
3684 case ADDR_SPACE_CONVERT_EXPR
:
3685 case FIXED_CONVERT_EXPR
:
3686 case FIX_TRUNC_EXPR
:
3698 case VEC_LSHIFT_EXPR
:
3699 case VEC_RSHIFT_EXPR
:
3706 case TRUTH_ANDIF_EXPR
:
3707 case TRUTH_ORIF_EXPR
:
3708 case TRUTH_AND_EXPR
:
3710 case TRUTH_XOR_EXPR
:
3711 case TRUTH_NOT_EXPR
:
3720 case UNORDERED_EXPR
:
3731 case PREDECREMENT_EXPR
:
3732 case PREINCREMENT_EXPR
:
3733 case POSTDECREMENT_EXPR
:
3734 case POSTINCREMENT_EXPR
:
3736 case REALIGN_LOAD_EXPR
:
3738 case REDUC_MAX_EXPR
:
3739 case REDUC_MIN_EXPR
:
3740 case REDUC_PLUS_EXPR
:
3741 case WIDEN_SUM_EXPR
:
3742 case WIDEN_MULT_EXPR
:
3745 case WIDEN_MULT_PLUS_EXPR
:
3746 case WIDEN_MULT_MINUS_EXPR
:
3747 case WIDEN_LSHIFT_EXPR
:
3749 case VEC_WIDEN_MULT_HI_EXPR
:
3750 case VEC_WIDEN_MULT_LO_EXPR
:
3751 case VEC_WIDEN_MULT_EVEN_EXPR
:
3752 case VEC_WIDEN_MULT_ODD_EXPR
:
3753 case VEC_UNPACK_HI_EXPR
:
3754 case VEC_UNPACK_LO_EXPR
:
3755 case VEC_UNPACK_FLOAT_HI_EXPR
:
3756 case VEC_UNPACK_FLOAT_LO_EXPR
:
3757 case VEC_PACK_TRUNC_EXPR
:
3758 case VEC_PACK_SAT_EXPR
:
3759 case VEC_PACK_FIX_TRUNC_EXPR
:
3760 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3761 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3765 /* Few special cases of expensive operations. This is useful
3766 to avoid inlining on functions having too many of these. */
3767 case TRUNC_DIV_EXPR
:
3769 case FLOOR_DIV_EXPR
:
3770 case ROUND_DIV_EXPR
:
3771 case EXACT_DIV_EXPR
:
3772 case TRUNC_MOD_EXPR
:
3774 case FLOOR_MOD_EXPR
:
3775 case ROUND_MOD_EXPR
:
3777 if (TREE_CODE (op2
) != INTEGER_CST
)
3778 return weights
->div_mod_cost
;
3782 /* We expect a copy assignment with no operator. */
3783 gcc_assert (get_gimple_rhs_class (code
) == GIMPLE_SINGLE_RHS
);
3789 /* Estimate number of instructions that will be created by expanding
3790 the statements in the statement sequence STMTS.
3791 WEIGHTS contains weights attributed to various constructs. */
3794 int estimate_num_insns_seq (gimple_seq stmts
, eni_weights
*weights
)
3797 gimple_stmt_iterator gsi
;
3800 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3801 cost
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
3807 /* Estimate number of instructions that will be created by expanding STMT.
3808 WEIGHTS contains weights attributed to various constructs. */
3811 estimate_num_insns (gimple stmt
, eni_weights
*weights
)
3814 enum gimple_code code
= gimple_code (stmt
);
3821 /* Try to estimate the cost of assignments. We have three cases to
3823 1) Simple assignments to registers;
3824 2) Stores to things that must live in memory. This includes
3825 "normal" stores to scalars, but also assignments of large
3826 structures, or constructors of big arrays;
3828 Let us look at the first two cases, assuming we have "a = b + C":
3829 <GIMPLE_ASSIGN <var_decl "a">
3830 <plus_expr <var_decl "b"> <constant C>>
3831 If "a" is a GIMPLE register, the assignment to it is free on almost
3832 any target, because "a" usually ends up in a real register. Hence
3833 the only cost of this expression comes from the PLUS_EXPR, and we
3834 can ignore the GIMPLE_ASSIGN.
3835 If "a" is not a GIMPLE register, the assignment to "a" will most
3836 likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost
3837 of moving something into "a", which we compute using the function
3838 estimate_move_cost. */
3839 if (gimple_clobber_p (stmt
))
3840 return 0; /* ={v} {CLOBBER} stmt expands to nothing. */
3842 lhs
= gimple_assign_lhs (stmt
);
3843 rhs
= gimple_assign_rhs1 (stmt
);
3847 /* Account for the cost of moving to / from memory. */
3848 if (gimple_store_p (stmt
))
3849 cost
+= estimate_move_cost (TREE_TYPE (lhs
), weights
->time_based
);
3850 if (gimple_assign_load_p (stmt
))
3851 cost
+= estimate_move_cost (TREE_TYPE (rhs
), weights
->time_based
);
3853 cost
+= estimate_operator_cost (gimple_assign_rhs_code (stmt
), weights
,
3854 gimple_assign_rhs1 (stmt
),
3855 get_gimple_rhs_class (gimple_assign_rhs_code (stmt
))
3856 == GIMPLE_BINARY_RHS
3857 ? gimple_assign_rhs2 (stmt
) : NULL
);
3861 cost
= 1 + estimate_operator_cost (gimple_cond_code (stmt
), weights
,
3862 gimple_op (stmt
, 0),
3863 gimple_op (stmt
, 1));
3867 /* Take into account cost of the switch + guess 2 conditional jumps for
3870 TODO: once the switch expansion logic is sufficiently separated, we can
3871 do better job on estimating cost of the switch. */
3872 if (weights
->time_based
)
3873 cost
= floor_log2 (gimple_switch_num_labels (stmt
)) * 2;
3875 cost
= gimple_switch_num_labels (stmt
) * 2;
3882 if (gimple_call_internal_p (stmt
))
3884 else if ((decl
= gimple_call_fndecl (stmt
))
3885 && DECL_BUILT_IN (decl
))
3887 /* Do not special case builtins where we see the body.
3888 This just confuse inliner. */
3889 struct cgraph_node
*node
;
3890 if (!(node
= cgraph_node::get (decl
))
3891 || node
->definition
)
3893 /* For buitins that are likely expanded to nothing or
3894 inlined do not account operand costs. */
3895 else if (is_simple_builtin (decl
))
3897 else if (is_inexpensive_builtin (decl
))
3898 return weights
->target_builtin_call_cost
;
3899 else if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
3901 /* We canonicalize x * x to pow (x, 2.0) with -ffast-math, so
3902 specialize the cheap expansion we do here.
3903 ??? This asks for a more general solution. */
3904 switch (DECL_FUNCTION_CODE (decl
))
3909 if (TREE_CODE (gimple_call_arg (stmt
, 1)) == REAL_CST
3910 && REAL_VALUES_EQUAL
3911 (TREE_REAL_CST (gimple_call_arg (stmt
, 1)), dconst2
))
3912 return estimate_operator_cost
3913 (MULT_EXPR
, weights
, gimple_call_arg (stmt
, 0),
3914 gimple_call_arg (stmt
, 0));
3923 cost
= decl
? weights
->call_cost
: weights
->indirect_call_cost
;
3924 if (gimple_call_lhs (stmt
))
3925 cost
+= estimate_move_cost (TREE_TYPE (gimple_call_lhs (stmt
)),
3926 weights
->time_based
);
3927 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
3929 tree arg
= gimple_call_arg (stmt
, i
);
3930 cost
+= estimate_move_cost (TREE_TYPE (arg
),
3931 weights
->time_based
);
3937 return weights
->return_cost
;
3943 case GIMPLE_PREDICT
:
3949 int count
= asm_str_count (gimple_asm_string (stmt
));
3950 /* 1000 means infinity. This avoids overflows later
3951 with very long asm statements. */
3958 /* This is either going to be an external function call with one
3959 argument, or two register copy statements plus a goto. */
3962 case GIMPLE_EH_DISPATCH
:
3963 /* ??? This is going to turn into a switch statement. Ideally
3964 we'd have a look at the eh region and estimate the number of
3969 return estimate_num_insns_seq (gimple_bind_body (stmt
), weights
);
3971 case GIMPLE_EH_FILTER
:
3972 return estimate_num_insns_seq (gimple_eh_filter_failure (stmt
), weights
);
3975 return estimate_num_insns_seq (gimple_catch_handler (stmt
), weights
);
3978 return (estimate_num_insns_seq (gimple_try_eval (stmt
), weights
)
3979 + estimate_num_insns_seq (gimple_try_cleanup (stmt
), weights
));
3981 /* OpenMP directives are generally very expensive. */
3983 case GIMPLE_OMP_RETURN
:
3984 case GIMPLE_OMP_SECTIONS_SWITCH
:
3985 case GIMPLE_OMP_ATOMIC_STORE
:
3986 case GIMPLE_OMP_CONTINUE
:
3987 /* ...except these, which are cheap. */
3990 case GIMPLE_OMP_ATOMIC_LOAD
:
3991 return weights
->omp_cost
;
3993 case GIMPLE_OMP_FOR
:
3994 return (weights
->omp_cost
3995 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
)
3996 + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt
), weights
));
3998 case GIMPLE_OMP_PARALLEL
:
3999 case GIMPLE_OMP_TASK
:
4000 case GIMPLE_OMP_CRITICAL
:
4001 case GIMPLE_OMP_MASTER
:
4002 case GIMPLE_OMP_TASKGROUP
:
4003 case GIMPLE_OMP_ORDERED
:
4004 case GIMPLE_OMP_SECTION
:
4005 case GIMPLE_OMP_SECTIONS
:
4006 case GIMPLE_OMP_SINGLE
:
4007 case GIMPLE_OMP_TARGET
:
4008 case GIMPLE_OMP_TEAMS
:
4009 return (weights
->omp_cost
4010 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
));
4012 case GIMPLE_TRANSACTION
:
4013 return (weights
->tm_cost
4014 + estimate_num_insns_seq (gimple_transaction_body (stmt
),
4024 /* Estimate number of instructions that will be created by expanding
4025 function FNDECL. WEIGHTS contains weights attributed to various
4029 estimate_num_insns_fn (tree fndecl
, eni_weights
*weights
)
4031 struct function
*my_function
= DECL_STRUCT_FUNCTION (fndecl
);
4032 gimple_stmt_iterator bsi
;
4036 gcc_assert (my_function
&& my_function
->cfg
);
4037 FOR_EACH_BB_FN (bb
, my_function
)
4039 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
4040 n
+= estimate_num_insns (gsi_stmt (bsi
), weights
);
4047 /* Initializes weights used by estimate_num_insns. */
4050 init_inline_once (void)
4052 eni_size_weights
.call_cost
= 1;
4053 eni_size_weights
.indirect_call_cost
= 3;
4054 eni_size_weights
.target_builtin_call_cost
= 1;
4055 eni_size_weights
.div_mod_cost
= 1;
4056 eni_size_weights
.omp_cost
= 40;
4057 eni_size_weights
.tm_cost
= 10;
4058 eni_size_weights
.time_based
= false;
4059 eni_size_weights
.return_cost
= 1;
4061 /* Estimating time for call is difficult, since we have no idea what the
4062 called function does. In the current uses of eni_time_weights,
4063 underestimating the cost does less harm than overestimating it, so
4064 we choose a rather small value here. */
4065 eni_time_weights
.call_cost
= 10;
4066 eni_time_weights
.indirect_call_cost
= 15;
4067 eni_time_weights
.target_builtin_call_cost
= 1;
4068 eni_time_weights
.div_mod_cost
= 10;
4069 eni_time_weights
.omp_cost
= 40;
4070 eni_time_weights
.tm_cost
= 40;
4071 eni_time_weights
.time_based
= true;
4072 eni_time_weights
.return_cost
= 2;
4075 /* Estimate the number of instructions in a gimple_seq. */
4078 count_insns_seq (gimple_seq seq
, eni_weights
*weights
)
4080 gimple_stmt_iterator gsi
;
4082 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4083 n
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
4089 /* Install new lexical TREE_BLOCK underneath 'current_block'. */
4092 prepend_lexical_block (tree current_block
, tree new_block
)
4094 BLOCK_CHAIN (new_block
) = BLOCK_SUBBLOCKS (current_block
);
4095 BLOCK_SUBBLOCKS (current_block
) = new_block
;
4096 BLOCK_SUPERCONTEXT (new_block
) = current_block
;
4099 /* Add local variables from CALLEE to CALLER. */
4102 add_local_variables (struct function
*callee
, struct function
*caller
,
4108 FOR_EACH_LOCAL_DECL (callee
, ix
, var
)
4109 if (!can_be_nonlocal (var
, id
))
4111 tree new_var
= remap_decl (var
, id
);
4113 /* Remap debug-expressions. */
4114 if (TREE_CODE (new_var
) == VAR_DECL
4115 && DECL_HAS_DEBUG_EXPR_P (var
)
4118 tree tem
= DECL_DEBUG_EXPR (var
);
4119 bool old_regimplify
= id
->regimplify
;
4120 id
->remapping_type_depth
++;
4121 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
4122 id
->remapping_type_depth
--;
4123 id
->regimplify
= old_regimplify
;
4124 SET_DECL_DEBUG_EXPR (new_var
, tem
);
4125 DECL_HAS_DEBUG_EXPR_P (new_var
) = 1;
4127 add_local_decl (caller
, new_var
);
4131 /* If STMT is a GIMPLE_CALL, replace it with its inline expansion. */
4134 expand_call_inline (basic_block bb
, gimple stmt
, copy_body_data
*id
)
4138 struct pointer_map_t
*st
, *dst
;
4141 location_t saved_location
;
4142 struct cgraph_edge
*cg_edge
;
4143 cgraph_inline_failed_t reason
;
4144 basic_block return_block
;
4146 gimple_stmt_iterator gsi
, stmt_gsi
;
4147 bool successfully_inlined
= FALSE
;
4148 bool purge_dead_abnormal_edges
;
4150 /* Set input_location here so we get the right instantiation context
4151 if we call instantiate_decl from inlinable_function_p. */
4152 /* FIXME: instantiate_decl isn't called by inlinable_function_p. */
4153 saved_location
= input_location
;
4154 input_location
= gimple_location (stmt
);
4156 /* From here on, we're only interested in CALL_EXPRs. */
4157 if (gimple_code (stmt
) != GIMPLE_CALL
)
4160 cg_edge
= id
->dst_node
->get_edge (stmt
);
4161 gcc_checking_assert (cg_edge
);
4162 /* First, see if we can figure out what function is being called.
4163 If we cannot, then there is no hope of inlining the function. */
4164 if (cg_edge
->indirect_unknown_callee
)
4166 fn
= cg_edge
->callee
->decl
;
4167 gcc_checking_assert (fn
);
4169 /* If FN is a declaration of a function in a nested scope that was
4170 globally declared inline, we don't set its DECL_INITIAL.
4171 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
4172 C++ front-end uses it for cdtors to refer to their internal
4173 declarations, that are not real functions. Fortunately those
4174 don't have trees to be saved, so we can tell by checking their
4176 if (!DECL_INITIAL (fn
)
4177 && DECL_ABSTRACT_ORIGIN (fn
)
4178 && gimple_has_body_p (DECL_ABSTRACT_ORIGIN (fn
)))
4179 fn
= DECL_ABSTRACT_ORIGIN (fn
);
4181 /* Don't try to inline functions that are not well-suited to inlining. */
4182 if (cg_edge
->inline_failed
)
4184 reason
= cg_edge
->inline_failed
;
4185 /* If this call was originally indirect, we do not want to emit any
4186 inlining related warnings or sorry messages because there are no
4187 guarantees regarding those. */
4188 if (cg_edge
->indirect_inlining_edge
)
4191 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
))
4192 /* For extern inline functions that get redefined we always
4193 silently ignored always_inline flag. Better behaviour would
4194 be to be able to keep both bodies and use extern inline body
4195 for inlining, but we can't do that because frontends overwrite
4197 && !cg_edge
->callee
->local
.redefined_extern_inline
4198 /* During early inline pass, report only when optimization is
4200 && (cgraph_global_info_ready
4202 || cgraph_inline_failed_type (reason
) == CIF_FINAL_ERROR
)
4203 /* PR 20090218-1_0.c. Body can be provided by another module. */
4204 && (reason
!= CIF_BODY_NOT_AVAILABLE
|| !flag_generate_lto
))
4206 error ("inlining failed in call to always_inline %q+F: %s", fn
,
4207 cgraph_inline_failed_string (reason
));
4208 error ("called from here");
4210 else if (warn_inline
4211 && DECL_DECLARED_INLINE_P (fn
)
4212 && !DECL_NO_INLINE_WARNING_P (fn
)
4213 && !DECL_IN_SYSTEM_HEADER (fn
)
4214 && reason
!= CIF_UNSPECIFIED
4215 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn
))
4216 /* Do not warn about not inlined recursive calls. */
4217 && !cgraph_edge_recursive_p (cg_edge
)
4218 /* Avoid warnings during early inline pass. */
4219 && cgraph_global_info_ready
)
4221 warning (OPT_Winline
, "inlining failed in call to %q+F: %s",
4222 fn
, _(cgraph_inline_failed_string (reason
)));
4223 warning (OPT_Winline
, "called from here");
4227 fn
= cg_edge
->callee
->decl
;
4228 cg_edge
->callee
->get_body ();
4230 #ifdef ENABLE_CHECKING
4231 if (cg_edge
->callee
->decl
!= id
->dst_node
->decl
)
4232 cg_edge
->callee
->verify ();
4235 /* We will be inlining this callee. */
4236 id
->eh_lp_nr
= lookup_stmt_eh_lp (stmt
);
4238 /* Update the callers EH personality. */
4239 if (DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->decl
))
4240 DECL_FUNCTION_PERSONALITY (cg_edge
->caller
->decl
)
4241 = DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->decl
);
4243 /* Split the block holding the GIMPLE_CALL. */
4244 e
= split_block (bb
, stmt
);
4246 return_block
= e
->dest
;
4249 /* split_block splits after the statement; work around this by
4250 moving the call into the second block manually. Not pretty,
4251 but seems easier than doing the CFG manipulation by hand
4252 when the GIMPLE_CALL is in the last statement of BB. */
4253 stmt_gsi
= gsi_last_bb (bb
);
4254 gsi_remove (&stmt_gsi
, false);
4256 /* If the GIMPLE_CALL was in the last statement of BB, it may have
4257 been the source of abnormal edges. In this case, schedule
4258 the removal of dead abnormal edges. */
4259 gsi
= gsi_start_bb (return_block
);
4260 if (gsi_end_p (gsi
))
4262 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
4263 purge_dead_abnormal_edges
= true;
4267 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
4268 purge_dead_abnormal_edges
= false;
4271 stmt_gsi
= gsi_start_bb (return_block
);
4273 /* Build a block containing code to initialize the arguments, the
4274 actual inline expansion of the body, and a label for the return
4275 statements within the function to jump to. The type of the
4276 statement expression is the return type of the function call.
4277 ??? If the call does not have an associated block then we will
4278 remap all callee blocks to NULL, effectively dropping most of
4279 its debug information. This should only happen for calls to
4280 artificial decls inserted by the compiler itself. We need to
4281 either link the inlined blocks into the caller block tree or
4282 not refer to them in any way to not break GC for locations. */
4283 if (gimple_block (stmt
))
4285 id
->block
= make_node (BLOCK
);
4286 BLOCK_ABSTRACT_ORIGIN (id
->block
) = fn
;
4287 BLOCK_SOURCE_LOCATION (id
->block
) = LOCATION_LOCUS (input_location
);
4288 prepend_lexical_block (gimple_block (stmt
), id
->block
);
4291 /* Local declarations will be replaced by their equivalents in this
4294 id
->decl_map
= pointer_map_create ();
4295 dst
= id
->debug_map
;
4296 id
->debug_map
= NULL
;
4298 /* Record the function we are about to inline. */
4300 id
->src_node
= cg_edge
->callee
;
4301 id
->src_cfun
= DECL_STRUCT_FUNCTION (fn
);
4302 id
->gimple_call
= stmt
;
4304 gcc_assert (!id
->src_cfun
->after_inlining
);
4307 if (lookup_attribute ("cold", DECL_ATTRIBUTES (fn
)))
4309 gimple_stmt_iterator si
= gsi_last_bb (bb
);
4310 gsi_insert_after (&si
, gimple_build_predict (PRED_COLD_FUNCTION
,
4314 initialize_inlined_parameters (id
, stmt
, fn
, bb
);
4316 if (DECL_INITIAL (fn
))
4318 if (gimple_block (stmt
))
4322 prepend_lexical_block (id
->block
,
4323 remap_blocks (DECL_INITIAL (fn
), id
));
4324 gcc_checking_assert (BLOCK_SUBBLOCKS (id
->block
)
4325 && (BLOCK_CHAIN (BLOCK_SUBBLOCKS (id
->block
))
4327 /* Move vars for PARM_DECLs from DECL_INITIAL block to id->block,
4328 otherwise for DWARF DW_TAG_formal_parameter will not be children of
4329 DW_TAG_inlined_subroutine, but of a DW_TAG_lexical_block
4330 under it. The parameters can be then evaluated in the debugger,
4331 but don't show in backtraces. */
4332 for (var
= &BLOCK_VARS (BLOCK_SUBBLOCKS (id
->block
)); *var
; )
4333 if (TREE_CODE (DECL_ORIGIN (*var
)) == PARM_DECL
)
4336 *var
= TREE_CHAIN (v
);
4337 TREE_CHAIN (v
) = BLOCK_VARS (id
->block
);
4338 BLOCK_VARS (id
->block
) = v
;
4341 var
= &TREE_CHAIN (*var
);
4344 remap_blocks_to_null (DECL_INITIAL (fn
), id
);
4347 /* Return statements in the function body will be replaced by jumps
4348 to the RET_LABEL. */
4349 gcc_assert (DECL_INITIAL (fn
));
4350 gcc_assert (TREE_CODE (DECL_INITIAL (fn
)) == BLOCK
);
4352 /* Find the LHS to which the result of this call is assigned. */
4354 if (gimple_call_lhs (stmt
))
4356 modify_dest
= gimple_call_lhs (stmt
);
4358 /* The function which we are inlining might not return a value,
4359 in which case we should issue a warning that the function
4360 does not return a value. In that case the optimizers will
4361 see that the variable to which the value is assigned was not
4362 initialized. We do not want to issue a warning about that
4363 uninitialized variable. */
4364 if (DECL_P (modify_dest
))
4365 TREE_NO_WARNING (modify_dest
) = 1;
4367 if (gimple_call_return_slot_opt_p (stmt
))
4369 return_slot
= modify_dest
;
4376 /* If we are inlining a call to the C++ operator new, we don't want
4377 to use type based alias analysis on the return value. Otherwise
4378 we may get confused if the compiler sees that the inlined new
4379 function returns a pointer which was just deleted. See bug
4381 if (DECL_IS_OPERATOR_NEW (fn
))
4387 /* Declare the return variable for the function. */
4388 use_retvar
= declare_return_variable (id
, return_slot
, modify_dest
, bb
);
4390 /* Add local vars in this inlined callee to caller. */
4391 add_local_variables (id
->src_cfun
, cfun
, id
);
4393 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4395 fprintf (dump_file
, "Inlining ");
4396 print_generic_expr (dump_file
, id
->src_fn
, 0);
4397 fprintf (dump_file
, " to ");
4398 print_generic_expr (dump_file
, id
->dst_fn
, 0);
4399 fprintf (dump_file
, " with frequency %i\n", cg_edge
->frequency
);
4402 /* This is it. Duplicate the callee body. Assume callee is
4403 pre-gimplified. Note that we must not alter the caller
4404 function in any way before this point, as this CALL_EXPR may be
4405 a self-referential call; if we're calling ourselves, we need to
4406 duplicate our body before altering anything. */
4407 copy_body (id
, cg_edge
->callee
->count
,
4408 GCOV_COMPUTE_SCALE (cg_edge
->frequency
, CGRAPH_FREQ_BASE
),
4409 bb
, return_block
, NULL
);
4411 /* Reset the escaped solution. */
4412 if (cfun
->gimple_df
)
4413 pt_solution_reset (&cfun
->gimple_df
->escaped
);
4418 pointer_map_destroy (id
->debug_map
);
4419 id
->debug_map
= dst
;
4421 pointer_map_destroy (id
->decl_map
);
4424 /* Unlink the calls virtual operands before replacing it. */
4425 unlink_stmt_vdef (stmt
);
4426 if (gimple_vdef (stmt
)
4427 && TREE_CODE (gimple_vdef (stmt
)) == SSA_NAME
)
4428 release_ssa_name (gimple_vdef (stmt
));
4430 /* If the inlined function returns a result that we care about,
4431 substitute the GIMPLE_CALL with an assignment of the return
4432 variable to the LHS of the call. That is, if STMT was
4433 'a = foo (...)', substitute the call with 'a = USE_RETVAR'. */
4434 if (use_retvar
&& gimple_call_lhs (stmt
))
4436 gimple old_stmt
= stmt
;
4437 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), use_retvar
);
4438 gsi_replace (&stmt_gsi
, stmt
, false);
4439 maybe_clean_or_replace_eh_stmt (old_stmt
, stmt
);
4443 /* Handle the case of inlining a function with no return
4444 statement, which causes the return value to become undefined. */
4445 if (gimple_call_lhs (stmt
)
4446 && TREE_CODE (gimple_call_lhs (stmt
)) == SSA_NAME
)
4448 tree name
= gimple_call_lhs (stmt
);
4449 tree var
= SSA_NAME_VAR (name
);
4450 tree def
= ssa_default_def (cfun
, var
);
4454 /* If the variable is used undefined, make this name
4455 undefined via a move. */
4456 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), def
);
4457 gsi_replace (&stmt_gsi
, stmt
, true);
4461 /* Otherwise make this variable undefined. */
4462 gsi_remove (&stmt_gsi
, true);
4463 set_ssa_default_def (cfun
, var
, name
);
4464 SSA_NAME_DEF_STMT (name
) = gimple_build_nop ();
4468 gsi_remove (&stmt_gsi
, true);
4471 if (purge_dead_abnormal_edges
)
4473 gimple_purge_dead_eh_edges (return_block
);
4474 gimple_purge_dead_abnormal_call_edges (return_block
);
4477 /* If the value of the new expression is ignored, that's OK. We
4478 don't warn about this for CALL_EXPRs, so we shouldn't warn about
4479 the equivalent inlined version either. */
4480 if (is_gimple_assign (stmt
))
4482 gcc_assert (gimple_assign_single_p (stmt
)
4483 || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
)));
4484 TREE_USED (gimple_assign_rhs1 (stmt
)) = 1;
4487 /* Output the inlining info for this abstract function, since it has been
4488 inlined. If we don't do this now, we can lose the information about the
4489 variables in the function when the blocks get blown away as soon as we
4490 remove the cgraph node. */
4491 if (gimple_block (stmt
))
4492 (*debug_hooks
->outlining_inline_function
) (cg_edge
->callee
->decl
);
4494 /* Update callgraph if needed. */
4495 cg_edge
->callee
->remove ();
4497 id
->block
= NULL_TREE
;
4498 successfully_inlined
= TRUE
;
4501 input_location
= saved_location
;
4502 return successfully_inlined
;
4505 /* Expand call statements reachable from STMT_P.
4506 We can only have CALL_EXPRs as the "toplevel" tree code or nested
4507 in a MODIFY_EXPR. */
4510 gimple_expand_calls_inline (basic_block bb
, copy_body_data
*id
)
4512 gimple_stmt_iterator gsi
;
4514 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4516 gimple stmt
= gsi_stmt (gsi
);
4518 if (is_gimple_call (stmt
)
4519 && !gimple_call_internal_p (stmt
)
4520 && expand_call_inline (bb
, stmt
, id
))
4528 /* Walk all basic blocks created after FIRST and try to fold every statement
4529 in the STATEMENTS pointer set. */
4532 fold_marked_statements (int first
, hash_set
<gimple
> *statements
)
4534 for (; first
< n_basic_blocks_for_fn (cfun
); first
++)
4535 if (BASIC_BLOCK_FOR_FN (cfun
, first
))
4537 gimple_stmt_iterator gsi
;
4539 for (gsi
= gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, first
));
4542 if (statements
->contains (gsi_stmt (gsi
)))
4544 gimple old_stmt
= gsi_stmt (gsi
);
4545 tree old_decl
= is_gimple_call (old_stmt
) ? gimple_call_fndecl (old_stmt
) : 0;
4547 if (old_decl
&& DECL_BUILT_IN (old_decl
))
4549 /* Folding builtins can create multiple instructions,
4550 we need to look at all of them. */
4551 gimple_stmt_iterator i2
= gsi
;
4553 if (fold_stmt (&gsi
))
4556 /* If a builtin at the end of a bb folded into nothing,
4557 the following loop won't work. */
4558 if (gsi_end_p (gsi
))
4560 cgraph_update_edges_for_call_stmt (old_stmt
,
4565 i2
= gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, first
));
4570 new_stmt
= gsi_stmt (i2
);
4571 update_stmt (new_stmt
);
4572 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4575 if (new_stmt
== gsi_stmt (gsi
))
4577 /* It is okay to check only for the very last
4578 of these statements. If it is a throwing
4579 statement nothing will change. If it isn't
4580 this can remove EH edges. If that weren't
4581 correct then because some intermediate stmts
4582 throw, but not the last one. That would mean
4583 we'd have to split the block, which we can't
4584 here and we'd loose anyway. And as builtins
4585 probably never throw, this all
4587 if (maybe_clean_or_replace_eh_stmt (old_stmt
,
4589 gimple_purge_dead_eh_edges (
4590 BASIC_BLOCK_FOR_FN (cfun
, first
));
4597 else if (fold_stmt (&gsi
))
4599 /* Re-read the statement from GSI as fold_stmt() may
4601 gimple new_stmt
= gsi_stmt (gsi
);
4602 update_stmt (new_stmt
);
4604 if (is_gimple_call (old_stmt
)
4605 || is_gimple_call (new_stmt
))
4606 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4609 if (maybe_clean_or_replace_eh_stmt (old_stmt
, new_stmt
))
4610 gimple_purge_dead_eh_edges (BASIC_BLOCK_FOR_FN (cfun
,
4617 /* Expand calls to inline functions in the body of FN. */
4620 optimize_inline_calls (tree fn
)
4624 int last
= n_basic_blocks_for_fn (cfun
);
4625 bool inlined_p
= false;
4628 memset (&id
, 0, sizeof (id
));
4630 id
.src_node
= id
.dst_node
= cgraph_node::get (fn
);
4631 gcc_assert (id
.dst_node
->definition
);
4633 /* Or any functions that aren't finished yet. */
4634 if (current_function_decl
)
4635 id
.dst_fn
= current_function_decl
;
4637 id
.copy_decl
= copy_decl_maybe_to_var
;
4638 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
4639 id
.transform_new_cfg
= false;
4640 id
.transform_return_to_modify
= true;
4641 id
.transform_parameter
= true;
4642 id
.transform_lang_insert_block
= NULL
;
4643 id
.statements_to_fold
= new hash_set
<gimple
>;
4645 push_gimplify_context ();
4647 /* We make no attempts to keep dominance info up-to-date. */
4648 free_dominance_info (CDI_DOMINATORS
);
4649 free_dominance_info (CDI_POST_DOMINATORS
);
4651 /* Register specific gimple functions. */
4652 gimple_register_cfg_hooks ();
4654 /* Reach the trees by walking over the CFG, and note the
4655 enclosing basic-blocks in the call edges. */
4656 /* We walk the blocks going forward, because inlined function bodies
4657 will split id->current_basic_block, and the new blocks will
4658 follow it; we'll trudge through them, processing their CALL_EXPRs
4660 FOR_EACH_BB_FN (bb
, cfun
)
4661 inlined_p
|= gimple_expand_calls_inline (bb
, &id
);
4663 pop_gimplify_context (NULL
);
4665 #ifdef ENABLE_CHECKING
4667 struct cgraph_edge
*e
;
4669 id
.dst_node
->verify ();
4671 /* Double check that we inlined everything we are supposed to inline. */
4672 for (e
= id
.dst_node
->callees
; e
; e
= e
->next_callee
)
4673 gcc_assert (e
->inline_failed
);
4677 /* Fold queued statements. */
4678 fold_marked_statements (last
, id
.statements_to_fold
);
4679 delete id
.statements_to_fold
;
4681 gcc_assert (!id
.debug_stmts
.exists ());
4683 /* If we didn't inline into the function there is nothing to do. */
4687 /* Renumber the lexical scoping (non-code) blocks consecutively. */
4690 delete_unreachable_blocks_update_callgraph (&id
);
4691 #ifdef ENABLE_CHECKING
4692 id
.dst_node
->verify ();
4695 /* It would be nice to check SSA/CFG/statement consistency here, but it is
4696 not possible yet - the IPA passes might make various functions to not
4697 throw and they don't care to proactively update local EH info. This is
4698 done later in fixup_cfg pass that also execute the verification. */
4699 return (TODO_update_ssa
4701 | (gimple_in_ssa_p (cfun
) ? TODO_remove_unused_locals
: 0)
4702 | (gimple_in_ssa_p (cfun
) ? TODO_update_address_taken
: 0)
4703 | (profile_status_for_fn (cfun
) != PROFILE_ABSENT
4704 ? TODO_rebuild_frequencies
: 0));
4707 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
4710 copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
4712 enum tree_code code
= TREE_CODE (*tp
);
4713 enum tree_code_class cl
= TREE_CODE_CLASS (code
);
4715 /* We make copies of most nodes. */
4716 if (IS_EXPR_CODE_CLASS (cl
)
4717 || code
== TREE_LIST
4719 || code
== TYPE_DECL
4720 || code
== OMP_CLAUSE
)
4722 /* Because the chain gets clobbered when we make a copy, we save it
4724 tree chain
= NULL_TREE
, new_tree
;
4726 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
4727 chain
= TREE_CHAIN (*tp
);
4729 /* Copy the node. */
4730 new_tree
= copy_node (*tp
);
4734 /* Now, restore the chain, if appropriate. That will cause
4735 walk_tree to walk into the chain as well. */
4736 if (code
== PARM_DECL
4737 || code
== TREE_LIST
4738 || code
== OMP_CLAUSE
)
4739 TREE_CHAIN (*tp
) = chain
;
4741 /* For now, we don't update BLOCKs when we make copies. So, we
4742 have to nullify all BIND_EXPRs. */
4743 if (TREE_CODE (*tp
) == BIND_EXPR
)
4744 BIND_EXPR_BLOCK (*tp
) = NULL_TREE
;
4746 else if (code
== CONSTRUCTOR
)
4748 /* CONSTRUCTOR nodes need special handling because
4749 we need to duplicate the vector of elements. */
4752 new_tree
= copy_node (*tp
);
4753 CONSTRUCTOR_ELTS (new_tree
) = vec_safe_copy (CONSTRUCTOR_ELTS (*tp
));
4756 else if (code
== STATEMENT_LIST
)
4757 /* We used to just abort on STATEMENT_LIST, but we can run into them
4758 with statement-expressions (c++/40975). */
4759 copy_statement_list (tp
);
4760 else if (TREE_CODE_CLASS (code
) == tcc_type
)
4762 else if (TREE_CODE_CLASS (code
) == tcc_declaration
)
4764 else if (TREE_CODE_CLASS (code
) == tcc_constant
)
4769 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
4770 information indicating to what new SAVE_EXPR this one should be mapped,
4771 use that one. Otherwise, create a new node and enter it in ST. FN is
4772 the function into which the copy will be placed. */
4775 remap_save_expr (tree
*tp
, void *st_
, int *walk_subtrees
)
4777 struct pointer_map_t
*st
= (struct pointer_map_t
*) st_
;
4781 /* See if we already encountered this SAVE_EXPR. */
4782 n
= (tree
*) pointer_map_contains (st
, *tp
);
4784 /* If we didn't already remap this SAVE_EXPR, do so now. */
4787 t
= copy_node (*tp
);
4789 /* Remember this SAVE_EXPR. */
4790 *pointer_map_insert (st
, *tp
) = t
;
4791 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
4792 *pointer_map_insert (st
, t
) = t
;
4796 /* We've already walked into this SAVE_EXPR; don't do it again. */
4801 /* Replace this SAVE_EXPR with the copy. */
4805 /* Called via walk_gimple_seq. If *GSIP points to a GIMPLE_LABEL for a local
4806 label, copies the declaration and enters it in the splay_tree in DATA (which
4807 is really a 'copy_body_data *'. */
4810 mark_local_labels_stmt (gimple_stmt_iterator
*gsip
,
4811 bool *handled_ops_p ATTRIBUTE_UNUSED
,
4812 struct walk_stmt_info
*wi
)
4814 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4815 gimple stmt
= gsi_stmt (*gsip
);
4817 if (gimple_code (stmt
) == GIMPLE_LABEL
)
4819 tree decl
= gimple_label_label (stmt
);
4821 /* Copy the decl and remember the copy. */
4822 insert_decl_map (id
, decl
, id
->copy_decl (decl
, id
));
4829 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
4830 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
4831 remaps all local declarations to appropriate replacements in gimple
4835 replace_locals_op (tree
*tp
, int *walk_subtrees
, void *data
)
4837 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
4838 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4839 struct pointer_map_t
*st
= id
->decl_map
;
4843 /* Only a local declaration (variable or label). */
4844 if ((TREE_CODE (expr
) == VAR_DECL
4845 && !TREE_STATIC (expr
))
4846 || TREE_CODE (expr
) == LABEL_DECL
)
4848 /* Lookup the declaration. */
4849 n
= (tree
*) pointer_map_contains (st
, expr
);
4851 /* If it's there, remap it. */
4856 else if (TREE_CODE (expr
) == STATEMENT_LIST
4857 || TREE_CODE (expr
) == BIND_EXPR
4858 || TREE_CODE (expr
) == SAVE_EXPR
)
4860 else if (TREE_CODE (expr
) == TARGET_EXPR
)
4862 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
4863 It's OK for this to happen if it was part of a subtree that
4864 isn't immediately expanded, such as operand 2 of another
4866 if (!TREE_OPERAND (expr
, 1))
4868 TREE_OPERAND (expr
, 1) = TREE_OPERAND (expr
, 3);
4869 TREE_OPERAND (expr
, 3) = NULL_TREE
;
4873 /* Keep iterating. */
4878 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
4879 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
4880 remaps all local declarations to appropriate replacements in gimple
4884 replace_locals_stmt (gimple_stmt_iterator
*gsip
,
4885 bool *handled_ops_p ATTRIBUTE_UNUSED
,
4886 struct walk_stmt_info
*wi
)
4888 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4889 gimple stmt
= gsi_stmt (*gsip
);
4891 if (gimple_code (stmt
) == GIMPLE_BIND
)
4893 tree block
= gimple_bind_block (stmt
);
4897 remap_block (&block
, id
);
4898 gimple_bind_set_block (stmt
, block
);
4901 /* This will remap a lot of the same decls again, but this should be
4903 if (gimple_bind_vars (stmt
))
4904 gimple_bind_set_vars (stmt
, remap_decls (gimple_bind_vars (stmt
),
4908 /* Keep iterating. */
4913 /* Copies everything in SEQ and replaces variables and labels local to
4914 current_function_decl. */
4917 copy_gimple_seq_and_replace_locals (gimple_seq seq
)
4920 struct walk_stmt_info wi
;
4923 /* There's nothing to do for NULL_TREE. */
4928 memset (&id
, 0, sizeof (id
));
4929 id
.src_fn
= current_function_decl
;
4930 id
.dst_fn
= current_function_decl
;
4931 id
.decl_map
= pointer_map_create ();
4932 id
.debug_map
= NULL
;
4934 id
.copy_decl
= copy_decl_no_change
;
4935 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
4936 id
.transform_new_cfg
= false;
4937 id
.transform_return_to_modify
= false;
4938 id
.transform_parameter
= false;
4939 id
.transform_lang_insert_block
= NULL
;
4941 /* Walk the tree once to find local labels. */
4942 memset (&wi
, 0, sizeof (wi
));
4943 hash_set
<tree
> visited
;
4946 walk_gimple_seq (seq
, mark_local_labels_stmt
, NULL
, &wi
);
4948 copy
= gimple_seq_copy (seq
);
4950 /* Walk the copy, remapping decls. */
4951 memset (&wi
, 0, sizeof (wi
));
4953 walk_gimple_seq (copy
, replace_locals_stmt
, replace_locals_op
, &wi
);
4956 pointer_map_destroy (id
.decl_map
);
4958 pointer_map_destroy (id
.debug_map
);
4964 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
4967 debug_find_tree_1 (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
, void *data
)
4976 debug_find_tree (tree top
, tree search
)
4978 return walk_tree_without_duplicates (&top
, debug_find_tree_1
, search
) != 0;
4982 /* Declare the variables created by the inliner. Add all the variables in
4983 VARS to BIND_EXPR. */
4986 declare_inline_vars (tree block
, tree vars
)
4989 for (t
= vars
; t
; t
= DECL_CHAIN (t
))
4991 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
4992 gcc_assert (!TREE_STATIC (t
) && !TREE_ASM_WRITTEN (t
));
4993 add_local_decl (cfun
, t
);
4997 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), vars
);
5000 /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN,
5001 but now it will be in the TO_FN. PARM_TO_VAR means enable PARM_DECL to
5002 VAR_DECL translation. */
5005 copy_decl_for_dup_finish (copy_body_data
*id
, tree decl
, tree copy
)
5007 /* Don't generate debug information for the copy if we wouldn't have
5008 generated it for the copy either. */
5009 DECL_ARTIFICIAL (copy
) = DECL_ARTIFICIAL (decl
);
5010 DECL_IGNORED_P (copy
) = DECL_IGNORED_P (decl
);
5012 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
5013 declaration inspired this copy. */
5014 DECL_ABSTRACT_ORIGIN (copy
) = DECL_ORIGIN (decl
);
5016 /* The new variable/label has no RTL, yet. */
5017 if (CODE_CONTAINS_STRUCT (TREE_CODE (copy
), TS_DECL_WRTL
)
5018 && !TREE_STATIC (copy
) && !DECL_EXTERNAL (copy
))
5019 SET_DECL_RTL (copy
, 0);
5021 /* These args would always appear unused, if not for this. */
5022 TREE_USED (copy
) = 1;
5024 /* Set the context for the new declaration. */
5025 if (!DECL_CONTEXT (decl
))
5026 /* Globals stay global. */
5028 else if (DECL_CONTEXT (decl
) != id
->src_fn
)
5029 /* Things that weren't in the scope of the function we're inlining
5030 from aren't in the scope we're inlining to, either. */
5032 else if (TREE_STATIC (decl
))
5033 /* Function-scoped static variables should stay in the original
5037 /* Ordinary automatic local variables are now in the scope of the
5039 DECL_CONTEXT (copy
) = id
->dst_fn
;
5045 copy_decl_to_var (tree decl
, copy_body_data
*id
)
5049 gcc_assert (TREE_CODE (decl
) == PARM_DECL
5050 || TREE_CODE (decl
) == RESULT_DECL
);
5052 type
= TREE_TYPE (decl
);
5054 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
5055 VAR_DECL
, DECL_NAME (decl
), type
);
5056 if (DECL_PT_UID_SET_P (decl
))
5057 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
5058 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
5059 TREE_READONLY (copy
) = TREE_READONLY (decl
);
5060 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
5061 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
5063 return copy_decl_for_dup_finish (id
, decl
, copy
);
5066 /* Like copy_decl_to_var, but create a return slot object instead of a
5067 pointer variable for return by invisible reference. */
5070 copy_result_decl_to_var (tree decl
, copy_body_data
*id
)
5074 gcc_assert (TREE_CODE (decl
) == PARM_DECL
5075 || TREE_CODE (decl
) == RESULT_DECL
);
5077 type
= TREE_TYPE (decl
);
5078 if (DECL_BY_REFERENCE (decl
))
5079 type
= TREE_TYPE (type
);
5081 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
5082 VAR_DECL
, DECL_NAME (decl
), type
);
5083 if (DECL_PT_UID_SET_P (decl
))
5084 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
5085 TREE_READONLY (copy
) = TREE_READONLY (decl
);
5086 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
5087 if (!DECL_BY_REFERENCE (decl
))
5089 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
5090 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
5093 return copy_decl_for_dup_finish (id
, decl
, copy
);
5097 copy_decl_no_change (tree decl
, copy_body_data
*id
)
5101 copy
= copy_node (decl
);
5103 /* The COPY is not abstract; it will be generated in DST_FN. */
5104 DECL_ABSTRACT (copy
) = 0;
5105 lang_hooks
.dup_lang_specific_decl (copy
);
5107 /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
5108 been taken; it's for internal bookkeeping in expand_goto_internal. */
5109 if (TREE_CODE (copy
) == LABEL_DECL
)
5111 TREE_ADDRESSABLE (copy
) = 0;
5112 LABEL_DECL_UID (copy
) = -1;
5115 return copy_decl_for_dup_finish (id
, decl
, copy
);
5119 copy_decl_maybe_to_var (tree decl
, copy_body_data
*id
)
5121 if (TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
)
5122 return copy_decl_to_var (decl
, id
);
5124 return copy_decl_no_change (decl
, id
);
5127 /* Return a copy of the function's argument tree. */
5129 copy_arguments_for_versioning (tree orig_parm
, copy_body_data
* id
,
5130 bitmap args_to_skip
, tree
*vars
)
5133 tree new_parm
= NULL
;
5138 for (arg
= orig_parm
; arg
; arg
= DECL_CHAIN (arg
), i
++)
5139 if (!args_to_skip
|| !bitmap_bit_p (args_to_skip
, i
))
5141 tree new_tree
= remap_decl (arg
, id
);
5142 if (TREE_CODE (new_tree
) != PARM_DECL
)
5143 new_tree
= id
->copy_decl (arg
, id
);
5144 lang_hooks
.dup_lang_specific_decl (new_tree
);
5146 parg
= &DECL_CHAIN (new_tree
);
5148 else if (!pointer_map_contains (id
->decl_map
, arg
))
5150 /* Make an equivalent VAR_DECL. If the argument was used
5151 as temporary variable later in function, the uses will be
5152 replaced by local variable. */
5153 tree var
= copy_decl_to_var (arg
, id
);
5154 insert_decl_map (id
, arg
, var
);
5155 /* Declare this new variable. */
5156 DECL_CHAIN (var
) = *vars
;
5162 /* Return a copy of the function's static chain. */
5164 copy_static_chain (tree static_chain
, copy_body_data
* id
)
5166 tree
*chain_copy
, *pvar
;
5168 chain_copy
= &static_chain
;
5169 for (pvar
= chain_copy
; *pvar
; pvar
= &DECL_CHAIN (*pvar
))
5171 tree new_tree
= remap_decl (*pvar
, id
);
5172 lang_hooks
.dup_lang_specific_decl (new_tree
);
5173 DECL_CHAIN (new_tree
) = DECL_CHAIN (*pvar
);
5176 return static_chain
;
5179 /* Return true if the function is allowed to be versioned.
5180 This is a guard for the versioning functionality. */
5183 tree_versionable_function_p (tree fndecl
)
5185 return (!lookup_attribute ("noclone", DECL_ATTRIBUTES (fndecl
))
5186 && copy_forbidden (DECL_STRUCT_FUNCTION (fndecl
), fndecl
) == NULL
);
5189 /* Delete all unreachable basic blocks and update callgraph.
5190 Doing so is somewhat nontrivial because we need to update all clones and
5191 remove inline function that become unreachable. */
5194 delete_unreachable_blocks_update_callgraph (copy_body_data
*id
)
5196 bool changed
= false;
5197 basic_block b
, next_bb
;
5199 find_unreachable_blocks ();
5201 /* Delete all unreachable basic blocks. */
5203 for (b
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
; b
5204 != EXIT_BLOCK_PTR_FOR_FN (cfun
); b
= next_bb
)
5206 next_bb
= b
->next_bb
;
5208 if (!(b
->flags
& BB_REACHABLE
))
5210 gimple_stmt_iterator bsi
;
5212 for (bsi
= gsi_start_bb (b
); !gsi_end_p (bsi
); gsi_next (&bsi
))
5214 struct cgraph_edge
*e
;
5215 struct cgraph_node
*node
;
5217 id
->dst_node
->remove_stmt_references (gsi_stmt (bsi
));
5219 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
5220 &&(e
= id
->dst_node
->get_edge (gsi_stmt (bsi
))) != NULL
)
5222 if (!e
->inline_failed
)
5223 e
->callee
->remove_symbol_and_inline_clones (id
->dst_node
);
5225 cgraph_remove_edge (e
);
5227 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
5228 && id
->dst_node
->clones
)
5229 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
5231 node
->remove_stmt_references (gsi_stmt (bsi
));
5232 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
5233 && (e
= node
->get_edge (gsi_stmt (bsi
))) != NULL
)
5235 if (!e
->inline_failed
)
5236 e
->callee
->remove_symbol_and_inline_clones (id
->dst_node
);
5238 cgraph_remove_edge (e
);
5242 node
= node
->clones
;
5243 else if (node
->next_sibling_clone
)
5244 node
= node
->next_sibling_clone
;
5247 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5248 node
= node
->clone_of
;
5249 if (node
!= id
->dst_node
)
5250 node
= node
->next_sibling_clone
;
5254 delete_basic_block (b
);
5262 /* Update clone info after duplication. */
5265 update_clone_info (copy_body_data
* id
)
5267 struct cgraph_node
*node
;
5268 if (!id
->dst_node
->clones
)
5270 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
5272 /* First update replace maps to match the new body. */
5273 if (node
->clone
.tree_map
)
5276 for (i
= 0; i
< vec_safe_length (node
->clone
.tree_map
); i
++)
5278 struct ipa_replace_map
*replace_info
;
5279 replace_info
= (*node
->clone
.tree_map
)[i
];
5280 walk_tree (&replace_info
->old_tree
, copy_tree_body_r
, id
, NULL
);
5281 walk_tree (&replace_info
->new_tree
, copy_tree_body_r
, id
, NULL
);
5285 node
= node
->clones
;
5286 else if (node
->next_sibling_clone
)
5287 node
= node
->next_sibling_clone
;
5290 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5291 node
= node
->clone_of
;
5292 if (node
!= id
->dst_node
)
5293 node
= node
->next_sibling_clone
;
5298 /* Create a copy of a function's tree.
5299 OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
5300 of the original function and the new copied function
5301 respectively. In case we want to replace a DECL
5302 tree with another tree while duplicating the function's
5303 body, TREE_MAP represents the mapping between these
5304 trees. If UPDATE_CLONES is set, the call_stmt fields
5305 of edges of clones of the function will be updated.
5307 If non-NULL ARGS_TO_SKIP determine function parameters to remove
5309 If SKIP_RETURN is true, the new version will return void.
5310 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
5311 If non_NULL NEW_ENTRY determine new entry BB of the clone.
5314 tree_function_versioning (tree old_decl
, tree new_decl
,
5315 vec
<ipa_replace_map
*, va_gc
> *tree_map
,
5316 bool update_clones
, bitmap args_to_skip
,
5317 bool skip_return
, bitmap blocks_to_copy
,
5318 basic_block new_entry
)
5320 struct cgraph_node
*old_version_node
;
5321 struct cgraph_node
*new_version_node
;
5325 struct ipa_replace_map
*replace_info
;
5326 basic_block old_entry_block
, bb
;
5327 auto_vec
<gimple
, 10> init_stmts
;
5328 tree vars
= NULL_TREE
;
5330 gcc_assert (TREE_CODE (old_decl
) == FUNCTION_DECL
5331 && TREE_CODE (new_decl
) == FUNCTION_DECL
);
5332 DECL_POSSIBLY_INLINED (old_decl
) = 1;
5334 old_version_node
= cgraph_node::get (old_decl
);
5335 gcc_checking_assert (old_version_node
);
5336 new_version_node
= cgraph_node::get (new_decl
);
5337 gcc_checking_assert (new_version_node
);
5339 /* Copy over debug args. */
5340 if (DECL_HAS_DEBUG_ARGS_P (old_decl
))
5342 vec
<tree
, va_gc
> **new_debug_args
, **old_debug_args
;
5343 gcc_checking_assert (decl_debug_args_lookup (new_decl
) == NULL
);
5344 DECL_HAS_DEBUG_ARGS_P (new_decl
) = 0;
5345 old_debug_args
= decl_debug_args_lookup (old_decl
);
5348 new_debug_args
= decl_debug_args_insert (new_decl
);
5349 *new_debug_args
= vec_safe_copy (*old_debug_args
);
5353 /* Output the inlining info for this abstract function, since it has been
5354 inlined. If we don't do this now, we can lose the information about the
5355 variables in the function when the blocks get blown away as soon as we
5356 remove the cgraph node. */
5357 (*debug_hooks
->outlining_inline_function
) (old_decl
);
5359 DECL_ARTIFICIAL (new_decl
) = 1;
5360 DECL_ABSTRACT_ORIGIN (new_decl
) = DECL_ORIGIN (old_decl
);
5361 if (DECL_ORIGIN (old_decl
) == old_decl
)
5362 old_version_node
->used_as_abstract_origin
= true;
5363 DECL_FUNCTION_PERSONALITY (new_decl
) = DECL_FUNCTION_PERSONALITY (old_decl
);
5365 /* Prepare the data structures for the tree copy. */
5366 memset (&id
, 0, sizeof (id
));
5368 /* Generate a new name for the new version. */
5369 id
.statements_to_fold
= new hash_set
<gimple
>;
5371 id
.decl_map
= pointer_map_create ();
5372 id
.debug_map
= NULL
;
5373 id
.src_fn
= old_decl
;
5374 id
.dst_fn
= new_decl
;
5375 id
.src_node
= old_version_node
;
5376 id
.dst_node
= new_version_node
;
5377 id
.src_cfun
= DECL_STRUCT_FUNCTION (old_decl
);
5378 id
.blocks_to_copy
= blocks_to_copy
;
5380 id
.copy_decl
= copy_decl_no_change
;
5381 id
.transform_call_graph_edges
5382 = update_clones
? CB_CGE_MOVE_CLONES
: CB_CGE_MOVE
;
5383 id
.transform_new_cfg
= true;
5384 id
.transform_return_to_modify
= false;
5385 id
.transform_parameter
= false;
5386 id
.transform_lang_insert_block
= NULL
;
5388 old_entry_block
= ENTRY_BLOCK_PTR_FOR_FN
5389 (DECL_STRUCT_FUNCTION (old_decl
));
5390 DECL_RESULT (new_decl
) = DECL_RESULT (old_decl
);
5391 DECL_ARGUMENTS (new_decl
) = DECL_ARGUMENTS (old_decl
);
5392 initialize_cfun (new_decl
, old_decl
,
5393 old_entry_block
->count
);
5394 if (DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
)
5395 DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
->ipa_pta
5396 = id
.src_cfun
->gimple_df
->ipa_pta
;
5398 /* Copy the function's static chain. */
5399 p
= DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
;
5401 DECL_STRUCT_FUNCTION (new_decl
)->static_chain_decl
=
5402 copy_static_chain (DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
,
5405 /* If there's a tree_map, prepare for substitution. */
5407 for (i
= 0; i
< tree_map
->length (); i
++)
5410 replace_info
= (*tree_map
)[i
];
5411 if (replace_info
->replace_p
)
5413 if (!replace_info
->old_tree
)
5415 int i
= replace_info
->parm_num
;
5419 for (parm
= DECL_ARGUMENTS (old_decl
); i
; parm
= DECL_CHAIN (parm
))
5421 replace_info
->old_tree
= parm
;
5422 req_type
= TREE_TYPE (parm
);
5423 if (!useless_type_conversion_p (req_type
, TREE_TYPE (replace_info
->new_tree
)))
5425 if (fold_convertible_p (req_type
, replace_info
->new_tree
))
5426 replace_info
->new_tree
= fold_build1 (NOP_EXPR
, req_type
, replace_info
->new_tree
);
5427 else if (TYPE_SIZE (req_type
) == TYPE_SIZE (TREE_TYPE (replace_info
->new_tree
)))
5428 replace_info
->new_tree
= fold_build1 (VIEW_CONVERT_EXPR
, req_type
, replace_info
->new_tree
);
5433 fprintf (dump_file
, " const ");
5434 print_generic_expr (dump_file
, replace_info
->new_tree
, 0);
5435 fprintf (dump_file
, " can't be converted to param ");
5436 print_generic_expr (dump_file
, parm
, 0);
5437 fprintf (dump_file
, "\n");
5439 replace_info
->old_tree
= NULL
;
5444 gcc_assert (TREE_CODE (replace_info
->old_tree
) == PARM_DECL
);
5445 if (replace_info
->old_tree
)
5447 init
= setup_one_parameter (&id
, replace_info
->old_tree
,
5448 replace_info
->new_tree
, id
.src_fn
,
5452 init_stmts
.safe_push (init
);
5456 /* Copy the function's arguments. */
5457 if (DECL_ARGUMENTS (old_decl
) != NULL_TREE
)
5458 DECL_ARGUMENTS (new_decl
) =
5459 copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl
), &id
,
5460 args_to_skip
, &vars
);
5462 DECL_INITIAL (new_decl
) = remap_blocks (DECL_INITIAL (id
.src_fn
), &id
);
5463 BLOCK_SUPERCONTEXT (DECL_INITIAL (new_decl
)) = new_decl
;
5465 declare_inline_vars (DECL_INITIAL (new_decl
), vars
);
5467 if (!vec_safe_is_empty (DECL_STRUCT_FUNCTION (old_decl
)->local_decls
))
5468 /* Add local vars. */
5469 add_local_variables (DECL_STRUCT_FUNCTION (old_decl
), cfun
, &id
);
5471 if (DECL_RESULT (old_decl
) == NULL_TREE
)
5473 else if (skip_return
&& !VOID_TYPE_P (TREE_TYPE (DECL_RESULT (old_decl
))))
5475 DECL_RESULT (new_decl
)
5476 = build_decl (DECL_SOURCE_LOCATION (DECL_RESULT (old_decl
)),
5477 RESULT_DECL
, NULL_TREE
, void_type_node
);
5478 DECL_CONTEXT (DECL_RESULT (new_decl
)) = new_decl
;
5479 cfun
->returns_struct
= 0;
5480 cfun
->returns_pcc_struct
= 0;
5485 DECL_RESULT (new_decl
) = remap_decl (DECL_RESULT (old_decl
), &id
);
5486 lang_hooks
.dup_lang_specific_decl (DECL_RESULT (new_decl
));
5487 if (gimple_in_ssa_p (id
.src_cfun
)
5488 && DECL_BY_REFERENCE (DECL_RESULT (old_decl
))
5489 && (old_name
= ssa_default_def (id
.src_cfun
, DECL_RESULT (old_decl
))))
5491 tree new_name
= make_ssa_name (DECL_RESULT (new_decl
), NULL
);
5492 insert_decl_map (&id
, old_name
, new_name
);
5493 SSA_NAME_DEF_STMT (new_name
) = gimple_build_nop ();
5494 set_ssa_default_def (cfun
, DECL_RESULT (new_decl
), new_name
);
5498 /* Set up the destination functions loop tree. */
5499 if (loops_for_fn (DECL_STRUCT_FUNCTION (old_decl
)) != NULL
)
5501 cfun
->curr_properties
&= ~PROP_loops
;
5502 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
5503 cfun
->curr_properties
|= PROP_loops
;
5506 /* Copy the Function's body. */
5507 copy_body (&id
, old_entry_block
->count
, REG_BR_PROB_BASE
,
5508 ENTRY_BLOCK_PTR_FOR_FN (cfun
), EXIT_BLOCK_PTR_FOR_FN (cfun
),
5511 /* Renumber the lexical scoping (non-code) blocks consecutively. */
5512 number_blocks (new_decl
);
5514 /* We want to create the BB unconditionally, so that the addition of
5515 debug stmts doesn't affect BB count, which may in the end cause
5516 codegen differences. */
5517 bb
= split_edge (single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
5518 while (init_stmts
.length ())
5519 insert_init_stmt (&id
, bb
, init_stmts
.pop ());
5520 update_clone_info (&id
);
5522 /* Remap the nonlocal_goto_save_area, if any. */
5523 if (cfun
->nonlocal_goto_save_area
)
5525 struct walk_stmt_info wi
;
5527 memset (&wi
, 0, sizeof (wi
));
5529 walk_tree (&cfun
->nonlocal_goto_save_area
, remap_gimple_op_r
, &wi
, NULL
);
5533 pointer_map_destroy (id
.decl_map
);
5535 pointer_map_destroy (id
.debug_map
);
5536 free_dominance_info (CDI_DOMINATORS
);
5537 free_dominance_info (CDI_POST_DOMINATORS
);
5539 fold_marked_statements (0, id
.statements_to_fold
);
5540 delete id
.statements_to_fold
;
5541 fold_cond_expr_cond ();
5542 delete_unreachable_blocks_update_callgraph (&id
);
5543 if (id
.dst_node
->definition
)
5544 cgraph_rebuild_references ();
5545 update_ssa (TODO_update_ssa
);
5547 /* After partial cloning we need to rescale frequencies, so they are
5548 within proper range in the cloned function. */
5551 struct cgraph_edge
*e
;
5552 rebuild_frequencies ();
5554 new_version_node
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5555 for (e
= new_version_node
->callees
; e
; e
= e
->next_callee
)
5557 basic_block bb
= gimple_bb (e
->call_stmt
);
5558 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
5560 e
->count
= bb
->count
;
5562 for (e
= new_version_node
->indirect_calls
; e
; e
= e
->next_callee
)
5564 basic_block bb
= gimple_bb (e
->call_stmt
);
5565 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
5567 e
->count
= bb
->count
;
5571 free_dominance_info (CDI_DOMINATORS
);
5572 free_dominance_info (CDI_POST_DOMINATORS
);
5574 gcc_assert (!id
.debug_stmts
.exists ());
5579 /* EXP is CALL_EXPR present in a GENERIC expression tree. Try to integrate
5580 the callee and return the inlined body on success. */
5583 maybe_inline_call_in_expr (tree exp
)
5585 tree fn
= get_callee_fndecl (exp
);
5587 /* We can only try to inline "const" functions. */
5588 if (fn
&& TREE_READONLY (fn
) && DECL_SAVED_TREE (fn
))
5590 struct pointer_map_t
*decl_map
= pointer_map_create ();
5591 call_expr_arg_iterator iter
;
5595 /* Remap the parameters. */
5596 for (param
= DECL_ARGUMENTS (fn
), arg
= first_call_expr_arg (exp
, &iter
);
5598 param
= DECL_CHAIN (param
), arg
= next_call_expr_arg (&iter
))
5599 *pointer_map_insert (decl_map
, param
) = arg
;
5601 memset (&id
, 0, sizeof (id
));
5603 id
.dst_fn
= current_function_decl
;
5604 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
5605 id
.decl_map
= decl_map
;
5607 id
.copy_decl
= copy_decl_no_change
;
5608 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5609 id
.transform_new_cfg
= false;
5610 id
.transform_return_to_modify
= true;
5611 id
.transform_parameter
= true;
5612 id
.transform_lang_insert_block
= NULL
;
5614 /* Make sure not to unshare trees behind the front-end's back
5615 since front-end specific mechanisms may rely on sharing. */
5616 id
.regimplify
= false;
5617 id
.do_not_unshare
= true;
5619 /* We're not inside any EH region. */
5622 t
= copy_tree_body (&id
);
5623 pointer_map_destroy (decl_map
);
5625 /* We can only return something suitable for use in a GENERIC
5627 if (TREE_CODE (t
) == MODIFY_EXPR
)
5628 return TREE_OPERAND (t
, 1);
5634 /* Duplicate a type, fields and all. */
5637 build_duplicate_type (tree type
)
5639 struct copy_body_data id
;
5641 memset (&id
, 0, sizeof (id
));
5642 id
.src_fn
= current_function_decl
;
5643 id
.dst_fn
= current_function_decl
;
5645 id
.decl_map
= pointer_map_create ();
5646 id
.debug_map
= NULL
;
5647 id
.copy_decl
= copy_decl_no_change
;
5649 type
= remap_type_1 (type
, &id
);
5651 pointer_map_destroy (id
.decl_map
);
5653 pointer_map_destroy (id
.debug_map
);
5655 TYPE_CANONICAL (type
) = type
;