2 Copyright (C) 2001-2016 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"
30 #include "tree-pass.h"
33 #include "tree-pretty-print.h"
34 #include "diagnostic-core.h"
35 #include "gimple-predict.h"
36 #include "fold-const.h"
37 #include "stor-layout.h"
39 #include "tree-inline.h"
40 #include "langhooks.h"
42 #include "tree-iterator.h"
44 #include "gimple-fold.h"
47 #include "gimple-iterator.h"
48 #include "gimplify-me.h"
49 #include "gimple-walk.h"
51 #include "tree-into-ssa.h"
56 #include "value-prof.h"
59 #include "tree-chkp.h"
62 /* I'm not real happy about this, but we need to handle gimple and
65 /* Inlining, Cloning, Versioning, Parallelization
67 Inlining: a function body is duplicated, but the PARM_DECLs are
68 remapped into VAR_DECLs, and non-void RETURN_EXPRs become
69 MODIFY_EXPRs that store to a dedicated returned-value variable.
70 The duplicated eh_region info of the copy will later be appended
71 to the info for the caller; the eh_region info in copied throwing
72 statements and RESX statements are adjusted accordingly.
74 Cloning: (only in C++) We have one body for a con/de/structor, and
75 multiple function decls, each with a unique parameter list.
76 Duplicate the body, using the given splay tree; some parameters
77 will become constants (like 0 or 1).
79 Versioning: a function body is duplicated and the result is a new
80 function rather than into blocks of an existing function as with
81 inlining. Some parameters will become constants.
83 Parallelization: a region of a function is duplicated resulting in
84 a new function. Variables may be replaced with complex expressions
85 to enable shared variable semantics.
87 All of these will simultaneously lookup any callgraph edges. If
88 we're going to inline the duplicated function body, and the given
89 function has some cloned callgraph nodes (one for each place this
90 function will be inlined) those callgraph edges will be duplicated.
91 If we're cloning the body, those callgraph edges will be
92 updated to point into the new body. (Note that the original
93 callgraph node and edge list will not be altered.)
95 See the CALL_EXPR handling case in copy_tree_body_r (). */
99 o In order to make inlining-on-trees work, we pessimized
100 function-local static constants. In particular, they are now
101 always output, even when not addressed. Fix this by treating
102 function-local static constants just like global static
103 constants; the back-end already knows not to output them if they
106 o Provide heuristics to clamp inlining of recursive template
110 /* Weights that estimate_num_insns uses to estimate the size of the
113 eni_weights eni_size_weights
;
115 /* Weights that estimate_num_insns uses to estimate the time necessary
116 to execute the produced code. */
118 eni_weights eni_time_weights
;
122 static tree
declare_return_variable (copy_body_data
*, tree
, tree
, tree
,
124 static void remap_block (tree
*, copy_body_data
*);
125 static void copy_bind_expr (tree
*, int *, copy_body_data
*);
126 static void declare_inline_vars (tree
, tree
);
127 static void remap_save_expr (tree
*, hash_map
<tree
, tree
> *, int *);
128 static void prepend_lexical_block (tree current_block
, tree new_block
);
129 static tree
copy_decl_to_var (tree
, copy_body_data
*);
130 static tree
copy_result_decl_to_var (tree
, copy_body_data
*);
131 static tree
copy_decl_maybe_to_var (tree
, copy_body_data
*);
132 static gimple_seq
remap_gimple_stmt (gimple
*, copy_body_data
*);
133 static bool delete_unreachable_blocks_update_callgraph (copy_body_data
*id
);
134 static void insert_init_stmt (copy_body_data
*, basic_block
, gimple
*);
136 /* Insert a tree->tree mapping for ID. Despite the name suggests
137 that the trees should be variables, it is used for more than that. */
140 insert_decl_map (copy_body_data
*id
, tree key
, tree value
)
142 id
->decl_map
->put (key
, value
);
144 /* Always insert an identity map as well. If we see this same new
145 node again, we won't want to duplicate it a second time. */
147 id
->decl_map
->put (value
, value
);
150 /* Insert a tree->tree mapping for ID. This is only used for
154 insert_debug_decl_map (copy_body_data
*id
, tree key
, tree value
)
156 if (!gimple_in_ssa_p (id
->src_cfun
))
159 if (!opt_for_fn (id
->dst_fn
, flag_var_tracking_assignments
))
162 if (!target_for_debug_bind (key
))
165 gcc_assert (TREE_CODE (key
) == PARM_DECL
);
166 gcc_assert (TREE_CODE (value
) == VAR_DECL
);
169 id
->debug_map
= new hash_map
<tree
, tree
>;
171 id
->debug_map
->put (key
, value
);
174 /* If nonzero, we're remapping the contents of inlined debug
175 statements. If negative, an error has occurred, such as a
176 reference to a variable that isn't available in the inlined
178 static int processing_debug_stmt
= 0;
180 /* Construct new SSA name for old NAME. ID is the inline context. */
183 remap_ssa_name (tree name
, copy_body_data
*id
)
188 gcc_assert (TREE_CODE (name
) == SSA_NAME
);
190 n
= id
->decl_map
->get (name
);
192 return unshare_expr (*n
);
194 if (processing_debug_stmt
)
196 if (SSA_NAME_IS_DEFAULT_DEF (name
)
197 && TREE_CODE (SSA_NAME_VAR (name
)) == PARM_DECL
198 && id
->entry_bb
== NULL
199 && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (cfun
)))
201 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
203 gimple_stmt_iterator gsi
;
204 tree val
= SSA_NAME_VAR (name
);
206 n
= id
->decl_map
->get (val
);
209 if (TREE_CODE (val
) != PARM_DECL
)
211 processing_debug_stmt
= -1;
214 def_temp
= gimple_build_debug_source_bind (vexpr
, val
, NULL
);
215 DECL_ARTIFICIAL (vexpr
) = 1;
216 TREE_TYPE (vexpr
) = TREE_TYPE (name
);
217 DECL_MODE (vexpr
) = DECL_MODE (SSA_NAME_VAR (name
));
218 gsi
= gsi_after_labels (single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
219 gsi_insert_before (&gsi
, def_temp
, GSI_SAME_STMT
);
223 processing_debug_stmt
= -1;
227 /* Remap anonymous SSA names or SSA names of anonymous decls. */
228 var
= SSA_NAME_VAR (name
);
230 || (!SSA_NAME_IS_DEFAULT_DEF (name
)
231 && TREE_CODE (var
) == VAR_DECL
232 && !VAR_DECL_IS_VIRTUAL_OPERAND (var
)
233 && DECL_ARTIFICIAL (var
)
234 && DECL_IGNORED_P (var
)
235 && !DECL_NAME (var
)))
237 struct ptr_info_def
*pi
;
238 new_tree
= make_ssa_name (remap_type (TREE_TYPE (name
), id
));
239 if (!var
&& SSA_NAME_IDENTIFIER (name
))
240 SET_SSA_NAME_VAR_OR_IDENTIFIER (new_tree
, SSA_NAME_IDENTIFIER (name
));
241 insert_decl_map (id
, name
, new_tree
);
242 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
243 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
244 /* At least IPA points-to info can be directly transferred. */
245 if (id
->src_cfun
->gimple_df
246 && id
->src_cfun
->gimple_df
->ipa_pta
247 && (pi
= SSA_NAME_PTR_INFO (name
))
250 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
256 /* Do not set DEF_STMT yet as statement is not copied yet. We do that
258 new_tree
= remap_decl (var
, id
);
260 /* We might've substituted constant or another SSA_NAME for
263 Replace the SSA name representing RESULT_DECL by variable during
264 inlining: this saves us from need to introduce PHI node in a case
265 return value is just partly initialized. */
266 if ((TREE_CODE (new_tree
) == VAR_DECL
|| TREE_CODE (new_tree
) == PARM_DECL
)
267 && (!SSA_NAME_VAR (name
)
268 || TREE_CODE (SSA_NAME_VAR (name
)) != RESULT_DECL
269 || !id
->transform_return_to_modify
))
271 struct ptr_info_def
*pi
;
272 new_tree
= make_ssa_name (new_tree
);
273 insert_decl_map (id
, name
, new_tree
);
274 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
275 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
276 /* At least IPA points-to info can be directly transferred. */
277 if (id
->src_cfun
->gimple_df
278 && id
->src_cfun
->gimple_df
->ipa_pta
279 && (pi
= SSA_NAME_PTR_INFO (name
))
282 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
285 if (SSA_NAME_IS_DEFAULT_DEF (name
))
287 /* By inlining function having uninitialized variable, we might
288 extend the lifetime (variable might get reused). This cause
289 ICE in the case we end up extending lifetime of SSA name across
290 abnormal edge, but also increase register pressure.
292 We simply initialize all uninitialized vars by 0 except
293 for case we are inlining to very first BB. We can avoid
294 this for all BBs that are not inside strongly connected
295 regions of the CFG, but this is expensive to test. */
297 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
)
298 && (!SSA_NAME_VAR (name
)
299 || TREE_CODE (SSA_NAME_VAR (name
)) != PARM_DECL
)
300 && (id
->entry_bb
!= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
),
302 || EDGE_COUNT (id
->entry_bb
->preds
) != 1))
304 gimple_stmt_iterator gsi
= gsi_last_bb (id
->entry_bb
);
306 tree zero
= build_zero_cst (TREE_TYPE (new_tree
));
308 init_stmt
= gimple_build_assign (new_tree
, zero
);
309 gsi_insert_after (&gsi
, init_stmt
, GSI_NEW_STMT
);
310 SSA_NAME_IS_DEFAULT_DEF (new_tree
) = 0;
314 SSA_NAME_DEF_STMT (new_tree
) = gimple_build_nop ();
315 set_ssa_default_def (cfun
, SSA_NAME_VAR (new_tree
), new_tree
);
320 insert_decl_map (id
, name
, new_tree
);
324 /* Remap DECL during the copying of the BLOCK tree for the function. */
327 remap_decl (tree decl
, copy_body_data
*id
)
331 /* We only remap local variables in the current function. */
333 /* See if we have remapped this declaration. */
335 n
= id
->decl_map
->get (decl
);
337 if (!n
&& processing_debug_stmt
)
339 processing_debug_stmt
= -1;
343 /* When remapping a type within copy_gimple_seq_and_replace_locals, all
344 necessary DECLs have already been remapped and we do not want to duplicate
345 a decl coming from outside of the sequence we are copying. */
347 && id
->prevent_decl_creation_for_types
348 && id
->remapping_type_depth
> 0
349 && (VAR_P (decl
) || TREE_CODE (decl
) == PARM_DECL
))
352 /* If we didn't already have an equivalent for this declaration, create one
356 /* Make a copy of the variable or label. */
357 tree t
= id
->copy_decl (decl
, id
);
359 /* Remember it, so that if we encounter this local entity again
360 we can reuse this copy. Do this early because remap_type may
361 need this decl for TYPE_STUB_DECL. */
362 insert_decl_map (id
, decl
, t
);
367 /* Remap types, if necessary. */
368 TREE_TYPE (t
) = remap_type (TREE_TYPE (t
), id
);
369 if (TREE_CODE (t
) == TYPE_DECL
)
371 DECL_ORIGINAL_TYPE (t
) = remap_type (DECL_ORIGINAL_TYPE (t
), id
);
373 /* Preserve the invariant that DECL_ORIGINAL_TYPE != TREE_TYPE,
374 which is enforced in gen_typedef_die when DECL_ABSTRACT_ORIGIN
375 is not set on the TYPE_DECL, for example in LTO mode. */
376 if (DECL_ORIGINAL_TYPE (t
) == TREE_TYPE (t
))
378 tree x
= build_variant_type_copy (TREE_TYPE (t
));
379 TYPE_STUB_DECL (x
) = TYPE_STUB_DECL (TREE_TYPE (t
));
380 TYPE_NAME (x
) = TYPE_NAME (TREE_TYPE (t
));
381 DECL_ORIGINAL_TYPE (t
) = x
;
385 /* Remap sizes as necessary. */
386 walk_tree (&DECL_SIZE (t
), copy_tree_body_r
, id
, NULL
);
387 walk_tree (&DECL_SIZE_UNIT (t
), copy_tree_body_r
, id
, NULL
);
389 /* If fields, do likewise for offset and qualifier. */
390 if (TREE_CODE (t
) == FIELD_DECL
)
392 walk_tree (&DECL_FIELD_OFFSET (t
), copy_tree_body_r
, id
, NULL
);
393 if (TREE_CODE (DECL_CONTEXT (t
)) == QUAL_UNION_TYPE
)
394 walk_tree (&DECL_QUALIFIER (t
), copy_tree_body_r
, id
, NULL
);
400 if (id
->do_not_unshare
)
403 return unshare_expr (*n
);
407 remap_type_1 (tree type
, copy_body_data
*id
)
411 /* We do need a copy. build and register it now. If this is a pointer or
412 reference type, remap the designated type and make a new pointer or
414 if (TREE_CODE (type
) == POINTER_TYPE
)
416 new_tree
= build_pointer_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
);
426 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
428 new_tree
= build_reference_type_for_mode (remap_type (TREE_TYPE (type
), id
),
430 TYPE_REF_CAN_ALIAS_ALL (type
));
431 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
432 new_tree
= build_type_attribute_qual_variant (new_tree
,
433 TYPE_ATTRIBUTES (type
),
435 insert_decl_map (id
, type
, new_tree
);
439 new_tree
= copy_node (type
);
441 insert_decl_map (id
, type
, new_tree
);
443 /* This is a new type, not a copy of an old type. Need to reassociate
444 variants. We can handle everything except the main variant lazily. */
445 t
= TYPE_MAIN_VARIANT (type
);
448 t
= remap_type (t
, id
);
449 TYPE_MAIN_VARIANT (new_tree
) = t
;
450 TYPE_NEXT_VARIANT (new_tree
) = TYPE_NEXT_VARIANT (t
);
451 TYPE_NEXT_VARIANT (t
) = new_tree
;
455 TYPE_MAIN_VARIANT (new_tree
) = new_tree
;
456 TYPE_NEXT_VARIANT (new_tree
) = NULL
;
459 if (TYPE_STUB_DECL (type
))
460 TYPE_STUB_DECL (new_tree
) = remap_decl (TYPE_STUB_DECL (type
), id
);
462 /* Lazily create pointer and reference types. */
463 TYPE_POINTER_TO (new_tree
) = NULL
;
464 TYPE_REFERENCE_TO (new_tree
) = NULL
;
466 /* Copy all types that may contain references to local variables; be sure to
467 preserve sharing in between type and its main variant when possible. */
468 switch (TREE_CODE (new_tree
))
472 case FIXED_POINT_TYPE
:
475 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
477 gcc_checking_assert (TYPE_MIN_VALUE (type
) == TYPE_MIN_VALUE (TYPE_MAIN_VARIANT (type
)));
478 gcc_checking_assert (TYPE_MAX_VALUE (type
) == TYPE_MAX_VALUE (TYPE_MAIN_VARIANT (type
)));
480 TYPE_MIN_VALUE (new_tree
) = TYPE_MIN_VALUE (TYPE_MAIN_VARIANT (new_tree
));
481 TYPE_MAX_VALUE (new_tree
) = TYPE_MAX_VALUE (TYPE_MAIN_VARIANT (new_tree
));
485 t
= TYPE_MIN_VALUE (new_tree
);
486 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
487 walk_tree (&TYPE_MIN_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
489 t
= TYPE_MAX_VALUE (new_tree
);
490 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
491 walk_tree (&TYPE_MAX_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
496 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
497 && TREE_TYPE (type
) == TREE_TYPE (TYPE_MAIN_VARIANT (type
)))
498 TREE_TYPE (new_tree
) = TREE_TYPE (TYPE_MAIN_VARIANT (new_tree
));
500 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
501 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
502 && TYPE_ARG_TYPES (type
) == TYPE_ARG_TYPES (TYPE_MAIN_VARIANT (type
)))
503 TYPE_ARG_TYPES (new_tree
) = TYPE_ARG_TYPES (TYPE_MAIN_VARIANT (new_tree
));
505 walk_tree (&TYPE_ARG_TYPES (new_tree
), copy_tree_body_r
, id
, NULL
);
509 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
510 && TREE_TYPE (type
) == TREE_TYPE (TYPE_MAIN_VARIANT (type
)))
511 TREE_TYPE (new_tree
) = TREE_TYPE (TYPE_MAIN_VARIANT (new_tree
));
513 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
515 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
517 gcc_checking_assert (TYPE_DOMAIN (type
) == TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)));
518 TYPE_DOMAIN (new_tree
) = TYPE_DOMAIN (TYPE_MAIN_VARIANT (new_tree
));
521 TYPE_DOMAIN (new_tree
) = remap_type (TYPE_DOMAIN (new_tree
), id
);
526 case QUAL_UNION_TYPE
:
527 if (TYPE_MAIN_VARIANT (type
) != type
528 && TYPE_FIELDS (type
) == TYPE_FIELDS (TYPE_MAIN_VARIANT (type
)))
529 TYPE_FIELDS (new_tree
) = TYPE_FIELDS (TYPE_MAIN_VARIANT (new_tree
));
534 for (f
= TYPE_FIELDS (new_tree
); f
; f
= DECL_CHAIN (f
))
536 t
= remap_decl (f
, id
);
537 DECL_CONTEXT (t
) = new_tree
;
541 TYPE_FIELDS (new_tree
) = nreverse (nf
);
547 /* Shouldn't have been thought variable sized. */
551 /* All variants of type share the same size, so use the already remaped data. */
552 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
554 gcc_checking_assert (TYPE_SIZE (type
) == TYPE_SIZE (TYPE_MAIN_VARIANT (type
)));
555 gcc_checking_assert (TYPE_SIZE_UNIT (type
) == TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type
)));
557 TYPE_SIZE (new_tree
) = TYPE_SIZE (TYPE_MAIN_VARIANT (new_tree
));
558 TYPE_SIZE_UNIT (new_tree
) = TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (new_tree
));
562 walk_tree (&TYPE_SIZE (new_tree
), copy_tree_body_r
, id
, NULL
);
563 walk_tree (&TYPE_SIZE_UNIT (new_tree
), copy_tree_body_r
, id
, NULL
);
570 remap_type (tree type
, copy_body_data
*id
)
578 /* See if we have remapped this type. */
579 node
= id
->decl_map
->get (type
);
583 /* The type only needs remapping if it's variably modified. */
584 if (! variably_modified_type_p (type
, id
->src_fn
))
586 insert_decl_map (id
, type
, type
);
590 id
->remapping_type_depth
++;
591 tmp
= remap_type_1 (type
, id
);
592 id
->remapping_type_depth
--;
597 /* Decide if DECL can be put into BLOCK_NONLOCAL_VARs. */
600 can_be_nonlocal (tree decl
, copy_body_data
*id
)
602 /* We can not duplicate function decls. */
603 if (TREE_CODE (decl
) == FUNCTION_DECL
)
606 /* Local static vars must be non-local or we get multiple declaration
608 if (TREE_CODE (decl
) == VAR_DECL
609 && !auto_var_in_fn_p (decl
, id
->src_fn
))
616 remap_decls (tree decls
, vec
<tree
, va_gc
> **nonlocalized_list
,
620 tree new_decls
= NULL_TREE
;
622 /* Remap its variables. */
623 for (old_var
= decls
; old_var
; old_var
= DECL_CHAIN (old_var
))
627 if (can_be_nonlocal (old_var
, id
))
629 /* We need to add this variable to the local decls as otherwise
630 nothing else will do so. */
631 if (TREE_CODE (old_var
) == VAR_DECL
632 && ! DECL_EXTERNAL (old_var
)
634 add_local_decl (cfun
, old_var
);
635 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
636 && !DECL_IGNORED_P (old_var
)
637 && nonlocalized_list
)
638 vec_safe_push (*nonlocalized_list
, old_var
);
642 /* Remap the variable. */
643 new_var
= remap_decl (old_var
, id
);
645 /* If we didn't remap this variable, we can't mess with its
646 TREE_CHAIN. If we remapped this variable to the return slot, it's
647 already declared somewhere else, so don't declare it here. */
649 if (new_var
== id
->retvar
)
653 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
654 && !DECL_IGNORED_P (old_var
)
655 && nonlocalized_list
)
656 vec_safe_push (*nonlocalized_list
, old_var
);
660 gcc_assert (DECL_P (new_var
));
661 DECL_CHAIN (new_var
) = new_decls
;
664 /* Also copy value-expressions. */
665 if (TREE_CODE (new_var
) == VAR_DECL
666 && DECL_HAS_VALUE_EXPR_P (new_var
))
668 tree tem
= DECL_VALUE_EXPR (new_var
);
669 bool old_regimplify
= id
->regimplify
;
670 id
->remapping_type_depth
++;
671 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
672 id
->remapping_type_depth
--;
673 id
->regimplify
= old_regimplify
;
674 SET_DECL_VALUE_EXPR (new_var
, tem
);
679 return nreverse (new_decls
);
682 /* Copy the BLOCK to contain remapped versions of the variables
683 therein. And hook the new block into the block-tree. */
686 remap_block (tree
*block
, copy_body_data
*id
)
691 /* Make the new block. */
693 new_block
= make_node (BLOCK
);
694 TREE_USED (new_block
) = TREE_USED (old_block
);
695 BLOCK_ABSTRACT_ORIGIN (new_block
) = old_block
;
696 BLOCK_SOURCE_LOCATION (new_block
) = BLOCK_SOURCE_LOCATION (old_block
);
697 BLOCK_NONLOCALIZED_VARS (new_block
)
698 = vec_safe_copy (BLOCK_NONLOCALIZED_VARS (old_block
));
701 /* Remap its variables. */
702 BLOCK_VARS (new_block
) = remap_decls (BLOCK_VARS (old_block
),
703 &BLOCK_NONLOCALIZED_VARS (new_block
),
706 if (id
->transform_lang_insert_block
)
707 id
->transform_lang_insert_block (new_block
);
709 /* Remember the remapped block. */
710 insert_decl_map (id
, old_block
, new_block
);
713 /* Copy the whole block tree and root it in id->block. */
715 remap_blocks (tree block
, copy_body_data
*id
)
718 tree new_tree
= block
;
723 remap_block (&new_tree
, id
);
724 gcc_assert (new_tree
!= block
);
725 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
726 prepend_lexical_block (new_tree
, remap_blocks (t
, id
));
727 /* Blocks are in arbitrary order, but make things slightly prettier and do
728 not swap order when producing a copy. */
729 BLOCK_SUBBLOCKS (new_tree
) = blocks_nreverse (BLOCK_SUBBLOCKS (new_tree
));
733 /* Remap the block tree rooted at BLOCK to nothing. */
735 remap_blocks_to_null (tree block
, copy_body_data
*id
)
738 insert_decl_map (id
, block
, NULL_TREE
);
739 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
740 remap_blocks_to_null (t
, id
);
744 copy_statement_list (tree
*tp
)
746 tree_stmt_iterator oi
, ni
;
749 new_tree
= alloc_stmt_list ();
750 ni
= tsi_start (new_tree
);
751 oi
= tsi_start (*tp
);
752 TREE_TYPE (new_tree
) = TREE_TYPE (*tp
);
755 for (; !tsi_end_p (oi
); tsi_next (&oi
))
757 tree stmt
= tsi_stmt (oi
);
758 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
759 /* This copy is not redundant; tsi_link_after will smash this
760 STATEMENT_LIST into the end of the one we're building, and we
761 don't want to do that with the original. */
762 copy_statement_list (&stmt
);
763 tsi_link_after (&ni
, stmt
, TSI_CONTINUE_LINKING
);
768 copy_bind_expr (tree
*tp
, int *walk_subtrees
, copy_body_data
*id
)
770 tree block
= BIND_EXPR_BLOCK (*tp
);
771 /* Copy (and replace) the statement. */
772 copy_tree_r (tp
, walk_subtrees
, NULL
);
775 remap_block (&block
, id
);
776 BIND_EXPR_BLOCK (*tp
) = block
;
779 if (BIND_EXPR_VARS (*tp
))
780 /* This will remap a lot of the same decls again, but this should be
782 BIND_EXPR_VARS (*tp
) = remap_decls (BIND_EXPR_VARS (*tp
), NULL
, id
);
786 /* Create a new gimple_seq by remapping all the statements in BODY
787 using the inlining information in ID. */
790 remap_gimple_seq (gimple_seq body
, copy_body_data
*id
)
792 gimple_stmt_iterator si
;
793 gimple_seq new_body
= NULL
;
795 for (si
= gsi_start (body
); !gsi_end_p (si
); gsi_next (&si
))
797 gimple_seq new_stmts
= remap_gimple_stmt (gsi_stmt (si
), id
);
798 gimple_seq_add_seq (&new_body
, new_stmts
);
805 /* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its
806 block using the mapping information in ID. */
809 copy_gimple_bind (gbind
*stmt
, copy_body_data
*id
)
812 tree new_block
, new_vars
;
813 gimple_seq body
, new_body
;
815 /* Copy the statement. Note that we purposely don't use copy_stmt
816 here because we need to remap statements as we copy. */
817 body
= gimple_bind_body (stmt
);
818 new_body
= remap_gimple_seq (body
, id
);
820 new_block
= gimple_bind_block (stmt
);
822 remap_block (&new_block
, id
);
824 /* This will remap a lot of the same decls again, but this should be
826 new_vars
= gimple_bind_vars (stmt
);
828 new_vars
= remap_decls (new_vars
, NULL
, id
);
830 new_bind
= gimple_build_bind (new_vars
, new_body
, new_block
);
835 /* Return true if DECL is a parameter or a SSA_NAME for a parameter. */
840 if (TREE_CODE (decl
) == SSA_NAME
)
842 decl
= SSA_NAME_VAR (decl
);
847 return (TREE_CODE (decl
) == PARM_DECL
);
850 /* Remap the dependence CLIQUE from the source to the destination function
851 as specified in ID. */
853 static unsigned short
854 remap_dependence_clique (copy_body_data
*id
, unsigned short clique
)
856 if (clique
== 0 || processing_debug_stmt
)
858 if (!id
->dependence_map
)
859 id
->dependence_map
= new hash_map
<dependence_hash
, unsigned short>;
861 unsigned short &newc
= id
->dependence_map
->get_or_insert (clique
, &existed
);
863 newc
= ++cfun
->last_clique
;
867 /* Remap the GIMPLE operand pointed to by *TP. DATA is really a
868 'struct walk_stmt_info *'. DATA->INFO is a 'copy_body_data *'.
869 WALK_SUBTREES is used to indicate walk_gimple_op whether to keep
870 recursing into the children nodes of *TP. */
873 remap_gimple_op_r (tree
*tp
, int *walk_subtrees
, void *data
)
875 struct walk_stmt_info
*wi_p
= (struct walk_stmt_info
*) data
;
876 copy_body_data
*id
= (copy_body_data
*) wi_p
->info
;
877 tree fn
= id
->src_fn
;
879 /* For recursive invocations this is no longer the LHS itself. */
880 bool is_lhs
= wi_p
->is_lhs
;
881 wi_p
->is_lhs
= false;
883 if (TREE_CODE (*tp
) == SSA_NAME
)
885 *tp
= remap_ssa_name (*tp
, id
);
888 SSA_NAME_DEF_STMT (*tp
) = wi_p
->stmt
;
891 else if (auto_var_in_fn_p (*tp
, fn
))
893 /* Local variables and labels need to be replaced by equivalent
894 variables. We don't want to copy static variables; there's
895 only one of those, no matter how many times we inline the
896 containing function. Similarly for globals from an outer
900 /* Remap the declaration. */
901 new_decl
= remap_decl (*tp
, id
);
902 gcc_assert (new_decl
);
903 /* Replace this variable with the copy. */
904 STRIP_TYPE_NOPS (new_decl
);
905 /* ??? The C++ frontend uses void * pointer zero to initialize
906 any other type. This confuses the middle-end type verification.
907 As cloned bodies do not go through gimplification again the fixup
908 there doesn't trigger. */
909 if (TREE_CODE (new_decl
) == INTEGER_CST
910 && !useless_type_conversion_p (TREE_TYPE (*tp
), TREE_TYPE (new_decl
)))
911 new_decl
= fold_convert (TREE_TYPE (*tp
), new_decl
);
915 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
917 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
919 else if (TREE_CODE (*tp
) == LABEL_DECL
920 && (!DECL_CONTEXT (*tp
)
921 || decl_function_context (*tp
) == id
->src_fn
))
922 /* These may need to be remapped for EH handling. */
923 *tp
= remap_decl (*tp
, id
);
924 else if (TREE_CODE (*tp
) == FIELD_DECL
)
926 /* If the enclosing record type is variably_modified_type_p, the field
927 has already been remapped. Otherwise, it need not be. */
928 tree
*n
= id
->decl_map
->get (*tp
);
933 else if (TYPE_P (*tp
))
934 /* Types may need remapping as well. */
935 *tp
= remap_type (*tp
, id
);
936 else if (CONSTANT_CLASS_P (*tp
))
938 /* If this is a constant, we have to copy the node iff the type
939 will be remapped. copy_tree_r will not copy a constant. */
940 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
942 if (new_type
== TREE_TYPE (*tp
))
945 else if (TREE_CODE (*tp
) == INTEGER_CST
)
946 *tp
= wide_int_to_tree (new_type
, *tp
);
949 *tp
= copy_node (*tp
);
950 TREE_TYPE (*tp
) = new_type
;
955 /* Otherwise, just copy the node. Note that copy_tree_r already
956 knows not to copy VAR_DECLs, etc., so this is safe. */
958 if (TREE_CODE (*tp
) == MEM_REF
)
960 /* We need to re-canonicalize MEM_REFs from inline substitutions
961 that can happen when a pointer argument is an ADDR_EXPR.
962 Recurse here manually to allow that. */
963 tree ptr
= TREE_OPERAND (*tp
, 0);
964 tree type
= remap_type (TREE_TYPE (*tp
), id
);
966 walk_tree (&ptr
, remap_gimple_op_r
, data
, NULL
);
967 *tp
= fold_build2 (MEM_REF
, type
, ptr
, TREE_OPERAND (*tp
, 1));
968 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
969 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
970 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
971 if (MR_DEPENDENCE_CLIQUE (old
) != 0)
973 MR_DEPENDENCE_CLIQUE (*tp
)
974 = remap_dependence_clique (id
, MR_DEPENDENCE_CLIQUE (old
));
975 MR_DEPENDENCE_BASE (*tp
) = MR_DEPENDENCE_BASE (old
);
977 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
978 remapped a parameter as the property might be valid only
979 for the parameter itself. */
980 if (TREE_THIS_NOTRAP (old
)
981 && (!is_parm (TREE_OPERAND (old
, 0))
982 || (!id
->transform_parameter
&& is_parm (ptr
))))
983 TREE_THIS_NOTRAP (*tp
) = 1;
984 REF_REVERSE_STORAGE_ORDER (*tp
) = REF_REVERSE_STORAGE_ORDER (old
);
989 /* Here is the "usual case". Copy this tree node, and then
990 tweak some special cases. */
991 copy_tree_r (tp
, walk_subtrees
, NULL
);
993 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
994 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
996 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
998 /* The copied TARGET_EXPR has never been expanded, even if the
999 original node was expanded already. */
1000 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
1001 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
1003 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
1005 /* Variable substitution need not be simple. In particular,
1006 the MEM_REF substitution above. Make sure that
1007 TREE_CONSTANT and friends are up-to-date. */
1008 int invariant
= is_gimple_min_invariant (*tp
);
1009 walk_tree (&TREE_OPERAND (*tp
, 0), remap_gimple_op_r
, data
, NULL
);
1010 recompute_tree_invariant_for_addr_expr (*tp
);
1012 /* If this used to be invariant, but is not any longer,
1013 then regimplification is probably needed. */
1014 if (invariant
&& !is_gimple_min_invariant (*tp
))
1015 id
->regimplify
= true;
1021 /* Update the TREE_BLOCK for the cloned expr. */
1024 tree new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
1025 tree old_block
= TREE_BLOCK (*tp
);
1029 n
= id
->decl_map
->get (TREE_BLOCK (*tp
));
1033 TREE_SET_BLOCK (*tp
, new_block
);
1036 /* Keep iterating. */
1041 /* Called from copy_body_id via walk_tree. DATA is really a
1042 `copy_body_data *'. */
1045 copy_tree_body_r (tree
*tp
, int *walk_subtrees
, void *data
)
1047 copy_body_data
*id
= (copy_body_data
*) data
;
1048 tree fn
= id
->src_fn
;
1051 /* Begin by recognizing trees that we'll completely rewrite for the
1052 inlining context. Our output for these trees is completely
1053 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1054 into an edge). Further down, we'll handle trees that get
1055 duplicated and/or tweaked. */
1057 /* When requested, RETURN_EXPRs should be transformed to just the
1058 contained MODIFY_EXPR. The branch semantics of the return will
1059 be handled elsewhere by manipulating the CFG rather than a statement. */
1060 if (TREE_CODE (*tp
) == RETURN_EXPR
&& id
->transform_return_to_modify
)
1062 tree assignment
= TREE_OPERAND (*tp
, 0);
1064 /* If we're returning something, just turn that into an
1065 assignment into the equivalent of the original RESULT_DECL.
1066 If the "assignment" is just the result decl, the result
1067 decl has already been set (e.g. a recent "foo (&result_decl,
1068 ...)"); just toss the entire RETURN_EXPR. */
1069 if (assignment
&& TREE_CODE (assignment
) == MODIFY_EXPR
)
1071 /* Replace the RETURN_EXPR with (a copy of) the
1072 MODIFY_EXPR hanging underneath. */
1073 *tp
= copy_node (assignment
);
1075 else /* Else the RETURN_EXPR returns no value. */
1078 return (tree
) (void *)1;
1081 else if (TREE_CODE (*tp
) == SSA_NAME
)
1083 *tp
= remap_ssa_name (*tp
, id
);
1088 /* Local variables and labels need to be replaced by equivalent
1089 variables. We don't want to copy static variables; there's only
1090 one of those, no matter how many times we inline the containing
1091 function. Similarly for globals from an outer function. */
1092 else if (auto_var_in_fn_p (*tp
, fn
))
1096 /* Remap the declaration. */
1097 new_decl
= remap_decl (*tp
, id
);
1098 gcc_assert (new_decl
);
1099 /* Replace this variable with the copy. */
1100 STRIP_TYPE_NOPS (new_decl
);
1104 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
1105 copy_statement_list (tp
);
1106 else if (TREE_CODE (*tp
) == SAVE_EXPR
1107 || TREE_CODE (*tp
) == TARGET_EXPR
)
1108 remap_save_expr (tp
, id
->decl_map
, walk_subtrees
);
1109 else if (TREE_CODE (*tp
) == LABEL_DECL
1110 && (! DECL_CONTEXT (*tp
)
1111 || decl_function_context (*tp
) == id
->src_fn
))
1112 /* These may need to be remapped for EH handling. */
1113 *tp
= remap_decl (*tp
, id
);
1114 else if (TREE_CODE (*tp
) == BIND_EXPR
)
1115 copy_bind_expr (tp
, walk_subtrees
, id
);
1116 /* Types may need remapping as well. */
1117 else if (TYPE_P (*tp
))
1118 *tp
= remap_type (*tp
, id
);
1120 /* If this is a constant, we have to copy the node iff the type will be
1121 remapped. copy_tree_r will not copy a constant. */
1122 else if (CONSTANT_CLASS_P (*tp
))
1124 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
1126 if (new_type
== TREE_TYPE (*tp
))
1129 else if (TREE_CODE (*tp
) == INTEGER_CST
)
1130 *tp
= wide_int_to_tree (new_type
, *tp
);
1133 *tp
= copy_node (*tp
);
1134 TREE_TYPE (*tp
) = new_type
;
1138 /* Otherwise, just copy the node. Note that copy_tree_r already
1139 knows not to copy VAR_DECLs, etc., so this is safe. */
1142 /* Here we handle trees that are not completely rewritten.
1143 First we detect some inlining-induced bogosities for
1145 if (TREE_CODE (*tp
) == MODIFY_EXPR
1146 && TREE_OPERAND (*tp
, 0) == TREE_OPERAND (*tp
, 1)
1147 && (auto_var_in_fn_p (TREE_OPERAND (*tp
, 0), fn
)))
1149 /* Some assignments VAR = VAR; don't generate any rtl code
1150 and thus don't count as variable modification. Avoid
1151 keeping bogosities like 0 = 0. */
1152 tree decl
= TREE_OPERAND (*tp
, 0), value
;
1155 n
= id
->decl_map
->get (decl
);
1159 STRIP_TYPE_NOPS (value
);
1160 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1162 *tp
= build_empty_stmt (EXPR_LOCATION (*tp
));
1163 return copy_tree_body_r (tp
, walk_subtrees
, data
);
1167 else if (TREE_CODE (*tp
) == INDIRECT_REF
)
1169 /* Get rid of *& from inline substitutions that can happen when a
1170 pointer argument is an ADDR_EXPR. */
1171 tree decl
= TREE_OPERAND (*tp
, 0);
1172 tree
*n
= id
->decl_map
->get (decl
);
1175 /* If we happen to get an ADDR_EXPR in n->value, strip
1176 it manually here as we'll eventually get ADDR_EXPRs
1177 which lie about their types pointed to. In this case
1178 build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
1179 but we absolutely rely on that. As fold_indirect_ref
1180 does other useful transformations, try that first, though. */
1181 tree type
= TREE_TYPE (*tp
);
1182 tree ptr
= id
->do_not_unshare
? *n
: unshare_expr (*n
);
1184 *tp
= gimple_fold_indirect_ref (ptr
);
1187 if (TREE_CODE (ptr
) == ADDR_EXPR
)
1190 = fold_indirect_ref_1 (EXPR_LOCATION (ptr
), type
, ptr
);
1191 /* ??? We should either assert here or build
1192 a VIEW_CONVERT_EXPR instead of blindly leaking
1193 incompatible types to our IL. */
1195 *tp
= TREE_OPERAND (ptr
, 0);
1199 *tp
= build1 (INDIRECT_REF
, type
, ptr
);
1200 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1201 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1202 TREE_READONLY (*tp
) = TREE_READONLY (old
);
1203 /* We cannot propagate the TREE_THIS_NOTRAP flag if we
1204 have remapped a parameter as the property might be
1205 valid only for the parameter itself. */
1206 if (TREE_THIS_NOTRAP (old
)
1207 && (!is_parm (TREE_OPERAND (old
, 0))
1208 || (!id
->transform_parameter
&& is_parm (ptr
))))
1209 TREE_THIS_NOTRAP (*tp
) = 1;
1216 else if (TREE_CODE (*tp
) == MEM_REF
)
1218 /* We need to re-canonicalize MEM_REFs from inline substitutions
1219 that can happen when a pointer argument is an ADDR_EXPR.
1220 Recurse here manually to allow that. */
1221 tree ptr
= TREE_OPERAND (*tp
, 0);
1222 tree type
= remap_type (TREE_TYPE (*tp
), id
);
1224 walk_tree (&ptr
, copy_tree_body_r
, data
, NULL
);
1225 *tp
= fold_build2 (MEM_REF
, type
, ptr
, TREE_OPERAND (*tp
, 1));
1226 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1227 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1228 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
1229 if (MR_DEPENDENCE_CLIQUE (old
) != 0)
1231 MR_DEPENDENCE_CLIQUE (*tp
)
1232 = remap_dependence_clique (id
, MR_DEPENDENCE_CLIQUE (old
));
1233 MR_DEPENDENCE_BASE (*tp
) = MR_DEPENDENCE_BASE (old
);
1235 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
1236 remapped a parameter as the property might be valid only
1237 for the parameter itself. */
1238 if (TREE_THIS_NOTRAP (old
)
1239 && (!is_parm (TREE_OPERAND (old
, 0))
1240 || (!id
->transform_parameter
&& is_parm (ptr
))))
1241 TREE_THIS_NOTRAP (*tp
) = 1;
1242 REF_REVERSE_STORAGE_ORDER (*tp
) = REF_REVERSE_STORAGE_ORDER (old
);
1247 /* Here is the "usual case". Copy this tree node, and then
1248 tweak some special cases. */
1249 copy_tree_r (tp
, walk_subtrees
, NULL
);
1251 /* If EXPR has block defined, map it to newly constructed block.
1252 When inlining we want EXPRs without block appear in the block
1253 of function call if we are not remapping a type. */
1256 new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
1257 if (TREE_BLOCK (*tp
))
1260 n
= id
->decl_map
->get (TREE_BLOCK (*tp
));
1264 TREE_SET_BLOCK (*tp
, new_block
);
1267 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
1268 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
1270 /* The copied TARGET_EXPR has never been expanded, even if the
1271 original node was expanded already. */
1272 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
1274 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
1275 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
1278 /* Variable substitution need not be simple. In particular, the
1279 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
1280 and friends are up-to-date. */
1281 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
1283 int invariant
= is_gimple_min_invariant (*tp
);
1284 walk_tree (&TREE_OPERAND (*tp
, 0), copy_tree_body_r
, id
, NULL
);
1286 /* Handle the case where we substituted an INDIRECT_REF
1287 into the operand of the ADDR_EXPR. */
1288 if (TREE_CODE (TREE_OPERAND (*tp
, 0)) == INDIRECT_REF
)
1290 tree t
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0);
1291 if (TREE_TYPE (t
) != TREE_TYPE (*tp
))
1292 t
= fold_convert (remap_type (TREE_TYPE (*tp
), id
), t
);
1296 recompute_tree_invariant_for_addr_expr (*tp
);
1298 /* If this used to be invariant, but is not any longer,
1299 then regimplification is probably needed. */
1300 if (invariant
&& !is_gimple_min_invariant (*tp
))
1301 id
->regimplify
= true;
1307 /* Keep iterating. */
1311 /* Helper for remap_gimple_stmt. Given an EH region number for the
1312 source function, map that to the duplicate EH region number in
1313 the destination function. */
1316 remap_eh_region_nr (int old_nr
, copy_body_data
*id
)
1318 eh_region old_r
, new_r
;
1320 old_r
= get_eh_region_from_number_fn (id
->src_cfun
, old_nr
);
1321 new_r
= static_cast<eh_region
> (*id
->eh_map
->get (old_r
));
1323 return new_r
->index
;
1326 /* Similar, but operate on INTEGER_CSTs. */
1329 remap_eh_region_tree_nr (tree old_t_nr
, copy_body_data
*id
)
1333 old_nr
= tree_to_shwi (old_t_nr
);
1334 new_nr
= remap_eh_region_nr (old_nr
, id
);
1336 return build_int_cst (integer_type_node
, new_nr
);
1339 /* Helper for copy_bb. Remap statement STMT using the inlining
1340 information in ID. Return the new statement copy. */
1343 remap_gimple_stmt (gimple
*stmt
, copy_body_data
*id
)
1345 gimple
*copy
= NULL
;
1346 struct walk_stmt_info wi
;
1347 bool skip_first
= false;
1348 gimple_seq stmts
= NULL
;
1350 if (is_gimple_debug (stmt
)
1351 && !opt_for_fn (id
->dst_fn
, flag_var_tracking_assignments
))
1354 /* Begin by recognizing trees that we'll completely rewrite for the
1355 inlining context. Our output for these trees is completely
1356 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1357 into an edge). Further down, we'll handle trees that get
1358 duplicated and/or tweaked. */
1360 /* When requested, GIMPLE_RETURNs should be transformed to just the
1361 contained GIMPLE_ASSIGN. The branch semantics of the return will
1362 be handled elsewhere by manipulating the CFG rather than the
1364 if (gimple_code (stmt
) == GIMPLE_RETURN
&& id
->transform_return_to_modify
)
1366 tree retval
= gimple_return_retval (as_a
<greturn
*> (stmt
));
1367 tree retbnd
= gimple_return_retbnd (stmt
);
1368 tree bndslot
= id
->retbnd
;
1370 if (retbnd
&& bndslot
)
1372 gimple
*bndcopy
= gimple_build_assign (bndslot
, retbnd
);
1373 memset (&wi
, 0, sizeof (wi
));
1375 walk_gimple_op (bndcopy
, remap_gimple_op_r
, &wi
);
1376 gimple_seq_add_stmt (&stmts
, bndcopy
);
1379 /* If we're returning something, just turn that into an
1380 assignment into the equivalent of the original RESULT_DECL.
1381 If RETVAL is just the result decl, the result decl has
1382 already been set (e.g. a recent "foo (&result_decl, ...)");
1383 just toss the entire GIMPLE_RETURN. */
1385 && (TREE_CODE (retval
) != RESULT_DECL
1386 && (TREE_CODE (retval
) != SSA_NAME
1387 || ! SSA_NAME_VAR (retval
)
1388 || TREE_CODE (SSA_NAME_VAR (retval
)) != RESULT_DECL
)))
1390 copy
= gimple_build_assign (id
->do_not_unshare
1391 ? id
->retvar
: unshare_expr (id
->retvar
),
1393 /* id->retvar is already substituted. Skip it on later remapping. */
1396 /* We need to copy bounds if return structure with pointers into
1397 instrumented function. */
1398 if (chkp_function_instrumented_p (id
->dst_fn
)
1400 && !BOUNDED_P (id
->retvar
)
1401 && chkp_type_has_pointer (TREE_TYPE (id
->retvar
)))
1402 id
->assign_stmts
.safe_push (copy
);
1408 else if (gimple_has_substatements (stmt
))
1412 /* When cloning bodies from the C++ front end, we will be handed bodies
1413 in High GIMPLE form. Handle here all the High GIMPLE statements that
1414 have embedded statements. */
1415 switch (gimple_code (stmt
))
1418 copy
= copy_gimple_bind (as_a
<gbind
*> (stmt
), id
);
1423 gcatch
*catch_stmt
= as_a
<gcatch
*> (stmt
);
1424 s1
= remap_gimple_seq (gimple_catch_handler (catch_stmt
), id
);
1425 copy
= gimple_build_catch (gimple_catch_types (catch_stmt
), s1
);
1429 case GIMPLE_EH_FILTER
:
1430 s1
= remap_gimple_seq (gimple_eh_filter_failure (stmt
), id
);
1431 copy
= gimple_build_eh_filter (gimple_eh_filter_types (stmt
), s1
);
1435 s1
= remap_gimple_seq (gimple_try_eval (stmt
), id
);
1436 s2
= remap_gimple_seq (gimple_try_cleanup (stmt
), id
);
1437 copy
= gimple_build_try (s1
, s2
, gimple_try_kind (stmt
));
1440 case GIMPLE_WITH_CLEANUP_EXPR
:
1441 s1
= remap_gimple_seq (gimple_wce_cleanup (stmt
), id
);
1442 copy
= gimple_build_wce (s1
);
1445 case GIMPLE_OMP_PARALLEL
:
1447 gomp_parallel
*omp_par_stmt
= as_a
<gomp_parallel
*> (stmt
);
1448 s1
= remap_gimple_seq (gimple_omp_body (omp_par_stmt
), id
);
1449 copy
= gimple_build_omp_parallel
1451 gimple_omp_parallel_clauses (omp_par_stmt
),
1452 gimple_omp_parallel_child_fn (omp_par_stmt
),
1453 gimple_omp_parallel_data_arg (omp_par_stmt
));
1457 case GIMPLE_OMP_TASK
:
1458 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1459 copy
= gimple_build_omp_task
1461 gimple_omp_task_clauses (stmt
),
1462 gimple_omp_task_child_fn (stmt
),
1463 gimple_omp_task_data_arg (stmt
),
1464 gimple_omp_task_copy_fn (stmt
),
1465 gimple_omp_task_arg_size (stmt
),
1466 gimple_omp_task_arg_align (stmt
));
1469 case GIMPLE_OMP_FOR
:
1470 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1471 s2
= remap_gimple_seq (gimple_omp_for_pre_body (stmt
), id
);
1472 copy
= gimple_build_omp_for (s1
, gimple_omp_for_kind (stmt
),
1473 gimple_omp_for_clauses (stmt
),
1474 gimple_omp_for_collapse (stmt
), s2
);
1477 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1479 gimple_omp_for_set_index (copy
, i
,
1480 gimple_omp_for_index (stmt
, i
));
1481 gimple_omp_for_set_initial (copy
, i
,
1482 gimple_omp_for_initial (stmt
, i
));
1483 gimple_omp_for_set_final (copy
, i
,
1484 gimple_omp_for_final (stmt
, i
));
1485 gimple_omp_for_set_incr (copy
, i
,
1486 gimple_omp_for_incr (stmt
, i
));
1487 gimple_omp_for_set_cond (copy
, i
,
1488 gimple_omp_for_cond (stmt
, i
));
1493 case GIMPLE_OMP_MASTER
:
1494 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1495 copy
= gimple_build_omp_master (s1
);
1498 case GIMPLE_OMP_TASKGROUP
:
1499 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1500 copy
= gimple_build_omp_taskgroup (s1
);
1503 case GIMPLE_OMP_ORDERED
:
1504 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1505 copy
= gimple_build_omp_ordered
1507 gimple_omp_ordered_clauses (as_a
<gomp_ordered
*> (stmt
)));
1510 case GIMPLE_OMP_SECTION
:
1511 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1512 copy
= gimple_build_omp_section (s1
);
1515 case GIMPLE_OMP_SECTIONS
:
1516 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1517 copy
= gimple_build_omp_sections
1518 (s1
, gimple_omp_sections_clauses (stmt
));
1521 case GIMPLE_OMP_SINGLE
:
1522 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1523 copy
= gimple_build_omp_single
1524 (s1
, gimple_omp_single_clauses (stmt
));
1527 case GIMPLE_OMP_TARGET
:
1528 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1529 copy
= gimple_build_omp_target
1530 (s1
, gimple_omp_target_kind (stmt
),
1531 gimple_omp_target_clauses (stmt
));
1534 case GIMPLE_OMP_TEAMS
:
1535 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1536 copy
= gimple_build_omp_teams
1537 (s1
, gimple_omp_teams_clauses (stmt
));
1540 case GIMPLE_OMP_CRITICAL
:
1541 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1542 copy
= gimple_build_omp_critical (s1
,
1543 gimple_omp_critical_name
1544 (as_a
<gomp_critical
*> (stmt
)),
1545 gimple_omp_critical_clauses
1546 (as_a
<gomp_critical
*> (stmt
)));
1549 case GIMPLE_TRANSACTION
:
1551 gtransaction
*old_trans_stmt
= as_a
<gtransaction
*> (stmt
);
1552 gtransaction
*new_trans_stmt
;
1553 s1
= remap_gimple_seq (gimple_transaction_body (old_trans_stmt
),
1555 copy
= new_trans_stmt
= gimple_build_transaction (s1
);
1556 gimple_transaction_set_subcode (new_trans_stmt
,
1557 gimple_transaction_subcode (old_trans_stmt
));
1558 gimple_transaction_set_label_norm (new_trans_stmt
,
1559 gimple_transaction_label_norm (old_trans_stmt
));
1560 gimple_transaction_set_label_uninst (new_trans_stmt
,
1561 gimple_transaction_label_uninst (old_trans_stmt
));
1562 gimple_transaction_set_label_over (new_trans_stmt
,
1563 gimple_transaction_label_over (old_trans_stmt
));
1573 if (gimple_assign_copy_p (stmt
)
1574 && gimple_assign_lhs (stmt
) == gimple_assign_rhs1 (stmt
)
1575 && auto_var_in_fn_p (gimple_assign_lhs (stmt
), id
->src_fn
))
1577 /* Here we handle statements that are not completely rewritten.
1578 First we detect some inlining-induced bogosities for
1581 /* Some assignments VAR = VAR; don't generate any rtl code
1582 and thus don't count as variable modification. Avoid
1583 keeping bogosities like 0 = 0. */
1584 tree decl
= gimple_assign_lhs (stmt
), value
;
1587 n
= id
->decl_map
->get (decl
);
1591 STRIP_TYPE_NOPS (value
);
1592 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1597 /* For *ptr_N ={v} {CLOBBER}, if ptr_N is SSA_NAME defined
1598 in a block that we aren't copying during tree_function_versioning,
1599 just drop the clobber stmt. */
1600 if (id
->blocks_to_copy
&& gimple_clobber_p (stmt
))
1602 tree lhs
= gimple_assign_lhs (stmt
);
1603 if (TREE_CODE (lhs
) == MEM_REF
1604 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == SSA_NAME
)
1606 gimple
*def_stmt
= SSA_NAME_DEF_STMT (TREE_OPERAND (lhs
, 0));
1607 if (gimple_bb (def_stmt
)
1608 && !bitmap_bit_p (id
->blocks_to_copy
,
1609 gimple_bb (def_stmt
)->index
))
1614 if (gimple_debug_bind_p (stmt
))
1617 = gimple_build_debug_bind (gimple_debug_bind_get_var (stmt
),
1618 gimple_debug_bind_get_value (stmt
),
1620 id
->debug_stmts
.safe_push (copy
);
1621 gimple_seq_add_stmt (&stmts
, copy
);
1624 if (gimple_debug_source_bind_p (stmt
))
1626 gdebug
*copy
= gimple_build_debug_source_bind
1627 (gimple_debug_source_bind_get_var (stmt
),
1628 gimple_debug_source_bind_get_value (stmt
),
1630 id
->debug_stmts
.safe_push (copy
);
1631 gimple_seq_add_stmt (&stmts
, copy
);
1635 /* Create a new deep copy of the statement. */
1636 copy
= gimple_copy (stmt
);
1638 /* Clear flags that need revisiting. */
1639 if (gcall
*call_stmt
= dyn_cast
<gcall
*> (copy
))
1641 if (gimple_call_tail_p (call_stmt
))
1642 gimple_call_set_tail (call_stmt
, false);
1643 if (gimple_call_from_thunk_p (call_stmt
))
1644 gimple_call_set_from_thunk (call_stmt
, false);
1645 if (gimple_call_internal_p (call_stmt
)
1646 && IN_RANGE (gimple_call_internal_fn (call_stmt
),
1647 IFN_GOMP_SIMD_ORDERED_START
,
1648 IFN_GOMP_SIMD_ORDERED_END
))
1649 DECL_STRUCT_FUNCTION (id
->dst_fn
)->has_simduid_loops
= true;
1652 /* Remap the region numbers for __builtin_eh_{pointer,filter},
1653 RESX and EH_DISPATCH. */
1655 switch (gimple_code (copy
))
1659 tree r
, fndecl
= gimple_call_fndecl (copy
);
1660 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
1661 switch (DECL_FUNCTION_CODE (fndecl
))
1663 case BUILT_IN_EH_COPY_VALUES
:
1664 r
= gimple_call_arg (copy
, 1);
1665 r
= remap_eh_region_tree_nr (r
, id
);
1666 gimple_call_set_arg (copy
, 1, r
);
1669 case BUILT_IN_EH_POINTER
:
1670 case BUILT_IN_EH_FILTER
:
1671 r
= gimple_call_arg (copy
, 0);
1672 r
= remap_eh_region_tree_nr (r
, id
);
1673 gimple_call_set_arg (copy
, 0, r
);
1680 /* Reset alias info if we didn't apply measures to
1681 keep it valid over inlining by setting DECL_PT_UID. */
1682 if (!id
->src_cfun
->gimple_df
1683 || !id
->src_cfun
->gimple_df
->ipa_pta
)
1684 gimple_call_reset_alias_info (as_a
<gcall
*> (copy
));
1690 gresx
*resx_stmt
= as_a
<gresx
*> (copy
);
1691 int r
= gimple_resx_region (resx_stmt
);
1692 r
= remap_eh_region_nr (r
, id
);
1693 gimple_resx_set_region (resx_stmt
, r
);
1697 case GIMPLE_EH_DISPATCH
:
1699 geh_dispatch
*eh_dispatch
= as_a
<geh_dispatch
*> (copy
);
1700 int r
= gimple_eh_dispatch_region (eh_dispatch
);
1701 r
= remap_eh_region_nr (r
, id
);
1702 gimple_eh_dispatch_set_region (eh_dispatch
, r
);
1711 /* If STMT has a block defined, map it to the newly constructed
1713 if (gimple_block (copy
))
1716 n
= id
->decl_map
->get (gimple_block (copy
));
1718 gimple_set_block (copy
, *n
);
1721 if (gimple_debug_bind_p (copy
) || gimple_debug_source_bind_p (copy
))
1723 gimple_seq_add_stmt (&stmts
, copy
);
1727 /* Remap all the operands in COPY. */
1728 memset (&wi
, 0, sizeof (wi
));
1731 walk_tree (gimple_op_ptr (copy
, 1), remap_gimple_op_r
, &wi
, NULL
);
1733 walk_gimple_op (copy
, remap_gimple_op_r
, &wi
);
1735 /* Clear the copied virtual operands. We are not remapping them here
1736 but are going to recreate them from scratch. */
1737 if (gimple_has_mem_ops (copy
))
1739 gimple_set_vdef (copy
, NULL_TREE
);
1740 gimple_set_vuse (copy
, NULL_TREE
);
1743 gimple_seq_add_stmt (&stmts
, copy
);
1748 /* Copy basic block, scale profile accordingly. Edges will be taken care of
1752 copy_bb (copy_body_data
*id
, basic_block bb
, int frequency_scale
,
1753 gcov_type count_scale
)
1755 gimple_stmt_iterator gsi
, copy_gsi
, seq_gsi
;
1756 basic_block copy_basic_block
;
1761 /* Search for previous copied basic block. */
1764 prev
= prev
->prev_bb
;
1766 /* create_basic_block() will append every new block to
1767 basic_block_info automatically. */
1768 copy_basic_block
= create_basic_block (NULL
, (basic_block
) prev
->aux
);
1769 copy_basic_block
->count
= apply_scale (bb
->count
, count_scale
);
1771 /* We are going to rebuild frequencies from scratch. These values
1772 have just small importance to drive canonicalize_loop_headers. */
1773 freq
= apply_scale ((gcov_type
)bb
->frequency
, frequency_scale
);
1775 /* We recompute frequencies after inlining, so this is quite safe. */
1776 if (freq
> BB_FREQ_MAX
)
1778 copy_basic_block
->frequency
= freq
;
1780 copy_gsi
= gsi_start_bb (copy_basic_block
);
1782 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1785 gimple
*stmt
= gsi_stmt (gsi
);
1786 gimple
*orig_stmt
= stmt
;
1787 gimple_stmt_iterator stmts_gsi
;
1788 bool stmt_added
= false;
1790 id
->regimplify
= false;
1791 stmts
= remap_gimple_stmt (stmt
, id
);
1793 if (gimple_seq_empty_p (stmts
))
1798 for (stmts_gsi
= gsi_start (stmts
);
1799 !gsi_end_p (stmts_gsi
); )
1801 stmt
= gsi_stmt (stmts_gsi
);
1803 /* Advance iterator now before stmt is moved to seq_gsi. */
1804 gsi_next (&stmts_gsi
);
1806 if (gimple_nop_p (stmt
))
1809 gimple_duplicate_stmt_histograms (cfun
, stmt
, id
->src_cfun
,
1812 /* With return slot optimization we can end up with
1813 non-gimple (foo *)&this->m, fix that here. */
1814 if (is_gimple_assign (stmt
)
1815 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
))
1816 && !is_gimple_val (gimple_assign_rhs1 (stmt
)))
1819 new_rhs
= force_gimple_operand_gsi (&seq_gsi
,
1820 gimple_assign_rhs1 (stmt
),
1822 GSI_CONTINUE_LINKING
);
1823 gimple_assign_set_rhs1 (stmt
, new_rhs
);
1824 id
->regimplify
= false;
1827 gsi_insert_after (&seq_gsi
, stmt
, GSI_NEW_STMT
);
1830 gimple_regimplify_operands (stmt
, &seq_gsi
);
1838 /* If copy_basic_block has been empty at the start of this iteration,
1839 call gsi_start_bb again to get at the newly added statements. */
1840 if (gsi_end_p (copy_gsi
))
1841 copy_gsi
= gsi_start_bb (copy_basic_block
);
1843 gsi_next (©_gsi
);
1845 /* Process the new statement. The call to gimple_regimplify_operands
1846 possibly turned the statement into multiple statements, we
1847 need to process all of them. */
1853 stmt
= gsi_stmt (copy_gsi
);
1854 call_stmt
= dyn_cast
<gcall
*> (stmt
);
1856 && gimple_call_va_arg_pack_p (call_stmt
)
1859 /* __builtin_va_arg_pack () should be replaced by
1860 all arguments corresponding to ... in the caller. */
1864 size_t nargs
= gimple_call_num_args (id
->call_stmt
);
1865 size_t n
, i
, nargs_to_copy
;
1866 bool remove_bounds
= false;
1868 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1871 /* Bounds should be removed from arg pack in case
1872 we handle not instrumented call in instrumented
1874 nargs_to_copy
= nargs
;
1875 if (gimple_call_with_bounds_p (id
->call_stmt
)
1876 && !gimple_call_with_bounds_p (stmt
))
1878 for (i
= gimple_call_num_args (id
->call_stmt
) - nargs
;
1879 i
< gimple_call_num_args (id
->call_stmt
);
1881 if (POINTER_BOUNDS_P (gimple_call_arg (id
->call_stmt
, i
)))
1883 remove_bounds
= true;
1886 /* Create the new array of arguments. */
1887 n
= nargs_to_copy
+ gimple_call_num_args (call_stmt
);
1888 argarray
.create (n
);
1889 argarray
.safe_grow_cleared (n
);
1891 /* Copy all the arguments before '...' */
1892 memcpy (argarray
.address (),
1893 gimple_call_arg_ptr (call_stmt
, 0),
1894 gimple_call_num_args (call_stmt
) * sizeof (tree
));
1898 /* Append the rest of arguments removing bounds. */
1899 unsigned cur
= gimple_call_num_args (call_stmt
);
1900 i
= gimple_call_num_args (id
->call_stmt
) - nargs
;
1901 for (i
= gimple_call_num_args (id
->call_stmt
) - nargs
;
1902 i
< gimple_call_num_args (id
->call_stmt
);
1904 if (!POINTER_BOUNDS_P (gimple_call_arg (id
->call_stmt
, i
)))
1905 argarray
[cur
++] = gimple_call_arg (id
->call_stmt
, i
);
1906 gcc_assert (cur
== n
);
1910 /* Append the arguments passed in '...' */
1911 memcpy (argarray
.address () + gimple_call_num_args (call_stmt
),
1912 gimple_call_arg_ptr (id
->call_stmt
, 0)
1913 + (gimple_call_num_args (id
->call_stmt
) - nargs
),
1914 nargs
* sizeof (tree
));
1917 new_call
= gimple_build_call_vec (gimple_call_fn (call_stmt
),
1920 argarray
.release ();
1922 /* Copy all GIMPLE_CALL flags, location and block, except
1923 GF_CALL_VA_ARG_PACK. */
1924 gimple_call_copy_flags (new_call
, call_stmt
);
1925 gimple_call_set_va_arg_pack (new_call
, false);
1926 gimple_set_location (new_call
, gimple_location (stmt
));
1927 gimple_set_block (new_call
, gimple_block (stmt
));
1928 gimple_call_set_lhs (new_call
, gimple_call_lhs (call_stmt
));
1930 gsi_replace (©_gsi
, new_call
, false);
1935 && (decl
= gimple_call_fndecl (stmt
))
1936 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
1937 && DECL_FUNCTION_CODE (decl
) == BUILT_IN_VA_ARG_PACK_LEN
)
1939 /* __builtin_va_arg_pack_len () should be replaced by
1940 the number of anonymous arguments. */
1941 size_t nargs
= gimple_call_num_args (id
->call_stmt
), i
;
1945 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1948 /* For instrumented calls we should ignore bounds. */
1949 for (i
= gimple_call_num_args (id
->call_stmt
) - nargs
;
1950 i
< gimple_call_num_args (id
->call_stmt
);
1952 if (POINTER_BOUNDS_P (gimple_call_arg (id
->call_stmt
, i
)))
1955 count
= build_int_cst (integer_type_node
, nargs
);
1956 new_stmt
= gimple_build_assign (gimple_call_lhs (stmt
), count
);
1957 gsi_replace (©_gsi
, new_stmt
, false);
1962 && gimple_call_internal_p (stmt
)
1963 && gimple_call_internal_fn (stmt
) == IFN_TSAN_FUNC_EXIT
)
1965 /* Drop TSAN_FUNC_EXIT () internal calls during inlining. */
1966 gsi_remove (©_gsi
, false);
1970 /* Statements produced by inlining can be unfolded, especially
1971 when we constant propagated some operands. We can't fold
1972 them right now for two reasons:
1973 1) folding require SSA_NAME_DEF_STMTs to be correct
1974 2) we can't change function calls to builtins.
1975 So we just mark statement for later folding. We mark
1976 all new statements, instead just statements that has changed
1977 by some nontrivial substitution so even statements made
1978 foldable indirectly are updated. If this turns out to be
1979 expensive, copy_body can be told to watch for nontrivial
1981 if (id
->statements_to_fold
)
1982 id
->statements_to_fold
->add (stmt
);
1984 /* We're duplicating a CALL_EXPR. Find any corresponding
1985 callgraph edges and update or duplicate them. */
1986 if (gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
))
1988 struct cgraph_edge
*edge
;
1990 switch (id
->transform_call_graph_edges
)
1992 case CB_CGE_DUPLICATE
:
1993 edge
= id
->src_node
->get_edge (orig_stmt
);
1996 int edge_freq
= edge
->frequency
;
1998 struct cgraph_edge
*old_edge
= edge
;
1999 edge
= edge
->clone (id
->dst_node
, call_stmt
,
2001 REG_BR_PROB_BASE
, CGRAPH_FREQ_BASE
,
2003 /* We could also just rescale the frequency, but
2004 doing so would introduce roundoff errors and make
2005 verifier unhappy. */
2006 new_freq
= compute_call_stmt_bb_frequency (id
->dst_node
->decl
,
2009 /* Speculative calls consist of two edges - direct and indirect.
2010 Duplicate the whole thing and distribute frequencies accordingly. */
2011 if (edge
->speculative
)
2013 struct cgraph_edge
*direct
, *indirect
;
2014 struct ipa_ref
*ref
;
2016 gcc_assert (!edge
->indirect_unknown_callee
);
2017 old_edge
->speculative_call_info (direct
, indirect
, ref
);
2018 indirect
= indirect
->clone (id
->dst_node
, call_stmt
,
2020 REG_BR_PROB_BASE
, CGRAPH_FREQ_BASE
,
2022 if (old_edge
->frequency
+ indirect
->frequency
)
2024 edge
->frequency
= MIN (RDIV ((gcov_type
)new_freq
* old_edge
->frequency
,
2025 (old_edge
->frequency
+ indirect
->frequency
)),
2027 indirect
->frequency
= MIN (RDIV ((gcov_type
)new_freq
* indirect
->frequency
,
2028 (old_edge
->frequency
+ indirect
->frequency
)),
2031 id
->dst_node
->clone_reference (ref
, stmt
);
2035 edge
->frequency
= new_freq
;
2037 && profile_status_for_fn (cfun
) != PROFILE_ABSENT
2038 && (edge_freq
> edge
->frequency
+ 10
2039 || edge_freq
< edge
->frequency
- 10))
2041 fprintf (dump_file
, "Edge frequency estimated by "
2042 "cgraph %i diverge from inliner's estimate %i\n",
2046 "Orig bb: %i, orig bb freq %i, new bb freq %i\n",
2049 copy_basic_block
->frequency
);
2055 case CB_CGE_MOVE_CLONES
:
2056 id
->dst_node
->set_call_stmt_including_clones (orig_stmt
,
2058 edge
= id
->dst_node
->get_edge (stmt
);
2062 edge
= id
->dst_node
->get_edge (orig_stmt
);
2064 edge
->set_call_stmt (call_stmt
);
2071 /* Constant propagation on argument done during inlining
2072 may create new direct call. Produce an edge for it. */
2074 || (edge
->indirect_inlining_edge
2075 && id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
))
2076 && id
->dst_node
->definition
2077 && (fn
= gimple_call_fndecl (stmt
)) != NULL
)
2079 struct cgraph_node
*dest
= cgraph_node::get_create (fn
);
2081 /* We have missing edge in the callgraph. This can happen
2082 when previous inlining turned an indirect call into a
2083 direct call by constant propagating arguments or we are
2084 producing dead clone (for further cloning). In all
2085 other cases we hit a bug (incorrect node sharing is the
2086 most common reason for missing edges). */
2087 gcc_assert (!dest
->definition
2088 || dest
->address_taken
2089 || !id
->src_node
->definition
2090 || !id
->dst_node
->definition
);
2091 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
)
2092 id
->dst_node
->create_edge_including_clones
2093 (dest
, orig_stmt
, call_stmt
, bb
->count
,
2094 compute_call_stmt_bb_frequency (id
->dst_node
->decl
,
2096 CIF_ORIGINALLY_INDIRECT_CALL
);
2098 id
->dst_node
->create_edge (dest
, call_stmt
,
2100 compute_call_stmt_bb_frequency
2101 (id
->dst_node
->decl
,
2102 copy_basic_block
))->inline_failed
2103 = CIF_ORIGINALLY_INDIRECT_CALL
;
2106 fprintf (dump_file
, "Created new direct edge to %s\n",
2111 notice_special_calls (as_a
<gcall
*> (stmt
));
2114 maybe_duplicate_eh_stmt_fn (cfun
, stmt
, id
->src_cfun
, orig_stmt
,
2115 id
->eh_map
, id
->eh_lp_nr
);
2117 gsi_next (©_gsi
);
2119 while (!gsi_end_p (copy_gsi
));
2121 copy_gsi
= gsi_last_bb (copy_basic_block
);
2124 return copy_basic_block
;
2127 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
2128 form is quite easy, since dominator relationship for old basic blocks does
2131 There is however exception where inlining might change dominator relation
2132 across EH edges from basic block within inlined functions destinating
2133 to landing pads in function we inline into.
2135 The function fills in PHI_RESULTs of such PHI nodes if they refer
2136 to gimple regs. Otherwise, the function mark PHI_RESULT of such
2137 PHI nodes for renaming. For non-gimple regs, renaming is safe: the
2138 EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
2139 set, and this means that there will be no overlapping live ranges
2140 for the underlying symbol.
2142 This might change in future if we allow redirecting of EH edges and
2143 we might want to change way build CFG pre-inlining to include
2144 all the possible edges then. */
2146 update_ssa_across_abnormal_edges (basic_block bb
, basic_block ret_bb
,
2147 bool can_throw
, bool nonlocal_goto
)
2152 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
2154 || ((basic_block
)e
->dest
->aux
)->index
== ENTRY_BLOCK
)
2160 gcc_assert (e
->flags
& EDGE_EH
);
2163 gcc_assert (!(e
->flags
& EDGE_EH
));
2165 for (si
= gsi_start_phis (e
->dest
); !gsi_end_p (si
); gsi_next (&si
))
2171 /* For abnormal goto/call edges the receiver can be the
2172 ENTRY_BLOCK. Do not assert this cannot happen. */
2174 gcc_assert ((e
->flags
& EDGE_EH
)
2175 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi
)));
2177 re
= find_edge (ret_bb
, e
->dest
);
2178 gcc_checking_assert (re
);
2179 gcc_assert ((re
->flags
& (EDGE_EH
| EDGE_ABNORMAL
))
2180 == (e
->flags
& (EDGE_EH
| EDGE_ABNORMAL
)));
2182 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, e
),
2183 USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, re
)));
2189 /* Copy edges from BB into its copy constructed earlier, scale profile
2190 accordingly. Edges will be taken care of later. Assume aux
2191 pointers to point to the copies of each BB. Return true if any
2192 debug stmts are left after a statement that must end the basic block. */
2195 copy_edges_for_bb (basic_block bb
, gcov_type count_scale
, basic_block ret_bb
,
2196 basic_block abnormal_goto_dest
)
2198 basic_block new_bb
= (basic_block
) bb
->aux
;
2201 gimple_stmt_iterator si
;
2203 bool need_debug_cleanup
= false;
2205 /* Use the indices from the original blocks to create edges for the
2207 FOR_EACH_EDGE (old_edge
, ei
, bb
->succs
)
2208 if (!(old_edge
->flags
& EDGE_EH
))
2212 flags
= old_edge
->flags
;
2214 /* Return edges do get a FALLTHRU flag when the get inlined. */
2215 if (old_edge
->dest
->index
== EXIT_BLOCK
2216 && !(old_edge
->flags
& (EDGE_TRUE_VALUE
|EDGE_FALSE_VALUE
|EDGE_FAKE
))
2217 && old_edge
->dest
->aux
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
2218 flags
|= EDGE_FALLTHRU
;
2219 new_edge
= make_edge (new_bb
, (basic_block
) old_edge
->dest
->aux
, flags
);
2220 new_edge
->count
= apply_scale (old_edge
->count
, count_scale
);
2221 new_edge
->probability
= old_edge
->probability
;
2224 if (bb
->index
== ENTRY_BLOCK
|| bb
->index
== EXIT_BLOCK
)
2227 for (si
= gsi_start_bb (new_bb
); !gsi_end_p (si
);)
2230 bool can_throw
, nonlocal_goto
;
2232 copy_stmt
= gsi_stmt (si
);
2233 if (!is_gimple_debug (copy_stmt
))
2234 update_stmt (copy_stmt
);
2236 /* Do this before the possible split_block. */
2239 /* If this tree could throw an exception, there are two
2240 cases where we need to add abnormal edge(s): the
2241 tree wasn't in a region and there is a "current
2242 region" in the caller; or the original tree had
2243 EH edges. In both cases split the block after the tree,
2244 and add abnormal edge(s) as needed; we need both
2245 those from the callee and the caller.
2246 We check whether the copy can throw, because the const
2247 propagation can change an INDIRECT_REF which throws
2248 into a COMPONENT_REF which doesn't. If the copy
2249 can throw, the original could also throw. */
2250 can_throw
= stmt_can_throw_internal (copy_stmt
);
2252 = (stmt_can_make_abnormal_goto (copy_stmt
)
2253 && !computed_goto_p (copy_stmt
));
2255 if (can_throw
|| nonlocal_goto
)
2257 if (!gsi_end_p (si
))
2259 while (!gsi_end_p (si
) && is_gimple_debug (gsi_stmt (si
)))
2262 need_debug_cleanup
= true;
2264 if (!gsi_end_p (si
))
2265 /* Note that bb's predecessor edges aren't necessarily
2266 right at this point; split_block doesn't care. */
2268 edge e
= split_block (new_bb
, copy_stmt
);
2271 new_bb
->aux
= e
->src
->aux
;
2272 si
= gsi_start_bb (new_bb
);
2276 if (gimple_code (copy_stmt
) == GIMPLE_EH_DISPATCH
)
2277 make_eh_dispatch_edges (as_a
<geh_dispatch
*> (copy_stmt
));
2279 make_eh_edges (copy_stmt
);
2281 /* If the call we inline cannot make abnormal goto do not add
2282 additional abnormal edges but only retain those already present
2283 in the original function body. */
2284 if (abnormal_goto_dest
== NULL
)
2285 nonlocal_goto
= false;
2288 basic_block copy_stmt_bb
= gimple_bb (copy_stmt
);
2290 if (get_abnormal_succ_dispatcher (copy_stmt_bb
))
2291 nonlocal_goto
= false;
2292 /* ABNORMAL_DISPATCHER (1) is for longjmp/setjmp or nonlocal gotos
2293 in OpenMP regions which aren't allowed to be left abnormally.
2294 So, no need to add abnormal edge in that case. */
2295 else if (is_gimple_call (copy_stmt
)
2296 && gimple_call_internal_p (copy_stmt
)
2297 && (gimple_call_internal_fn (copy_stmt
)
2298 == IFN_ABNORMAL_DISPATCHER
)
2299 && gimple_call_arg (copy_stmt
, 0) == boolean_true_node
)
2300 nonlocal_goto
= false;
2302 make_edge (copy_stmt_bb
, abnormal_goto_dest
, EDGE_ABNORMAL
);
2305 if ((can_throw
|| nonlocal_goto
)
2306 && gimple_in_ssa_p (cfun
))
2307 update_ssa_across_abnormal_edges (gimple_bb (copy_stmt
), ret_bb
,
2308 can_throw
, nonlocal_goto
);
2310 return need_debug_cleanup
;
2313 /* Copy the PHIs. All blocks and edges are copied, some blocks
2314 was possibly split and new outgoing EH edges inserted.
2315 BB points to the block of original function and AUX pointers links
2316 the original and newly copied blocks. */
2319 copy_phis_for_bb (basic_block bb
, copy_body_data
*id
)
2321 basic_block
const new_bb
= (basic_block
) bb
->aux
;
2326 bool inserted
= false;
2328 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
2334 res
= PHI_RESULT (phi
);
2336 if (!virtual_operand_p (res
))
2338 walk_tree (&new_res
, copy_tree_body_r
, id
, NULL
);
2339 new_phi
= create_phi_node (new_res
, new_bb
);
2340 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2342 edge old_edge
= find_edge ((basic_block
) new_edge
->src
->aux
, bb
);
2348 /* When doing partial cloning, we allow PHIs on the entry block
2349 as long as all the arguments are the same. Find any input
2350 edge to see argument to copy. */
2352 FOR_EACH_EDGE (old_edge
, ei2
, bb
->preds
)
2353 if (!old_edge
->src
->aux
)
2356 arg
= PHI_ARG_DEF_FROM_EDGE (phi
, old_edge
);
2358 walk_tree (&new_arg
, copy_tree_body_r
, id
, NULL
);
2359 gcc_assert (new_arg
);
2360 /* With return slot optimization we can end up with
2361 non-gimple (foo *)&this->m, fix that here. */
2362 if (TREE_CODE (new_arg
) != SSA_NAME
2363 && TREE_CODE (new_arg
) != FUNCTION_DECL
2364 && !is_gimple_val (new_arg
))
2366 gimple_seq stmts
= NULL
;
2367 new_arg
= force_gimple_operand (new_arg
, &stmts
, true, NULL
);
2368 gsi_insert_seq_on_edge (new_edge
, stmts
);
2371 locus
= gimple_phi_arg_location_from_edge (phi
, old_edge
);
2372 if (LOCATION_BLOCK (locus
))
2375 n
= id
->decl_map
->get (LOCATION_BLOCK (locus
));
2377 locus
= set_block (locus
, *n
);
2380 locus
= LOCATION_LOCUS (locus
);
2382 add_phi_arg (new_phi
, new_arg
, new_edge
, locus
);
2387 /* Commit the delayed edge insertions. */
2389 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2390 gsi_commit_one_edge_insert (new_edge
, NULL
);
2394 /* Wrapper for remap_decl so it can be used as a callback. */
2397 remap_decl_1 (tree decl
, void *data
)
2399 return remap_decl (decl
, (copy_body_data
*) data
);
2402 /* Build struct function and associated datastructures for the new clone
2403 NEW_FNDECL to be build. CALLEE_FNDECL is the original. Function changes
2404 the cfun to the function of new_fndecl (and current_function_decl too). */
2407 initialize_cfun (tree new_fndecl
, tree callee_fndecl
, gcov_type count
)
2409 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2410 gcov_type count_scale
;
2412 if (!DECL_ARGUMENTS (new_fndecl
))
2413 DECL_ARGUMENTS (new_fndecl
) = DECL_ARGUMENTS (callee_fndecl
);
2414 if (!DECL_RESULT (new_fndecl
))
2415 DECL_RESULT (new_fndecl
) = DECL_RESULT (callee_fndecl
);
2417 if (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
)
2419 = GCOV_COMPUTE_SCALE (count
,
2420 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
);
2422 count_scale
= REG_BR_PROB_BASE
;
2424 /* Register specific tree functions. */
2425 gimple_register_cfg_hooks ();
2427 /* Get clean struct function. */
2428 push_struct_function (new_fndecl
);
2430 /* We will rebuild these, so just sanity check that they are empty. */
2431 gcc_assert (VALUE_HISTOGRAMS (cfun
) == NULL
);
2432 gcc_assert (cfun
->local_decls
== NULL
);
2433 gcc_assert (cfun
->cfg
== NULL
);
2434 gcc_assert (cfun
->decl
== new_fndecl
);
2436 /* Copy items we preserve during cloning. */
2437 cfun
->static_chain_decl
= src_cfun
->static_chain_decl
;
2438 cfun
->nonlocal_goto_save_area
= src_cfun
->nonlocal_goto_save_area
;
2439 cfun
->function_end_locus
= src_cfun
->function_end_locus
;
2440 cfun
->curr_properties
= src_cfun
->curr_properties
;
2441 cfun
->last_verified
= src_cfun
->last_verified
;
2442 cfun
->va_list_gpr_size
= src_cfun
->va_list_gpr_size
;
2443 cfun
->va_list_fpr_size
= src_cfun
->va_list_fpr_size
;
2444 cfun
->has_nonlocal_label
= src_cfun
->has_nonlocal_label
;
2445 cfun
->stdarg
= src_cfun
->stdarg
;
2446 cfun
->after_inlining
= src_cfun
->after_inlining
;
2447 cfun
->can_throw_non_call_exceptions
2448 = src_cfun
->can_throw_non_call_exceptions
;
2449 cfun
->can_delete_dead_exceptions
= src_cfun
->can_delete_dead_exceptions
;
2450 cfun
->returns_struct
= src_cfun
->returns_struct
;
2451 cfun
->returns_pcc_struct
= src_cfun
->returns_pcc_struct
;
2453 init_empty_tree_cfg ();
2455 profile_status_for_fn (cfun
) = profile_status_for_fn (src_cfun
);
2456 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
=
2457 (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
* count_scale
/
2459 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
2460 = ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->frequency
;
2461 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
=
2462 (EXIT_BLOCK_PTR_FOR_FN (src_cfun
)->count
* count_scale
/
2464 EXIT_BLOCK_PTR_FOR_FN (cfun
)->frequency
=
2465 EXIT_BLOCK_PTR_FOR_FN (src_cfun
)->frequency
;
2467 init_eh_for_function ();
2469 if (src_cfun
->gimple_df
)
2471 init_tree_ssa (cfun
);
2472 cfun
->gimple_df
->in_ssa_p
= src_cfun
->gimple_df
->in_ssa_p
;
2473 if (cfun
->gimple_df
->in_ssa_p
)
2474 init_ssa_operands (cfun
);
2478 /* Helper function for copy_cfg_body. Move debug stmts from the end
2479 of NEW_BB to the beginning of successor basic blocks when needed. If the
2480 successor has multiple predecessors, reset them, otherwise keep
2484 maybe_move_debug_stmts_to_successors (copy_body_data
*id
, basic_block new_bb
)
2488 gimple_stmt_iterator si
= gsi_last_nondebug_bb (new_bb
);
2491 || gsi_one_before_end_p (si
)
2492 || !(stmt_can_throw_internal (gsi_stmt (si
))
2493 || stmt_can_make_abnormal_goto (gsi_stmt (si
))))
2496 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
2498 gimple_stmt_iterator ssi
= gsi_last_bb (new_bb
);
2499 gimple_stmt_iterator dsi
= gsi_after_labels (e
->dest
);
2500 while (is_gimple_debug (gsi_stmt (ssi
)))
2502 gimple
*stmt
= gsi_stmt (ssi
);
2507 /* For the last edge move the debug stmts instead of copying
2509 if (ei_one_before_end_p (ei
))
2513 if (!single_pred_p (e
->dest
) && gimple_debug_bind_p (stmt
))
2514 gimple_debug_bind_reset_value (stmt
);
2515 gsi_remove (&si
, false);
2516 gsi_insert_before (&dsi
, stmt
, GSI_SAME_STMT
);
2520 if (gimple_debug_bind_p (stmt
))
2522 var
= gimple_debug_bind_get_var (stmt
);
2523 if (single_pred_p (e
->dest
))
2525 value
= gimple_debug_bind_get_value (stmt
);
2526 value
= unshare_expr (value
);
2530 new_stmt
= gimple_build_debug_bind (var
, value
, stmt
);
2532 else if (gimple_debug_source_bind_p (stmt
))
2534 var
= gimple_debug_source_bind_get_var (stmt
);
2535 value
= gimple_debug_source_bind_get_value (stmt
);
2536 new_stmt
= gimple_build_debug_source_bind (var
, value
, stmt
);
2540 gsi_insert_before (&dsi
, new_stmt
, GSI_SAME_STMT
);
2541 id
->debug_stmts
.safe_push (new_stmt
);
2547 /* Make a copy of the sub-loops of SRC_PARENT and place them
2548 as siblings of DEST_PARENT. */
2551 copy_loops (copy_body_data
*id
,
2552 struct loop
*dest_parent
, struct loop
*src_parent
)
2554 struct loop
*src_loop
= src_parent
->inner
;
2557 if (!id
->blocks_to_copy
2558 || bitmap_bit_p (id
->blocks_to_copy
, src_loop
->header
->index
))
2560 struct loop
*dest_loop
= alloc_loop ();
2562 /* Assign the new loop its header and latch and associate
2563 those with the new loop. */
2564 dest_loop
->header
= (basic_block
)src_loop
->header
->aux
;
2565 dest_loop
->header
->loop_father
= dest_loop
;
2566 if (src_loop
->latch
!= NULL
)
2568 dest_loop
->latch
= (basic_block
)src_loop
->latch
->aux
;
2569 dest_loop
->latch
->loop_father
= dest_loop
;
2572 /* Copy loop meta-data. */
2573 copy_loop_info (src_loop
, dest_loop
);
2575 /* Finally place it into the loop array and the loop tree. */
2576 place_new_loop (cfun
, dest_loop
);
2577 flow_loop_tree_node_add (dest_parent
, dest_loop
);
2579 dest_loop
->safelen
= src_loop
->safelen
;
2580 dest_loop
->dont_vectorize
= src_loop
->dont_vectorize
;
2581 if (src_loop
->force_vectorize
)
2583 dest_loop
->force_vectorize
= true;
2584 cfun
->has_force_vectorize_loops
= true;
2586 if (src_loop
->simduid
)
2588 dest_loop
->simduid
= remap_decl (src_loop
->simduid
, id
);
2589 cfun
->has_simduid_loops
= true;
2593 copy_loops (id
, dest_loop
, src_loop
);
2595 src_loop
= src_loop
->next
;
2599 /* Call cgraph_redirect_edge_call_stmt_to_callee on all calls in BB */
2602 redirect_all_calls (copy_body_data
* id
, basic_block bb
)
2604 gimple_stmt_iterator si
;
2605 gimple
*last
= last_stmt (bb
);
2606 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
2608 gimple
*stmt
= gsi_stmt (si
);
2609 if (is_gimple_call (stmt
))
2611 struct cgraph_edge
*edge
= id
->dst_node
->get_edge (stmt
);
2614 edge
->redirect_call_stmt_to_callee ();
2615 if (stmt
== last
&& id
->call_stmt
&& maybe_clean_eh_stmt (stmt
))
2616 gimple_purge_dead_eh_edges (bb
);
2622 /* Convert estimated frequencies into counts for NODE, scaling COUNT
2623 with each bb's frequency. Used when NODE has a 0-weight entry
2624 but we are about to inline it into a non-zero count call bb.
2625 See the comments for handle_missing_profiles() in predict.c for
2626 when this can happen for COMDATs. */
2629 freqs_to_counts (struct cgraph_node
*node
, gcov_type count
)
2634 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
2636 FOR_ALL_BB_FN(bb
, fn
)
2638 bb
->count
= apply_scale (count
,
2639 GCOV_COMPUTE_SCALE (bb
->frequency
, BB_FREQ_MAX
));
2640 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
2641 e
->count
= apply_probability (e
->src
->count
, e
->probability
);
2645 /* Make a copy of the body of FN so that it can be inserted inline in
2646 another function. Walks FN via CFG, returns new fndecl. */
2649 copy_cfg_body (copy_body_data
* id
, gcov_type count
, int frequency_scale
,
2650 basic_block entry_block_map
, basic_block exit_block_map
,
2651 basic_block new_entry
)
2653 tree callee_fndecl
= id
->src_fn
;
2654 /* Original cfun for the callee, doesn't change. */
2655 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2656 struct function
*cfun_to_copy
;
2658 tree new_fndecl
= NULL
;
2659 bool need_debug_cleanup
= false;
2660 gcov_type count_scale
;
2662 int incoming_frequency
= 0;
2663 gcov_type incoming_count
= 0;
2665 /* This can happen for COMDAT routines that end up with 0 counts
2666 despite being called (see the comments for handle_missing_profiles()
2667 in predict.c as to why). Apply counts to the blocks in the callee
2668 before inlining, using the guessed edge frequencies, so that we don't
2669 end up with a 0-count inline body which can confuse downstream
2670 optimizations such as function splitting. */
2671 if (!ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
&& count
)
2673 /* Apply the larger of the call bb count and the total incoming
2674 call edge count to the callee. */
2675 gcov_type in_count
= 0;
2676 struct cgraph_edge
*in_edge
;
2677 for (in_edge
= id
->src_node
->callers
; in_edge
;
2678 in_edge
= in_edge
->next_caller
)
2679 in_count
+= in_edge
->count
;
2680 freqs_to_counts (id
->src_node
, count
> in_count
? count
: in_count
);
2683 if (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
)
2685 = GCOV_COMPUTE_SCALE (count
,
2686 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
);
2688 count_scale
= REG_BR_PROB_BASE
;
2690 /* Register specific tree functions. */
2691 gimple_register_cfg_hooks ();
2693 /* If we are inlining just region of the function, make sure to connect
2694 new entry to ENTRY_BLOCK_PTR_FOR_FN (cfun). Since new entry can be
2695 part of loop, we must compute frequency and probability of
2696 ENTRY_BLOCK_PTR_FOR_FN (cfun) based on the frequencies and
2697 probabilities of edges incoming from nonduplicated region. */
2703 FOR_EACH_EDGE (e
, ei
, new_entry
->preds
)
2706 incoming_frequency
+= EDGE_FREQUENCY (e
);
2707 incoming_count
+= e
->count
;
2709 incoming_count
= apply_scale (incoming_count
, count_scale
);
2711 = apply_scale ((gcov_type
)incoming_frequency
, frequency_scale
);
2712 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= incoming_count
;
2713 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
= incoming_frequency
;
2716 /* Must have a CFG here at this point. */
2717 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN
2718 (DECL_STRUCT_FUNCTION (callee_fndecl
)));
2720 cfun_to_copy
= id
->src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2722 ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy
)->aux
= entry_block_map
;
2723 EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy
)->aux
= exit_block_map
;
2724 entry_block_map
->aux
= ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy
);
2725 exit_block_map
->aux
= EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy
);
2727 /* Duplicate any exception-handling regions. */
2729 id
->eh_map
= duplicate_eh_regions (cfun_to_copy
, NULL
, id
->eh_lp_nr
,
2732 /* Use aux pointers to map the original blocks to copy. */
2733 FOR_EACH_BB_FN (bb
, cfun_to_copy
)
2734 if (!id
->blocks_to_copy
|| bitmap_bit_p (id
->blocks_to_copy
, bb
->index
))
2736 basic_block new_bb
= copy_bb (id
, bb
, frequency_scale
, count_scale
);
2739 new_bb
->loop_father
= entry_block_map
->loop_father
;
2742 last
= last_basic_block_for_fn (cfun
);
2744 /* Now that we've duplicated the blocks, duplicate their edges. */
2745 basic_block abnormal_goto_dest
= NULL
;
2747 && stmt_can_make_abnormal_goto (id
->call_stmt
))
2749 gimple_stmt_iterator gsi
= gsi_for_stmt (id
->call_stmt
);
2751 bb
= gimple_bb (id
->call_stmt
);
2753 if (gsi_end_p (gsi
))
2754 abnormal_goto_dest
= get_abnormal_succ_dispatcher (bb
);
2756 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2757 if (!id
->blocks_to_copy
2758 || (bb
->index
> 0 && bitmap_bit_p (id
->blocks_to_copy
, bb
->index
)))
2759 need_debug_cleanup
|= copy_edges_for_bb (bb
, count_scale
, exit_block_map
,
2760 abnormal_goto_dest
);
2764 edge e
= make_edge (entry_block_map
, (basic_block
)new_entry
->aux
, EDGE_FALLTHRU
);
2765 e
->probability
= REG_BR_PROB_BASE
;
2766 e
->count
= incoming_count
;
2769 /* Duplicate the loop tree, if available and wanted. */
2770 if (loops_for_fn (src_cfun
) != NULL
2771 && current_loops
!= NULL
)
2773 copy_loops (id
, entry_block_map
->loop_father
,
2774 get_loop (src_cfun
, 0));
2775 /* Defer to cfgcleanup to update loop-father fields of basic-blocks. */
2776 loops_state_set (LOOPS_NEED_FIXUP
);
2779 /* If the loop tree in the source function needed fixup, mark the
2780 destination loop tree for fixup, too. */
2781 if (loops_for_fn (src_cfun
)->state
& LOOPS_NEED_FIXUP
)
2782 loops_state_set (LOOPS_NEED_FIXUP
);
2784 if (gimple_in_ssa_p (cfun
))
2785 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2786 if (!id
->blocks_to_copy
2787 || (bb
->index
> 0 && bitmap_bit_p (id
->blocks_to_copy
, bb
->index
)))
2788 copy_phis_for_bb (bb
, id
);
2790 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2793 if (need_debug_cleanup
2794 && bb
->index
!= ENTRY_BLOCK
2795 && bb
->index
!= EXIT_BLOCK
)
2796 maybe_move_debug_stmts_to_successors (id
, (basic_block
) bb
->aux
);
2797 /* Update call edge destinations. This can not be done before loop
2798 info is updated, because we may split basic blocks. */
2799 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
2800 && bb
->index
!= ENTRY_BLOCK
2801 && bb
->index
!= EXIT_BLOCK
)
2802 redirect_all_calls (id
, (basic_block
)bb
->aux
);
2803 ((basic_block
)bb
->aux
)->aux
= NULL
;
2807 /* Zero out AUX fields of newly created block during EH edge
2809 for (; last
< last_basic_block_for_fn (cfun
); last
++)
2811 if (need_debug_cleanup
)
2812 maybe_move_debug_stmts_to_successors (id
,
2813 BASIC_BLOCK_FOR_FN (cfun
, last
));
2814 BASIC_BLOCK_FOR_FN (cfun
, last
)->aux
= NULL
;
2815 /* Update call edge destinations. This can not be done before loop
2816 info is updated, because we may split basic blocks. */
2817 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
)
2818 redirect_all_calls (id
, BASIC_BLOCK_FOR_FN (cfun
, last
));
2820 entry_block_map
->aux
= NULL
;
2821 exit_block_map
->aux
= NULL
;
2828 if (id
->dependence_map
)
2830 delete id
->dependence_map
;
2831 id
->dependence_map
= NULL
;
2837 /* Copy the debug STMT using ID. We deal with these statements in a
2838 special way: if any variable in their VALUE expression wasn't
2839 remapped yet, we won't remap it, because that would get decl uids
2840 out of sync, causing codegen differences between -g and -g0. If
2841 this arises, we drop the VALUE expression altogether. */
2844 copy_debug_stmt (gdebug
*stmt
, copy_body_data
*id
)
2847 struct walk_stmt_info wi
;
2849 if (gimple_block (stmt
))
2851 n
= id
->decl_map
->get (gimple_block (stmt
));
2852 gimple_set_block (stmt
, n
? *n
: id
->block
);
2855 /* Remap all the operands in COPY. */
2856 memset (&wi
, 0, sizeof (wi
));
2859 processing_debug_stmt
= 1;
2861 if (gimple_debug_source_bind_p (stmt
))
2862 t
= gimple_debug_source_bind_get_var (stmt
);
2864 t
= gimple_debug_bind_get_var (stmt
);
2866 if (TREE_CODE (t
) == PARM_DECL
&& id
->debug_map
2867 && (n
= id
->debug_map
->get (t
)))
2869 gcc_assert (TREE_CODE (*n
) == VAR_DECL
);
2872 else if (TREE_CODE (t
) == VAR_DECL
2873 && !is_global_var (t
)
2874 && !id
->decl_map
->get (t
))
2875 /* T is a non-localized variable. */;
2877 walk_tree (&t
, remap_gimple_op_r
, &wi
, NULL
);
2879 if (gimple_debug_bind_p (stmt
))
2881 gimple_debug_bind_set_var (stmt
, t
);
2883 if (gimple_debug_bind_has_value_p (stmt
))
2884 walk_tree (gimple_debug_bind_get_value_ptr (stmt
),
2885 remap_gimple_op_r
, &wi
, NULL
);
2887 /* Punt if any decl couldn't be remapped. */
2888 if (processing_debug_stmt
< 0)
2889 gimple_debug_bind_reset_value (stmt
);
2891 else if (gimple_debug_source_bind_p (stmt
))
2893 gimple_debug_source_bind_set_var (stmt
, t
);
2894 /* When inlining and source bind refers to one of the optimized
2895 away parameters, change the source bind into normal debug bind
2896 referring to the corresponding DEBUG_EXPR_DECL that should have
2897 been bound before the call stmt. */
2898 t
= gimple_debug_source_bind_get_value (stmt
);
2900 && TREE_CODE (t
) == PARM_DECL
2903 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (id
->src_fn
);
2905 if (debug_args
!= NULL
)
2907 for (i
= 0; i
< vec_safe_length (*debug_args
); i
+= 2)
2908 if ((**debug_args
)[i
] == DECL_ORIGIN (t
)
2909 && TREE_CODE ((**debug_args
)[i
+ 1]) == DEBUG_EXPR_DECL
)
2911 t
= (**debug_args
)[i
+ 1];
2912 stmt
->subcode
= GIMPLE_DEBUG_BIND
;
2913 gimple_debug_bind_set_value (stmt
, t
);
2918 if (gimple_debug_source_bind_p (stmt
))
2919 walk_tree (gimple_debug_source_bind_get_value_ptr (stmt
),
2920 remap_gimple_op_r
, &wi
, NULL
);
2923 processing_debug_stmt
= 0;
2928 /* Process deferred debug stmts. In order to give values better odds
2929 of being successfully remapped, we delay the processing of debug
2930 stmts until all other stmts that might require remapping are
2934 copy_debug_stmts (copy_body_data
*id
)
2939 if (!id
->debug_stmts
.exists ())
2942 FOR_EACH_VEC_ELT (id
->debug_stmts
, i
, stmt
)
2943 copy_debug_stmt (stmt
, id
);
2945 id
->debug_stmts
.release ();
2948 /* Make a copy of the body of SRC_FN so that it can be inserted inline in
2949 another function. */
2952 copy_tree_body (copy_body_data
*id
)
2954 tree fndecl
= id
->src_fn
;
2955 tree body
= DECL_SAVED_TREE (fndecl
);
2957 walk_tree (&body
, copy_tree_body_r
, id
, NULL
);
2962 /* Make a copy of the body of FN so that it can be inserted inline in
2963 another function. */
2966 copy_body (copy_body_data
*id
, gcov_type count
, int frequency_scale
,
2967 basic_block entry_block_map
, basic_block exit_block_map
,
2968 basic_block new_entry
)
2970 tree fndecl
= id
->src_fn
;
2973 /* If this body has a CFG, walk CFG and copy. */
2974 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (fndecl
)));
2975 body
= copy_cfg_body (id
, count
, frequency_scale
, entry_block_map
, exit_block_map
,
2977 copy_debug_stmts (id
);
2982 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
2983 defined in function FN, or of a data member thereof. */
2986 self_inlining_addr_expr (tree value
, tree fn
)
2990 if (TREE_CODE (value
) != ADDR_EXPR
)
2993 var
= get_base_address (TREE_OPERAND (value
, 0));
2995 return var
&& auto_var_in_fn_p (var
, fn
);
2998 /* Append to BB a debug annotation that binds VAR to VALUE, inheriting
2999 lexical block and line number information from base_stmt, if given,
3000 or from the last stmt of the block otherwise. */
3003 insert_init_debug_bind (copy_body_data
*id
,
3004 basic_block bb
, tree var
, tree value
,
3008 gimple_stmt_iterator gsi
;
3011 if (!gimple_in_ssa_p (id
->src_cfun
))
3014 if (!opt_for_fn (id
->dst_fn
, flag_var_tracking_assignments
))
3017 tracked_var
= target_for_debug_bind (var
);
3023 gsi
= gsi_last_bb (bb
);
3024 if (!base_stmt
&& !gsi_end_p (gsi
))
3025 base_stmt
= gsi_stmt (gsi
);
3028 note
= gimple_build_debug_bind (tracked_var
, unshare_expr (value
), base_stmt
);
3032 if (!gsi_end_p (gsi
))
3033 gsi_insert_after (&gsi
, note
, GSI_SAME_STMT
);
3035 gsi_insert_before (&gsi
, note
, GSI_SAME_STMT
);
3042 insert_init_stmt (copy_body_data
*id
, basic_block bb
, gimple
*init_stmt
)
3044 /* If VAR represents a zero-sized variable, it's possible that the
3045 assignment statement may result in no gimple statements. */
3048 gimple_stmt_iterator si
= gsi_last_bb (bb
);
3050 /* We can end up with init statements that store to a non-register
3051 from a rhs with a conversion. Handle that here by forcing the
3052 rhs into a temporary. gimple_regimplify_operands is not
3053 prepared to do this for us. */
3054 if (!is_gimple_debug (init_stmt
)
3055 && !is_gimple_reg (gimple_assign_lhs (init_stmt
))
3056 && is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (init_stmt
)))
3057 && gimple_assign_rhs_class (init_stmt
) == GIMPLE_UNARY_RHS
)
3059 tree rhs
= build1 (gimple_assign_rhs_code (init_stmt
),
3060 gimple_expr_type (init_stmt
),
3061 gimple_assign_rhs1 (init_stmt
));
3062 rhs
= force_gimple_operand_gsi (&si
, rhs
, true, NULL_TREE
, false,
3064 gimple_assign_set_rhs_code (init_stmt
, TREE_CODE (rhs
));
3065 gimple_assign_set_rhs1 (init_stmt
, rhs
);
3067 gsi_insert_after (&si
, init_stmt
, GSI_NEW_STMT
);
3068 gimple_regimplify_operands (init_stmt
, &si
);
3070 if (!is_gimple_debug (init_stmt
))
3072 tree def
= gimple_assign_lhs (init_stmt
);
3073 insert_init_debug_bind (id
, bb
, def
, def
, init_stmt
);
3078 /* Initialize parameter P with VALUE. If needed, produce init statement
3079 at the end of BB. When BB is NULL, we return init statement to be
3082 setup_one_parameter (copy_body_data
*id
, tree p
, tree value
, tree fn
,
3083 basic_block bb
, tree
*vars
)
3085 gimple
*init_stmt
= NULL
;
3088 tree def
= (gimple_in_ssa_p (cfun
)
3089 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
3092 && value
!= error_mark_node
3093 && !useless_type_conversion_p (TREE_TYPE (p
), TREE_TYPE (value
)))
3095 /* If we can match up types by promotion/demotion do so. */
3096 if (fold_convertible_p (TREE_TYPE (p
), value
))
3097 rhs
= fold_convert (TREE_TYPE (p
), value
);
3100 /* ??? For valid programs we should not end up here.
3101 Still if we end up with truly mismatched types here, fall back
3102 to using a VIEW_CONVERT_EXPR or a literal zero to not leak invalid
3103 GIMPLE to the following passes. */
3104 if (!is_gimple_reg_type (TREE_TYPE (value
))
3105 || TYPE_SIZE (TREE_TYPE (p
)) == TYPE_SIZE (TREE_TYPE (value
)))
3106 rhs
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (p
), value
);
3108 rhs
= build_zero_cst (TREE_TYPE (p
));
3112 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
3113 here since the type of this decl must be visible to the calling
3115 var
= copy_decl_to_var (p
, id
);
3117 /* Declare this new variable. */
3118 DECL_CHAIN (var
) = *vars
;
3121 /* Make gimplifier happy about this variable. */
3122 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
3124 /* If the parameter is never assigned to, has no SSA_NAMEs created,
3125 we would not need to create a new variable here at all, if it
3126 weren't for debug info. Still, we can just use the argument
3128 if (TREE_READONLY (p
)
3129 && !TREE_ADDRESSABLE (p
)
3130 && value
&& !TREE_SIDE_EFFECTS (value
)
3133 /* We may produce non-gimple trees by adding NOPs or introduce
3134 invalid sharing when operand is not really constant.
3135 It is not big deal to prohibit constant propagation here as
3136 we will constant propagate in DOM1 pass anyway. */
3137 if (is_gimple_min_invariant (value
)
3138 && useless_type_conversion_p (TREE_TYPE (p
),
3140 /* We have to be very careful about ADDR_EXPR. Make sure
3141 the base variable isn't a local variable of the inlined
3142 function, e.g., when doing recursive inlining, direct or
3143 mutually-recursive or whatever, which is why we don't
3144 just test whether fn == current_function_decl. */
3145 && ! self_inlining_addr_expr (value
, fn
))
3147 insert_decl_map (id
, p
, value
);
3148 insert_debug_decl_map (id
, p
, var
);
3149 return insert_init_debug_bind (id
, bb
, var
, value
, NULL
);
3153 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
3154 that way, when the PARM_DECL is encountered, it will be
3155 automatically replaced by the VAR_DECL. */
3156 insert_decl_map (id
, p
, var
);
3158 /* Even if P was TREE_READONLY, the new VAR should not be.
3159 In the original code, we would have constructed a
3160 temporary, and then the function body would have never
3161 changed the value of P. However, now, we will be
3162 constructing VAR directly. The constructor body may
3163 change its value multiple times as it is being
3164 constructed. Therefore, it must not be TREE_READONLY;
3165 the back-end assumes that TREE_READONLY variable is
3166 assigned to only once. */
3167 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p
)))
3168 TREE_READONLY (var
) = 0;
3170 /* If there is no setup required and we are in SSA, take the easy route
3171 replacing all SSA names representing the function parameter by the
3172 SSA name passed to function.
3174 We need to construct map for the variable anyway as it might be used
3175 in different SSA names when parameter is set in function.
3177 Do replacement at -O0 for const arguments replaced by constant.
3178 This is important for builtin_constant_p and other construct requiring
3179 constant argument to be visible in inlined function body. */
3180 if (gimple_in_ssa_p (cfun
) && rhs
&& def
&& is_gimple_reg (p
)
3182 || (TREE_READONLY (p
)
3183 && is_gimple_min_invariant (rhs
)))
3184 && (TREE_CODE (rhs
) == SSA_NAME
3185 || is_gimple_min_invariant (rhs
))
3186 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
3188 insert_decl_map (id
, def
, rhs
);
3189 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3192 /* If the value of argument is never used, don't care about initializing
3194 if (optimize
&& gimple_in_ssa_p (cfun
) && !def
&& is_gimple_reg (p
))
3196 gcc_assert (!value
|| !TREE_SIDE_EFFECTS (value
));
3197 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3200 /* Initialize this VAR_DECL from the equivalent argument. Convert
3201 the argument to the proper type in case it was promoted. */
3204 if (rhs
== error_mark_node
)
3206 insert_decl_map (id
, p
, var
);
3207 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3210 STRIP_USELESS_TYPE_CONVERSION (rhs
);
3212 /* If we are in SSA form properly remap the default definition
3213 or assign to a dummy SSA name if the parameter is unused and
3214 we are not optimizing. */
3215 if (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
))
3219 def
= remap_ssa_name (def
, id
);
3220 init_stmt
= gimple_build_assign (def
, rhs
);
3221 SSA_NAME_IS_DEFAULT_DEF (def
) = 0;
3222 set_ssa_default_def (cfun
, var
, NULL
);
3226 def
= make_ssa_name (var
);
3227 init_stmt
= gimple_build_assign (def
, rhs
);
3231 init_stmt
= gimple_build_assign (var
, rhs
);
3233 if (bb
&& init_stmt
)
3234 insert_init_stmt (id
, bb
, init_stmt
);
3239 /* Generate code to initialize the parameters of the function at the
3240 top of the stack in ID from the GIMPLE_CALL STMT. */
3243 initialize_inlined_parameters (copy_body_data
*id
, gimple
*stmt
,
3244 tree fn
, basic_block bb
)
3249 tree vars
= NULL_TREE
;
3250 tree static_chain
= gimple_call_chain (stmt
);
3252 /* Figure out what the parameters are. */
3253 parms
= DECL_ARGUMENTS (fn
);
3255 /* Loop through the parameter declarations, replacing each with an
3256 equivalent VAR_DECL, appropriately initialized. */
3257 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
3260 val
= i
< gimple_call_num_args (stmt
) ? gimple_call_arg (stmt
, i
) : NULL
;
3261 setup_one_parameter (id
, p
, val
, fn
, bb
, &vars
);
3263 /* After remapping parameters remap their types. This has to be done
3264 in a second loop over all parameters to appropriately remap
3265 variable sized arrays when the size is specified in a
3266 parameter following the array. */
3267 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
3269 tree
*varp
= id
->decl_map
->get (p
);
3271 && TREE_CODE (*varp
) == VAR_DECL
)
3273 tree def
= (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
)
3274 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
3276 TREE_TYPE (var
) = remap_type (TREE_TYPE (var
), id
);
3277 /* Also remap the default definition if it was remapped
3278 to the default definition of the parameter replacement
3279 by the parameter setup. */
3282 tree
*defp
= id
->decl_map
->get (def
);
3284 && TREE_CODE (*defp
) == SSA_NAME
3285 && SSA_NAME_VAR (*defp
) == var
)
3286 TREE_TYPE (*defp
) = TREE_TYPE (var
);
3291 /* Initialize the static chain. */
3292 p
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
3293 gcc_assert (fn
!= current_function_decl
);
3296 /* No static chain? Seems like a bug in tree-nested.c. */
3297 gcc_assert (static_chain
);
3299 setup_one_parameter (id
, p
, static_chain
, fn
, bb
, &vars
);
3302 declare_inline_vars (id
->block
, vars
);
3306 /* Declare a return variable to replace the RESULT_DECL for the
3307 function we are calling. An appropriate DECL_STMT is returned.
3308 The USE_STMT is filled to contain a use of the declaration to
3309 indicate the return value of the function.
3311 RETURN_SLOT, if non-null is place where to store the result. It
3312 is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null,
3313 was the LHS of the MODIFY_EXPR to which this call is the RHS.
3315 RETURN_BOUNDS holds a destination for returned bounds.
3317 The return value is a (possibly null) value that holds the result
3318 as seen by the caller. */
3321 declare_return_variable (copy_body_data
*id
, tree return_slot
, tree modify_dest
,
3322 tree return_bounds
, basic_block entry_bb
)
3324 tree callee
= id
->src_fn
;
3325 tree result
= DECL_RESULT (callee
);
3326 tree callee_type
= TREE_TYPE (result
);
3330 /* Handle type-mismatches in the function declaration return type
3331 vs. the call expression. */
3333 caller_type
= TREE_TYPE (modify_dest
);
3335 caller_type
= TREE_TYPE (TREE_TYPE (callee
));
3337 /* We don't need to do anything for functions that don't return anything. */
3338 if (VOID_TYPE_P (callee_type
))
3341 /* If there was a return slot, then the return value is the
3342 dereferenced address of that object. */
3345 /* The front end shouldn't have used both return_slot and
3346 a modify expression. */
3347 gcc_assert (!modify_dest
);
3348 if (DECL_BY_REFERENCE (result
))
3350 tree return_slot_addr
= build_fold_addr_expr (return_slot
);
3351 STRIP_USELESS_TYPE_CONVERSION (return_slot_addr
);
3353 /* We are going to construct *&return_slot and we can't do that
3354 for variables believed to be not addressable.
3356 FIXME: This check possibly can match, because values returned
3357 via return slot optimization are not believed to have address
3358 taken by alias analysis. */
3359 gcc_assert (TREE_CODE (return_slot
) != SSA_NAME
);
3360 var
= return_slot_addr
;
3365 gcc_assert (TREE_CODE (var
) != SSA_NAME
);
3366 if (TREE_ADDRESSABLE (result
))
3367 mark_addressable (var
);
3369 if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
3370 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
3371 && !DECL_GIMPLE_REG_P (result
)
3373 DECL_GIMPLE_REG_P (var
) = 0;
3378 /* All types requiring non-trivial constructors should have been handled. */
3379 gcc_assert (!TREE_ADDRESSABLE (callee_type
));
3381 /* Attempt to avoid creating a new temporary variable. */
3383 && TREE_CODE (modify_dest
) != SSA_NAME
)
3385 bool use_it
= false;
3387 /* We can't use MODIFY_DEST if there's type promotion involved. */
3388 if (!useless_type_conversion_p (callee_type
, caller_type
))
3391 /* ??? If we're assigning to a variable sized type, then we must
3392 reuse the destination variable, because we've no good way to
3393 create variable sized temporaries at this point. */
3394 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type
)) != INTEGER_CST
)
3397 /* If the callee cannot possibly modify MODIFY_DEST, then we can
3398 reuse it as the result of the call directly. Don't do this if
3399 it would promote MODIFY_DEST to addressable. */
3400 else if (TREE_ADDRESSABLE (result
))
3404 tree base_m
= get_base_address (modify_dest
);
3406 /* If the base isn't a decl, then it's a pointer, and we don't
3407 know where that's going to go. */
3408 if (!DECL_P (base_m
))
3410 else if (is_global_var (base_m
))
3412 else if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
3413 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
3414 && !DECL_GIMPLE_REG_P (result
)
3415 && DECL_GIMPLE_REG_P (base_m
))
3417 else if (!TREE_ADDRESSABLE (base_m
))
3429 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type
)) == INTEGER_CST
);
3431 var
= copy_result_decl_to_var (result
, id
);
3432 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
3434 /* Do not have the rest of GCC warn about this variable as it should
3435 not be visible to the user. */
3436 TREE_NO_WARNING (var
) = 1;
3438 declare_inline_vars (id
->block
, var
);
3440 /* Build the use expr. If the return type of the function was
3441 promoted, convert it back to the expected type. */
3443 if (!useless_type_conversion_p (caller_type
, TREE_TYPE (var
)))
3445 /* If we can match up types by promotion/demotion do so. */
3446 if (fold_convertible_p (caller_type
, var
))
3447 use
= fold_convert (caller_type
, var
);
3450 /* ??? For valid programs we should not end up here.
3451 Still if we end up with truly mismatched types here, fall back
3452 to using a MEM_REF to not leak invalid GIMPLE to the following
3454 /* Prevent var from being written into SSA form. */
3455 if (TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
3456 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
)
3457 DECL_GIMPLE_REG_P (var
) = false;
3458 else if (is_gimple_reg_type (TREE_TYPE (var
)))
3459 TREE_ADDRESSABLE (var
) = true;
3460 use
= fold_build2 (MEM_REF
, caller_type
,
3461 build_fold_addr_expr (var
),
3462 build_int_cst (ptr_type_node
, 0));
3466 STRIP_USELESS_TYPE_CONVERSION (use
);
3468 if (DECL_BY_REFERENCE (result
))
3470 TREE_ADDRESSABLE (var
) = 1;
3471 var
= build_fold_addr_expr (var
);
3475 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
3476 way, when the RESULT_DECL is encountered, it will be
3477 automatically replaced by the VAR_DECL.
3479 When returning by reference, ensure that RESULT_DECL remaps to
3481 if (DECL_BY_REFERENCE (result
)
3482 && !is_gimple_val (var
))
3484 tree temp
= create_tmp_var (TREE_TYPE (result
), "retvalptr");
3485 insert_decl_map (id
, result
, temp
);
3486 /* When RESULT_DECL is in SSA form, we need to remap and initialize
3487 it's default_def SSA_NAME. */
3488 if (gimple_in_ssa_p (id
->src_cfun
)
3489 && is_gimple_reg (result
))
3491 temp
= make_ssa_name (temp
);
3492 insert_decl_map (id
, ssa_default_def (id
->src_cfun
, result
), temp
);
3494 insert_init_stmt (id
, entry_bb
, gimple_build_assign (temp
, var
));
3497 insert_decl_map (id
, result
, var
);
3499 /* Remember this so we can ignore it in remap_decls. */
3502 /* If returned bounds are used, then make var for them. */
3505 tree bndtemp
= create_tmp_var (pointer_bounds_type_node
, "retbnd");
3506 DECL_SEEN_IN_BIND_EXPR_P (bndtemp
) = 1;
3507 TREE_NO_WARNING (bndtemp
) = 1;
3508 declare_inline_vars (id
->block
, bndtemp
);
3510 id
->retbnd
= bndtemp
;
3511 insert_init_stmt (id
, entry_bb
,
3512 gimple_build_assign (bndtemp
, chkp_get_zero_bounds_var ()));
3518 /* Determine if the function can be copied. If so return NULL. If
3519 not return a string describng the reason for failure. */
3522 copy_forbidden (struct function
*fun
)
3524 const char *reason
= fun
->cannot_be_copied_reason
;
3526 /* Only examine the function once. */
3527 if (fun
->cannot_be_copied_set
)
3530 /* We cannot copy a function that receives a non-local goto
3531 because we cannot remap the destination label used in the
3532 function that is performing the non-local goto. */
3533 /* ??? Actually, this should be possible, if we work at it.
3534 No doubt there's just a handful of places that simply
3535 assume it doesn't happen and don't substitute properly. */
3536 if (fun
->has_nonlocal_label
)
3538 reason
= G_("function %q+F can never be copied "
3539 "because it receives a non-local goto");
3543 if (fun
->has_forced_label_in_static
)
3545 reason
= G_("function %q+F can never be copied because it saves "
3546 "address of local label in a static variable");
3551 fun
->cannot_be_copied_reason
= reason
;
3552 fun
->cannot_be_copied_set
= true;
3557 static const char *inline_forbidden_reason
;
3559 /* A callback for walk_gimple_seq to handle statements. Returns non-null
3560 iff a function can not be inlined. Also sets the reason why. */
3563 inline_forbidden_p_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
3564 struct walk_stmt_info
*wip
)
3566 tree fn
= (tree
) wip
->info
;
3568 gimple
*stmt
= gsi_stmt (*gsi
);
3570 switch (gimple_code (stmt
))
3573 /* Refuse to inline alloca call unless user explicitly forced so as
3574 this may change program's memory overhead drastically when the
3575 function using alloca is called in loop. In GCC present in
3576 SPEC2000 inlining into schedule_block cause it to require 2GB of
3577 RAM instead of 256MB. Don't do so for alloca calls emitted for
3578 VLA objects as those can't cause unbounded growth (they're always
3579 wrapped inside stack_save/stack_restore regions. */
3580 if (gimple_alloca_call_p (stmt
)
3581 && !gimple_call_alloca_for_var_p (as_a
<gcall
*> (stmt
))
3582 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
3584 inline_forbidden_reason
3585 = G_("function %q+F can never be inlined because it uses "
3586 "alloca (override using the always_inline attribute)");
3587 *handled_ops_p
= true;
3591 t
= gimple_call_fndecl (stmt
);
3595 /* We cannot inline functions that call setjmp. */
3596 if (setjmp_call_p (t
))
3598 inline_forbidden_reason
3599 = G_("function %q+F can never be inlined because it uses setjmp");
3600 *handled_ops_p
= true;
3604 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
3605 switch (DECL_FUNCTION_CODE (t
))
3607 /* We cannot inline functions that take a variable number of
3609 case BUILT_IN_VA_START
:
3610 case BUILT_IN_NEXT_ARG
:
3611 case BUILT_IN_VA_END
:
3612 inline_forbidden_reason
3613 = G_("function %q+F can never be inlined because it "
3614 "uses variable argument lists");
3615 *handled_ops_p
= true;
3618 case BUILT_IN_LONGJMP
:
3619 /* We can't inline functions that call __builtin_longjmp at
3620 all. The non-local goto machinery really requires the
3621 destination be in a different function. If we allow the
3622 function calling __builtin_longjmp to be inlined into the
3623 function calling __builtin_setjmp, Things will Go Awry. */
3624 inline_forbidden_reason
3625 = G_("function %q+F can never be inlined because "
3626 "it uses setjmp-longjmp exception handling");
3627 *handled_ops_p
= true;
3630 case BUILT_IN_NONLOCAL_GOTO
:
3632 inline_forbidden_reason
3633 = G_("function %q+F can never be inlined because "
3634 "it uses non-local goto");
3635 *handled_ops_p
= true;
3638 case BUILT_IN_RETURN
:
3639 case BUILT_IN_APPLY_ARGS
:
3640 /* If a __builtin_apply_args caller would be inlined,
3641 it would be saving arguments of the function it has
3642 been inlined into. Similarly __builtin_return would
3643 return from the function the inline has been inlined into. */
3644 inline_forbidden_reason
3645 = G_("function %q+F can never be inlined because "
3646 "it uses __builtin_return or __builtin_apply_args");
3647 *handled_ops_p
= true;
3656 t
= gimple_goto_dest (stmt
);
3658 /* We will not inline a function which uses computed goto. The
3659 addresses of its local labels, which may be tucked into
3660 global storage, are of course not constant across
3661 instantiations, which causes unexpected behavior. */
3662 if (TREE_CODE (t
) != LABEL_DECL
)
3664 inline_forbidden_reason
3665 = G_("function %q+F can never be inlined "
3666 "because it contains a computed goto");
3667 *handled_ops_p
= true;
3676 *handled_ops_p
= false;
3680 /* Return true if FNDECL is a function that cannot be inlined into
3684 inline_forbidden_p (tree fndecl
)
3686 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
3687 struct walk_stmt_info wi
;
3689 bool forbidden_p
= false;
3691 /* First check for shared reasons not to copy the code. */
3692 inline_forbidden_reason
= copy_forbidden (fun
);
3693 if (inline_forbidden_reason
!= NULL
)
3696 /* Next, walk the statements of the function looking for
3697 constraucts we can't handle, or are non-optimal for inlining. */
3698 hash_set
<tree
> visited_nodes
;
3699 memset (&wi
, 0, sizeof (wi
));
3700 wi
.info
= (void *) fndecl
;
3701 wi
.pset
= &visited_nodes
;
3703 FOR_EACH_BB_FN (bb
, fun
)
3706 gimple_seq seq
= bb_seq (bb
);
3707 ret
= walk_gimple_seq (seq
, inline_forbidden_p_stmt
, NULL
, &wi
);
3708 forbidden_p
= (ret
!= NULL
);
3716 /* Return false if the function FNDECL cannot be inlined on account of its
3717 attributes, true otherwise. */
3719 function_attribute_inlinable_p (const_tree fndecl
)
3721 if (targetm
.attribute_table
)
3725 for (a
= DECL_ATTRIBUTES (fndecl
); a
; a
= TREE_CHAIN (a
))
3727 const_tree name
= TREE_PURPOSE (a
);
3730 for (i
= 0; targetm
.attribute_table
[i
].name
!= NULL
; i
++)
3731 if (is_attribute_p (targetm
.attribute_table
[i
].name
, name
))
3732 return targetm
.function_attribute_inlinable_p (fndecl
);
3739 /* Returns nonzero if FN is a function that does not have any
3740 fundamental inline blocking properties. */
3743 tree_inlinable_function_p (tree fn
)
3745 bool inlinable
= true;
3749 /* If we've already decided this function shouldn't be inlined,
3750 there's no need to check again. */
3751 if (DECL_UNINLINABLE (fn
))
3754 /* We only warn for functions declared `inline' by the user. */
3755 do_warning
= (warn_inline
3756 && DECL_DECLARED_INLINE_P (fn
)
3757 && !DECL_NO_INLINE_WARNING_P (fn
)
3758 && !DECL_IN_SYSTEM_HEADER (fn
));
3760 always_inline
= lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
));
3763 && always_inline
== NULL
)
3766 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3767 "is suppressed using -fno-inline", fn
);
3771 else if (!function_attribute_inlinable_p (fn
))
3774 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3775 "uses attributes conflicting with inlining", fn
);
3779 else if (inline_forbidden_p (fn
))
3781 /* See if we should warn about uninlinable functions. Previously,
3782 some of these warnings would be issued while trying to expand
3783 the function inline, but that would cause multiple warnings
3784 about functions that would for example call alloca. But since
3785 this a property of the function, just one warning is enough.
3786 As a bonus we can now give more details about the reason why a
3787 function is not inlinable. */
3789 error (inline_forbidden_reason
, fn
);
3790 else if (do_warning
)
3791 warning (OPT_Winline
, inline_forbidden_reason
, fn
);
3796 /* Squirrel away the result so that we don't have to check again. */
3797 DECL_UNINLINABLE (fn
) = !inlinable
;
3802 /* Estimate the cost of a memory move of type TYPE. Use machine dependent
3803 word size and take possible memcpy call into account and return
3804 cost based on whether optimizing for size or speed according to SPEED_P. */
3807 estimate_move_cost (tree type
, bool ARG_UNUSED (speed_p
))
3811 gcc_assert (!VOID_TYPE_P (type
));
3813 if (TREE_CODE (type
) == VECTOR_TYPE
)
3815 machine_mode inner
= TYPE_MODE (TREE_TYPE (type
));
3817 = targetm
.vectorize
.preferred_simd_mode (inner
);
3818 int simd_mode_size
= GET_MODE_SIZE (simd
);
3819 return ((GET_MODE_SIZE (TYPE_MODE (type
)) + simd_mode_size
- 1)
3823 size
= int_size_in_bytes (type
);
3825 if (size
< 0 || size
> MOVE_MAX_PIECES
* MOVE_RATIO (speed_p
))
3826 /* Cost of a memcpy call, 3 arguments and the call. */
3829 return ((size
+ MOVE_MAX_PIECES
- 1) / MOVE_MAX_PIECES
);
3832 /* Returns cost of operation CODE, according to WEIGHTS */
3835 estimate_operator_cost (enum tree_code code
, eni_weights
*weights
,
3836 tree op1 ATTRIBUTE_UNUSED
, tree op2
)
3840 /* These are "free" conversions, or their presumed cost
3841 is folded into other operations. */
3846 case VIEW_CONVERT_EXPR
:
3849 /* Assign cost of 1 to usual operations.
3850 ??? We may consider mapping RTL costs to this. */
3856 case POINTER_PLUS_EXPR
:
3859 case MULT_HIGHPART_EXPR
:
3862 case ADDR_SPACE_CONVERT_EXPR
:
3863 case FIXED_CONVERT_EXPR
:
3864 case FIX_TRUNC_EXPR
:
3882 case TRUTH_ANDIF_EXPR
:
3883 case TRUTH_ORIF_EXPR
:
3884 case TRUTH_AND_EXPR
:
3886 case TRUTH_XOR_EXPR
:
3887 case TRUTH_NOT_EXPR
:
3896 case UNORDERED_EXPR
:
3907 case PREDECREMENT_EXPR
:
3908 case PREINCREMENT_EXPR
:
3909 case POSTDECREMENT_EXPR
:
3910 case POSTINCREMENT_EXPR
:
3912 case REALIGN_LOAD_EXPR
:
3914 case REDUC_MAX_EXPR
:
3915 case REDUC_MIN_EXPR
:
3916 case REDUC_PLUS_EXPR
:
3917 case WIDEN_SUM_EXPR
:
3918 case WIDEN_MULT_EXPR
:
3921 case WIDEN_MULT_PLUS_EXPR
:
3922 case WIDEN_MULT_MINUS_EXPR
:
3923 case WIDEN_LSHIFT_EXPR
:
3925 case VEC_WIDEN_MULT_HI_EXPR
:
3926 case VEC_WIDEN_MULT_LO_EXPR
:
3927 case VEC_WIDEN_MULT_EVEN_EXPR
:
3928 case VEC_WIDEN_MULT_ODD_EXPR
:
3929 case VEC_UNPACK_HI_EXPR
:
3930 case VEC_UNPACK_LO_EXPR
:
3931 case VEC_UNPACK_FLOAT_HI_EXPR
:
3932 case VEC_UNPACK_FLOAT_LO_EXPR
:
3933 case VEC_PACK_TRUNC_EXPR
:
3934 case VEC_PACK_SAT_EXPR
:
3935 case VEC_PACK_FIX_TRUNC_EXPR
:
3936 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3937 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3941 /* Few special cases of expensive operations. This is useful
3942 to avoid inlining on functions having too many of these. */
3943 case TRUNC_DIV_EXPR
:
3945 case FLOOR_DIV_EXPR
:
3946 case ROUND_DIV_EXPR
:
3947 case EXACT_DIV_EXPR
:
3948 case TRUNC_MOD_EXPR
:
3950 case FLOOR_MOD_EXPR
:
3951 case ROUND_MOD_EXPR
:
3953 if (TREE_CODE (op2
) != INTEGER_CST
)
3954 return weights
->div_mod_cost
;
3957 /* Bit-field insertion needs several shift and mask operations. */
3958 case BIT_INSERT_EXPR
:
3962 /* We expect a copy assignment with no operator. */
3963 gcc_assert (get_gimple_rhs_class (code
) == GIMPLE_SINGLE_RHS
);
3969 /* Estimate number of instructions that will be created by expanding
3970 the statements in the statement sequence STMTS.
3971 WEIGHTS contains weights attributed to various constructs. */
3974 estimate_num_insns_seq (gimple_seq stmts
, eni_weights
*weights
)
3977 gimple_stmt_iterator gsi
;
3980 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3981 cost
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
3987 /* Estimate number of instructions that will be created by expanding STMT.
3988 WEIGHTS contains weights attributed to various constructs. */
3991 estimate_num_insns (gimple
*stmt
, eni_weights
*weights
)
3994 enum gimple_code code
= gimple_code (stmt
);
4001 /* Try to estimate the cost of assignments. We have three cases to
4003 1) Simple assignments to registers;
4004 2) Stores to things that must live in memory. This includes
4005 "normal" stores to scalars, but also assignments of large
4006 structures, or constructors of big arrays;
4008 Let us look at the first two cases, assuming we have "a = b + C":
4009 <GIMPLE_ASSIGN <var_decl "a">
4010 <plus_expr <var_decl "b"> <constant C>>
4011 If "a" is a GIMPLE register, the assignment to it is free on almost
4012 any target, because "a" usually ends up in a real register. Hence
4013 the only cost of this expression comes from the PLUS_EXPR, and we
4014 can ignore the GIMPLE_ASSIGN.
4015 If "a" is not a GIMPLE register, the assignment to "a" will most
4016 likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost
4017 of moving something into "a", which we compute using the function
4018 estimate_move_cost. */
4019 if (gimple_clobber_p (stmt
))
4020 return 0; /* ={v} {CLOBBER} stmt expands to nothing. */
4022 lhs
= gimple_assign_lhs (stmt
);
4023 rhs
= gimple_assign_rhs1 (stmt
);
4027 /* Account for the cost of moving to / from memory. */
4028 if (gimple_store_p (stmt
))
4029 cost
+= estimate_move_cost (TREE_TYPE (lhs
), weights
->time_based
);
4030 if (gimple_assign_load_p (stmt
))
4031 cost
+= estimate_move_cost (TREE_TYPE (rhs
), weights
->time_based
);
4033 cost
+= estimate_operator_cost (gimple_assign_rhs_code (stmt
), weights
,
4034 gimple_assign_rhs1 (stmt
),
4035 get_gimple_rhs_class (gimple_assign_rhs_code (stmt
))
4036 == GIMPLE_BINARY_RHS
4037 ? gimple_assign_rhs2 (stmt
) : NULL
);
4041 cost
= 1 + estimate_operator_cost (gimple_cond_code (stmt
), weights
,
4042 gimple_op (stmt
, 0),
4043 gimple_op (stmt
, 1));
4048 gswitch
*switch_stmt
= as_a
<gswitch
*> (stmt
);
4049 /* Take into account cost of the switch + guess 2 conditional jumps for
4052 TODO: once the switch expansion logic is sufficiently separated, we can
4053 do better job on estimating cost of the switch. */
4054 if (weights
->time_based
)
4055 cost
= floor_log2 (gimple_switch_num_labels (switch_stmt
)) * 2;
4057 cost
= gimple_switch_num_labels (switch_stmt
) * 2;
4065 if (gimple_call_internal_p (stmt
))
4067 else if ((decl
= gimple_call_fndecl (stmt
))
4068 && DECL_BUILT_IN (decl
))
4070 /* Do not special case builtins where we see the body.
4071 This just confuse inliner. */
4072 struct cgraph_node
*node
;
4073 if (!(node
= cgraph_node::get (decl
))
4074 || node
->definition
)
4076 /* For buitins that are likely expanded to nothing or
4077 inlined do not account operand costs. */
4078 else if (is_simple_builtin (decl
))
4080 else if (is_inexpensive_builtin (decl
))
4081 return weights
->target_builtin_call_cost
;
4082 else if (gimple_call_builtin_p (stmt
, BUILT_IN_NORMAL
))
4084 /* We canonicalize x * x to pow (x, 2.0) with -ffast-math, so
4085 specialize the cheap expansion we do here.
4086 ??? This asks for a more general solution. */
4087 switch (DECL_FUNCTION_CODE (decl
))
4092 if (TREE_CODE (gimple_call_arg (stmt
, 1)) == REAL_CST
4094 (&TREE_REAL_CST (gimple_call_arg (stmt
, 1)),
4096 return estimate_operator_cost
4097 (MULT_EXPR
, weights
, gimple_call_arg (stmt
, 0),
4098 gimple_call_arg (stmt
, 0));
4107 cost
= decl
? weights
->call_cost
: weights
->indirect_call_cost
;
4108 if (gimple_call_lhs (stmt
))
4109 cost
+= estimate_move_cost (TREE_TYPE (gimple_call_lhs (stmt
)),
4110 weights
->time_based
);
4111 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
4113 tree arg
= gimple_call_arg (stmt
, i
);
4114 cost
+= estimate_move_cost (TREE_TYPE (arg
),
4115 weights
->time_based
);
4121 return weights
->return_cost
;
4127 case GIMPLE_PREDICT
:
4133 int count
= asm_str_count (gimple_asm_string (as_a
<gasm
*> (stmt
)));
4134 /* 1000 means infinity. This avoids overflows later
4135 with very long asm statements. */
4142 /* This is either going to be an external function call with one
4143 argument, or two register copy statements plus a goto. */
4146 case GIMPLE_EH_DISPATCH
:
4147 /* ??? This is going to turn into a switch statement. Ideally
4148 we'd have a look at the eh region and estimate the number of
4153 return estimate_num_insns_seq (
4154 gimple_bind_body (as_a
<gbind
*> (stmt
)),
4157 case GIMPLE_EH_FILTER
:
4158 return estimate_num_insns_seq (gimple_eh_filter_failure (stmt
), weights
);
4161 return estimate_num_insns_seq (gimple_catch_handler (
4162 as_a
<gcatch
*> (stmt
)),
4166 return (estimate_num_insns_seq (gimple_try_eval (stmt
), weights
)
4167 + estimate_num_insns_seq (gimple_try_cleanup (stmt
), weights
));
4169 /* OMP directives are generally very expensive. */
4171 case GIMPLE_OMP_RETURN
:
4172 case GIMPLE_OMP_SECTIONS_SWITCH
:
4173 case GIMPLE_OMP_ATOMIC_STORE
:
4174 case GIMPLE_OMP_CONTINUE
:
4175 /* ...except these, which are cheap. */
4178 case GIMPLE_OMP_ATOMIC_LOAD
:
4179 return weights
->omp_cost
;
4181 case GIMPLE_OMP_FOR
:
4182 return (weights
->omp_cost
4183 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
)
4184 + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt
), weights
));
4186 case GIMPLE_OMP_PARALLEL
:
4187 case GIMPLE_OMP_TASK
:
4188 case GIMPLE_OMP_CRITICAL
:
4189 case GIMPLE_OMP_MASTER
:
4190 case GIMPLE_OMP_TASKGROUP
:
4191 case GIMPLE_OMP_ORDERED
:
4192 case GIMPLE_OMP_SECTION
:
4193 case GIMPLE_OMP_SECTIONS
:
4194 case GIMPLE_OMP_SINGLE
:
4195 case GIMPLE_OMP_TARGET
:
4196 case GIMPLE_OMP_TEAMS
:
4197 return (weights
->omp_cost
4198 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
));
4200 case GIMPLE_TRANSACTION
:
4201 return (weights
->tm_cost
4202 + estimate_num_insns_seq (gimple_transaction_body (
4203 as_a
<gtransaction
*> (stmt
)),
4213 /* Estimate number of instructions that will be created by expanding
4214 function FNDECL. WEIGHTS contains weights attributed to various
4218 estimate_num_insns_fn (tree fndecl
, eni_weights
*weights
)
4220 struct function
*my_function
= DECL_STRUCT_FUNCTION (fndecl
);
4221 gimple_stmt_iterator bsi
;
4225 gcc_assert (my_function
&& my_function
->cfg
);
4226 FOR_EACH_BB_FN (bb
, my_function
)
4228 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
4229 n
+= estimate_num_insns (gsi_stmt (bsi
), weights
);
4236 /* Initializes weights used by estimate_num_insns. */
4239 init_inline_once (void)
4241 eni_size_weights
.call_cost
= 1;
4242 eni_size_weights
.indirect_call_cost
= 3;
4243 eni_size_weights
.target_builtin_call_cost
= 1;
4244 eni_size_weights
.div_mod_cost
= 1;
4245 eni_size_weights
.omp_cost
= 40;
4246 eni_size_weights
.tm_cost
= 10;
4247 eni_size_weights
.time_based
= false;
4248 eni_size_weights
.return_cost
= 1;
4250 /* Estimating time for call is difficult, since we have no idea what the
4251 called function does. In the current uses of eni_time_weights,
4252 underestimating the cost does less harm than overestimating it, so
4253 we choose a rather small value here. */
4254 eni_time_weights
.call_cost
= 10;
4255 eni_time_weights
.indirect_call_cost
= 15;
4256 eni_time_weights
.target_builtin_call_cost
= 1;
4257 eni_time_weights
.div_mod_cost
= 10;
4258 eni_time_weights
.omp_cost
= 40;
4259 eni_time_weights
.tm_cost
= 40;
4260 eni_time_weights
.time_based
= true;
4261 eni_time_weights
.return_cost
= 2;
4265 /* Install new lexical TREE_BLOCK underneath 'current_block'. */
4268 prepend_lexical_block (tree current_block
, tree new_block
)
4270 BLOCK_CHAIN (new_block
) = BLOCK_SUBBLOCKS (current_block
);
4271 BLOCK_SUBBLOCKS (current_block
) = new_block
;
4272 BLOCK_SUPERCONTEXT (new_block
) = current_block
;
4275 /* Add local variables from CALLEE to CALLER. */
4278 add_local_variables (struct function
*callee
, struct function
*caller
,
4284 FOR_EACH_LOCAL_DECL (callee
, ix
, var
)
4285 if (!can_be_nonlocal (var
, id
))
4287 tree new_var
= remap_decl (var
, id
);
4289 /* Remap debug-expressions. */
4290 if (TREE_CODE (new_var
) == VAR_DECL
4291 && DECL_HAS_DEBUG_EXPR_P (var
)
4294 tree tem
= DECL_DEBUG_EXPR (var
);
4295 bool old_regimplify
= id
->regimplify
;
4296 id
->remapping_type_depth
++;
4297 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
4298 id
->remapping_type_depth
--;
4299 id
->regimplify
= old_regimplify
;
4300 SET_DECL_DEBUG_EXPR (new_var
, tem
);
4301 DECL_HAS_DEBUG_EXPR_P (new_var
) = 1;
4303 add_local_decl (caller
, new_var
);
4307 /* Add to BINDINGS a debug stmt resetting SRCVAR if inlining might
4308 have brought in or introduced any debug stmts for SRCVAR. */
4311 reset_debug_binding (copy_body_data
*id
, tree srcvar
, gimple_seq
*bindings
)
4313 tree
*remappedvarp
= id
->decl_map
->get (srcvar
);
4318 if (TREE_CODE (*remappedvarp
) != VAR_DECL
)
4321 if (*remappedvarp
== id
->retvar
|| *remappedvarp
== id
->retbnd
)
4324 tree tvar
= target_for_debug_bind (*remappedvarp
);
4328 gdebug
*stmt
= gimple_build_debug_bind (tvar
, NULL_TREE
,
4330 gimple_seq_add_stmt (bindings
, stmt
);
4333 /* For each inlined variable for which we may have debug bind stmts,
4334 add before GSI a final debug stmt resetting it, marking the end of
4335 its life, so that var-tracking knows it doesn't have to compute
4336 further locations for it. */
4339 reset_debug_bindings (copy_body_data
*id
, gimple_stmt_iterator gsi
)
4343 gimple_seq bindings
= NULL
;
4345 if (!gimple_in_ssa_p (id
->src_cfun
))
4348 if (!opt_for_fn (id
->dst_fn
, flag_var_tracking_assignments
))
4351 for (var
= DECL_ARGUMENTS (id
->src_fn
);
4352 var
; var
= DECL_CHAIN (var
))
4353 reset_debug_binding (id
, var
, &bindings
);
4355 FOR_EACH_LOCAL_DECL (id
->src_cfun
, ix
, var
)
4356 reset_debug_binding (id
, var
, &bindings
);
4358 gsi_insert_seq_before_without_update (&gsi
, bindings
, GSI_SAME_STMT
);
4361 /* If STMT is a GIMPLE_CALL, replace it with its inline expansion. */
4364 expand_call_inline (basic_block bb
, gimple
*stmt
, copy_body_data
*id
)
4368 hash_map
<tree
, tree
> *dst
;
4369 hash_map
<tree
, tree
> *st
= NULL
;
4372 tree return_bounds
= NULL
;
4373 struct cgraph_edge
*cg_edge
;
4374 cgraph_inline_failed_t reason
;
4375 basic_block return_block
;
4377 gimple_stmt_iterator gsi
, stmt_gsi
;
4378 bool successfully_inlined
= false;
4379 bool purge_dead_abnormal_edges
;
4383 /* The gimplifier uses input_location in too many places, such as
4384 internal_get_tmp_var (). */
4385 location_t saved_location
= input_location
;
4386 input_location
= gimple_location (stmt
);
4388 /* From here on, we're only interested in CALL_EXPRs. */
4389 call_stmt
= dyn_cast
<gcall
*> (stmt
);
4393 cg_edge
= id
->dst_node
->get_edge (stmt
);
4394 gcc_checking_assert (cg_edge
);
4395 /* First, see if we can figure out what function is being called.
4396 If we cannot, then there is no hope of inlining the function. */
4397 if (cg_edge
->indirect_unknown_callee
)
4399 fn
= cg_edge
->callee
->decl
;
4400 gcc_checking_assert (fn
);
4402 /* If FN is a declaration of a function in a nested scope that was
4403 globally declared inline, we don't set its DECL_INITIAL.
4404 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
4405 C++ front-end uses it for cdtors to refer to their internal
4406 declarations, that are not real functions. Fortunately those
4407 don't have trees to be saved, so we can tell by checking their
4409 if (!DECL_INITIAL (fn
)
4410 && DECL_ABSTRACT_ORIGIN (fn
)
4411 && gimple_has_body_p (DECL_ABSTRACT_ORIGIN (fn
)))
4412 fn
= DECL_ABSTRACT_ORIGIN (fn
);
4414 /* Don't try to inline functions that are not well-suited to inlining. */
4415 if (cg_edge
->inline_failed
)
4417 reason
= cg_edge
->inline_failed
;
4418 /* If this call was originally indirect, we do not want to emit any
4419 inlining related warnings or sorry messages because there are no
4420 guarantees regarding those. */
4421 if (cg_edge
->indirect_inlining_edge
)
4424 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
))
4425 /* For extern inline functions that get redefined we always
4426 silently ignored always_inline flag. Better behavior would
4427 be to be able to keep both bodies and use extern inline body
4428 for inlining, but we can't do that because frontends overwrite
4430 && !cg_edge
->callee
->local
.redefined_extern_inline
4431 /* During early inline pass, report only when optimization is
4433 && (symtab
->global_info_ready
4435 || cgraph_inline_failed_type (reason
) == CIF_FINAL_ERROR
)
4436 /* PR 20090218-1_0.c. Body can be provided by another module. */
4437 && (reason
!= CIF_BODY_NOT_AVAILABLE
|| !flag_generate_lto
))
4439 error ("inlining failed in call to always_inline %q+F: %s", fn
,
4440 cgraph_inline_failed_string (reason
));
4441 if (gimple_location (stmt
) != UNKNOWN_LOCATION
)
4442 inform (gimple_location (stmt
), "called from here");
4443 else if (DECL_SOURCE_LOCATION (cfun
->decl
) != UNKNOWN_LOCATION
)
4444 inform (DECL_SOURCE_LOCATION (cfun
->decl
),
4445 "called from this function");
4447 else if (warn_inline
4448 && DECL_DECLARED_INLINE_P (fn
)
4449 && !DECL_NO_INLINE_WARNING_P (fn
)
4450 && !DECL_IN_SYSTEM_HEADER (fn
)
4451 && reason
!= CIF_UNSPECIFIED
4452 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn
))
4453 /* Do not warn about not inlined recursive calls. */
4454 && !cg_edge
->recursive_p ()
4455 /* Avoid warnings during early inline pass. */
4456 && symtab
->global_info_ready
)
4458 if (warning (OPT_Winline
, "inlining failed in call to %q+F: %s",
4459 fn
, _(cgraph_inline_failed_string (reason
))))
4461 if (gimple_location (stmt
) != UNKNOWN_LOCATION
)
4462 inform (gimple_location (stmt
), "called from here");
4463 else if (DECL_SOURCE_LOCATION (cfun
->decl
) != UNKNOWN_LOCATION
)
4464 inform (DECL_SOURCE_LOCATION (cfun
->decl
),
4465 "called from this function");
4470 id
->src_node
= cg_edge
->callee
;
4472 /* If callee is thunk, all we need is to adjust the THIS pointer
4473 and redirect to function being thunked. */
4474 if (id
->src_node
->thunk
.thunk_p
)
4477 tree virtual_offset
= NULL
;
4478 int freq
= cg_edge
->frequency
;
4479 gcov_type count
= cg_edge
->count
;
4481 gimple_stmt_iterator iter
= gsi_for_stmt (stmt
);
4484 edge
= id
->src_node
->callees
->clone (id
->dst_node
, call_stmt
,
4486 REG_BR_PROB_BASE
, CGRAPH_FREQ_BASE
,
4488 edge
->frequency
= freq
;
4489 edge
->count
= count
;
4490 if (id
->src_node
->thunk
.virtual_offset_p
)
4491 virtual_offset
= size_int (id
->src_node
->thunk
.virtual_value
);
4492 op
= create_tmp_reg_fn (cfun
, TREE_TYPE (gimple_call_arg (stmt
, 0)),
4494 gsi_insert_before (&iter
, gimple_build_assign (op
,
4495 gimple_call_arg (stmt
, 0)),
4497 gcc_assert (id
->src_node
->thunk
.this_adjusting
);
4498 op
= thunk_adjust (&iter
, op
, 1, id
->src_node
->thunk
.fixed_offset
,
4501 gimple_call_set_arg (stmt
, 0, op
);
4502 gimple_call_set_fndecl (stmt
, edge
->callee
->decl
);
4504 id
->src_node
->remove ();
4505 expand_call_inline (bb
, stmt
, id
);
4506 maybe_remove_unused_call_args (cfun
, stmt
);
4509 fn
= cg_edge
->callee
->decl
;
4510 cg_edge
->callee
->get_untransformed_body ();
4512 if (flag_checking
&& cg_edge
->callee
->decl
!= id
->dst_node
->decl
)
4513 cg_edge
->callee
->verify ();
4515 /* We will be inlining this callee. */
4516 id
->eh_lp_nr
= lookup_stmt_eh_lp (stmt
);
4517 id
->assign_stmts
.create (0);
4519 /* Update the callers EH personality. */
4520 if (DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->decl
))
4521 DECL_FUNCTION_PERSONALITY (cg_edge
->caller
->decl
)
4522 = DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->decl
);
4524 /* Split the block holding the GIMPLE_CALL. */
4525 e
= split_block (bb
, stmt
);
4527 return_block
= e
->dest
;
4530 /* split_block splits after the statement; work around this by
4531 moving the call into the second block manually. Not pretty,
4532 but seems easier than doing the CFG manipulation by hand
4533 when the GIMPLE_CALL is in the last statement of BB. */
4534 stmt_gsi
= gsi_last_bb (bb
);
4535 gsi_remove (&stmt_gsi
, false);
4537 /* If the GIMPLE_CALL was in the last statement of BB, it may have
4538 been the source of abnormal edges. In this case, schedule
4539 the removal of dead abnormal edges. */
4540 gsi
= gsi_start_bb (return_block
);
4541 if (gsi_end_p (gsi
))
4543 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
4544 purge_dead_abnormal_edges
= true;
4548 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
4549 purge_dead_abnormal_edges
= false;
4552 stmt_gsi
= gsi_start_bb (return_block
);
4554 /* Build a block containing code to initialize the arguments, the
4555 actual inline expansion of the body, and a label for the return
4556 statements within the function to jump to. The type of the
4557 statement expression is the return type of the function call.
4558 ??? If the call does not have an associated block then we will
4559 remap all callee blocks to NULL, effectively dropping most of
4560 its debug information. This should only happen for calls to
4561 artificial decls inserted by the compiler itself. We need to
4562 either link the inlined blocks into the caller block tree or
4563 not refer to them in any way to not break GC for locations. */
4564 if (gimple_block (stmt
))
4566 id
->block
= make_node (BLOCK
);
4567 BLOCK_ABSTRACT_ORIGIN (id
->block
) = fn
;
4568 BLOCK_SOURCE_LOCATION (id
->block
)
4569 = LOCATION_LOCUS (gimple_location (stmt
));
4570 prepend_lexical_block (gimple_block (stmt
), id
->block
);
4573 /* Local declarations will be replaced by their equivalents in this
4576 id
->decl_map
= new hash_map
<tree
, tree
>;
4577 dst
= id
->debug_map
;
4578 id
->debug_map
= NULL
;
4580 /* Record the function we are about to inline. */
4582 id
->src_cfun
= DECL_STRUCT_FUNCTION (fn
);
4583 id
->call_stmt
= stmt
;
4585 /* If the src function contains an IFN_VA_ARG, then so will the dst
4586 function after inlining. */
4587 if ((id
->src_cfun
->curr_properties
& PROP_gimple_lva
) == 0)
4589 struct function
*dst_cfun
= DECL_STRUCT_FUNCTION (id
->dst_fn
);
4590 dst_cfun
->curr_properties
&= ~PROP_gimple_lva
;
4593 gcc_assert (!id
->src_cfun
->after_inlining
);
4596 if (lookup_attribute ("cold", DECL_ATTRIBUTES (fn
)))
4598 gimple_stmt_iterator si
= gsi_last_bb (bb
);
4599 gsi_insert_after (&si
, gimple_build_predict (PRED_COLD_FUNCTION
,
4603 initialize_inlined_parameters (id
, stmt
, fn
, bb
);
4605 if (DECL_INITIAL (fn
))
4607 if (gimple_block (stmt
))
4611 prepend_lexical_block (id
->block
,
4612 remap_blocks (DECL_INITIAL (fn
), id
));
4613 gcc_checking_assert (BLOCK_SUBBLOCKS (id
->block
)
4614 && (BLOCK_CHAIN (BLOCK_SUBBLOCKS (id
->block
))
4616 /* Move vars for PARM_DECLs from DECL_INITIAL block to id->block,
4617 otherwise for DWARF DW_TAG_formal_parameter will not be children of
4618 DW_TAG_inlined_subroutine, but of a DW_TAG_lexical_block
4619 under it. The parameters can be then evaluated in the debugger,
4620 but don't show in backtraces. */
4621 for (var
= &BLOCK_VARS (BLOCK_SUBBLOCKS (id
->block
)); *var
; )
4622 if (TREE_CODE (DECL_ORIGIN (*var
)) == PARM_DECL
)
4625 *var
= TREE_CHAIN (v
);
4626 TREE_CHAIN (v
) = BLOCK_VARS (id
->block
);
4627 BLOCK_VARS (id
->block
) = v
;
4630 var
= &TREE_CHAIN (*var
);
4633 remap_blocks_to_null (DECL_INITIAL (fn
), id
);
4636 /* Return statements in the function body will be replaced by jumps
4637 to the RET_LABEL. */
4638 gcc_assert (DECL_INITIAL (fn
));
4639 gcc_assert (TREE_CODE (DECL_INITIAL (fn
)) == BLOCK
);
4641 /* Find the LHS to which the result of this call is assigned. */
4643 if (gimple_call_lhs (stmt
))
4645 modify_dest
= gimple_call_lhs (stmt
);
4647 /* Remember where to copy returned bounds. */
4648 if (gimple_call_with_bounds_p (stmt
)
4649 && TREE_CODE (modify_dest
) == SSA_NAME
)
4651 gcall
*retbnd
= chkp_retbnd_call_by_val (modify_dest
);
4654 return_bounds
= gimple_call_lhs (retbnd
);
4655 /* If returned bounds are not used then just
4656 remove unused call. */
4659 gimple_stmt_iterator iter
= gsi_for_stmt (retbnd
);
4660 gsi_remove (&iter
, true);
4665 /* The function which we are inlining might not return a value,
4666 in which case we should issue a warning that the function
4667 does not return a value. In that case the optimizers will
4668 see that the variable to which the value is assigned was not
4669 initialized. We do not want to issue a warning about that
4670 uninitialized variable. */
4671 if (DECL_P (modify_dest
))
4672 TREE_NO_WARNING (modify_dest
) = 1;
4674 if (gimple_call_return_slot_opt_p (call_stmt
))
4676 return_slot
= modify_dest
;
4683 /* If we are inlining a call to the C++ operator new, we don't want
4684 to use type based alias analysis on the return value. Otherwise
4685 we may get confused if the compiler sees that the inlined new
4686 function returns a pointer which was just deleted. See bug
4688 if (DECL_IS_OPERATOR_NEW (fn
))
4694 /* Declare the return variable for the function. */
4695 use_retvar
= declare_return_variable (id
, return_slot
, modify_dest
,
4698 /* Add local vars in this inlined callee to caller. */
4699 add_local_variables (id
->src_cfun
, cfun
, id
);
4701 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4703 fprintf (dump_file
, "Inlining ");
4704 print_generic_expr (dump_file
, id
->src_fn
, 0);
4705 fprintf (dump_file
, " to ");
4706 print_generic_expr (dump_file
, id
->dst_fn
, 0);
4707 fprintf (dump_file
, " with frequency %i\n", cg_edge
->frequency
);
4710 /* This is it. Duplicate the callee body. Assume callee is
4711 pre-gimplified. Note that we must not alter the caller
4712 function in any way before this point, as this CALL_EXPR may be
4713 a self-referential call; if we're calling ourselves, we need to
4714 duplicate our body before altering anything. */
4715 copy_body (id
, cg_edge
->callee
->count
,
4716 GCOV_COMPUTE_SCALE (cg_edge
->frequency
, CGRAPH_FREQ_BASE
),
4717 bb
, return_block
, NULL
);
4719 reset_debug_bindings (id
, stmt_gsi
);
4721 /* Reset the escaped solution. */
4722 if (cfun
->gimple_df
)
4723 pt_solution_reset (&cfun
->gimple_df
->escaped
);
4728 delete id
->debug_map
;
4729 id
->debug_map
= dst
;
4731 delete id
->decl_map
;
4734 /* Unlink the calls virtual operands before replacing it. */
4735 unlink_stmt_vdef (stmt
);
4736 if (gimple_vdef (stmt
)
4737 && TREE_CODE (gimple_vdef (stmt
)) == SSA_NAME
)
4738 release_ssa_name (gimple_vdef (stmt
));
4740 /* If the inlined function returns a result that we care about,
4741 substitute the GIMPLE_CALL with an assignment of the return
4742 variable to the LHS of the call. That is, if STMT was
4743 'a = foo (...)', substitute the call with 'a = USE_RETVAR'. */
4744 if (use_retvar
&& gimple_call_lhs (stmt
))
4746 gimple
*old_stmt
= stmt
;
4747 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), use_retvar
);
4748 gsi_replace (&stmt_gsi
, stmt
, false);
4749 maybe_clean_or_replace_eh_stmt (old_stmt
, stmt
);
4751 /* Copy bounds if we copy structure with bounds. */
4752 if (chkp_function_instrumented_p (id
->dst_fn
)
4753 && !BOUNDED_P (use_retvar
)
4754 && chkp_type_has_pointer (TREE_TYPE (use_retvar
)))
4755 id
->assign_stmts
.safe_push (stmt
);
4759 /* Handle the case of inlining a function with no return
4760 statement, which causes the return value to become undefined. */
4761 if (gimple_call_lhs (stmt
)
4762 && TREE_CODE (gimple_call_lhs (stmt
)) == SSA_NAME
)
4764 tree name
= gimple_call_lhs (stmt
);
4765 tree var
= SSA_NAME_VAR (name
);
4766 tree def
= var
? ssa_default_def (cfun
, var
) : NULL
;
4770 /* If the variable is used undefined, make this name
4771 undefined via a move. */
4772 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), def
);
4773 gsi_replace (&stmt_gsi
, stmt
, true);
4779 tree var
= create_tmp_reg_fn (cfun
, TREE_TYPE (name
), NULL
);
4780 SET_SSA_NAME_VAR_OR_IDENTIFIER (name
, var
);
4782 /* Otherwise make this variable undefined. */
4783 gsi_remove (&stmt_gsi
, true);
4784 set_ssa_default_def (cfun
, var
, name
);
4785 SSA_NAME_DEF_STMT (name
) = gimple_build_nop ();
4789 gsi_remove (&stmt_gsi
, true);
4792 /* Put returned bounds into the correct place if required. */
4795 gimple
*old_stmt
= SSA_NAME_DEF_STMT (return_bounds
);
4796 gimple
*new_stmt
= gimple_build_assign (return_bounds
, id
->retbnd
);
4797 gimple_stmt_iterator bnd_gsi
= gsi_for_stmt (old_stmt
);
4798 unlink_stmt_vdef (old_stmt
);
4799 gsi_replace (&bnd_gsi
, new_stmt
, false);
4800 maybe_clean_or_replace_eh_stmt (old_stmt
, new_stmt
);
4801 cgraph_update_edges_for_call_stmt (old_stmt
,
4802 gimple_call_fndecl (old_stmt
),
4806 if (purge_dead_abnormal_edges
)
4808 gimple_purge_dead_eh_edges (return_block
);
4809 gimple_purge_dead_abnormal_call_edges (return_block
);
4812 /* If the value of the new expression is ignored, that's OK. We
4813 don't warn about this for CALL_EXPRs, so we shouldn't warn about
4814 the equivalent inlined version either. */
4815 if (is_gimple_assign (stmt
))
4817 gcc_assert (gimple_assign_single_p (stmt
)
4818 || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
)));
4819 TREE_USED (gimple_assign_rhs1 (stmt
)) = 1;
4822 /* Copy bounds for all generated assigns that need it. */
4823 for (i
= 0; i
< id
->assign_stmts
.length (); i
++)
4824 chkp_copy_bounds_for_assign (id
->assign_stmts
[i
], cg_edge
);
4825 id
->assign_stmts
.release ();
4827 /* Output the inlining info for this abstract function, since it has been
4828 inlined. If we don't do this now, we can lose the information about the
4829 variables in the function when the blocks get blown away as soon as we
4830 remove the cgraph node. */
4831 if (gimple_block (stmt
))
4832 (*debug_hooks
->outlining_inline_function
) (cg_edge
->callee
->decl
);
4834 /* Update callgraph if needed. */
4835 cg_edge
->callee
->remove ();
4837 id
->block
= NULL_TREE
;
4838 successfully_inlined
= true;
4841 input_location
= saved_location
;
4842 return successfully_inlined
;
4845 /* Expand call statements reachable from STMT_P.
4846 We can only have CALL_EXPRs as the "toplevel" tree code or nested
4847 in a MODIFY_EXPR. */
4850 gimple_expand_calls_inline (basic_block bb
, copy_body_data
*id
)
4852 gimple_stmt_iterator gsi
;
4853 bool inlined
= false;
4855 for (gsi
= gsi_last_bb (bb
); !gsi_end_p (gsi
);)
4857 gimple
*stmt
= gsi_stmt (gsi
);
4860 if (is_gimple_call (stmt
)
4861 && !gimple_call_internal_p (stmt
))
4862 inlined
|= expand_call_inline (bb
, stmt
, id
);
4869 /* Walk all basic blocks created after FIRST and try to fold every statement
4870 in the STATEMENTS pointer set. */
4873 fold_marked_statements (int first
, hash_set
<gimple
*> *statements
)
4875 for (; first
< n_basic_blocks_for_fn (cfun
); first
++)
4876 if (BASIC_BLOCK_FOR_FN (cfun
, first
))
4878 gimple_stmt_iterator gsi
;
4880 for (gsi
= gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, first
));
4883 if (statements
->contains (gsi_stmt (gsi
)))
4885 gimple
*old_stmt
= gsi_stmt (gsi
);
4886 tree old_decl
= is_gimple_call (old_stmt
) ? gimple_call_fndecl (old_stmt
) : 0;
4888 if (old_decl
&& DECL_BUILT_IN (old_decl
))
4890 /* Folding builtins can create multiple instructions,
4891 we need to look at all of them. */
4892 gimple_stmt_iterator i2
= gsi
;
4894 if (fold_stmt (&gsi
))
4897 /* If a builtin at the end of a bb folded into nothing,
4898 the following loop won't work. */
4899 if (gsi_end_p (gsi
))
4901 cgraph_update_edges_for_call_stmt (old_stmt
,
4906 i2
= gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, first
));
4911 new_stmt
= gsi_stmt (i2
);
4912 update_stmt (new_stmt
);
4913 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4916 if (new_stmt
== gsi_stmt (gsi
))
4918 /* It is okay to check only for the very last
4919 of these statements. If it is a throwing
4920 statement nothing will change. If it isn't
4921 this can remove EH edges. If that weren't
4922 correct then because some intermediate stmts
4923 throw, but not the last one. That would mean
4924 we'd have to split the block, which we can't
4925 here and we'd loose anyway. And as builtins
4926 probably never throw, this all
4928 if (maybe_clean_or_replace_eh_stmt (old_stmt
,
4930 gimple_purge_dead_eh_edges (
4931 BASIC_BLOCK_FOR_FN (cfun
, first
));
4938 else if (fold_stmt (&gsi
))
4940 /* Re-read the statement from GSI as fold_stmt() may
4942 gimple
*new_stmt
= gsi_stmt (gsi
);
4943 update_stmt (new_stmt
);
4945 if (is_gimple_call (old_stmt
)
4946 || is_gimple_call (new_stmt
))
4947 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4950 if (maybe_clean_or_replace_eh_stmt (old_stmt
, new_stmt
))
4951 gimple_purge_dead_eh_edges (BASIC_BLOCK_FOR_FN (cfun
,
4958 /* Expand calls to inline functions in the body of FN. */
4961 optimize_inline_calls (tree fn
)
4965 int last
= n_basic_blocks_for_fn (cfun
);
4966 bool inlined_p
= false;
4969 memset (&id
, 0, sizeof (id
));
4971 id
.src_node
= id
.dst_node
= cgraph_node::get (fn
);
4972 gcc_assert (id
.dst_node
->definition
);
4974 /* Or any functions that aren't finished yet. */
4975 if (current_function_decl
)
4976 id
.dst_fn
= current_function_decl
;
4978 id
.copy_decl
= copy_decl_maybe_to_var
;
4979 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
4980 id
.transform_new_cfg
= false;
4981 id
.transform_return_to_modify
= true;
4982 id
.transform_parameter
= true;
4983 id
.transform_lang_insert_block
= NULL
;
4984 id
.statements_to_fold
= new hash_set
<gimple
*>;
4986 push_gimplify_context ();
4988 /* We make no attempts to keep dominance info up-to-date. */
4989 free_dominance_info (CDI_DOMINATORS
);
4990 free_dominance_info (CDI_POST_DOMINATORS
);
4992 /* Register specific gimple functions. */
4993 gimple_register_cfg_hooks ();
4995 /* Reach the trees by walking over the CFG, and note the
4996 enclosing basic-blocks in the call edges. */
4997 /* We walk the blocks going forward, because inlined function bodies
4998 will split id->current_basic_block, and the new blocks will
4999 follow it; we'll trudge through them, processing their CALL_EXPRs
5001 FOR_EACH_BB_FN (bb
, cfun
)
5002 inlined_p
|= gimple_expand_calls_inline (bb
, &id
);
5004 pop_gimplify_context (NULL
);
5008 struct cgraph_edge
*e
;
5010 id
.dst_node
->verify ();
5012 /* Double check that we inlined everything we are supposed to inline. */
5013 for (e
= id
.dst_node
->callees
; e
; e
= e
->next_callee
)
5014 gcc_assert (e
->inline_failed
);
5017 /* Fold queued statements. */
5018 fold_marked_statements (last
, id
.statements_to_fold
);
5019 delete id
.statements_to_fold
;
5021 gcc_assert (!id
.debug_stmts
.exists ());
5023 /* If we didn't inline into the function there is nothing to do. */
5027 /* Renumber the lexical scoping (non-code) blocks consecutively. */
5030 delete_unreachable_blocks_update_callgraph (&id
);
5032 id
.dst_node
->verify ();
5034 /* It would be nice to check SSA/CFG/statement consistency here, but it is
5035 not possible yet - the IPA passes might make various functions to not
5036 throw and they don't care to proactively update local EH info. This is
5037 done later in fixup_cfg pass that also execute the verification. */
5038 return (TODO_update_ssa
5040 | (gimple_in_ssa_p (cfun
) ? TODO_remove_unused_locals
: 0)
5041 | (gimple_in_ssa_p (cfun
) ? TODO_update_address_taken
: 0)
5042 | (profile_status_for_fn (cfun
) != PROFILE_ABSENT
5043 ? TODO_rebuild_frequencies
: 0));
5046 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
5049 copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
5051 enum tree_code code
= TREE_CODE (*tp
);
5052 enum tree_code_class cl
= TREE_CODE_CLASS (code
);
5054 /* We make copies of most nodes. */
5055 if (IS_EXPR_CODE_CLASS (cl
)
5056 || code
== TREE_LIST
5058 || code
== TYPE_DECL
5059 || code
== OMP_CLAUSE
)
5061 /* Because the chain gets clobbered when we make a copy, we save it
5063 tree chain
= NULL_TREE
, new_tree
;
5065 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
5066 chain
= TREE_CHAIN (*tp
);
5068 /* Copy the node. */
5069 new_tree
= copy_node (*tp
);
5073 /* Now, restore the chain, if appropriate. That will cause
5074 walk_tree to walk into the chain as well. */
5075 if (code
== PARM_DECL
5076 || code
== TREE_LIST
5077 || code
== OMP_CLAUSE
)
5078 TREE_CHAIN (*tp
) = chain
;
5080 /* For now, we don't update BLOCKs when we make copies. So, we
5081 have to nullify all BIND_EXPRs. */
5082 if (TREE_CODE (*tp
) == BIND_EXPR
)
5083 BIND_EXPR_BLOCK (*tp
) = NULL_TREE
;
5085 else if (code
== CONSTRUCTOR
)
5087 /* CONSTRUCTOR nodes need special handling because
5088 we need to duplicate the vector of elements. */
5091 new_tree
= copy_node (*tp
);
5092 CONSTRUCTOR_ELTS (new_tree
) = vec_safe_copy (CONSTRUCTOR_ELTS (*tp
));
5095 else if (code
== STATEMENT_LIST
)
5096 /* We used to just abort on STATEMENT_LIST, but we can run into them
5097 with statement-expressions (c++/40975). */
5098 copy_statement_list (tp
);
5099 else if (TREE_CODE_CLASS (code
) == tcc_type
)
5101 else if (TREE_CODE_CLASS (code
) == tcc_declaration
)
5103 else if (TREE_CODE_CLASS (code
) == tcc_constant
)
5108 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
5109 information indicating to what new SAVE_EXPR this one should be mapped,
5110 use that one. Otherwise, create a new node and enter it in ST. FN is
5111 the function into which the copy will be placed. */
5114 remap_save_expr (tree
*tp
, hash_map
<tree
, tree
> *st
, int *walk_subtrees
)
5119 /* See if we already encountered this SAVE_EXPR. */
5122 /* If we didn't already remap this SAVE_EXPR, do so now. */
5125 t
= copy_node (*tp
);
5127 /* Remember this SAVE_EXPR. */
5129 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
5134 /* We've already walked into this SAVE_EXPR; don't do it again. */
5139 /* Replace this SAVE_EXPR with the copy. */
5143 /* Called via walk_gimple_seq. If *GSIP points to a GIMPLE_LABEL for a local
5144 label, copies the declaration and enters it in the splay_tree in DATA (which
5145 is really a 'copy_body_data *'. */
5148 mark_local_labels_stmt (gimple_stmt_iterator
*gsip
,
5149 bool *handled_ops_p ATTRIBUTE_UNUSED
,
5150 struct walk_stmt_info
*wi
)
5152 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
5153 glabel
*stmt
= dyn_cast
<glabel
*> (gsi_stmt (*gsip
));
5157 tree decl
= gimple_label_label (stmt
);
5159 /* Copy the decl and remember the copy. */
5160 insert_decl_map (id
, decl
, id
->copy_decl (decl
, id
));
5166 static gimple_seq
duplicate_remap_omp_clause_seq (gimple_seq seq
,
5167 struct walk_stmt_info
*wi
);
5169 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
5170 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
5171 remaps all local declarations to appropriate replacements in gimple
5175 replace_locals_op (tree
*tp
, int *walk_subtrees
, void *data
)
5177 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
5178 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
5179 hash_map
<tree
, tree
> *st
= id
->decl_map
;
5183 /* For recursive invocations this is no longer the LHS itself. */
5184 bool is_lhs
= wi
->is_lhs
;
5187 if (TREE_CODE (expr
) == SSA_NAME
)
5189 *tp
= remap_ssa_name (*tp
, id
);
5192 SSA_NAME_DEF_STMT (*tp
) = gsi_stmt (wi
->gsi
);
5194 /* Only a local declaration (variable or label). */
5195 else if ((TREE_CODE (expr
) == VAR_DECL
5196 && !TREE_STATIC (expr
))
5197 || TREE_CODE (expr
) == LABEL_DECL
)
5199 /* Lookup the declaration. */
5202 /* If it's there, remap it. */
5207 else if (TREE_CODE (expr
) == STATEMENT_LIST
5208 || TREE_CODE (expr
) == BIND_EXPR
5209 || TREE_CODE (expr
) == SAVE_EXPR
)
5211 else if (TREE_CODE (expr
) == TARGET_EXPR
)
5213 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
5214 It's OK for this to happen if it was part of a subtree that
5215 isn't immediately expanded, such as operand 2 of another
5217 if (!TREE_OPERAND (expr
, 1))
5219 TREE_OPERAND (expr
, 1) = TREE_OPERAND (expr
, 3);
5220 TREE_OPERAND (expr
, 3) = NULL_TREE
;
5223 else if (TREE_CODE (expr
) == OMP_CLAUSE
)
5225 /* Before the omplower pass completes, some OMP clauses can contain
5226 sequences that are neither copied by gimple_seq_copy nor walked by
5227 walk_gimple_seq. To make copy_gimple_seq_and_replace_locals work even
5228 in those situations, we have to copy and process them explicitely. */
5230 if (OMP_CLAUSE_CODE (expr
) == OMP_CLAUSE_LASTPRIVATE
)
5232 gimple_seq seq
= OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (expr
);
5233 seq
= duplicate_remap_omp_clause_seq (seq
, wi
);
5234 OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (expr
) = seq
;
5236 else if (OMP_CLAUSE_CODE (expr
) == OMP_CLAUSE_LINEAR
)
5238 gimple_seq seq
= OMP_CLAUSE_LINEAR_GIMPLE_SEQ (expr
);
5239 seq
= duplicate_remap_omp_clause_seq (seq
, wi
);
5240 OMP_CLAUSE_LINEAR_GIMPLE_SEQ (expr
) = seq
;
5242 else if (OMP_CLAUSE_CODE (expr
) == OMP_CLAUSE_REDUCTION
)
5244 gimple_seq seq
= OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr
);
5245 seq
= duplicate_remap_omp_clause_seq (seq
, wi
);
5246 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr
) = seq
;
5247 seq
= OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr
);
5248 seq
= duplicate_remap_omp_clause_seq (seq
, wi
);
5249 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr
) = seq
;
5253 /* Keep iterating. */
5258 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
5259 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
5260 remaps all local declarations to appropriate replacements in gimple
5264 replace_locals_stmt (gimple_stmt_iterator
*gsip
,
5265 bool *handled_ops_p ATTRIBUTE_UNUSED
,
5266 struct walk_stmt_info
*wi
)
5268 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
5269 gimple
*gs
= gsi_stmt (*gsip
);
5271 if (gbind
*stmt
= dyn_cast
<gbind
*> (gs
))
5273 tree block
= gimple_bind_block (stmt
);
5277 remap_block (&block
, id
);
5278 gimple_bind_set_block (stmt
, block
);
5281 /* This will remap a lot of the same decls again, but this should be
5283 if (gimple_bind_vars (stmt
))
5285 tree old_var
, decls
= gimple_bind_vars (stmt
);
5287 for (old_var
= decls
; old_var
; old_var
= DECL_CHAIN (old_var
))
5288 if (!can_be_nonlocal (old_var
, id
)
5289 && ! variably_modified_type_p (TREE_TYPE (old_var
), id
->src_fn
))
5290 remap_decl (old_var
, id
);
5292 gcc_checking_assert (!id
->prevent_decl_creation_for_types
);
5293 id
->prevent_decl_creation_for_types
= true;
5294 gimple_bind_set_vars (stmt
, remap_decls (decls
, NULL
, id
));
5295 id
->prevent_decl_creation_for_types
= false;
5299 /* Keep iterating. */
5303 /* Create a copy of SEQ and remap all decls in it. */
5306 duplicate_remap_omp_clause_seq (gimple_seq seq
, struct walk_stmt_info
*wi
)
5311 /* If there are any labels in OMP sequences, they can be only referred to in
5312 the sequence itself and therefore we can do both here. */
5313 walk_gimple_seq (seq
, mark_local_labels_stmt
, NULL
, wi
);
5314 gimple_seq copy
= gimple_seq_copy (seq
);
5315 walk_gimple_seq (copy
, replace_locals_stmt
, replace_locals_op
, wi
);
5319 /* Copies everything in SEQ and replaces variables and labels local to
5320 current_function_decl. */
5323 copy_gimple_seq_and_replace_locals (gimple_seq seq
)
5326 struct walk_stmt_info wi
;
5329 /* There's nothing to do for NULL_TREE. */
5334 memset (&id
, 0, sizeof (id
));
5335 id
.src_fn
= current_function_decl
;
5336 id
.dst_fn
= current_function_decl
;
5338 id
.decl_map
= new hash_map
<tree
, tree
>;
5339 id
.debug_map
= NULL
;
5341 id
.copy_decl
= copy_decl_no_change
;
5342 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5343 id
.transform_new_cfg
= false;
5344 id
.transform_return_to_modify
= false;
5345 id
.transform_parameter
= false;
5346 id
.transform_lang_insert_block
= NULL
;
5348 /* Walk the tree once to find local labels. */
5349 memset (&wi
, 0, sizeof (wi
));
5350 hash_set
<tree
> visited
;
5353 walk_gimple_seq (seq
, mark_local_labels_stmt
, NULL
, &wi
);
5355 copy
= gimple_seq_copy (seq
);
5357 /* Walk the copy, remapping decls. */
5358 memset (&wi
, 0, sizeof (wi
));
5360 walk_gimple_seq (copy
, replace_locals_stmt
, replace_locals_op
, &wi
);
5365 delete id
.debug_map
;
5366 if (id
.dependence_map
)
5368 delete id
.dependence_map
;
5369 id
.dependence_map
= NULL
;
5376 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
5379 debug_find_tree_1 (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
, void *data
)
5388 debug_find_tree (tree top
, tree search
)
5390 return walk_tree_without_duplicates (&top
, debug_find_tree_1
, search
) != 0;
5394 /* Declare the variables created by the inliner. Add all the variables in
5395 VARS to BIND_EXPR. */
5398 declare_inline_vars (tree block
, tree vars
)
5401 for (t
= vars
; t
; t
= DECL_CHAIN (t
))
5403 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
5404 gcc_assert (!TREE_STATIC (t
) && !TREE_ASM_WRITTEN (t
));
5405 add_local_decl (cfun
, t
);
5409 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), vars
);
5412 /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN,
5413 but now it will be in the TO_FN. PARM_TO_VAR means enable PARM_DECL to
5414 VAR_DECL translation. */
5417 copy_decl_for_dup_finish (copy_body_data
*id
, tree decl
, tree copy
)
5419 /* Don't generate debug information for the copy if we wouldn't have
5420 generated it for the copy either. */
5421 DECL_ARTIFICIAL (copy
) = DECL_ARTIFICIAL (decl
);
5422 DECL_IGNORED_P (copy
) = DECL_IGNORED_P (decl
);
5424 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
5425 declaration inspired this copy. */
5426 DECL_ABSTRACT_ORIGIN (copy
) = DECL_ORIGIN (decl
);
5428 /* The new variable/label has no RTL, yet. */
5429 if (CODE_CONTAINS_STRUCT (TREE_CODE (copy
), TS_DECL_WRTL
)
5430 && !TREE_STATIC (copy
) && !DECL_EXTERNAL (copy
))
5431 SET_DECL_RTL (copy
, 0);
5433 /* These args would always appear unused, if not for this. */
5434 TREE_USED (copy
) = 1;
5436 /* Set the context for the new declaration. */
5437 if (!DECL_CONTEXT (decl
))
5438 /* Globals stay global. */
5440 else if (DECL_CONTEXT (decl
) != id
->src_fn
)
5441 /* Things that weren't in the scope of the function we're inlining
5442 from aren't in the scope we're inlining to, either. */
5444 else if (TREE_STATIC (decl
))
5445 /* Function-scoped static variables should stay in the original
5449 /* Ordinary automatic local variables are now in the scope of the
5451 DECL_CONTEXT (copy
) = id
->dst_fn
;
5457 copy_decl_to_var (tree decl
, copy_body_data
*id
)
5461 gcc_assert (TREE_CODE (decl
) == PARM_DECL
5462 || TREE_CODE (decl
) == RESULT_DECL
);
5464 type
= TREE_TYPE (decl
);
5466 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
5467 VAR_DECL
, DECL_NAME (decl
), type
);
5468 if (DECL_PT_UID_SET_P (decl
))
5469 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
5470 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
5471 TREE_READONLY (copy
) = TREE_READONLY (decl
);
5472 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
5473 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
5475 return copy_decl_for_dup_finish (id
, decl
, copy
);
5478 /* Like copy_decl_to_var, but create a return slot object instead of a
5479 pointer variable for return by invisible reference. */
5482 copy_result_decl_to_var (tree decl
, copy_body_data
*id
)
5486 gcc_assert (TREE_CODE (decl
) == PARM_DECL
5487 || TREE_CODE (decl
) == RESULT_DECL
);
5489 type
= TREE_TYPE (decl
);
5490 if (DECL_BY_REFERENCE (decl
))
5491 type
= TREE_TYPE (type
);
5493 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
5494 VAR_DECL
, DECL_NAME (decl
), type
);
5495 if (DECL_PT_UID_SET_P (decl
))
5496 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
5497 TREE_READONLY (copy
) = TREE_READONLY (decl
);
5498 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
5499 if (!DECL_BY_REFERENCE (decl
))
5501 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
5502 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
5505 return copy_decl_for_dup_finish (id
, decl
, copy
);
5509 copy_decl_no_change (tree decl
, copy_body_data
*id
)
5513 copy
= copy_node (decl
);
5515 /* The COPY is not abstract; it will be generated in DST_FN. */
5516 DECL_ABSTRACT_P (copy
) = false;
5517 lang_hooks
.dup_lang_specific_decl (copy
);
5519 /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
5520 been taken; it's for internal bookkeeping in expand_goto_internal. */
5521 if (TREE_CODE (copy
) == LABEL_DECL
)
5523 TREE_ADDRESSABLE (copy
) = 0;
5524 LABEL_DECL_UID (copy
) = -1;
5527 return copy_decl_for_dup_finish (id
, decl
, copy
);
5531 copy_decl_maybe_to_var (tree decl
, copy_body_data
*id
)
5533 if (TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
)
5534 return copy_decl_to_var (decl
, id
);
5536 return copy_decl_no_change (decl
, id
);
5539 /* Return a copy of the function's argument tree. */
5541 copy_arguments_for_versioning (tree orig_parm
, copy_body_data
* id
,
5542 bitmap args_to_skip
, tree
*vars
)
5545 tree new_parm
= NULL
;
5550 for (arg
= orig_parm
; arg
; arg
= DECL_CHAIN (arg
), i
++)
5551 if (!args_to_skip
|| !bitmap_bit_p (args_to_skip
, i
))
5553 tree new_tree
= remap_decl (arg
, id
);
5554 if (TREE_CODE (new_tree
) != PARM_DECL
)
5555 new_tree
= id
->copy_decl (arg
, id
);
5556 lang_hooks
.dup_lang_specific_decl (new_tree
);
5558 parg
= &DECL_CHAIN (new_tree
);
5560 else if (!id
->decl_map
->get (arg
))
5562 /* Make an equivalent VAR_DECL. If the argument was used
5563 as temporary variable later in function, the uses will be
5564 replaced by local variable. */
5565 tree var
= copy_decl_to_var (arg
, id
);
5566 insert_decl_map (id
, arg
, var
);
5567 /* Declare this new variable. */
5568 DECL_CHAIN (var
) = *vars
;
5574 /* Return a copy of the function's static chain. */
5576 copy_static_chain (tree static_chain
, copy_body_data
* id
)
5578 tree
*chain_copy
, *pvar
;
5580 chain_copy
= &static_chain
;
5581 for (pvar
= chain_copy
; *pvar
; pvar
= &DECL_CHAIN (*pvar
))
5583 tree new_tree
= remap_decl (*pvar
, id
);
5584 lang_hooks
.dup_lang_specific_decl (new_tree
);
5585 DECL_CHAIN (new_tree
) = DECL_CHAIN (*pvar
);
5588 return static_chain
;
5591 /* Return true if the function is allowed to be versioned.
5592 This is a guard for the versioning functionality. */
5595 tree_versionable_function_p (tree fndecl
)
5597 return (!lookup_attribute ("noclone", DECL_ATTRIBUTES (fndecl
))
5598 && copy_forbidden (DECL_STRUCT_FUNCTION (fndecl
)) == NULL
);
5601 /* Delete all unreachable basic blocks and update callgraph.
5602 Doing so is somewhat nontrivial because we need to update all clones and
5603 remove inline function that become unreachable. */
5606 delete_unreachable_blocks_update_callgraph (copy_body_data
*id
)
5608 bool changed
= false;
5609 basic_block b
, next_bb
;
5611 find_unreachable_blocks ();
5613 /* Delete all unreachable basic blocks. */
5615 for (b
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
; b
5616 != EXIT_BLOCK_PTR_FOR_FN (cfun
); b
= next_bb
)
5618 next_bb
= b
->next_bb
;
5620 if (!(b
->flags
& BB_REACHABLE
))
5622 gimple_stmt_iterator bsi
;
5624 for (bsi
= gsi_start_bb (b
); !gsi_end_p (bsi
); gsi_next (&bsi
))
5626 struct cgraph_edge
*e
;
5627 struct cgraph_node
*node
;
5629 id
->dst_node
->remove_stmt_references (gsi_stmt (bsi
));
5631 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
5632 &&(e
= id
->dst_node
->get_edge (gsi_stmt (bsi
))) != NULL
)
5634 if (!e
->inline_failed
)
5635 e
->callee
->remove_symbol_and_inline_clones (id
->dst_node
);
5639 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
5640 && id
->dst_node
->clones
)
5641 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
5643 node
->remove_stmt_references (gsi_stmt (bsi
));
5644 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
5645 && (e
= node
->get_edge (gsi_stmt (bsi
))) != NULL
)
5647 if (!e
->inline_failed
)
5648 e
->callee
->remove_symbol_and_inline_clones (id
->dst_node
);
5654 node
= node
->clones
;
5655 else if (node
->next_sibling_clone
)
5656 node
= node
->next_sibling_clone
;
5659 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5660 node
= node
->clone_of
;
5661 if (node
!= id
->dst_node
)
5662 node
= node
->next_sibling_clone
;
5666 delete_basic_block (b
);
5674 /* Update clone info after duplication. */
5677 update_clone_info (copy_body_data
* id
)
5679 struct cgraph_node
*node
;
5680 if (!id
->dst_node
->clones
)
5682 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
5684 /* First update replace maps to match the new body. */
5685 if (node
->clone
.tree_map
)
5688 for (i
= 0; i
< vec_safe_length (node
->clone
.tree_map
); i
++)
5690 struct ipa_replace_map
*replace_info
;
5691 replace_info
= (*node
->clone
.tree_map
)[i
];
5692 walk_tree (&replace_info
->old_tree
, copy_tree_body_r
, id
, NULL
);
5693 walk_tree (&replace_info
->new_tree
, copy_tree_body_r
, id
, NULL
);
5697 node
= node
->clones
;
5698 else if (node
->next_sibling_clone
)
5699 node
= node
->next_sibling_clone
;
5702 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5703 node
= node
->clone_of
;
5704 if (node
!= id
->dst_node
)
5705 node
= node
->next_sibling_clone
;
5710 /* Create a copy of a function's tree.
5711 OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
5712 of the original function and the new copied function
5713 respectively. In case we want to replace a DECL
5714 tree with another tree while duplicating the function's
5715 body, TREE_MAP represents the mapping between these
5716 trees. If UPDATE_CLONES is set, the call_stmt fields
5717 of edges of clones of the function will be updated.
5719 If non-NULL ARGS_TO_SKIP determine function parameters to remove
5721 If SKIP_RETURN is true, the new version will return void.
5722 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
5723 If non_NULL NEW_ENTRY determine new entry BB of the clone.
5726 tree_function_versioning (tree old_decl
, tree new_decl
,
5727 vec
<ipa_replace_map
*, va_gc
> *tree_map
,
5728 bool update_clones
, bitmap args_to_skip
,
5729 bool skip_return
, bitmap blocks_to_copy
,
5730 basic_block new_entry
)
5732 struct cgraph_node
*old_version_node
;
5733 struct cgraph_node
*new_version_node
;
5737 struct ipa_replace_map
*replace_info
;
5738 basic_block old_entry_block
, bb
;
5739 auto_vec
<gimple
*, 10> init_stmts
;
5740 tree vars
= NULL_TREE
;
5741 bitmap debug_args_to_skip
= args_to_skip
;
5743 gcc_assert (TREE_CODE (old_decl
) == FUNCTION_DECL
5744 && TREE_CODE (new_decl
) == FUNCTION_DECL
);
5745 DECL_POSSIBLY_INLINED (old_decl
) = 1;
5747 old_version_node
= cgraph_node::get (old_decl
);
5748 gcc_checking_assert (old_version_node
);
5749 new_version_node
= cgraph_node::get (new_decl
);
5750 gcc_checking_assert (new_version_node
);
5752 /* Copy over debug args. */
5753 if (DECL_HAS_DEBUG_ARGS_P (old_decl
))
5755 vec
<tree
, va_gc
> **new_debug_args
, **old_debug_args
;
5756 gcc_checking_assert (decl_debug_args_lookup (new_decl
) == NULL
);
5757 DECL_HAS_DEBUG_ARGS_P (new_decl
) = 0;
5758 old_debug_args
= decl_debug_args_lookup (old_decl
);
5761 new_debug_args
= decl_debug_args_insert (new_decl
);
5762 *new_debug_args
= vec_safe_copy (*old_debug_args
);
5766 /* Output the inlining info for this abstract function, since it has been
5767 inlined. If we don't do this now, we can lose the information about the
5768 variables in the function when the blocks get blown away as soon as we
5769 remove the cgraph node. */
5770 (*debug_hooks
->outlining_inline_function
) (old_decl
);
5772 DECL_ARTIFICIAL (new_decl
) = 1;
5773 DECL_ABSTRACT_ORIGIN (new_decl
) = DECL_ORIGIN (old_decl
);
5774 if (DECL_ORIGIN (old_decl
) == old_decl
)
5775 old_version_node
->used_as_abstract_origin
= true;
5776 DECL_FUNCTION_PERSONALITY (new_decl
) = DECL_FUNCTION_PERSONALITY (old_decl
);
5778 /* Prepare the data structures for the tree copy. */
5779 memset (&id
, 0, sizeof (id
));
5781 /* Generate a new name for the new version. */
5782 id
.statements_to_fold
= new hash_set
<gimple
*>;
5784 id
.decl_map
= new hash_map
<tree
, tree
>;
5785 id
.debug_map
= NULL
;
5786 id
.src_fn
= old_decl
;
5787 id
.dst_fn
= new_decl
;
5788 id
.src_node
= old_version_node
;
5789 id
.dst_node
= new_version_node
;
5790 id
.src_cfun
= DECL_STRUCT_FUNCTION (old_decl
);
5791 id
.blocks_to_copy
= blocks_to_copy
;
5793 id
.copy_decl
= copy_decl_no_change
;
5794 id
.transform_call_graph_edges
5795 = update_clones
? CB_CGE_MOVE_CLONES
: CB_CGE_MOVE
;
5796 id
.transform_new_cfg
= true;
5797 id
.transform_return_to_modify
= false;
5798 id
.transform_parameter
= false;
5799 id
.transform_lang_insert_block
= NULL
;
5801 old_entry_block
= ENTRY_BLOCK_PTR_FOR_FN
5802 (DECL_STRUCT_FUNCTION (old_decl
));
5803 DECL_RESULT (new_decl
) = DECL_RESULT (old_decl
);
5804 DECL_ARGUMENTS (new_decl
) = DECL_ARGUMENTS (old_decl
);
5805 initialize_cfun (new_decl
, old_decl
,
5806 old_entry_block
->count
);
5807 if (DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
)
5808 DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
->ipa_pta
5809 = id
.src_cfun
->gimple_df
->ipa_pta
;
5811 /* Copy the function's static chain. */
5812 p
= DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
;
5814 DECL_STRUCT_FUNCTION (new_decl
)->static_chain_decl
5815 = copy_static_chain (p
, &id
);
5817 /* If there's a tree_map, prepare for substitution. */
5819 for (i
= 0; i
< tree_map
->length (); i
++)
5822 replace_info
= (*tree_map
)[i
];
5823 if (replace_info
->replace_p
)
5826 if (!replace_info
->old_tree
)
5828 int p
= replace_info
->parm_num
;
5830 tree req_type
, new_type
;
5832 for (parm
= DECL_ARGUMENTS (old_decl
); p
;
5833 parm
= DECL_CHAIN (parm
))
5835 replace_info
->old_tree
= parm
;
5836 parm_num
= replace_info
->parm_num
;
5837 req_type
= TREE_TYPE (parm
);
5838 new_type
= TREE_TYPE (replace_info
->new_tree
);
5839 if (!useless_type_conversion_p (req_type
, new_type
))
5841 if (fold_convertible_p (req_type
, replace_info
->new_tree
))
5842 replace_info
->new_tree
5843 = fold_build1 (NOP_EXPR
, req_type
,
5844 replace_info
->new_tree
);
5845 else if (TYPE_SIZE (req_type
) == TYPE_SIZE (new_type
))
5846 replace_info
->new_tree
5847 = fold_build1 (VIEW_CONVERT_EXPR
, req_type
,
5848 replace_info
->new_tree
);
5853 fprintf (dump_file
, " const ");
5854 print_generic_expr (dump_file
,
5855 replace_info
->new_tree
, 0);
5857 " can't be converted to param ");
5858 print_generic_expr (dump_file
, parm
, 0);
5859 fprintf (dump_file
, "\n");
5861 replace_info
->old_tree
= NULL
;
5866 gcc_assert (TREE_CODE (replace_info
->old_tree
) == PARM_DECL
);
5867 if (replace_info
->old_tree
)
5869 init
= setup_one_parameter (&id
, replace_info
->old_tree
,
5870 replace_info
->new_tree
, id
.src_fn
,
5874 init_stmts
.safe_push (init
);
5875 if (MAY_HAVE_DEBUG_STMTS
&& args_to_skip
)
5881 for (parm
= DECL_ARGUMENTS (old_decl
), p
= 0; parm
;
5882 parm
= DECL_CHAIN (parm
), p
++)
5883 if (parm
== replace_info
->old_tree
)
5891 if (debug_args_to_skip
== args_to_skip
)
5893 debug_args_to_skip
= BITMAP_ALLOC (NULL
);
5894 bitmap_copy (debug_args_to_skip
, args_to_skip
);
5896 bitmap_clear_bit (debug_args_to_skip
, parm_num
);
5902 /* Copy the function's arguments. */
5903 if (DECL_ARGUMENTS (old_decl
) != NULL_TREE
)
5904 DECL_ARGUMENTS (new_decl
)
5905 = copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl
), &id
,
5906 args_to_skip
, &vars
);
5908 DECL_INITIAL (new_decl
) = remap_blocks (DECL_INITIAL (id
.src_fn
), &id
);
5909 BLOCK_SUPERCONTEXT (DECL_INITIAL (new_decl
)) = new_decl
;
5911 declare_inline_vars (DECL_INITIAL (new_decl
), vars
);
5913 if (!vec_safe_is_empty (DECL_STRUCT_FUNCTION (old_decl
)->local_decls
))
5914 /* Add local vars. */
5915 add_local_variables (DECL_STRUCT_FUNCTION (old_decl
), cfun
, &id
);
5917 if (DECL_RESULT (old_decl
) == NULL_TREE
)
5919 else if (skip_return
&& !VOID_TYPE_P (TREE_TYPE (DECL_RESULT (old_decl
))))
5921 DECL_RESULT (new_decl
)
5922 = build_decl (DECL_SOURCE_LOCATION (DECL_RESULT (old_decl
)),
5923 RESULT_DECL
, NULL_TREE
, void_type_node
);
5924 DECL_CONTEXT (DECL_RESULT (new_decl
)) = new_decl
;
5925 cfun
->returns_struct
= 0;
5926 cfun
->returns_pcc_struct
= 0;
5931 DECL_RESULT (new_decl
) = remap_decl (DECL_RESULT (old_decl
), &id
);
5932 lang_hooks
.dup_lang_specific_decl (DECL_RESULT (new_decl
));
5933 if (gimple_in_ssa_p (id
.src_cfun
)
5934 && DECL_BY_REFERENCE (DECL_RESULT (old_decl
))
5935 && (old_name
= ssa_default_def (id
.src_cfun
, DECL_RESULT (old_decl
))))
5937 tree new_name
= make_ssa_name (DECL_RESULT (new_decl
));
5938 insert_decl_map (&id
, old_name
, new_name
);
5939 SSA_NAME_DEF_STMT (new_name
) = gimple_build_nop ();
5940 set_ssa_default_def (cfun
, DECL_RESULT (new_decl
), new_name
);
5944 /* Set up the destination functions loop tree. */
5945 if (loops_for_fn (DECL_STRUCT_FUNCTION (old_decl
)) != NULL
)
5947 cfun
->curr_properties
&= ~PROP_loops
;
5948 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
5949 cfun
->curr_properties
|= PROP_loops
;
5952 /* Copy the Function's body. */
5953 copy_body (&id
, old_entry_block
->count
, REG_BR_PROB_BASE
,
5954 ENTRY_BLOCK_PTR_FOR_FN (cfun
), EXIT_BLOCK_PTR_FOR_FN (cfun
),
5957 /* Renumber the lexical scoping (non-code) blocks consecutively. */
5958 number_blocks (new_decl
);
5960 /* We want to create the BB unconditionally, so that the addition of
5961 debug stmts doesn't affect BB count, which may in the end cause
5962 codegen differences. */
5963 bb
= split_edge (single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
5964 while (init_stmts
.length ())
5965 insert_init_stmt (&id
, bb
, init_stmts
.pop ());
5966 update_clone_info (&id
);
5968 /* Remap the nonlocal_goto_save_area, if any. */
5969 if (cfun
->nonlocal_goto_save_area
)
5971 struct walk_stmt_info wi
;
5973 memset (&wi
, 0, sizeof (wi
));
5975 walk_tree (&cfun
->nonlocal_goto_save_area
, remap_gimple_op_r
, &wi
, NULL
);
5981 delete id
.debug_map
;
5982 free_dominance_info (CDI_DOMINATORS
);
5983 free_dominance_info (CDI_POST_DOMINATORS
);
5985 fold_marked_statements (0, id
.statements_to_fold
);
5986 delete id
.statements_to_fold
;
5987 delete_unreachable_blocks_update_callgraph (&id
);
5988 if (id
.dst_node
->definition
)
5989 cgraph_edge::rebuild_references ();
5990 if (loops_state_satisfies_p (LOOPS_NEED_FIXUP
))
5992 calculate_dominance_info (CDI_DOMINATORS
);
5993 fix_loop_structure (NULL
);
5995 update_ssa (TODO_update_ssa
);
5997 /* After partial cloning we need to rescale frequencies, so they are
5998 within proper range in the cloned function. */
6001 struct cgraph_edge
*e
;
6002 rebuild_frequencies ();
6004 new_version_node
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
6005 for (e
= new_version_node
->callees
; e
; e
= e
->next_callee
)
6007 basic_block bb
= gimple_bb (e
->call_stmt
);
6008 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
6010 e
->count
= bb
->count
;
6012 for (e
= new_version_node
->indirect_calls
; e
; e
= e
->next_callee
)
6014 basic_block bb
= gimple_bb (e
->call_stmt
);
6015 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
6017 e
->count
= bb
->count
;
6021 if (debug_args_to_skip
&& MAY_HAVE_DEBUG_STMTS
)
6024 vec
<tree
, va_gc
> **debug_args
= NULL
;
6025 unsigned int len
= 0;
6026 for (parm
= DECL_ARGUMENTS (old_decl
), i
= 0;
6027 parm
; parm
= DECL_CHAIN (parm
), i
++)
6028 if (bitmap_bit_p (debug_args_to_skip
, i
) && is_gimple_reg (parm
))
6032 if (debug_args
== NULL
)
6034 debug_args
= decl_debug_args_insert (new_decl
);
6035 len
= vec_safe_length (*debug_args
);
6037 ddecl
= make_node (DEBUG_EXPR_DECL
);
6038 DECL_ARTIFICIAL (ddecl
) = 1;
6039 TREE_TYPE (ddecl
) = TREE_TYPE (parm
);
6040 DECL_MODE (ddecl
) = DECL_MODE (parm
);
6041 vec_safe_push (*debug_args
, DECL_ORIGIN (parm
));
6042 vec_safe_push (*debug_args
, ddecl
);
6044 if (debug_args
!= NULL
)
6046 /* On the callee side, add
6049 stmts to the first bb where var is a VAR_DECL created for the
6050 optimized away parameter in DECL_INITIAL block. This hints
6051 in the debug info that var (whole DECL_ORIGIN is the parm
6052 PARM_DECL) is optimized away, but could be looked up at the
6053 call site as value of D#X there. */
6054 tree var
= vars
, vexpr
;
6055 gimple_stmt_iterator cgsi
6056 = gsi_after_labels (single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
6059 i
= vec_safe_length (*debug_args
);
6063 while (var
!= NULL_TREE
6064 && DECL_ABSTRACT_ORIGIN (var
) != (**debug_args
)[i
])
6065 var
= TREE_CHAIN (var
);
6066 if (var
== NULL_TREE
)
6068 vexpr
= make_node (DEBUG_EXPR_DECL
);
6069 parm
= (**debug_args
)[i
];
6070 DECL_ARTIFICIAL (vexpr
) = 1;
6071 TREE_TYPE (vexpr
) = TREE_TYPE (parm
);
6072 DECL_MODE (vexpr
) = DECL_MODE (parm
);
6073 def_temp
= gimple_build_debug_bind (var
, vexpr
, NULL
);
6074 gsi_insert_before (&cgsi
, def_temp
, GSI_NEW_STMT
);
6075 def_temp
= gimple_build_debug_source_bind (vexpr
, parm
, NULL
);
6076 gsi_insert_before (&cgsi
, def_temp
, GSI_NEW_STMT
);
6082 if (debug_args_to_skip
&& debug_args_to_skip
!= args_to_skip
)
6083 BITMAP_FREE (debug_args_to_skip
);
6084 free_dominance_info (CDI_DOMINATORS
);
6085 free_dominance_info (CDI_POST_DOMINATORS
);
6087 gcc_assert (!id
.debug_stmts
.exists ());
6092 /* EXP is CALL_EXPR present in a GENERIC expression tree. Try to integrate
6093 the callee and return the inlined body on success. */
6096 maybe_inline_call_in_expr (tree exp
)
6098 tree fn
= get_callee_fndecl (exp
);
6100 /* We can only try to inline "const" functions. */
6101 if (fn
&& TREE_READONLY (fn
) && DECL_SAVED_TREE (fn
))
6103 call_expr_arg_iterator iter
;
6106 hash_map
<tree
, tree
> decl_map
;
6108 /* Remap the parameters. */
6109 for (param
= DECL_ARGUMENTS (fn
), arg
= first_call_expr_arg (exp
, &iter
);
6111 param
= DECL_CHAIN (param
), arg
= next_call_expr_arg (&iter
))
6112 decl_map
.put (param
, arg
);
6114 memset (&id
, 0, sizeof (id
));
6116 id
.dst_fn
= current_function_decl
;
6117 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
6118 id
.decl_map
= &decl_map
;
6120 id
.copy_decl
= copy_decl_no_change
;
6121 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
6122 id
.transform_new_cfg
= false;
6123 id
.transform_return_to_modify
= true;
6124 id
.transform_parameter
= true;
6125 id
.transform_lang_insert_block
= NULL
;
6127 /* Make sure not to unshare trees behind the front-end's back
6128 since front-end specific mechanisms may rely on sharing. */
6129 id
.regimplify
= false;
6130 id
.do_not_unshare
= true;
6132 /* We're not inside any EH region. */
6135 t
= copy_tree_body (&id
);
6137 /* We can only return something suitable for use in a GENERIC
6139 if (TREE_CODE (t
) == MODIFY_EXPR
)
6140 return TREE_OPERAND (t
, 1);
6146 /* Duplicate a type, fields and all. */
6149 build_duplicate_type (tree type
)
6151 struct copy_body_data id
;
6153 memset (&id
, 0, sizeof (id
));
6154 id
.src_fn
= current_function_decl
;
6155 id
.dst_fn
= current_function_decl
;
6157 id
.decl_map
= new hash_map
<tree
, tree
>;
6158 id
.debug_map
= NULL
;
6159 id
.copy_decl
= copy_decl_no_change
;
6161 type
= remap_type_1 (type
, &id
);
6165 delete id
.debug_map
;
6167 TYPE_CANONICAL (type
) = type
;
6172 /* Unshare the entire DECL_SAVED_TREE of FN and return the remapped
6173 parameters and RESULT_DECL in PARMS and RESULT. Used by C++ constexpr
6177 copy_fn (tree fn
, tree
& parms
, tree
& result
)
6181 hash_map
<tree
, tree
> decl_map
;
6186 memset (&id
, 0, sizeof (id
));
6188 id
.dst_fn
= current_function_decl
;
6189 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
6190 id
.decl_map
= &decl_map
;
6192 id
.copy_decl
= copy_decl_no_change
;
6193 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
6194 id
.transform_new_cfg
= false;
6195 id
.transform_return_to_modify
= false;
6196 id
.transform_parameter
= true;
6197 id
.transform_lang_insert_block
= NULL
;
6199 /* Make sure not to unshare trees behind the front-end's back
6200 since front-end specific mechanisms may rely on sharing. */
6201 id
.regimplify
= false;
6202 id
.do_not_unshare
= true;
6204 /* We're not inside any EH region. */
6207 /* Remap the parameters and result and return them to the caller. */
6208 for (param
= DECL_ARGUMENTS (fn
);
6210 param
= DECL_CHAIN (param
))
6212 *p
= remap_decl (param
, &id
);
6213 p
= &DECL_CHAIN (*p
);
6216 if (DECL_RESULT (fn
))
6217 result
= remap_decl (DECL_RESULT (fn
), &id
);
6221 return copy_tree_body (&id
);