2 Copyright (C) 2001-2017 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"
60 #include "stringpool.h"
63 /* I'm not real happy about this, but we need to handle gimple and
66 /* Inlining, Cloning, Versioning, Parallelization
68 Inlining: a function body is duplicated, but the PARM_DECLs are
69 remapped into VAR_DECLs, and non-void RETURN_EXPRs become
70 MODIFY_EXPRs that store to a dedicated returned-value variable.
71 The duplicated eh_region info of the copy will later be appended
72 to the info for the caller; the eh_region info in copied throwing
73 statements and RESX statements are adjusted accordingly.
75 Cloning: (only in C++) We have one body for a con/de/structor, and
76 multiple function decls, each with a unique parameter list.
77 Duplicate the body, using the given splay tree; some parameters
78 will become constants (like 0 or 1).
80 Versioning: a function body is duplicated and the result is a new
81 function rather than into blocks of an existing function as with
82 inlining. Some parameters will become constants.
84 Parallelization: a region of a function is duplicated resulting in
85 a new function. Variables may be replaced with complex expressions
86 to enable shared variable semantics.
88 All of these will simultaneously lookup any callgraph edges. If
89 we're going to inline the duplicated function body, and the given
90 function has some cloned callgraph nodes (one for each place this
91 function will be inlined) those callgraph edges will be duplicated.
92 If we're cloning the body, those callgraph edges will be
93 updated to point into the new body. (Note that the original
94 callgraph node and edge list will not be altered.)
96 See the CALL_EXPR handling case in copy_tree_body_r (). */
100 o In order to make inlining-on-trees work, we pessimized
101 function-local static constants. In particular, they are now
102 always output, even when not addressed. Fix this by treating
103 function-local static constants just like global static
104 constants; the back-end already knows not to output them if they
107 o Provide heuristics to clamp inlining of recursive template
111 /* Weights that estimate_num_insns uses to estimate the size of the
114 eni_weights eni_size_weights
;
116 /* Weights that estimate_num_insns uses to estimate the time necessary
117 to execute the produced code. */
119 eni_weights eni_time_weights
;
123 static tree
declare_return_variable (copy_body_data
*, tree
, tree
, tree
,
125 static void remap_block (tree
*, copy_body_data
*);
126 static void copy_bind_expr (tree
*, int *, copy_body_data
*);
127 static void declare_inline_vars (tree
, tree
);
128 static void remap_save_expr (tree
*, hash_map
<tree
, tree
> *, int *);
129 static void prepend_lexical_block (tree current_block
, tree new_block
);
130 static tree
copy_decl_to_var (tree
, copy_body_data
*);
131 static tree
copy_result_decl_to_var (tree
, copy_body_data
*);
132 static tree
copy_decl_maybe_to_var (tree
, copy_body_data
*);
133 static gimple_seq
remap_gimple_stmt (gimple
*, copy_body_data
*);
134 static bool delete_unreachable_blocks_update_callgraph (copy_body_data
*id
);
135 static void insert_init_stmt (copy_body_data
*, basic_block
, gimple
*);
137 /* Insert a tree->tree mapping for ID. Despite the name suggests
138 that the trees should be variables, it is used for more than that. */
141 insert_decl_map (copy_body_data
*id
, tree key
, tree value
)
143 id
->decl_map
->put (key
, value
);
145 /* Always insert an identity map as well. If we see this same new
146 node again, we won't want to duplicate it a second time. */
148 id
->decl_map
->put (value
, value
);
151 /* Insert a tree->tree mapping for ID. This is only used for
155 insert_debug_decl_map (copy_body_data
*id
, tree key
, tree value
)
157 if (!gimple_in_ssa_p (id
->src_cfun
))
160 if (!opt_for_fn (id
->dst_fn
, flag_var_tracking_assignments
))
163 if (!target_for_debug_bind (key
))
166 gcc_assert (TREE_CODE (key
) == PARM_DECL
);
167 gcc_assert (VAR_P (value
));
170 id
->debug_map
= new hash_map
<tree
, tree
>;
172 id
->debug_map
->put (key
, value
);
175 /* If nonzero, we're remapping the contents of inlined debug
176 statements. If negative, an error has occurred, such as a
177 reference to a variable that isn't available in the inlined
179 static int processing_debug_stmt
= 0;
181 /* Construct new SSA name for old NAME. ID is the inline context. */
184 remap_ssa_name (tree name
, copy_body_data
*id
)
189 gcc_assert (TREE_CODE (name
) == SSA_NAME
);
191 n
= id
->decl_map
->get (name
);
193 return unshare_expr (*n
);
195 if (processing_debug_stmt
)
197 if (SSA_NAME_IS_DEFAULT_DEF (name
)
198 && TREE_CODE (SSA_NAME_VAR (name
)) == PARM_DECL
199 && id
->entry_bb
== NULL
200 && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (cfun
)))
202 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
204 gimple_stmt_iterator gsi
;
205 tree val
= SSA_NAME_VAR (name
);
207 n
= id
->decl_map
->get (val
);
210 if (TREE_CODE (val
) != PARM_DECL
)
212 processing_debug_stmt
= -1;
215 def_temp
= gimple_build_debug_source_bind (vexpr
, val
, NULL
);
216 DECL_ARTIFICIAL (vexpr
) = 1;
217 TREE_TYPE (vexpr
) = TREE_TYPE (name
);
218 SET_DECL_MODE (vexpr
, DECL_MODE (SSA_NAME_VAR (name
)));
219 gsi
= gsi_after_labels (single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
220 gsi_insert_before (&gsi
, def_temp
, GSI_SAME_STMT
);
224 processing_debug_stmt
= -1;
228 /* Remap anonymous SSA names or SSA names of anonymous decls. */
229 var
= SSA_NAME_VAR (name
);
231 || (!SSA_NAME_IS_DEFAULT_DEF (name
)
233 && !VAR_DECL_IS_VIRTUAL_OPERAND (var
)
234 && DECL_ARTIFICIAL (var
)
235 && DECL_IGNORED_P (var
)
236 && !DECL_NAME (var
)))
238 struct ptr_info_def
*pi
;
239 new_tree
= make_ssa_name (remap_type (TREE_TYPE (name
), id
));
240 if (!var
&& SSA_NAME_IDENTIFIER (name
))
241 SET_SSA_NAME_VAR_OR_IDENTIFIER (new_tree
, SSA_NAME_IDENTIFIER (name
));
242 insert_decl_map (id
, name
, new_tree
);
243 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
244 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
245 /* At least IPA points-to info can be directly transferred. */
246 if (id
->src_cfun
->gimple_df
247 && id
->src_cfun
->gimple_df
->ipa_pta
248 && POINTER_TYPE_P (TREE_TYPE (name
))
249 && (pi
= SSA_NAME_PTR_INFO (name
))
252 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
258 /* Do not set DEF_STMT yet as statement is not copied yet. We do that
260 new_tree
= remap_decl (var
, id
);
262 /* We might've substituted constant or another SSA_NAME for
265 Replace the SSA name representing RESULT_DECL by variable during
266 inlining: this saves us from need to introduce PHI node in a case
267 return value is just partly initialized. */
268 if ((VAR_P (new_tree
) || TREE_CODE (new_tree
) == PARM_DECL
)
269 && (!SSA_NAME_VAR (name
)
270 || TREE_CODE (SSA_NAME_VAR (name
)) != RESULT_DECL
271 || !id
->transform_return_to_modify
))
273 struct ptr_info_def
*pi
;
274 new_tree
= make_ssa_name (new_tree
);
275 insert_decl_map (id
, name
, new_tree
);
276 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
277 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
278 /* At least IPA points-to info can be directly transferred. */
279 if (id
->src_cfun
->gimple_df
280 && id
->src_cfun
->gimple_df
->ipa_pta
281 && POINTER_TYPE_P (TREE_TYPE (name
))
282 && (pi
= SSA_NAME_PTR_INFO (name
))
285 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
288 if (SSA_NAME_IS_DEFAULT_DEF (name
))
290 /* By inlining function having uninitialized variable, we might
291 extend the lifetime (variable might get reused). This cause
292 ICE in the case we end up extending lifetime of SSA name across
293 abnormal edge, but also increase register pressure.
295 We simply initialize all uninitialized vars by 0 except
296 for case we are inlining to very first BB. We can avoid
297 this for all BBs that are not inside strongly connected
298 regions of the CFG, but this is expensive to test. */
300 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
)
301 && (!SSA_NAME_VAR (name
)
302 || TREE_CODE (SSA_NAME_VAR (name
)) != PARM_DECL
)
303 && (id
->entry_bb
!= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
),
305 || EDGE_COUNT (id
->entry_bb
->preds
) != 1))
307 gimple_stmt_iterator gsi
= gsi_last_bb (id
->entry_bb
);
309 tree zero
= build_zero_cst (TREE_TYPE (new_tree
));
311 init_stmt
= gimple_build_assign (new_tree
, zero
);
312 gsi_insert_after (&gsi
, init_stmt
, GSI_NEW_STMT
);
313 SSA_NAME_IS_DEFAULT_DEF (new_tree
) = 0;
317 SSA_NAME_DEF_STMT (new_tree
) = gimple_build_nop ();
318 set_ssa_default_def (cfun
, SSA_NAME_VAR (new_tree
), new_tree
);
323 insert_decl_map (id
, name
, new_tree
);
327 /* Remap DECL during the copying of the BLOCK tree for the function. */
330 remap_decl (tree decl
, copy_body_data
*id
)
334 /* We only remap local variables in the current function. */
336 /* See if we have remapped this declaration. */
338 n
= id
->decl_map
->get (decl
);
340 if (!n
&& processing_debug_stmt
)
342 processing_debug_stmt
= -1;
346 /* When remapping a type within copy_gimple_seq_and_replace_locals, all
347 necessary DECLs have already been remapped and we do not want to duplicate
348 a decl coming from outside of the sequence we are copying. */
350 && id
->prevent_decl_creation_for_types
351 && id
->remapping_type_depth
> 0
352 && (VAR_P (decl
) || TREE_CODE (decl
) == PARM_DECL
))
355 /* If we didn't already have an equivalent for this declaration, create one
359 /* Make a copy of the variable or label. */
360 tree t
= id
->copy_decl (decl
, id
);
362 /* Remember it, so that if we encounter this local entity again
363 we can reuse this copy. Do this early because remap_type may
364 need this decl for TYPE_STUB_DECL. */
365 insert_decl_map (id
, decl
, t
);
370 /* Remap types, if necessary. */
371 TREE_TYPE (t
) = remap_type (TREE_TYPE (t
), id
);
372 if (TREE_CODE (t
) == TYPE_DECL
)
374 DECL_ORIGINAL_TYPE (t
) = remap_type (DECL_ORIGINAL_TYPE (t
), id
);
376 /* Preserve the invariant that DECL_ORIGINAL_TYPE != TREE_TYPE,
377 which is enforced in gen_typedef_die when DECL_ABSTRACT_ORIGIN
378 is not set on the TYPE_DECL, for example in LTO mode. */
379 if (DECL_ORIGINAL_TYPE (t
) == TREE_TYPE (t
))
381 tree x
= build_variant_type_copy (TREE_TYPE (t
));
382 TYPE_STUB_DECL (x
) = TYPE_STUB_DECL (TREE_TYPE (t
));
383 TYPE_NAME (x
) = TYPE_NAME (TREE_TYPE (t
));
384 DECL_ORIGINAL_TYPE (t
) = x
;
388 /* Remap sizes as necessary. */
389 walk_tree (&DECL_SIZE (t
), copy_tree_body_r
, id
, NULL
);
390 walk_tree (&DECL_SIZE_UNIT (t
), copy_tree_body_r
, id
, NULL
);
392 /* If fields, do likewise for offset and qualifier. */
393 if (TREE_CODE (t
) == FIELD_DECL
)
395 walk_tree (&DECL_FIELD_OFFSET (t
), copy_tree_body_r
, id
, NULL
);
396 if (TREE_CODE (DECL_CONTEXT (t
)) == QUAL_UNION_TYPE
)
397 walk_tree (&DECL_QUALIFIER (t
), copy_tree_body_r
, id
, NULL
);
403 if (id
->do_not_unshare
)
406 return unshare_expr (*n
);
410 remap_type_1 (tree type
, copy_body_data
*id
)
414 /* We do need a copy. build and register it now. If this is a pointer or
415 reference type, remap the designated type and make a new pointer or
417 if (TREE_CODE (type
) == POINTER_TYPE
)
419 new_tree
= build_pointer_type_for_mode (remap_type (TREE_TYPE (type
), id
),
421 TYPE_REF_CAN_ALIAS_ALL (type
));
422 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
423 new_tree
= build_type_attribute_qual_variant (new_tree
,
424 TYPE_ATTRIBUTES (type
),
426 insert_decl_map (id
, type
, new_tree
);
429 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
431 new_tree
= build_reference_type_for_mode (remap_type (TREE_TYPE (type
), id
),
433 TYPE_REF_CAN_ALIAS_ALL (type
));
434 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
435 new_tree
= build_type_attribute_qual_variant (new_tree
,
436 TYPE_ATTRIBUTES (type
),
438 insert_decl_map (id
, type
, new_tree
);
442 new_tree
= copy_node (type
);
444 insert_decl_map (id
, type
, new_tree
);
446 /* This is a new type, not a copy of an old type. Need to reassociate
447 variants. We can handle everything except the main variant lazily. */
448 t
= TYPE_MAIN_VARIANT (type
);
451 t
= remap_type (t
, id
);
452 TYPE_MAIN_VARIANT (new_tree
) = t
;
453 TYPE_NEXT_VARIANT (new_tree
) = TYPE_NEXT_VARIANT (t
);
454 TYPE_NEXT_VARIANT (t
) = new_tree
;
458 TYPE_MAIN_VARIANT (new_tree
) = new_tree
;
459 TYPE_NEXT_VARIANT (new_tree
) = NULL
;
462 if (TYPE_STUB_DECL (type
))
463 TYPE_STUB_DECL (new_tree
) = remap_decl (TYPE_STUB_DECL (type
), id
);
465 /* Lazily create pointer and reference types. */
466 TYPE_POINTER_TO (new_tree
) = NULL
;
467 TYPE_REFERENCE_TO (new_tree
) = NULL
;
469 /* Copy all types that may contain references to local variables; be sure to
470 preserve sharing in between type and its main variant when possible. */
471 switch (TREE_CODE (new_tree
))
475 case FIXED_POINT_TYPE
:
478 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
480 gcc_checking_assert (TYPE_MIN_VALUE (type
) == TYPE_MIN_VALUE (TYPE_MAIN_VARIANT (type
)));
481 gcc_checking_assert (TYPE_MAX_VALUE (type
) == TYPE_MAX_VALUE (TYPE_MAIN_VARIANT (type
)));
483 TYPE_MIN_VALUE (new_tree
) = TYPE_MIN_VALUE (TYPE_MAIN_VARIANT (new_tree
));
484 TYPE_MAX_VALUE (new_tree
) = TYPE_MAX_VALUE (TYPE_MAIN_VARIANT (new_tree
));
488 t
= TYPE_MIN_VALUE (new_tree
);
489 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
490 walk_tree (&TYPE_MIN_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
492 t
= TYPE_MAX_VALUE (new_tree
);
493 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
494 walk_tree (&TYPE_MAX_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
499 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
500 && TREE_TYPE (type
) == TREE_TYPE (TYPE_MAIN_VARIANT (type
)))
501 TREE_TYPE (new_tree
) = TREE_TYPE (TYPE_MAIN_VARIANT (new_tree
));
503 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
504 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
505 && TYPE_ARG_TYPES (type
) == TYPE_ARG_TYPES (TYPE_MAIN_VARIANT (type
)))
506 TYPE_ARG_TYPES (new_tree
) = TYPE_ARG_TYPES (TYPE_MAIN_VARIANT (new_tree
));
508 walk_tree (&TYPE_ARG_TYPES (new_tree
), copy_tree_body_r
, id
, NULL
);
512 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
513 && TREE_TYPE (type
) == TREE_TYPE (TYPE_MAIN_VARIANT (type
)))
514 TREE_TYPE (new_tree
) = TREE_TYPE (TYPE_MAIN_VARIANT (new_tree
));
516 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
518 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
520 gcc_checking_assert (TYPE_DOMAIN (type
) == TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)));
521 TYPE_DOMAIN (new_tree
) = TYPE_DOMAIN (TYPE_MAIN_VARIANT (new_tree
));
524 TYPE_DOMAIN (new_tree
) = remap_type (TYPE_DOMAIN (new_tree
), id
);
529 case QUAL_UNION_TYPE
:
530 if (TYPE_MAIN_VARIANT (type
) != type
531 && TYPE_FIELDS (type
) == TYPE_FIELDS (TYPE_MAIN_VARIANT (type
)))
532 TYPE_FIELDS (new_tree
) = TYPE_FIELDS (TYPE_MAIN_VARIANT (new_tree
));
537 for (f
= TYPE_FIELDS (new_tree
); f
; f
= DECL_CHAIN (f
))
539 t
= remap_decl (f
, id
);
540 DECL_CONTEXT (t
) = new_tree
;
544 TYPE_FIELDS (new_tree
) = nreverse (nf
);
550 /* Shouldn't have been thought variable sized. */
554 /* All variants of type share the same size, so use the already remaped data. */
555 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
557 tree s
= TYPE_SIZE (type
);
558 tree mvs
= TYPE_SIZE (TYPE_MAIN_VARIANT (type
));
559 tree su
= TYPE_SIZE_UNIT (type
);
560 tree mvsu
= TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type
));
561 gcc_checking_assert ((TREE_CODE (s
) == PLACEHOLDER_EXPR
562 && (TREE_CODE (mvs
) == PLACEHOLDER_EXPR
))
564 gcc_checking_assert ((TREE_CODE (su
) == PLACEHOLDER_EXPR
565 && (TREE_CODE (mvsu
) == PLACEHOLDER_EXPR
))
567 TYPE_SIZE (new_tree
) = TYPE_SIZE (TYPE_MAIN_VARIANT (new_tree
));
568 TYPE_SIZE_UNIT (new_tree
) = TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (new_tree
));
572 walk_tree (&TYPE_SIZE (new_tree
), copy_tree_body_r
, id
, NULL
);
573 walk_tree (&TYPE_SIZE_UNIT (new_tree
), copy_tree_body_r
, id
, NULL
);
580 remap_type (tree type
, copy_body_data
*id
)
588 /* See if we have remapped this type. */
589 node
= id
->decl_map
->get (type
);
593 /* The type only needs remapping if it's variably modified. */
594 if (! variably_modified_type_p (type
, id
->src_fn
))
596 insert_decl_map (id
, type
, type
);
600 id
->remapping_type_depth
++;
601 tmp
= remap_type_1 (type
, id
);
602 id
->remapping_type_depth
--;
607 /* Decide if DECL can be put into BLOCK_NONLOCAL_VARs. */
610 can_be_nonlocal (tree decl
, copy_body_data
*id
)
612 /* We can not duplicate function decls. */
613 if (TREE_CODE (decl
) == FUNCTION_DECL
)
616 /* Local static vars must be non-local or we get multiple declaration
618 if (VAR_P (decl
) && !auto_var_in_fn_p (decl
, id
->src_fn
))
625 remap_decls (tree decls
, vec
<tree
, va_gc
> **nonlocalized_list
,
629 tree new_decls
= NULL_TREE
;
631 /* Remap its variables. */
632 for (old_var
= decls
; old_var
; old_var
= DECL_CHAIN (old_var
))
636 if (can_be_nonlocal (old_var
, id
))
638 /* We need to add this variable to the local decls as otherwise
639 nothing else will do so. */
640 if (VAR_P (old_var
) && ! DECL_EXTERNAL (old_var
) && cfun
)
641 add_local_decl (cfun
, old_var
);
642 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
643 && !DECL_IGNORED_P (old_var
)
644 && nonlocalized_list
)
645 vec_safe_push (*nonlocalized_list
, old_var
);
649 /* Remap the variable. */
650 new_var
= remap_decl (old_var
, id
);
652 /* If we didn't remap this variable, we can't mess with its
653 TREE_CHAIN. If we remapped this variable to the return slot, it's
654 already declared somewhere else, so don't declare it here. */
656 if (new_var
== id
->retvar
)
660 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
661 && !DECL_IGNORED_P (old_var
)
662 && nonlocalized_list
)
663 vec_safe_push (*nonlocalized_list
, old_var
);
667 gcc_assert (DECL_P (new_var
));
668 DECL_CHAIN (new_var
) = new_decls
;
671 /* Also copy value-expressions. */
672 if (VAR_P (new_var
) && DECL_HAS_VALUE_EXPR_P (new_var
))
674 tree tem
= DECL_VALUE_EXPR (new_var
);
675 bool old_regimplify
= id
->regimplify
;
676 id
->remapping_type_depth
++;
677 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
678 id
->remapping_type_depth
--;
679 id
->regimplify
= old_regimplify
;
680 SET_DECL_VALUE_EXPR (new_var
, tem
);
685 return nreverse (new_decls
);
688 /* Copy the BLOCK to contain remapped versions of the variables
689 therein. And hook the new block into the block-tree. */
692 remap_block (tree
*block
, copy_body_data
*id
)
697 /* Make the new block. */
699 new_block
= make_node (BLOCK
);
700 TREE_USED (new_block
) = TREE_USED (old_block
);
701 BLOCK_ABSTRACT_ORIGIN (new_block
) = old_block
;
702 BLOCK_SOURCE_LOCATION (new_block
) = BLOCK_SOURCE_LOCATION (old_block
);
703 BLOCK_NONLOCALIZED_VARS (new_block
)
704 = vec_safe_copy (BLOCK_NONLOCALIZED_VARS (old_block
));
707 /* Remap its variables. */
708 BLOCK_VARS (new_block
) = remap_decls (BLOCK_VARS (old_block
),
709 &BLOCK_NONLOCALIZED_VARS (new_block
),
712 if (id
->transform_lang_insert_block
)
713 id
->transform_lang_insert_block (new_block
);
715 /* Remember the remapped block. */
716 insert_decl_map (id
, old_block
, new_block
);
719 /* Copy the whole block tree and root it in id->block. */
721 remap_blocks (tree block
, copy_body_data
*id
)
724 tree new_tree
= block
;
729 remap_block (&new_tree
, id
);
730 gcc_assert (new_tree
!= block
);
731 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
732 prepend_lexical_block (new_tree
, remap_blocks (t
, id
));
733 /* Blocks are in arbitrary order, but make things slightly prettier and do
734 not swap order when producing a copy. */
735 BLOCK_SUBBLOCKS (new_tree
) = blocks_nreverse (BLOCK_SUBBLOCKS (new_tree
));
739 /* Remap the block tree rooted at BLOCK to nothing. */
741 remap_blocks_to_null (tree block
, copy_body_data
*id
)
744 insert_decl_map (id
, block
, NULL_TREE
);
745 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
746 remap_blocks_to_null (t
, id
);
750 copy_statement_list (tree
*tp
)
752 tree_stmt_iterator oi
, ni
;
755 new_tree
= alloc_stmt_list ();
756 ni
= tsi_start (new_tree
);
757 oi
= tsi_start (*tp
);
758 TREE_TYPE (new_tree
) = TREE_TYPE (*tp
);
761 for (; !tsi_end_p (oi
); tsi_next (&oi
))
763 tree stmt
= tsi_stmt (oi
);
764 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
765 /* This copy is not redundant; tsi_link_after will smash this
766 STATEMENT_LIST into the end of the one we're building, and we
767 don't want to do that with the original. */
768 copy_statement_list (&stmt
);
769 tsi_link_after (&ni
, stmt
, TSI_CONTINUE_LINKING
);
774 copy_bind_expr (tree
*tp
, int *walk_subtrees
, copy_body_data
*id
)
776 tree block
= BIND_EXPR_BLOCK (*tp
);
777 /* Copy (and replace) the statement. */
778 copy_tree_r (tp
, walk_subtrees
, NULL
);
781 remap_block (&block
, id
);
782 BIND_EXPR_BLOCK (*tp
) = block
;
785 if (BIND_EXPR_VARS (*tp
))
786 /* This will remap a lot of the same decls again, but this should be
788 BIND_EXPR_VARS (*tp
) = remap_decls (BIND_EXPR_VARS (*tp
), NULL
, id
);
792 /* Create a new gimple_seq by remapping all the statements in BODY
793 using the inlining information in ID. */
796 remap_gimple_seq (gimple_seq body
, copy_body_data
*id
)
798 gimple_stmt_iterator si
;
799 gimple_seq new_body
= NULL
;
801 for (si
= gsi_start (body
); !gsi_end_p (si
); gsi_next (&si
))
803 gimple_seq new_stmts
= remap_gimple_stmt (gsi_stmt (si
), id
);
804 gimple_seq_add_seq (&new_body
, new_stmts
);
811 /* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its
812 block using the mapping information in ID. */
815 copy_gimple_bind (gbind
*stmt
, copy_body_data
*id
)
818 tree new_block
, new_vars
;
819 gimple_seq body
, new_body
;
821 /* Copy the statement. Note that we purposely don't use copy_stmt
822 here because we need to remap statements as we copy. */
823 body
= gimple_bind_body (stmt
);
824 new_body
= remap_gimple_seq (body
, id
);
826 new_block
= gimple_bind_block (stmt
);
828 remap_block (&new_block
, id
);
830 /* This will remap a lot of the same decls again, but this should be
832 new_vars
= gimple_bind_vars (stmt
);
834 new_vars
= remap_decls (new_vars
, NULL
, id
);
836 new_bind
= gimple_build_bind (new_vars
, new_body
, new_block
);
841 /* Return true if DECL is a parameter or a SSA_NAME for a parameter. */
846 if (TREE_CODE (decl
) == SSA_NAME
)
848 decl
= SSA_NAME_VAR (decl
);
853 return (TREE_CODE (decl
) == PARM_DECL
);
856 /* Remap the dependence CLIQUE from the source to the destination function
857 as specified in ID. */
859 static unsigned short
860 remap_dependence_clique (copy_body_data
*id
, unsigned short clique
)
862 if (clique
== 0 || processing_debug_stmt
)
864 if (!id
->dependence_map
)
865 id
->dependence_map
= new hash_map
<dependence_hash
, unsigned short>;
867 unsigned short &newc
= id
->dependence_map
->get_or_insert (clique
, &existed
);
869 newc
= ++cfun
->last_clique
;
873 /* Remap the GIMPLE operand pointed to by *TP. DATA is really a
874 'struct walk_stmt_info *'. DATA->INFO is a 'copy_body_data *'.
875 WALK_SUBTREES is used to indicate walk_gimple_op whether to keep
876 recursing into the children nodes of *TP. */
879 remap_gimple_op_r (tree
*tp
, int *walk_subtrees
, void *data
)
881 struct walk_stmt_info
*wi_p
= (struct walk_stmt_info
*) data
;
882 copy_body_data
*id
= (copy_body_data
*) wi_p
->info
;
883 tree fn
= id
->src_fn
;
885 /* For recursive invocations this is no longer the LHS itself. */
886 bool is_lhs
= wi_p
->is_lhs
;
887 wi_p
->is_lhs
= false;
889 if (TREE_CODE (*tp
) == SSA_NAME
)
891 *tp
= remap_ssa_name (*tp
, id
);
894 SSA_NAME_DEF_STMT (*tp
) = wi_p
->stmt
;
897 else if (auto_var_in_fn_p (*tp
, fn
))
899 /* Local variables and labels need to be replaced by equivalent
900 variables. We don't want to copy static variables; there's
901 only one of those, no matter how many times we inline the
902 containing function. Similarly for globals from an outer
906 /* Remap the declaration. */
907 new_decl
= remap_decl (*tp
, id
);
908 gcc_assert (new_decl
);
909 /* Replace this variable with the copy. */
910 STRIP_TYPE_NOPS (new_decl
);
911 /* ??? The C++ frontend uses void * pointer zero to initialize
912 any other type. This confuses the middle-end type verification.
913 As cloned bodies do not go through gimplification again the fixup
914 there doesn't trigger. */
915 if (TREE_CODE (new_decl
) == INTEGER_CST
916 && !useless_type_conversion_p (TREE_TYPE (*tp
), TREE_TYPE (new_decl
)))
917 new_decl
= fold_convert (TREE_TYPE (*tp
), new_decl
);
921 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
923 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
925 else if (TREE_CODE (*tp
) == LABEL_DECL
926 && (!DECL_CONTEXT (*tp
)
927 || decl_function_context (*tp
) == id
->src_fn
))
928 /* These may need to be remapped for EH handling. */
929 *tp
= remap_decl (*tp
, id
);
930 else if (TREE_CODE (*tp
) == FIELD_DECL
)
932 /* If the enclosing record type is variably_modified_type_p, the field
933 has already been remapped. Otherwise, it need not be. */
934 tree
*n
= id
->decl_map
->get (*tp
);
939 else if (TYPE_P (*tp
))
940 /* Types may need remapping as well. */
941 *tp
= remap_type (*tp
, id
);
942 else if (CONSTANT_CLASS_P (*tp
))
944 /* If this is a constant, we have to copy the node iff the type
945 will be remapped. copy_tree_r will not copy a constant. */
946 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
948 if (new_type
== TREE_TYPE (*tp
))
951 else if (TREE_CODE (*tp
) == INTEGER_CST
)
952 *tp
= wide_int_to_tree (new_type
, wi::to_wide (*tp
));
955 *tp
= copy_node (*tp
);
956 TREE_TYPE (*tp
) = new_type
;
961 /* Otherwise, just copy the node. Note that copy_tree_r already
962 knows not to copy VAR_DECLs, etc., so this is safe. */
964 if (TREE_CODE (*tp
) == MEM_REF
)
966 /* We need to re-canonicalize MEM_REFs from inline substitutions
967 that can happen when a pointer argument is an ADDR_EXPR.
968 Recurse here manually to allow that. */
969 tree ptr
= TREE_OPERAND (*tp
, 0);
970 tree type
= remap_type (TREE_TYPE (*tp
), id
);
972 walk_tree (&ptr
, remap_gimple_op_r
, data
, NULL
);
973 *tp
= fold_build2 (MEM_REF
, type
, ptr
, TREE_OPERAND (*tp
, 1));
974 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
975 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
976 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
977 if (MR_DEPENDENCE_CLIQUE (old
) != 0)
979 MR_DEPENDENCE_CLIQUE (*tp
)
980 = remap_dependence_clique (id
, MR_DEPENDENCE_CLIQUE (old
));
981 MR_DEPENDENCE_BASE (*tp
) = MR_DEPENDENCE_BASE (old
);
983 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
984 remapped a parameter as the property might be valid only
985 for the parameter itself. */
986 if (TREE_THIS_NOTRAP (old
)
987 && (!is_parm (TREE_OPERAND (old
, 0))
988 || (!id
->transform_parameter
&& is_parm (ptr
))))
989 TREE_THIS_NOTRAP (*tp
) = 1;
990 REF_REVERSE_STORAGE_ORDER (*tp
) = REF_REVERSE_STORAGE_ORDER (old
);
995 /* Here is the "usual case". Copy this tree node, and then
996 tweak some special cases. */
997 copy_tree_r (tp
, walk_subtrees
, NULL
);
999 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
1000 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
1002 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
1004 /* The copied TARGET_EXPR has never been expanded, even if the
1005 original node was expanded already. */
1006 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
1007 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
1009 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
1011 /* Variable substitution need not be simple. In particular,
1012 the MEM_REF substitution above. Make sure that
1013 TREE_CONSTANT and friends are up-to-date. */
1014 int invariant
= is_gimple_min_invariant (*tp
);
1015 walk_tree (&TREE_OPERAND (*tp
, 0), remap_gimple_op_r
, data
, NULL
);
1016 recompute_tree_invariant_for_addr_expr (*tp
);
1018 /* If this used to be invariant, but is not any longer,
1019 then regimplification is probably needed. */
1020 if (invariant
&& !is_gimple_min_invariant (*tp
))
1021 id
->regimplify
= true;
1027 /* Update the TREE_BLOCK for the cloned expr. */
1030 tree new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
1031 tree old_block
= TREE_BLOCK (*tp
);
1035 n
= id
->decl_map
->get (TREE_BLOCK (*tp
));
1039 TREE_SET_BLOCK (*tp
, new_block
);
1042 /* Keep iterating. */
1047 /* Called from copy_body_id via walk_tree. DATA is really a
1048 `copy_body_data *'. */
1051 copy_tree_body_r (tree
*tp
, int *walk_subtrees
, void *data
)
1053 copy_body_data
*id
= (copy_body_data
*) data
;
1054 tree fn
= id
->src_fn
;
1057 /* Begin by recognizing trees that we'll completely rewrite for the
1058 inlining context. Our output for these trees is completely
1059 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1060 into an edge). Further down, we'll handle trees that get
1061 duplicated and/or tweaked. */
1063 /* When requested, RETURN_EXPRs should be transformed to just the
1064 contained MODIFY_EXPR. The branch semantics of the return will
1065 be handled elsewhere by manipulating the CFG rather than a statement. */
1066 if (TREE_CODE (*tp
) == RETURN_EXPR
&& id
->transform_return_to_modify
)
1068 tree assignment
= TREE_OPERAND (*tp
, 0);
1070 /* If we're returning something, just turn that into an
1071 assignment into the equivalent of the original RESULT_DECL.
1072 If the "assignment" is just the result decl, the result
1073 decl has already been set (e.g. a recent "foo (&result_decl,
1074 ...)"); just toss the entire RETURN_EXPR. */
1075 if (assignment
&& TREE_CODE (assignment
) == MODIFY_EXPR
)
1077 /* Replace the RETURN_EXPR with (a copy of) the
1078 MODIFY_EXPR hanging underneath. */
1079 *tp
= copy_node (assignment
);
1081 else /* Else the RETURN_EXPR returns no value. */
1084 return (tree
) (void *)1;
1087 else if (TREE_CODE (*tp
) == SSA_NAME
)
1089 *tp
= remap_ssa_name (*tp
, id
);
1094 /* Local variables and labels need to be replaced by equivalent
1095 variables. We don't want to copy static variables; there's only
1096 one of those, no matter how many times we inline the containing
1097 function. Similarly for globals from an outer function. */
1098 else if (auto_var_in_fn_p (*tp
, fn
))
1102 /* Remap the declaration. */
1103 new_decl
= remap_decl (*tp
, id
);
1104 gcc_assert (new_decl
);
1105 /* Replace this variable with the copy. */
1106 STRIP_TYPE_NOPS (new_decl
);
1110 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
1111 copy_statement_list (tp
);
1112 else if (TREE_CODE (*tp
) == SAVE_EXPR
1113 || TREE_CODE (*tp
) == TARGET_EXPR
)
1114 remap_save_expr (tp
, id
->decl_map
, walk_subtrees
);
1115 else if (TREE_CODE (*tp
) == LABEL_DECL
1116 && (! DECL_CONTEXT (*tp
)
1117 || decl_function_context (*tp
) == id
->src_fn
))
1118 /* These may need to be remapped for EH handling. */
1119 *tp
= remap_decl (*tp
, id
);
1120 else if (TREE_CODE (*tp
) == BIND_EXPR
)
1121 copy_bind_expr (tp
, walk_subtrees
, id
);
1122 /* Types may need remapping as well. */
1123 else if (TYPE_P (*tp
))
1124 *tp
= remap_type (*tp
, id
);
1126 /* If this is a constant, we have to copy the node iff the type will be
1127 remapped. copy_tree_r will not copy a constant. */
1128 else if (CONSTANT_CLASS_P (*tp
))
1130 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
1132 if (new_type
== TREE_TYPE (*tp
))
1135 else if (TREE_CODE (*tp
) == INTEGER_CST
)
1136 *tp
= wide_int_to_tree (new_type
, wi::to_wide (*tp
));
1139 *tp
= copy_node (*tp
);
1140 TREE_TYPE (*tp
) = new_type
;
1144 /* Otherwise, just copy the node. Note that copy_tree_r already
1145 knows not to copy VAR_DECLs, etc., so this is safe. */
1148 /* Here we handle trees that are not completely rewritten.
1149 First we detect some inlining-induced bogosities for
1151 if (TREE_CODE (*tp
) == MODIFY_EXPR
1152 && TREE_OPERAND (*tp
, 0) == TREE_OPERAND (*tp
, 1)
1153 && (auto_var_in_fn_p (TREE_OPERAND (*tp
, 0), fn
)))
1155 /* Some assignments VAR = VAR; don't generate any rtl code
1156 and thus don't count as variable modification. Avoid
1157 keeping bogosities like 0 = 0. */
1158 tree decl
= TREE_OPERAND (*tp
, 0), value
;
1161 n
= id
->decl_map
->get (decl
);
1165 STRIP_TYPE_NOPS (value
);
1166 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1168 *tp
= build_empty_stmt (EXPR_LOCATION (*tp
));
1169 return copy_tree_body_r (tp
, walk_subtrees
, data
);
1173 else if (TREE_CODE (*tp
) == INDIRECT_REF
)
1175 /* Get rid of *& from inline substitutions that can happen when a
1176 pointer argument is an ADDR_EXPR. */
1177 tree decl
= TREE_OPERAND (*tp
, 0);
1178 tree
*n
= id
->decl_map
->get (decl
);
1181 /* If we happen to get an ADDR_EXPR in n->value, strip
1182 it manually here as we'll eventually get ADDR_EXPRs
1183 which lie about their types pointed to. In this case
1184 build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
1185 but we absolutely rely on that. As fold_indirect_ref
1186 does other useful transformations, try that first, though. */
1187 tree type
= TREE_TYPE (*tp
);
1188 tree ptr
= id
->do_not_unshare
? *n
: unshare_expr (*n
);
1190 *tp
= gimple_fold_indirect_ref (ptr
);
1193 if (TREE_CODE (ptr
) == ADDR_EXPR
)
1196 = fold_indirect_ref_1 (EXPR_LOCATION (ptr
), type
, ptr
);
1197 /* ??? We should either assert here or build
1198 a VIEW_CONVERT_EXPR instead of blindly leaking
1199 incompatible types to our IL. */
1201 *tp
= TREE_OPERAND (ptr
, 0);
1205 *tp
= build1 (INDIRECT_REF
, type
, ptr
);
1206 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1207 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1208 TREE_READONLY (*tp
) = TREE_READONLY (old
);
1209 /* We cannot propagate the TREE_THIS_NOTRAP flag if we
1210 have remapped a parameter as the property might be
1211 valid only for the parameter itself. */
1212 if (TREE_THIS_NOTRAP (old
)
1213 && (!is_parm (TREE_OPERAND (old
, 0))
1214 || (!id
->transform_parameter
&& is_parm (ptr
))))
1215 TREE_THIS_NOTRAP (*tp
) = 1;
1222 else if (TREE_CODE (*tp
) == MEM_REF
)
1224 /* We need to re-canonicalize MEM_REFs from inline substitutions
1225 that can happen when a pointer argument is an ADDR_EXPR.
1226 Recurse here manually to allow that. */
1227 tree ptr
= TREE_OPERAND (*tp
, 0);
1228 tree type
= remap_type (TREE_TYPE (*tp
), id
);
1230 walk_tree (&ptr
, copy_tree_body_r
, data
, NULL
);
1231 *tp
= fold_build2 (MEM_REF
, type
, ptr
, TREE_OPERAND (*tp
, 1));
1232 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1233 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1234 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
1235 if (MR_DEPENDENCE_CLIQUE (old
) != 0)
1237 MR_DEPENDENCE_CLIQUE (*tp
)
1238 = remap_dependence_clique (id
, MR_DEPENDENCE_CLIQUE (old
));
1239 MR_DEPENDENCE_BASE (*tp
) = MR_DEPENDENCE_BASE (old
);
1241 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
1242 remapped a parameter as the property might be valid only
1243 for the parameter itself. */
1244 if (TREE_THIS_NOTRAP (old
)
1245 && (!is_parm (TREE_OPERAND (old
, 0))
1246 || (!id
->transform_parameter
&& is_parm (ptr
))))
1247 TREE_THIS_NOTRAP (*tp
) = 1;
1248 REF_REVERSE_STORAGE_ORDER (*tp
) = REF_REVERSE_STORAGE_ORDER (old
);
1253 /* Here is the "usual case". Copy this tree node, and then
1254 tweak some special cases. */
1255 copy_tree_r (tp
, walk_subtrees
, NULL
);
1257 /* If EXPR has block defined, map it to newly constructed block.
1258 When inlining we want EXPRs without block appear in the block
1259 of function call if we are not remapping a type. */
1262 new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
1263 if (TREE_BLOCK (*tp
))
1266 n
= id
->decl_map
->get (TREE_BLOCK (*tp
));
1270 TREE_SET_BLOCK (*tp
, new_block
);
1273 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
1274 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
1276 /* The copied TARGET_EXPR has never been expanded, even if the
1277 original node was expanded already. */
1278 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
1280 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
1281 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
1284 /* Variable substitution need not be simple. In particular, the
1285 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
1286 and friends are up-to-date. */
1287 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
1289 int invariant
= is_gimple_min_invariant (*tp
);
1290 walk_tree (&TREE_OPERAND (*tp
, 0), copy_tree_body_r
, id
, NULL
);
1292 /* Handle the case where we substituted an INDIRECT_REF
1293 into the operand of the ADDR_EXPR. */
1294 if (TREE_CODE (TREE_OPERAND (*tp
, 0)) == INDIRECT_REF
)
1296 tree t
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0);
1297 if (TREE_TYPE (t
) != TREE_TYPE (*tp
))
1298 t
= fold_convert (remap_type (TREE_TYPE (*tp
), id
), t
);
1302 recompute_tree_invariant_for_addr_expr (*tp
);
1304 /* If this used to be invariant, but is not any longer,
1305 then regimplification is probably needed. */
1306 if (invariant
&& !is_gimple_min_invariant (*tp
))
1307 id
->regimplify
= true;
1313 /* Keep iterating. */
1317 /* Helper for remap_gimple_stmt. Given an EH region number for the
1318 source function, map that to the duplicate EH region number in
1319 the destination function. */
1322 remap_eh_region_nr (int old_nr
, copy_body_data
*id
)
1324 eh_region old_r
, new_r
;
1326 old_r
= get_eh_region_from_number_fn (id
->src_cfun
, old_nr
);
1327 new_r
= static_cast<eh_region
> (*id
->eh_map
->get (old_r
));
1329 return new_r
->index
;
1332 /* Similar, but operate on INTEGER_CSTs. */
1335 remap_eh_region_tree_nr (tree old_t_nr
, copy_body_data
*id
)
1339 old_nr
= tree_to_shwi (old_t_nr
);
1340 new_nr
= remap_eh_region_nr (old_nr
, id
);
1342 return build_int_cst (integer_type_node
, new_nr
);
1345 /* Helper for copy_bb. Remap statement STMT using the inlining
1346 information in ID. Return the new statement copy. */
1349 remap_gimple_stmt (gimple
*stmt
, copy_body_data
*id
)
1351 gimple
*copy
= NULL
;
1352 struct walk_stmt_info wi
;
1353 bool skip_first
= false;
1354 gimple_seq stmts
= NULL
;
1356 if (is_gimple_debug (stmt
)
1357 && !opt_for_fn (id
->dst_fn
, flag_var_tracking_assignments
))
1360 /* Begin by recognizing trees that we'll completely rewrite for the
1361 inlining context. Our output for these trees is completely
1362 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1363 into an edge). Further down, we'll handle trees that get
1364 duplicated and/or tweaked. */
1366 /* When requested, GIMPLE_RETURNs should be transformed to just the
1367 contained GIMPLE_ASSIGN. The branch semantics of the return will
1368 be handled elsewhere by manipulating the CFG rather than the
1370 if (gimple_code (stmt
) == GIMPLE_RETURN
&& id
->transform_return_to_modify
)
1372 tree retval
= gimple_return_retval (as_a
<greturn
*> (stmt
));
1373 tree retbnd
= gimple_return_retbnd (stmt
);
1374 tree bndslot
= id
->retbnd
;
1376 if (retbnd
&& bndslot
)
1378 gimple
*bndcopy
= gimple_build_assign (bndslot
, retbnd
);
1379 memset (&wi
, 0, sizeof (wi
));
1381 walk_gimple_op (bndcopy
, remap_gimple_op_r
, &wi
);
1382 gimple_seq_add_stmt (&stmts
, bndcopy
);
1385 /* If we're returning something, just turn that into an
1386 assignment into the equivalent of the original RESULT_DECL.
1387 If RETVAL is just the result decl, the result decl has
1388 already been set (e.g. a recent "foo (&result_decl, ...)");
1389 just toss the entire GIMPLE_RETURN. */
1391 && (TREE_CODE (retval
) != RESULT_DECL
1392 && (TREE_CODE (retval
) != SSA_NAME
1393 || ! SSA_NAME_VAR (retval
)
1394 || TREE_CODE (SSA_NAME_VAR (retval
)) != RESULT_DECL
)))
1396 copy
= gimple_build_assign (id
->do_not_unshare
1397 ? id
->retvar
: unshare_expr (id
->retvar
),
1399 /* id->retvar is already substituted. Skip it on later remapping. */
1402 /* We need to copy bounds if return structure with pointers into
1403 instrumented function. */
1404 if (chkp_function_instrumented_p (id
->dst_fn
)
1406 && !BOUNDED_P (id
->retvar
)
1407 && chkp_type_has_pointer (TREE_TYPE (id
->retvar
)))
1408 id
->assign_stmts
.safe_push (copy
);
1414 else if (gimple_has_substatements (stmt
))
1418 /* When cloning bodies from the C++ front end, we will be handed bodies
1419 in High GIMPLE form. Handle here all the High GIMPLE statements that
1420 have embedded statements. */
1421 switch (gimple_code (stmt
))
1424 copy
= copy_gimple_bind (as_a
<gbind
*> (stmt
), id
);
1429 gcatch
*catch_stmt
= as_a
<gcatch
*> (stmt
);
1430 s1
= remap_gimple_seq (gimple_catch_handler (catch_stmt
), id
);
1431 copy
= gimple_build_catch (gimple_catch_types (catch_stmt
), s1
);
1435 case GIMPLE_EH_FILTER
:
1436 s1
= remap_gimple_seq (gimple_eh_filter_failure (stmt
), id
);
1437 copy
= gimple_build_eh_filter (gimple_eh_filter_types (stmt
), s1
);
1441 s1
= remap_gimple_seq (gimple_try_eval (stmt
), id
);
1442 s2
= remap_gimple_seq (gimple_try_cleanup (stmt
), id
);
1443 copy
= gimple_build_try (s1
, s2
, gimple_try_kind (stmt
));
1446 case GIMPLE_WITH_CLEANUP_EXPR
:
1447 s1
= remap_gimple_seq (gimple_wce_cleanup (stmt
), id
);
1448 copy
= gimple_build_wce (s1
);
1451 case GIMPLE_OMP_PARALLEL
:
1453 gomp_parallel
*omp_par_stmt
= as_a
<gomp_parallel
*> (stmt
);
1454 s1
= remap_gimple_seq (gimple_omp_body (omp_par_stmt
), id
);
1455 copy
= gimple_build_omp_parallel
1457 gimple_omp_parallel_clauses (omp_par_stmt
),
1458 gimple_omp_parallel_child_fn (omp_par_stmt
),
1459 gimple_omp_parallel_data_arg (omp_par_stmt
));
1463 case GIMPLE_OMP_TASK
:
1464 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1465 copy
= gimple_build_omp_task
1467 gimple_omp_task_clauses (stmt
),
1468 gimple_omp_task_child_fn (stmt
),
1469 gimple_omp_task_data_arg (stmt
),
1470 gimple_omp_task_copy_fn (stmt
),
1471 gimple_omp_task_arg_size (stmt
),
1472 gimple_omp_task_arg_align (stmt
));
1475 case GIMPLE_OMP_FOR
:
1476 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1477 s2
= remap_gimple_seq (gimple_omp_for_pre_body (stmt
), id
);
1478 copy
= gimple_build_omp_for (s1
, gimple_omp_for_kind (stmt
),
1479 gimple_omp_for_clauses (stmt
),
1480 gimple_omp_for_collapse (stmt
), s2
);
1483 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1485 gimple_omp_for_set_index (copy
, i
,
1486 gimple_omp_for_index (stmt
, i
));
1487 gimple_omp_for_set_initial (copy
, i
,
1488 gimple_omp_for_initial (stmt
, i
));
1489 gimple_omp_for_set_final (copy
, i
,
1490 gimple_omp_for_final (stmt
, i
));
1491 gimple_omp_for_set_incr (copy
, i
,
1492 gimple_omp_for_incr (stmt
, i
));
1493 gimple_omp_for_set_cond (copy
, i
,
1494 gimple_omp_for_cond (stmt
, i
));
1499 case GIMPLE_OMP_MASTER
:
1500 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1501 copy
= gimple_build_omp_master (s1
);
1504 case GIMPLE_OMP_TASKGROUP
:
1505 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1506 copy
= gimple_build_omp_taskgroup (s1
);
1509 case GIMPLE_OMP_ORDERED
:
1510 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1511 copy
= gimple_build_omp_ordered
1513 gimple_omp_ordered_clauses (as_a
<gomp_ordered
*> (stmt
)));
1516 case GIMPLE_OMP_SECTION
:
1517 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1518 copy
= gimple_build_omp_section (s1
);
1521 case GIMPLE_OMP_SECTIONS
:
1522 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1523 copy
= gimple_build_omp_sections
1524 (s1
, gimple_omp_sections_clauses (stmt
));
1527 case GIMPLE_OMP_SINGLE
:
1528 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1529 copy
= gimple_build_omp_single
1530 (s1
, gimple_omp_single_clauses (stmt
));
1533 case GIMPLE_OMP_TARGET
:
1534 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1535 copy
= gimple_build_omp_target
1536 (s1
, gimple_omp_target_kind (stmt
),
1537 gimple_omp_target_clauses (stmt
));
1540 case GIMPLE_OMP_TEAMS
:
1541 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1542 copy
= gimple_build_omp_teams
1543 (s1
, gimple_omp_teams_clauses (stmt
));
1546 case GIMPLE_OMP_CRITICAL
:
1547 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1548 copy
= gimple_build_omp_critical (s1
,
1549 gimple_omp_critical_name
1550 (as_a
<gomp_critical
*> (stmt
)),
1551 gimple_omp_critical_clauses
1552 (as_a
<gomp_critical
*> (stmt
)));
1555 case GIMPLE_TRANSACTION
:
1557 gtransaction
*old_trans_stmt
= as_a
<gtransaction
*> (stmt
);
1558 gtransaction
*new_trans_stmt
;
1559 s1
= remap_gimple_seq (gimple_transaction_body (old_trans_stmt
),
1561 copy
= new_trans_stmt
= gimple_build_transaction (s1
);
1562 gimple_transaction_set_subcode (new_trans_stmt
,
1563 gimple_transaction_subcode (old_trans_stmt
));
1564 gimple_transaction_set_label_norm (new_trans_stmt
,
1565 gimple_transaction_label_norm (old_trans_stmt
));
1566 gimple_transaction_set_label_uninst (new_trans_stmt
,
1567 gimple_transaction_label_uninst (old_trans_stmt
));
1568 gimple_transaction_set_label_over (new_trans_stmt
,
1569 gimple_transaction_label_over (old_trans_stmt
));
1579 if (gimple_assign_copy_p (stmt
)
1580 && gimple_assign_lhs (stmt
) == gimple_assign_rhs1 (stmt
)
1581 && auto_var_in_fn_p (gimple_assign_lhs (stmt
), id
->src_fn
))
1583 /* Here we handle statements that are not completely rewritten.
1584 First we detect some inlining-induced bogosities for
1587 /* Some assignments VAR = VAR; don't generate any rtl code
1588 and thus don't count as variable modification. Avoid
1589 keeping bogosities like 0 = 0. */
1590 tree decl
= gimple_assign_lhs (stmt
), value
;
1593 n
= id
->decl_map
->get (decl
);
1597 STRIP_TYPE_NOPS (value
);
1598 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1603 /* For *ptr_N ={v} {CLOBBER}, if ptr_N is SSA_NAME defined
1604 in a block that we aren't copying during tree_function_versioning,
1605 just drop the clobber stmt. */
1606 if (id
->blocks_to_copy
&& gimple_clobber_p (stmt
))
1608 tree lhs
= gimple_assign_lhs (stmt
);
1609 if (TREE_CODE (lhs
) == MEM_REF
1610 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == SSA_NAME
)
1612 gimple
*def_stmt
= SSA_NAME_DEF_STMT (TREE_OPERAND (lhs
, 0));
1613 if (gimple_bb (def_stmt
)
1614 && !bitmap_bit_p (id
->blocks_to_copy
,
1615 gimple_bb (def_stmt
)->index
))
1620 if (gimple_debug_bind_p (stmt
))
1623 = gimple_build_debug_bind (gimple_debug_bind_get_var (stmt
),
1624 gimple_debug_bind_get_value (stmt
),
1626 id
->debug_stmts
.safe_push (copy
);
1627 gimple_seq_add_stmt (&stmts
, copy
);
1630 if (gimple_debug_source_bind_p (stmt
))
1632 gdebug
*copy
= gimple_build_debug_source_bind
1633 (gimple_debug_source_bind_get_var (stmt
),
1634 gimple_debug_source_bind_get_value (stmt
),
1636 id
->debug_stmts
.safe_push (copy
);
1637 gimple_seq_add_stmt (&stmts
, copy
);
1641 /* Create a new deep copy of the statement. */
1642 copy
= gimple_copy (stmt
);
1644 /* Clear flags that need revisiting. */
1645 if (gcall
*call_stmt
= dyn_cast
<gcall
*> (copy
))
1647 if (gimple_call_tail_p (call_stmt
))
1648 gimple_call_set_tail (call_stmt
, false);
1649 if (gimple_call_from_thunk_p (call_stmt
))
1650 gimple_call_set_from_thunk (call_stmt
, false);
1651 if (gimple_call_internal_p (call_stmt
))
1652 switch (gimple_call_internal_fn (call_stmt
))
1654 case IFN_GOMP_SIMD_LANE
:
1655 case IFN_GOMP_SIMD_VF
:
1656 case IFN_GOMP_SIMD_LAST_LANE
:
1657 case IFN_GOMP_SIMD_ORDERED_START
:
1658 case IFN_GOMP_SIMD_ORDERED_END
:
1659 DECL_STRUCT_FUNCTION (id
->dst_fn
)->has_simduid_loops
= true;
1666 /* Remap the region numbers for __builtin_eh_{pointer,filter},
1667 RESX and EH_DISPATCH. */
1669 switch (gimple_code (copy
))
1673 tree r
, fndecl
= gimple_call_fndecl (copy
);
1674 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
1675 switch (DECL_FUNCTION_CODE (fndecl
))
1677 case BUILT_IN_EH_COPY_VALUES
:
1678 r
= gimple_call_arg (copy
, 1);
1679 r
= remap_eh_region_tree_nr (r
, id
);
1680 gimple_call_set_arg (copy
, 1, r
);
1683 case BUILT_IN_EH_POINTER
:
1684 case BUILT_IN_EH_FILTER
:
1685 r
= gimple_call_arg (copy
, 0);
1686 r
= remap_eh_region_tree_nr (r
, id
);
1687 gimple_call_set_arg (copy
, 0, r
);
1694 /* Reset alias info if we didn't apply measures to
1695 keep it valid over inlining by setting DECL_PT_UID. */
1696 if (!id
->src_cfun
->gimple_df
1697 || !id
->src_cfun
->gimple_df
->ipa_pta
)
1698 gimple_call_reset_alias_info (as_a
<gcall
*> (copy
));
1704 gresx
*resx_stmt
= as_a
<gresx
*> (copy
);
1705 int r
= gimple_resx_region (resx_stmt
);
1706 r
= remap_eh_region_nr (r
, id
);
1707 gimple_resx_set_region (resx_stmt
, r
);
1711 case GIMPLE_EH_DISPATCH
:
1713 geh_dispatch
*eh_dispatch
= as_a
<geh_dispatch
*> (copy
);
1714 int r
= gimple_eh_dispatch_region (eh_dispatch
);
1715 r
= remap_eh_region_nr (r
, id
);
1716 gimple_eh_dispatch_set_region (eh_dispatch
, r
);
1725 /* If STMT has a block defined, map it to the newly constructed
1727 if (gimple_block (copy
))
1730 n
= id
->decl_map
->get (gimple_block (copy
));
1732 gimple_set_block (copy
, *n
);
1735 if (gimple_debug_bind_p (copy
) || gimple_debug_source_bind_p (copy
))
1737 gimple_seq_add_stmt (&stmts
, copy
);
1741 /* Remap all the operands in COPY. */
1742 memset (&wi
, 0, sizeof (wi
));
1745 walk_tree (gimple_op_ptr (copy
, 1), remap_gimple_op_r
, &wi
, NULL
);
1747 walk_gimple_op (copy
, remap_gimple_op_r
, &wi
);
1749 /* Clear the copied virtual operands. We are not remapping them here
1750 but are going to recreate them from scratch. */
1751 if (gimple_has_mem_ops (copy
))
1753 gimple_set_vdef (copy
, NULL_TREE
);
1754 gimple_set_vuse (copy
, NULL_TREE
);
1757 gimple_seq_add_stmt (&stmts
, copy
);
1762 /* Copy basic block, scale profile accordingly. Edges will be taken care of
1766 copy_bb (copy_body_data
*id
, basic_block bb
,
1767 profile_count num
, profile_count den
)
1769 gimple_stmt_iterator gsi
, copy_gsi
, seq_gsi
;
1770 basic_block copy_basic_block
;
1774 profile_count::adjust_for_ipa_scaling (&num
, &den
);
1776 /* Search for previous copied basic block. */
1779 prev
= prev
->prev_bb
;
1781 /* create_basic_block() will append every new block to
1782 basic_block_info automatically. */
1783 copy_basic_block
= create_basic_block (NULL
, (basic_block
) prev
->aux
);
1784 copy_basic_block
->count
= bb
->count
.apply_scale (num
, den
);
1786 copy_gsi
= gsi_start_bb (copy_basic_block
);
1788 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1791 gimple
*stmt
= gsi_stmt (gsi
);
1792 gimple
*orig_stmt
= stmt
;
1793 gimple_stmt_iterator stmts_gsi
;
1794 bool stmt_added
= false;
1796 id
->regimplify
= false;
1797 stmts
= remap_gimple_stmt (stmt
, id
);
1799 if (gimple_seq_empty_p (stmts
))
1804 for (stmts_gsi
= gsi_start (stmts
);
1805 !gsi_end_p (stmts_gsi
); )
1807 stmt
= gsi_stmt (stmts_gsi
);
1809 /* Advance iterator now before stmt is moved to seq_gsi. */
1810 gsi_next (&stmts_gsi
);
1812 if (gimple_nop_p (stmt
))
1815 gimple_duplicate_stmt_histograms (cfun
, stmt
, id
->src_cfun
,
1818 /* With return slot optimization we can end up with
1819 non-gimple (foo *)&this->m, fix that here. */
1820 if (is_gimple_assign (stmt
)
1821 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
))
1822 && !is_gimple_val (gimple_assign_rhs1 (stmt
)))
1825 new_rhs
= force_gimple_operand_gsi (&seq_gsi
,
1826 gimple_assign_rhs1 (stmt
),
1828 GSI_CONTINUE_LINKING
);
1829 gimple_assign_set_rhs1 (stmt
, new_rhs
);
1830 id
->regimplify
= false;
1833 gsi_insert_after (&seq_gsi
, stmt
, GSI_NEW_STMT
);
1836 gimple_regimplify_operands (stmt
, &seq_gsi
);
1844 /* If copy_basic_block has been empty at the start of this iteration,
1845 call gsi_start_bb again to get at the newly added statements. */
1846 if (gsi_end_p (copy_gsi
))
1847 copy_gsi
= gsi_start_bb (copy_basic_block
);
1849 gsi_next (©_gsi
);
1851 /* Process the new statement. The call to gimple_regimplify_operands
1852 possibly turned the statement into multiple statements, we
1853 need to process all of them. */
1859 stmt
= gsi_stmt (copy_gsi
);
1860 call_stmt
= dyn_cast
<gcall
*> (stmt
);
1862 && gimple_call_va_arg_pack_p (call_stmt
)
1864 && ! gimple_call_va_arg_pack_p (id
->call_stmt
))
1866 /* __builtin_va_arg_pack () should be replaced by
1867 all arguments corresponding to ... in the caller. */
1871 size_t nargs
= gimple_call_num_args (id
->call_stmt
);
1872 size_t n
, i
, nargs_to_copy
;
1873 bool remove_bounds
= false;
1875 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1878 /* Bounds should be removed from arg pack in case
1879 we handle not instrumented call in instrumented
1881 nargs_to_copy
= nargs
;
1882 if (gimple_call_with_bounds_p (id
->call_stmt
)
1883 && !gimple_call_with_bounds_p (stmt
))
1885 for (i
= gimple_call_num_args (id
->call_stmt
) - nargs
;
1886 i
< gimple_call_num_args (id
->call_stmt
);
1888 if (POINTER_BOUNDS_P (gimple_call_arg (id
->call_stmt
, i
)))
1890 remove_bounds
= true;
1893 /* Create the new array of arguments. */
1894 n
= nargs_to_copy
+ gimple_call_num_args (call_stmt
);
1895 argarray
.create (n
);
1896 argarray
.safe_grow_cleared (n
);
1898 /* Copy all the arguments before '...' */
1899 memcpy (argarray
.address (),
1900 gimple_call_arg_ptr (call_stmt
, 0),
1901 gimple_call_num_args (call_stmt
) * sizeof (tree
));
1905 /* Append the rest of arguments removing bounds. */
1906 unsigned cur
= gimple_call_num_args (call_stmt
);
1907 i
= gimple_call_num_args (id
->call_stmt
) - nargs
;
1908 for (i
= gimple_call_num_args (id
->call_stmt
) - nargs
;
1909 i
< gimple_call_num_args (id
->call_stmt
);
1911 if (!POINTER_BOUNDS_P (gimple_call_arg (id
->call_stmt
, i
)))
1912 argarray
[cur
++] = gimple_call_arg (id
->call_stmt
, i
);
1913 gcc_assert (cur
== n
);
1917 /* Append the arguments passed in '...' */
1918 memcpy (argarray
.address () + gimple_call_num_args (call_stmt
),
1919 gimple_call_arg_ptr (id
->call_stmt
, 0)
1920 + (gimple_call_num_args (id
->call_stmt
) - nargs
),
1921 nargs
* sizeof (tree
));
1924 new_call
= gimple_build_call_vec (gimple_call_fn (call_stmt
),
1927 argarray
.release ();
1929 /* Copy all GIMPLE_CALL flags, location and block, except
1930 GF_CALL_VA_ARG_PACK. */
1931 gimple_call_copy_flags (new_call
, call_stmt
);
1932 gimple_call_set_va_arg_pack (new_call
, false);
1933 gimple_set_location (new_call
, gimple_location (stmt
));
1934 gimple_set_block (new_call
, gimple_block (stmt
));
1935 gimple_call_set_lhs (new_call
, gimple_call_lhs (call_stmt
));
1937 gsi_replace (©_gsi
, new_call
, false);
1942 && (decl
= gimple_call_fndecl (stmt
))
1943 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
1944 && DECL_FUNCTION_CODE (decl
) == BUILT_IN_VA_ARG_PACK_LEN
1945 && ! gimple_call_va_arg_pack_p (id
->call_stmt
))
1947 /* __builtin_va_arg_pack_len () should be replaced by
1948 the number of anonymous arguments. */
1949 size_t nargs
= gimple_call_num_args (id
->call_stmt
), i
;
1953 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1956 /* For instrumented calls we should ignore bounds. */
1957 for (i
= gimple_call_num_args (id
->call_stmt
) - nargs
;
1958 i
< gimple_call_num_args (id
->call_stmt
);
1960 if (POINTER_BOUNDS_P (gimple_call_arg (id
->call_stmt
, i
)))
1963 count
= build_int_cst (integer_type_node
, nargs
);
1964 new_stmt
= gimple_build_assign (gimple_call_lhs (stmt
), count
);
1965 gsi_replace (©_gsi
, new_stmt
, false);
1970 && gimple_call_internal_p (stmt
)
1971 && gimple_call_internal_fn (stmt
) == IFN_TSAN_FUNC_EXIT
)
1973 /* Drop TSAN_FUNC_EXIT () internal calls during inlining. */
1974 gsi_remove (©_gsi
, false);
1978 /* Statements produced by inlining can be unfolded, especially
1979 when we constant propagated some operands. We can't fold
1980 them right now for two reasons:
1981 1) folding require SSA_NAME_DEF_STMTs to be correct
1982 2) we can't change function calls to builtins.
1983 So we just mark statement for later folding. We mark
1984 all new statements, instead just statements that has changed
1985 by some nontrivial substitution so even statements made
1986 foldable indirectly are updated. If this turns out to be
1987 expensive, copy_body can be told to watch for nontrivial
1989 if (id
->statements_to_fold
)
1990 id
->statements_to_fold
->add (stmt
);
1992 /* We're duplicating a CALL_EXPR. Find any corresponding
1993 callgraph edges and update or duplicate them. */
1994 if (gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
))
1996 struct cgraph_edge
*edge
;
1998 switch (id
->transform_call_graph_edges
)
2000 case CB_CGE_DUPLICATE
:
2001 edge
= id
->src_node
->get_edge (orig_stmt
);
2004 int edge_freq
= edge
->frequency
;
2006 struct cgraph_edge
*old_edge
= edge
;
2007 edge
= edge
->clone (id
->dst_node
, call_stmt
,
2009 profile_count::one (),
2010 profile_count::one (),
2013 /* We could also just rescale the frequency, but
2014 doing so would introduce roundoff errors and make
2015 verifier unhappy. */
2016 new_freq
= compute_call_stmt_bb_frequency (id
->dst_node
->decl
,
2019 /* Speculative calls consist of two edges - direct and indirect.
2020 Duplicate the whole thing and distribute frequencies accordingly. */
2021 if (edge
->speculative
)
2023 struct cgraph_edge
*direct
, *indirect
;
2024 struct ipa_ref
*ref
;
2026 gcc_assert (!edge
->indirect_unknown_callee
);
2027 old_edge
->speculative_call_info (direct
, indirect
, ref
);
2028 indirect
= indirect
->clone (id
->dst_node
, call_stmt
,
2030 profile_count::one (),
2031 profile_count::one (),
2034 if (old_edge
->frequency
+ indirect
->frequency
)
2036 edge
->frequency
= MIN (RDIV ((gcov_type
)new_freq
* old_edge
->frequency
,
2037 (old_edge
->frequency
+ indirect
->frequency
)),
2039 indirect
->frequency
= MIN (RDIV ((gcov_type
)new_freq
* indirect
->frequency
,
2040 (old_edge
->frequency
+ indirect
->frequency
)),
2043 id
->dst_node
->clone_reference (ref
, stmt
);
2047 edge
->frequency
= new_freq
;
2049 && profile_status_for_fn (cfun
) != PROFILE_ABSENT
2050 && (edge_freq
> edge
->frequency
+ 10
2051 || edge_freq
< edge
->frequency
- 10))
2053 fprintf (dump_file
, "Edge frequency estimated by "
2054 "cgraph %i diverge from inliner's estimate %i\n",
2058 "Orig bb: %i, orig bb freq %i, new bb freq %i\n",
2060 bb
->count
.to_frequency (cfun
),
2061 copy_basic_block
->count
.to_frequency (cfun
));
2067 case CB_CGE_MOVE_CLONES
:
2068 id
->dst_node
->set_call_stmt_including_clones (orig_stmt
,
2070 edge
= id
->dst_node
->get_edge (stmt
);
2074 edge
= id
->dst_node
->get_edge (orig_stmt
);
2076 edge
->set_call_stmt (call_stmt
);
2083 /* Constant propagation on argument done during inlining
2084 may create new direct call. Produce an edge for it. */
2086 || (edge
->indirect_inlining_edge
2087 && id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
))
2088 && id
->dst_node
->definition
2089 && (fn
= gimple_call_fndecl (stmt
)) != NULL
)
2091 struct cgraph_node
*dest
= cgraph_node::get_create (fn
);
2093 /* We have missing edge in the callgraph. This can happen
2094 when previous inlining turned an indirect call into a
2095 direct call by constant propagating arguments or we are
2096 producing dead clone (for further cloning). In all
2097 other cases we hit a bug (incorrect node sharing is the
2098 most common reason for missing edges). */
2099 gcc_assert (!dest
->definition
2100 || dest
->address_taken
2101 || !id
->src_node
->definition
2102 || !id
->dst_node
->definition
);
2103 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
)
2104 id
->dst_node
->create_edge_including_clones
2105 (dest
, orig_stmt
, call_stmt
, bb
->count
,
2106 compute_call_stmt_bb_frequency (id
->dst_node
->decl
,
2108 CIF_ORIGINALLY_INDIRECT_CALL
);
2110 id
->dst_node
->create_edge (dest
, call_stmt
,
2112 compute_call_stmt_bb_frequency
2113 (id
->dst_node
->decl
,
2114 copy_basic_block
))->inline_failed
2115 = CIF_ORIGINALLY_INDIRECT_CALL
;
2118 fprintf (dump_file
, "Created new direct edge to %s\n",
2123 notice_special_calls (as_a
<gcall
*> (stmt
));
2126 maybe_duplicate_eh_stmt_fn (cfun
, stmt
, id
->src_cfun
, orig_stmt
,
2127 id
->eh_map
, id
->eh_lp_nr
);
2129 gsi_next (©_gsi
);
2131 while (!gsi_end_p (copy_gsi
));
2133 copy_gsi
= gsi_last_bb (copy_basic_block
);
2136 return copy_basic_block
;
2139 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
2140 form is quite easy, since dominator relationship for old basic blocks does
2143 There is however exception where inlining might change dominator relation
2144 across EH edges from basic block within inlined functions destinating
2145 to landing pads in function we inline into.
2147 The function fills in PHI_RESULTs of such PHI nodes if they refer
2148 to gimple regs. Otherwise, the function mark PHI_RESULT of such
2149 PHI nodes for renaming. For non-gimple regs, renaming is safe: the
2150 EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
2151 set, and this means that there will be no overlapping live ranges
2152 for the underlying symbol.
2154 This might change in future if we allow redirecting of EH edges and
2155 we might want to change way build CFG pre-inlining to include
2156 all the possible edges then. */
2158 update_ssa_across_abnormal_edges (basic_block bb
, basic_block ret_bb
,
2159 bool can_throw
, bool nonlocal_goto
)
2164 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
2166 || ((basic_block
)e
->dest
->aux
)->index
== ENTRY_BLOCK
)
2172 gcc_assert (e
->flags
& EDGE_EH
);
2175 gcc_assert (!(e
->flags
& EDGE_EH
));
2177 for (si
= gsi_start_phis (e
->dest
); !gsi_end_p (si
); gsi_next (&si
))
2183 /* For abnormal goto/call edges the receiver can be the
2184 ENTRY_BLOCK. Do not assert this cannot happen. */
2186 gcc_assert ((e
->flags
& EDGE_EH
)
2187 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi
)));
2189 re
= find_edge (ret_bb
, e
->dest
);
2190 gcc_checking_assert (re
);
2191 gcc_assert ((re
->flags
& (EDGE_EH
| EDGE_ABNORMAL
))
2192 == (e
->flags
& (EDGE_EH
| EDGE_ABNORMAL
)));
2194 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, e
),
2195 USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, re
)));
2201 /* Copy edges from BB into its copy constructed earlier, scale profile
2202 accordingly. Edges will be taken care of later. Assume aux
2203 pointers to point to the copies of each BB. Return true if any
2204 debug stmts are left after a statement that must end the basic block. */
2207 copy_edges_for_bb (basic_block bb
,
2208 basic_block ret_bb
, basic_block abnormal_goto_dest
)
2210 basic_block new_bb
= (basic_block
) bb
->aux
;
2213 gimple_stmt_iterator si
;
2215 bool need_debug_cleanup
= false;
2217 /* Use the indices from the original blocks to create edges for the
2219 FOR_EACH_EDGE (old_edge
, ei
, bb
->succs
)
2220 if (!(old_edge
->flags
& EDGE_EH
))
2224 flags
= old_edge
->flags
;
2226 /* Return edges do get a FALLTHRU flag when the get inlined. */
2227 if (old_edge
->dest
->index
== EXIT_BLOCK
2228 && !(old_edge
->flags
& (EDGE_TRUE_VALUE
|EDGE_FALSE_VALUE
|EDGE_FAKE
))
2229 && old_edge
->dest
->aux
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
2230 flags
|= EDGE_FALLTHRU
;
2231 new_edge
= make_edge (new_bb
, (basic_block
) old_edge
->dest
->aux
, flags
);
2232 new_edge
->probability
= old_edge
->probability
;
2235 if (bb
->index
== ENTRY_BLOCK
|| bb
->index
== EXIT_BLOCK
)
2238 for (si
= gsi_start_bb (new_bb
); !gsi_end_p (si
);)
2241 bool can_throw
, nonlocal_goto
;
2243 copy_stmt
= gsi_stmt (si
);
2244 if (!is_gimple_debug (copy_stmt
))
2245 update_stmt (copy_stmt
);
2247 /* Do this before the possible split_block. */
2250 /* If this tree could throw an exception, there are two
2251 cases where we need to add abnormal edge(s): the
2252 tree wasn't in a region and there is a "current
2253 region" in the caller; or the original tree had
2254 EH edges. In both cases split the block after the tree,
2255 and add abnormal edge(s) as needed; we need both
2256 those from the callee and the caller.
2257 We check whether the copy can throw, because the const
2258 propagation can change an INDIRECT_REF which throws
2259 into a COMPONENT_REF which doesn't. If the copy
2260 can throw, the original could also throw. */
2261 can_throw
= stmt_can_throw_internal (copy_stmt
);
2263 = (stmt_can_make_abnormal_goto (copy_stmt
)
2264 && !computed_goto_p (copy_stmt
));
2266 if (can_throw
|| nonlocal_goto
)
2268 if (!gsi_end_p (si
))
2270 while (!gsi_end_p (si
) && is_gimple_debug (gsi_stmt (si
)))
2273 need_debug_cleanup
= true;
2275 if (!gsi_end_p (si
))
2276 /* Note that bb's predecessor edges aren't necessarily
2277 right at this point; split_block doesn't care. */
2279 edge e
= split_block (new_bb
, copy_stmt
);
2282 new_bb
->aux
= e
->src
->aux
;
2283 si
= gsi_start_bb (new_bb
);
2287 bool update_probs
= false;
2289 if (gimple_code (copy_stmt
) == GIMPLE_EH_DISPATCH
)
2291 make_eh_dispatch_edges (as_a
<geh_dispatch
*> (copy_stmt
));
2292 update_probs
= true;
2296 make_eh_edges (copy_stmt
);
2297 update_probs
= true;
2300 /* EH edges may not match old edges. Copy as much as possible. */
2305 basic_block copy_stmt_bb
= gimple_bb (copy_stmt
);
2307 FOR_EACH_EDGE (old_edge
, ei
, bb
->succs
)
2308 if ((old_edge
->flags
& EDGE_EH
)
2309 && (e
= find_edge (copy_stmt_bb
,
2310 (basic_block
) old_edge
->dest
->aux
))
2311 && (e
->flags
& EDGE_EH
))
2312 e
->probability
= old_edge
->probability
;
2314 FOR_EACH_EDGE (e
, ei
, copy_stmt_bb
->succs
)
2315 if ((e
->flags
& EDGE_EH
) && !e
->probability
.initialized_p ())
2316 e
->probability
= profile_probability::never ();
2320 /* If the call we inline cannot make abnormal goto do not add
2321 additional abnormal edges but only retain those already present
2322 in the original function body. */
2323 if (abnormal_goto_dest
== NULL
)
2324 nonlocal_goto
= false;
2327 basic_block copy_stmt_bb
= gimple_bb (copy_stmt
);
2329 if (get_abnormal_succ_dispatcher (copy_stmt_bb
))
2330 nonlocal_goto
= false;
2331 /* ABNORMAL_DISPATCHER (1) is for longjmp/setjmp or nonlocal gotos
2332 in OpenMP regions which aren't allowed to be left abnormally.
2333 So, no need to add abnormal edge in that case. */
2334 else if (is_gimple_call (copy_stmt
)
2335 && gimple_call_internal_p (copy_stmt
)
2336 && (gimple_call_internal_fn (copy_stmt
)
2337 == IFN_ABNORMAL_DISPATCHER
)
2338 && gimple_call_arg (copy_stmt
, 0) == boolean_true_node
)
2339 nonlocal_goto
= false;
2341 make_single_succ_edge (copy_stmt_bb
, abnormal_goto_dest
,
2345 if ((can_throw
|| nonlocal_goto
)
2346 && gimple_in_ssa_p (cfun
))
2347 update_ssa_across_abnormal_edges (gimple_bb (copy_stmt
), ret_bb
,
2348 can_throw
, nonlocal_goto
);
2350 return need_debug_cleanup
;
2353 /* Copy the PHIs. All blocks and edges are copied, some blocks
2354 was possibly split and new outgoing EH edges inserted.
2355 BB points to the block of original function and AUX pointers links
2356 the original and newly copied blocks. */
2359 copy_phis_for_bb (basic_block bb
, copy_body_data
*id
)
2361 basic_block
const new_bb
= (basic_block
) bb
->aux
;
2366 bool inserted
= false;
2368 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
2374 res
= PHI_RESULT (phi
);
2376 if (!virtual_operand_p (res
))
2378 walk_tree (&new_res
, copy_tree_body_r
, id
, NULL
);
2379 if (EDGE_COUNT (new_bb
->preds
) == 0)
2381 /* Technically we'd want a SSA_DEFAULT_DEF here... */
2382 SSA_NAME_DEF_STMT (new_res
) = gimple_build_nop ();
2386 new_phi
= create_phi_node (new_res
, new_bb
);
2387 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2389 edge old_edge
= find_edge ((basic_block
) new_edge
->src
->aux
,
2396 /* When doing partial cloning, we allow PHIs on the entry
2397 block as long as all the arguments are the same.
2398 Find any input edge to see argument to copy. */
2400 FOR_EACH_EDGE (old_edge
, ei2
, bb
->preds
)
2401 if (!old_edge
->src
->aux
)
2404 arg
= PHI_ARG_DEF_FROM_EDGE (phi
, old_edge
);
2406 walk_tree (&new_arg
, copy_tree_body_r
, id
, NULL
);
2407 gcc_assert (new_arg
);
2408 /* With return slot optimization we can end up with
2409 non-gimple (foo *)&this->m, fix that here. */
2410 if (TREE_CODE (new_arg
) != SSA_NAME
2411 && TREE_CODE (new_arg
) != FUNCTION_DECL
2412 && !is_gimple_val (new_arg
))
2414 gimple_seq stmts
= NULL
;
2415 new_arg
= force_gimple_operand (new_arg
, &stmts
, true,
2417 gsi_insert_seq_on_edge (new_edge
, stmts
);
2420 locus
= gimple_phi_arg_location_from_edge (phi
, old_edge
);
2421 if (LOCATION_BLOCK (locus
))
2424 n
= id
->decl_map
->get (LOCATION_BLOCK (locus
));
2426 locus
= set_block (locus
, *n
);
2429 locus
= LOCATION_LOCUS (locus
);
2431 add_phi_arg (new_phi
, new_arg
, new_edge
, locus
);
2437 /* Commit the delayed edge insertions. */
2439 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2440 gsi_commit_one_edge_insert (new_edge
, NULL
);
2444 /* Wrapper for remap_decl so it can be used as a callback. */
2447 remap_decl_1 (tree decl
, void *data
)
2449 return remap_decl (decl
, (copy_body_data
*) data
);
2452 /* Build struct function and associated datastructures for the new clone
2453 NEW_FNDECL to be build. CALLEE_FNDECL is the original. Function changes
2454 the cfun to the function of new_fndecl (and current_function_decl too). */
2457 initialize_cfun (tree new_fndecl
, tree callee_fndecl
, profile_count count
)
2459 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2461 if (!DECL_ARGUMENTS (new_fndecl
))
2462 DECL_ARGUMENTS (new_fndecl
) = DECL_ARGUMENTS (callee_fndecl
);
2463 if (!DECL_RESULT (new_fndecl
))
2464 DECL_RESULT (new_fndecl
) = DECL_RESULT (callee_fndecl
);
2466 /* Register specific tree functions. */
2467 gimple_register_cfg_hooks ();
2469 /* Get clean struct function. */
2470 push_struct_function (new_fndecl
);
2472 /* We will rebuild these, so just sanity check that they are empty. */
2473 gcc_assert (VALUE_HISTOGRAMS (cfun
) == NULL
);
2474 gcc_assert (cfun
->local_decls
== NULL
);
2475 gcc_assert (cfun
->cfg
== NULL
);
2476 gcc_assert (cfun
->decl
== new_fndecl
);
2478 /* Copy items we preserve during cloning. */
2479 cfun
->static_chain_decl
= src_cfun
->static_chain_decl
;
2480 cfun
->nonlocal_goto_save_area
= src_cfun
->nonlocal_goto_save_area
;
2481 cfun
->function_end_locus
= src_cfun
->function_end_locus
;
2482 cfun
->curr_properties
= src_cfun
->curr_properties
;
2483 cfun
->last_verified
= src_cfun
->last_verified
;
2484 cfun
->va_list_gpr_size
= src_cfun
->va_list_gpr_size
;
2485 cfun
->va_list_fpr_size
= src_cfun
->va_list_fpr_size
;
2486 cfun
->has_nonlocal_label
= src_cfun
->has_nonlocal_label
;
2487 cfun
->stdarg
= src_cfun
->stdarg
;
2488 cfun
->after_inlining
= src_cfun
->after_inlining
;
2489 cfun
->can_throw_non_call_exceptions
2490 = src_cfun
->can_throw_non_call_exceptions
;
2491 cfun
->can_delete_dead_exceptions
= src_cfun
->can_delete_dead_exceptions
;
2492 cfun
->returns_struct
= src_cfun
->returns_struct
;
2493 cfun
->returns_pcc_struct
= src_cfun
->returns_pcc_struct
;
2495 init_empty_tree_cfg ();
2497 profile_status_for_fn (cfun
) = profile_status_for_fn (src_cfun
);
2499 if (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
.initialized_p ()
2500 && count
.ipa ().initialized_p ())
2502 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
=
2503 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
.apply_scale (count
,
2504 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
);
2505 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
=
2506 EXIT_BLOCK_PTR_FOR_FN (src_cfun
)->count
.apply_scale (count
,
2507 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
);
2511 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
2512 = ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
;
2513 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
2514 = EXIT_BLOCK_PTR_FOR_FN (src_cfun
)->count
;
2517 init_eh_for_function ();
2519 if (src_cfun
->gimple_df
)
2521 init_tree_ssa (cfun
);
2522 cfun
->gimple_df
->in_ssa_p
= src_cfun
->gimple_df
->in_ssa_p
;
2523 if (cfun
->gimple_df
->in_ssa_p
)
2524 init_ssa_operands (cfun
);
2528 /* Helper function for copy_cfg_body. Move debug stmts from the end
2529 of NEW_BB to the beginning of successor basic blocks when needed. If the
2530 successor has multiple predecessors, reset them, otherwise keep
2534 maybe_move_debug_stmts_to_successors (copy_body_data
*id
, basic_block new_bb
)
2538 gimple_stmt_iterator si
= gsi_last_nondebug_bb (new_bb
);
2541 || gsi_one_before_end_p (si
)
2542 || !(stmt_can_throw_internal (gsi_stmt (si
))
2543 || stmt_can_make_abnormal_goto (gsi_stmt (si
))))
2546 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
2548 gimple_stmt_iterator ssi
= gsi_last_bb (new_bb
);
2549 gimple_stmt_iterator dsi
= gsi_after_labels (e
->dest
);
2550 while (is_gimple_debug (gsi_stmt (ssi
)))
2552 gimple
*stmt
= gsi_stmt (ssi
);
2557 /* For the last edge move the debug stmts instead of copying
2559 if (ei_one_before_end_p (ei
))
2563 if (!single_pred_p (e
->dest
) && gimple_debug_bind_p (stmt
))
2564 gimple_debug_bind_reset_value (stmt
);
2565 gsi_remove (&si
, false);
2566 gsi_insert_before (&dsi
, stmt
, GSI_SAME_STMT
);
2570 if (gimple_debug_bind_p (stmt
))
2572 var
= gimple_debug_bind_get_var (stmt
);
2573 if (single_pred_p (e
->dest
))
2575 value
= gimple_debug_bind_get_value (stmt
);
2576 value
= unshare_expr (value
);
2580 new_stmt
= gimple_build_debug_bind (var
, value
, stmt
);
2582 else if (gimple_debug_source_bind_p (stmt
))
2584 var
= gimple_debug_source_bind_get_var (stmt
);
2585 value
= gimple_debug_source_bind_get_value (stmt
);
2586 new_stmt
= gimple_build_debug_source_bind (var
, value
, stmt
);
2590 gsi_insert_before (&dsi
, new_stmt
, GSI_SAME_STMT
);
2591 id
->debug_stmts
.safe_push (new_stmt
);
2597 /* Make a copy of the sub-loops of SRC_PARENT and place them
2598 as siblings of DEST_PARENT. */
2601 copy_loops (copy_body_data
*id
,
2602 struct loop
*dest_parent
, struct loop
*src_parent
)
2604 struct loop
*src_loop
= src_parent
->inner
;
2607 if (!id
->blocks_to_copy
2608 || bitmap_bit_p (id
->blocks_to_copy
, src_loop
->header
->index
))
2610 struct loop
*dest_loop
= alloc_loop ();
2612 /* Assign the new loop its header and latch and associate
2613 those with the new loop. */
2614 dest_loop
->header
= (basic_block
)src_loop
->header
->aux
;
2615 dest_loop
->header
->loop_father
= dest_loop
;
2616 if (src_loop
->latch
!= NULL
)
2618 dest_loop
->latch
= (basic_block
)src_loop
->latch
->aux
;
2619 dest_loop
->latch
->loop_father
= dest_loop
;
2622 /* Copy loop meta-data. */
2623 copy_loop_info (src_loop
, dest_loop
);
2625 /* Finally place it into the loop array and the loop tree. */
2626 place_new_loop (cfun
, dest_loop
);
2627 flow_loop_tree_node_add (dest_parent
, dest_loop
);
2629 dest_loop
->safelen
= src_loop
->safelen
;
2630 dest_loop
->dont_vectorize
= src_loop
->dont_vectorize
;
2631 if (src_loop
->force_vectorize
)
2633 dest_loop
->force_vectorize
= true;
2634 cfun
->has_force_vectorize_loops
= true;
2636 if (src_loop
->simduid
)
2638 dest_loop
->simduid
= remap_decl (src_loop
->simduid
, id
);
2639 cfun
->has_simduid_loops
= true;
2643 copy_loops (id
, dest_loop
, src_loop
);
2645 src_loop
= src_loop
->next
;
2649 /* Call cgraph_redirect_edge_call_stmt_to_callee on all calls in BB */
2652 redirect_all_calls (copy_body_data
* id
, basic_block bb
)
2654 gimple_stmt_iterator si
;
2655 gimple
*last
= last_stmt (bb
);
2656 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
2658 gimple
*stmt
= gsi_stmt (si
);
2659 if (is_gimple_call (stmt
))
2661 struct cgraph_edge
*edge
= id
->dst_node
->get_edge (stmt
);
2664 edge
->redirect_call_stmt_to_callee ();
2665 if (stmt
== last
&& id
->call_stmt
&& maybe_clean_eh_stmt (stmt
))
2666 gimple_purge_dead_eh_edges (bb
);
2672 /* Make a copy of the body of FN so that it can be inserted inline in
2673 another function. Walks FN via CFG, returns new fndecl. */
2676 copy_cfg_body (copy_body_data
* id
, profile_count
,
2677 basic_block entry_block_map
, basic_block exit_block_map
,
2678 basic_block new_entry
)
2680 tree callee_fndecl
= id
->src_fn
;
2681 /* Original cfun for the callee, doesn't change. */
2682 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2683 struct function
*cfun_to_copy
;
2685 tree new_fndecl
= NULL
;
2686 bool need_debug_cleanup
= false;
2688 profile_count den
= ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
;
2689 profile_count num
= entry_block_map
->count
;
2691 profile_count::adjust_for_ipa_scaling (&num
, &den
);
2693 cfun_to_copy
= id
->src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2695 /* Register specific tree functions. */
2696 gimple_register_cfg_hooks ();
2698 /* If we are inlining just region of the function, make sure to connect
2699 new entry to ENTRY_BLOCK_PTR_FOR_FN (cfun). Since new entry can be
2700 part of loop, we must compute frequency and probability of
2701 ENTRY_BLOCK_PTR_FOR_FN (cfun) based on the frequencies and
2702 probabilities of edges incoming from nonduplicated region. */
2707 den
= profile_count::zero ();
2709 FOR_EACH_EDGE (e
, ei
, new_entry
->preds
)
2712 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= den
;
2715 /* Must have a CFG here at this point. */
2716 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN
2717 (DECL_STRUCT_FUNCTION (callee_fndecl
)));
2720 ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy
)->aux
= entry_block_map
;
2721 EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy
)->aux
= exit_block_map
;
2722 entry_block_map
->aux
= ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy
);
2723 exit_block_map
->aux
= EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy
);
2725 /* Duplicate any exception-handling regions. */
2727 id
->eh_map
= duplicate_eh_regions (cfun_to_copy
, NULL
, id
->eh_lp_nr
,
2730 /* Use aux pointers to map the original blocks to copy. */
2731 FOR_EACH_BB_FN (bb
, cfun_to_copy
)
2732 if (!id
->blocks_to_copy
|| bitmap_bit_p (id
->blocks_to_copy
, bb
->index
))
2734 basic_block new_bb
= copy_bb (id
, bb
, num
, den
);
2737 new_bb
->loop_father
= entry_block_map
->loop_father
;
2740 last
= last_basic_block_for_fn (cfun
);
2742 /* Now that we've duplicated the blocks, duplicate their edges. */
2743 basic_block abnormal_goto_dest
= NULL
;
2745 && stmt_can_make_abnormal_goto (id
->call_stmt
))
2747 gimple_stmt_iterator gsi
= gsi_for_stmt (id
->call_stmt
);
2749 bb
= gimple_bb (id
->call_stmt
);
2751 if (gsi_end_p (gsi
))
2752 abnormal_goto_dest
= get_abnormal_succ_dispatcher (bb
);
2754 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2755 if (!id
->blocks_to_copy
2756 || (bb
->index
> 0 && bitmap_bit_p (id
->blocks_to_copy
, bb
->index
)))
2757 need_debug_cleanup
|= copy_edges_for_bb (bb
, exit_block_map
,
2758 abnormal_goto_dest
);
2762 edge e
= make_edge (entry_block_map
, (basic_block
)new_entry
->aux
, EDGE_FALLTHRU
);
2763 e
->probability
= profile_probability::always ();
2766 /* Duplicate the loop tree, if available and wanted. */
2767 if (loops_for_fn (src_cfun
) != NULL
2768 && current_loops
!= NULL
)
2770 copy_loops (id
, entry_block_map
->loop_father
,
2771 get_loop (src_cfun
, 0));
2772 /* Defer to cfgcleanup to update loop-father fields of basic-blocks. */
2773 loops_state_set (LOOPS_NEED_FIXUP
);
2776 /* If the loop tree in the source function needed fixup, mark the
2777 destination loop tree for fixup, too. */
2778 if (loops_for_fn (src_cfun
)->state
& LOOPS_NEED_FIXUP
)
2779 loops_state_set (LOOPS_NEED_FIXUP
);
2781 if (gimple_in_ssa_p (cfun
))
2782 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2783 if (!id
->blocks_to_copy
2784 || (bb
->index
> 0 && bitmap_bit_p (id
->blocks_to_copy
, bb
->index
)))
2785 copy_phis_for_bb (bb
, id
);
2787 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2790 if (need_debug_cleanup
2791 && bb
->index
!= ENTRY_BLOCK
2792 && bb
->index
!= EXIT_BLOCK
)
2793 maybe_move_debug_stmts_to_successors (id
, (basic_block
) bb
->aux
);
2794 /* Update call edge destinations. This can not be done before loop
2795 info is updated, because we may split basic blocks. */
2796 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
2797 && bb
->index
!= ENTRY_BLOCK
2798 && bb
->index
!= EXIT_BLOCK
)
2799 redirect_all_calls (id
, (basic_block
)bb
->aux
);
2800 ((basic_block
)bb
->aux
)->aux
= NULL
;
2804 /* Zero out AUX fields of newly created block during EH edge
2806 for (; last
< last_basic_block_for_fn (cfun
); last
++)
2808 if (need_debug_cleanup
)
2809 maybe_move_debug_stmts_to_successors (id
,
2810 BASIC_BLOCK_FOR_FN (cfun
, last
));
2811 BASIC_BLOCK_FOR_FN (cfun
, last
)->aux
= NULL
;
2812 /* Update call edge destinations. This can not be done before loop
2813 info is updated, because we may split basic blocks. */
2814 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
)
2815 redirect_all_calls (id
, BASIC_BLOCK_FOR_FN (cfun
, last
));
2817 entry_block_map
->aux
= NULL
;
2818 exit_block_map
->aux
= NULL
;
2825 if (id
->dependence_map
)
2827 delete id
->dependence_map
;
2828 id
->dependence_map
= NULL
;
2834 /* Copy the debug STMT using ID. We deal with these statements in a
2835 special way: if any variable in their VALUE expression wasn't
2836 remapped yet, we won't remap it, because that would get decl uids
2837 out of sync, causing codegen differences between -g and -g0. If
2838 this arises, we drop the VALUE expression altogether. */
2841 copy_debug_stmt (gdebug
*stmt
, copy_body_data
*id
)
2844 struct walk_stmt_info wi
;
2846 if (gimple_block (stmt
))
2848 n
= id
->decl_map
->get (gimple_block (stmt
));
2849 gimple_set_block (stmt
, n
? *n
: id
->block
);
2852 /* Remap all the operands in COPY. */
2853 memset (&wi
, 0, sizeof (wi
));
2856 processing_debug_stmt
= 1;
2858 if (gimple_debug_source_bind_p (stmt
))
2859 t
= gimple_debug_source_bind_get_var (stmt
);
2861 t
= gimple_debug_bind_get_var (stmt
);
2863 if (TREE_CODE (t
) == PARM_DECL
&& id
->debug_map
2864 && (n
= id
->debug_map
->get (t
)))
2866 gcc_assert (VAR_P (*n
));
2869 else if (VAR_P (t
) && !is_global_var (t
) && !id
->decl_map
->get (t
))
2870 /* T is a non-localized variable. */;
2872 walk_tree (&t
, remap_gimple_op_r
, &wi
, NULL
);
2874 if (gimple_debug_bind_p (stmt
))
2876 gimple_debug_bind_set_var (stmt
, t
);
2878 if (gimple_debug_bind_has_value_p (stmt
))
2879 walk_tree (gimple_debug_bind_get_value_ptr (stmt
),
2880 remap_gimple_op_r
, &wi
, NULL
);
2882 /* Punt if any decl couldn't be remapped. */
2883 if (processing_debug_stmt
< 0)
2884 gimple_debug_bind_reset_value (stmt
);
2886 else if (gimple_debug_source_bind_p (stmt
))
2888 gimple_debug_source_bind_set_var (stmt
, t
);
2889 /* When inlining and source bind refers to one of the optimized
2890 away parameters, change the source bind into normal debug bind
2891 referring to the corresponding DEBUG_EXPR_DECL that should have
2892 been bound before the call stmt. */
2893 t
= gimple_debug_source_bind_get_value (stmt
);
2895 && TREE_CODE (t
) == PARM_DECL
2898 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (id
->src_fn
);
2900 if (debug_args
!= NULL
)
2902 for (i
= 0; i
< vec_safe_length (*debug_args
); i
+= 2)
2903 if ((**debug_args
)[i
] == DECL_ORIGIN (t
)
2904 && TREE_CODE ((**debug_args
)[i
+ 1]) == DEBUG_EXPR_DECL
)
2906 t
= (**debug_args
)[i
+ 1];
2907 stmt
->subcode
= GIMPLE_DEBUG_BIND
;
2908 gimple_debug_bind_set_value (stmt
, t
);
2913 if (gimple_debug_source_bind_p (stmt
))
2914 walk_tree (gimple_debug_source_bind_get_value_ptr (stmt
),
2915 remap_gimple_op_r
, &wi
, NULL
);
2918 processing_debug_stmt
= 0;
2923 /* Process deferred debug stmts. In order to give values better odds
2924 of being successfully remapped, we delay the processing of debug
2925 stmts until all other stmts that might require remapping are
2929 copy_debug_stmts (copy_body_data
*id
)
2934 if (!id
->debug_stmts
.exists ())
2937 FOR_EACH_VEC_ELT (id
->debug_stmts
, i
, stmt
)
2938 copy_debug_stmt (stmt
, id
);
2940 id
->debug_stmts
.release ();
2943 /* Make a copy of the body of SRC_FN so that it can be inserted inline in
2944 another function. */
2947 copy_tree_body (copy_body_data
*id
)
2949 tree fndecl
= id
->src_fn
;
2950 tree body
= DECL_SAVED_TREE (fndecl
);
2952 walk_tree (&body
, copy_tree_body_r
, id
, NULL
);
2957 /* Make a copy of the body of FN so that it can be inserted inline in
2958 another function. */
2961 copy_body (copy_body_data
*id
, profile_count count
,
2962 basic_block entry_block_map
, basic_block exit_block_map
,
2963 basic_block new_entry
)
2965 tree fndecl
= id
->src_fn
;
2968 /* If this body has a CFG, walk CFG and copy. */
2969 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (fndecl
)));
2970 body
= copy_cfg_body (id
, count
, entry_block_map
, exit_block_map
,
2972 copy_debug_stmts (id
);
2977 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
2978 defined in function FN, or of a data member thereof. */
2981 self_inlining_addr_expr (tree value
, tree fn
)
2985 if (TREE_CODE (value
) != ADDR_EXPR
)
2988 var
= get_base_address (TREE_OPERAND (value
, 0));
2990 return var
&& auto_var_in_fn_p (var
, fn
);
2993 /* Append to BB a debug annotation that binds VAR to VALUE, inheriting
2994 lexical block and line number information from base_stmt, if given,
2995 or from the last stmt of the block otherwise. */
2998 insert_init_debug_bind (copy_body_data
*id
,
2999 basic_block bb
, tree var
, tree value
,
3003 gimple_stmt_iterator gsi
;
3006 if (!gimple_in_ssa_p (id
->src_cfun
))
3009 if (!opt_for_fn (id
->dst_fn
, flag_var_tracking_assignments
))
3012 tracked_var
= target_for_debug_bind (var
);
3018 gsi
= gsi_last_bb (bb
);
3019 if (!base_stmt
&& !gsi_end_p (gsi
))
3020 base_stmt
= gsi_stmt (gsi
);
3023 note
= gimple_build_debug_bind (tracked_var
, unshare_expr (value
), base_stmt
);
3027 if (!gsi_end_p (gsi
))
3028 gsi_insert_after (&gsi
, note
, GSI_SAME_STMT
);
3030 gsi_insert_before (&gsi
, note
, GSI_SAME_STMT
);
3037 insert_init_stmt (copy_body_data
*id
, basic_block bb
, gimple
*init_stmt
)
3039 /* If VAR represents a zero-sized variable, it's possible that the
3040 assignment statement may result in no gimple statements. */
3043 gimple_stmt_iterator si
= gsi_last_bb (bb
);
3045 /* We can end up with init statements that store to a non-register
3046 from a rhs with a conversion. Handle that here by forcing the
3047 rhs into a temporary. gimple_regimplify_operands is not
3048 prepared to do this for us. */
3049 if (!is_gimple_debug (init_stmt
)
3050 && !is_gimple_reg (gimple_assign_lhs (init_stmt
))
3051 && is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (init_stmt
)))
3052 && gimple_assign_rhs_class (init_stmt
) == GIMPLE_UNARY_RHS
)
3054 tree rhs
= build1 (gimple_assign_rhs_code (init_stmt
),
3055 gimple_expr_type (init_stmt
),
3056 gimple_assign_rhs1 (init_stmt
));
3057 rhs
= force_gimple_operand_gsi (&si
, rhs
, true, NULL_TREE
, false,
3059 gimple_assign_set_rhs_code (init_stmt
, TREE_CODE (rhs
));
3060 gimple_assign_set_rhs1 (init_stmt
, rhs
);
3062 gsi_insert_after (&si
, init_stmt
, GSI_NEW_STMT
);
3063 gimple_regimplify_operands (init_stmt
, &si
);
3065 if (!is_gimple_debug (init_stmt
))
3067 tree def
= gimple_assign_lhs (init_stmt
);
3068 insert_init_debug_bind (id
, bb
, def
, def
, init_stmt
);
3073 /* Initialize parameter P with VALUE. If needed, produce init statement
3074 at the end of BB. When BB is NULL, we return init statement to be
3077 setup_one_parameter (copy_body_data
*id
, tree p
, tree value
, tree fn
,
3078 basic_block bb
, tree
*vars
)
3080 gimple
*init_stmt
= NULL
;
3083 tree def
= (gimple_in_ssa_p (cfun
)
3084 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
3087 && value
!= error_mark_node
3088 && !useless_type_conversion_p (TREE_TYPE (p
), TREE_TYPE (value
)))
3090 /* If we can match up types by promotion/demotion do so. */
3091 if (fold_convertible_p (TREE_TYPE (p
), value
))
3092 rhs
= fold_convert (TREE_TYPE (p
), value
);
3095 /* ??? For valid programs we should not end up here.
3096 Still if we end up with truly mismatched types here, fall back
3097 to using a VIEW_CONVERT_EXPR or a literal zero to not leak invalid
3098 GIMPLE to the following passes. */
3099 if (!is_gimple_reg_type (TREE_TYPE (value
))
3100 || TYPE_SIZE (TREE_TYPE (p
)) == TYPE_SIZE (TREE_TYPE (value
)))
3101 rhs
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (p
), value
);
3103 rhs
= build_zero_cst (TREE_TYPE (p
));
3107 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
3108 here since the type of this decl must be visible to the calling
3110 var
= copy_decl_to_var (p
, id
);
3112 /* Declare this new variable. */
3113 DECL_CHAIN (var
) = *vars
;
3116 /* Make gimplifier happy about this variable. */
3117 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
3119 /* If the parameter is never assigned to, has no SSA_NAMEs created,
3120 we would not need to create a new variable here at all, if it
3121 weren't for debug info. Still, we can just use the argument
3123 if (TREE_READONLY (p
)
3124 && !TREE_ADDRESSABLE (p
)
3125 && value
&& !TREE_SIDE_EFFECTS (value
)
3128 /* We may produce non-gimple trees by adding NOPs or introduce
3129 invalid sharing when operand is not really constant.
3130 It is not big deal to prohibit constant propagation here as
3131 we will constant propagate in DOM1 pass anyway. */
3132 if (is_gimple_min_invariant (value
)
3133 && useless_type_conversion_p (TREE_TYPE (p
),
3135 /* We have to be very careful about ADDR_EXPR. Make sure
3136 the base variable isn't a local variable of the inlined
3137 function, e.g., when doing recursive inlining, direct or
3138 mutually-recursive or whatever, which is why we don't
3139 just test whether fn == current_function_decl. */
3140 && ! self_inlining_addr_expr (value
, fn
))
3142 insert_decl_map (id
, p
, value
);
3143 insert_debug_decl_map (id
, p
, var
);
3144 return insert_init_debug_bind (id
, bb
, var
, value
, NULL
);
3148 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
3149 that way, when the PARM_DECL is encountered, it will be
3150 automatically replaced by the VAR_DECL. */
3151 insert_decl_map (id
, p
, var
);
3153 /* Even if P was TREE_READONLY, the new VAR should not be.
3154 In the original code, we would have constructed a
3155 temporary, and then the function body would have never
3156 changed the value of P. However, now, we will be
3157 constructing VAR directly. The constructor body may
3158 change its value multiple times as it is being
3159 constructed. Therefore, it must not be TREE_READONLY;
3160 the back-end assumes that TREE_READONLY variable is
3161 assigned to only once. */
3162 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p
)))
3163 TREE_READONLY (var
) = 0;
3165 /* If there is no setup required and we are in SSA, take the easy route
3166 replacing all SSA names representing the function parameter by the
3167 SSA name passed to function.
3169 We need to construct map for the variable anyway as it might be used
3170 in different SSA names when parameter is set in function.
3172 Do replacement at -O0 for const arguments replaced by constant.
3173 This is important for builtin_constant_p and other construct requiring
3174 constant argument to be visible in inlined function body. */
3175 if (gimple_in_ssa_p (cfun
) && rhs
&& def
&& is_gimple_reg (p
)
3177 || (TREE_READONLY (p
)
3178 && is_gimple_min_invariant (rhs
)))
3179 && (TREE_CODE (rhs
) == SSA_NAME
3180 || is_gimple_min_invariant (rhs
))
3181 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
3183 insert_decl_map (id
, def
, rhs
);
3184 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3187 /* If the value of argument is never used, don't care about initializing
3189 if (optimize
&& gimple_in_ssa_p (cfun
) && !def
&& is_gimple_reg (p
))
3191 gcc_assert (!value
|| !TREE_SIDE_EFFECTS (value
));
3192 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3195 /* Initialize this VAR_DECL from the equivalent argument. Convert
3196 the argument to the proper type in case it was promoted. */
3199 if (rhs
== error_mark_node
)
3201 insert_decl_map (id
, p
, var
);
3202 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3205 STRIP_USELESS_TYPE_CONVERSION (rhs
);
3207 /* If we are in SSA form properly remap the default definition
3208 or assign to a dummy SSA name if the parameter is unused and
3209 we are not optimizing. */
3210 if (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
))
3214 def
= remap_ssa_name (def
, id
);
3215 init_stmt
= gimple_build_assign (def
, rhs
);
3216 SSA_NAME_IS_DEFAULT_DEF (def
) = 0;
3217 set_ssa_default_def (cfun
, var
, NULL
);
3221 def
= make_ssa_name (var
);
3222 init_stmt
= gimple_build_assign (def
, rhs
);
3226 init_stmt
= gimple_build_assign (var
, rhs
);
3228 if (bb
&& init_stmt
)
3229 insert_init_stmt (id
, bb
, init_stmt
);
3234 /* Generate code to initialize the parameters of the function at the
3235 top of the stack in ID from the GIMPLE_CALL STMT. */
3238 initialize_inlined_parameters (copy_body_data
*id
, gimple
*stmt
,
3239 tree fn
, basic_block bb
)
3244 tree vars
= NULL_TREE
;
3245 tree static_chain
= gimple_call_chain (stmt
);
3247 /* Figure out what the parameters are. */
3248 parms
= DECL_ARGUMENTS (fn
);
3250 /* Loop through the parameter declarations, replacing each with an
3251 equivalent VAR_DECL, appropriately initialized. */
3252 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
3255 val
= i
< gimple_call_num_args (stmt
) ? gimple_call_arg (stmt
, i
) : NULL
;
3256 setup_one_parameter (id
, p
, val
, fn
, bb
, &vars
);
3258 /* After remapping parameters remap their types. This has to be done
3259 in a second loop over all parameters to appropriately remap
3260 variable sized arrays when the size is specified in a
3261 parameter following the array. */
3262 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
3264 tree
*varp
= id
->decl_map
->get (p
);
3265 if (varp
&& VAR_P (*varp
))
3267 tree def
= (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
)
3268 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
3270 TREE_TYPE (var
) = remap_type (TREE_TYPE (var
), id
);
3271 /* Also remap the default definition if it was remapped
3272 to the default definition of the parameter replacement
3273 by the parameter setup. */
3276 tree
*defp
= id
->decl_map
->get (def
);
3278 && TREE_CODE (*defp
) == SSA_NAME
3279 && SSA_NAME_VAR (*defp
) == var
)
3280 TREE_TYPE (*defp
) = TREE_TYPE (var
);
3285 /* Initialize the static chain. */
3286 p
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
3287 gcc_assert (fn
!= current_function_decl
);
3290 /* No static chain? Seems like a bug in tree-nested.c. */
3291 gcc_assert (static_chain
);
3293 setup_one_parameter (id
, p
, static_chain
, fn
, bb
, &vars
);
3296 declare_inline_vars (id
->block
, vars
);
3300 /* Declare a return variable to replace the RESULT_DECL for the
3301 function we are calling. An appropriate DECL_STMT is returned.
3302 The USE_STMT is filled to contain a use of the declaration to
3303 indicate the return value of the function.
3305 RETURN_SLOT, if non-null is place where to store the result. It
3306 is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null,
3307 was the LHS of the MODIFY_EXPR to which this call is the RHS.
3309 RETURN_BOUNDS holds a destination for returned bounds.
3311 The return value is a (possibly null) value that holds the result
3312 as seen by the caller. */
3315 declare_return_variable (copy_body_data
*id
, tree return_slot
, tree modify_dest
,
3316 tree return_bounds
, basic_block entry_bb
)
3318 tree callee
= id
->src_fn
;
3319 tree result
= DECL_RESULT (callee
);
3320 tree callee_type
= TREE_TYPE (result
);
3324 /* Handle type-mismatches in the function declaration return type
3325 vs. the call expression. */
3327 caller_type
= TREE_TYPE (modify_dest
);
3329 caller_type
= TREE_TYPE (TREE_TYPE (callee
));
3331 /* We don't need to do anything for functions that don't return anything. */
3332 if (VOID_TYPE_P (callee_type
))
3335 /* If there was a return slot, then the return value is the
3336 dereferenced address of that object. */
3339 /* The front end shouldn't have used both return_slot and
3340 a modify expression. */
3341 gcc_assert (!modify_dest
);
3342 if (DECL_BY_REFERENCE (result
))
3344 tree return_slot_addr
= build_fold_addr_expr (return_slot
);
3345 STRIP_USELESS_TYPE_CONVERSION (return_slot_addr
);
3347 /* We are going to construct *&return_slot and we can't do that
3348 for variables believed to be not addressable.
3350 FIXME: This check possibly can match, because values returned
3351 via return slot optimization are not believed to have address
3352 taken by alias analysis. */
3353 gcc_assert (TREE_CODE (return_slot
) != SSA_NAME
);
3354 var
= return_slot_addr
;
3359 gcc_assert (TREE_CODE (var
) != SSA_NAME
);
3360 if (TREE_ADDRESSABLE (result
))
3361 mark_addressable (var
);
3363 if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
3364 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
3365 && !DECL_GIMPLE_REG_P (result
)
3367 DECL_GIMPLE_REG_P (var
) = 0;
3372 /* All types requiring non-trivial constructors should have been handled. */
3373 gcc_assert (!TREE_ADDRESSABLE (callee_type
));
3375 /* Attempt to avoid creating a new temporary variable. */
3377 && TREE_CODE (modify_dest
) != SSA_NAME
)
3379 bool use_it
= false;
3381 /* We can't use MODIFY_DEST if there's type promotion involved. */
3382 if (!useless_type_conversion_p (callee_type
, caller_type
))
3385 /* ??? If we're assigning to a variable sized type, then we must
3386 reuse the destination variable, because we've no good way to
3387 create variable sized temporaries at this point. */
3388 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type
)) != INTEGER_CST
)
3391 /* If the callee cannot possibly modify MODIFY_DEST, then we can
3392 reuse it as the result of the call directly. Don't do this if
3393 it would promote MODIFY_DEST to addressable. */
3394 else if (TREE_ADDRESSABLE (result
))
3398 tree base_m
= get_base_address (modify_dest
);
3400 /* If the base isn't a decl, then it's a pointer, and we don't
3401 know where that's going to go. */
3402 if (!DECL_P (base_m
))
3404 else if (is_global_var (base_m
))
3406 else if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
3407 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
3408 && !DECL_GIMPLE_REG_P (result
)
3409 && DECL_GIMPLE_REG_P (base_m
))
3411 else if (!TREE_ADDRESSABLE (base_m
))
3423 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type
)) == INTEGER_CST
);
3425 var
= copy_result_decl_to_var (result
, id
);
3426 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
3428 /* Do not have the rest of GCC warn about this variable as it should
3429 not be visible to the user. */
3430 TREE_NO_WARNING (var
) = 1;
3432 declare_inline_vars (id
->block
, var
);
3434 /* Build the use expr. If the return type of the function was
3435 promoted, convert it back to the expected type. */
3437 if (!useless_type_conversion_p (caller_type
, TREE_TYPE (var
)))
3439 /* If we can match up types by promotion/demotion do so. */
3440 if (fold_convertible_p (caller_type
, var
))
3441 use
= fold_convert (caller_type
, var
);
3444 /* ??? For valid programs we should not end up here.
3445 Still if we end up with truly mismatched types here, fall back
3446 to using a MEM_REF to not leak invalid GIMPLE to the following
3448 /* Prevent var from being written into SSA form. */
3449 if (TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
3450 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
)
3451 DECL_GIMPLE_REG_P (var
) = false;
3452 else if (is_gimple_reg_type (TREE_TYPE (var
)))
3453 TREE_ADDRESSABLE (var
) = true;
3454 use
= fold_build2 (MEM_REF
, caller_type
,
3455 build_fold_addr_expr (var
),
3456 build_int_cst (ptr_type_node
, 0));
3460 STRIP_USELESS_TYPE_CONVERSION (use
);
3462 if (DECL_BY_REFERENCE (result
))
3464 TREE_ADDRESSABLE (var
) = 1;
3465 var
= build_fold_addr_expr (var
);
3469 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
3470 way, when the RESULT_DECL is encountered, it will be
3471 automatically replaced by the VAR_DECL.
3473 When returning by reference, ensure that RESULT_DECL remaps to
3475 if (DECL_BY_REFERENCE (result
)
3476 && !is_gimple_val (var
))
3478 tree temp
= create_tmp_var (TREE_TYPE (result
), "retvalptr");
3479 insert_decl_map (id
, result
, temp
);
3480 /* When RESULT_DECL is in SSA form, we need to remap and initialize
3481 it's default_def SSA_NAME. */
3482 if (gimple_in_ssa_p (id
->src_cfun
)
3483 && is_gimple_reg (result
))
3485 temp
= make_ssa_name (temp
);
3486 insert_decl_map (id
, ssa_default_def (id
->src_cfun
, result
), temp
);
3488 insert_init_stmt (id
, entry_bb
, gimple_build_assign (temp
, var
));
3491 insert_decl_map (id
, result
, var
);
3493 /* Remember this so we can ignore it in remap_decls. */
3496 /* If returned bounds are used, then make var for them. */
3499 tree bndtemp
= create_tmp_var (pointer_bounds_type_node
, "retbnd");
3500 DECL_SEEN_IN_BIND_EXPR_P (bndtemp
) = 1;
3501 TREE_NO_WARNING (bndtemp
) = 1;
3502 declare_inline_vars (id
->block
, bndtemp
);
3504 id
->retbnd
= bndtemp
;
3505 insert_init_stmt (id
, entry_bb
,
3506 gimple_build_assign (bndtemp
, chkp_get_zero_bounds_var ()));
3512 /* Determine if the function can be copied. If so return NULL. If
3513 not return a string describng the reason for failure. */
3516 copy_forbidden (struct function
*fun
)
3518 const char *reason
= fun
->cannot_be_copied_reason
;
3520 /* Only examine the function once. */
3521 if (fun
->cannot_be_copied_set
)
3524 /* We cannot copy a function that receives a non-local goto
3525 because we cannot remap the destination label used in the
3526 function that is performing the non-local goto. */
3527 /* ??? Actually, this should be possible, if we work at it.
3528 No doubt there's just a handful of places that simply
3529 assume it doesn't happen and don't substitute properly. */
3530 if (fun
->has_nonlocal_label
)
3532 reason
= G_("function %q+F can never be copied "
3533 "because it receives a non-local goto");
3537 if (fun
->has_forced_label_in_static
)
3539 reason
= G_("function %q+F can never be copied because it saves "
3540 "address of local label in a static variable");
3545 fun
->cannot_be_copied_reason
= reason
;
3546 fun
->cannot_be_copied_set
= true;
3551 static const char *inline_forbidden_reason
;
3553 /* A callback for walk_gimple_seq to handle statements. Returns non-null
3554 iff a function can not be inlined. Also sets the reason why. */
3557 inline_forbidden_p_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
3558 struct walk_stmt_info
*wip
)
3560 tree fn
= (tree
) wip
->info
;
3562 gimple
*stmt
= gsi_stmt (*gsi
);
3564 switch (gimple_code (stmt
))
3567 /* Refuse to inline alloca call unless user explicitly forced so as
3568 this may change program's memory overhead drastically when the
3569 function using alloca is called in loop. In GCC present in
3570 SPEC2000 inlining into schedule_block cause it to require 2GB of
3571 RAM instead of 256MB. Don't do so for alloca calls emitted for
3572 VLA objects as those can't cause unbounded growth (they're always
3573 wrapped inside stack_save/stack_restore regions. */
3574 if (gimple_maybe_alloca_call_p (stmt
)
3575 && !gimple_call_alloca_for_var_p (as_a
<gcall
*> (stmt
))
3576 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
3578 inline_forbidden_reason
3579 = G_("function %q+F can never be inlined because it uses "
3580 "alloca (override using the always_inline attribute)");
3581 *handled_ops_p
= true;
3585 t
= gimple_call_fndecl (stmt
);
3589 /* We cannot inline functions that call setjmp. */
3590 if (setjmp_call_p (t
))
3592 inline_forbidden_reason
3593 = G_("function %q+F can never be inlined because it uses setjmp");
3594 *handled_ops_p
= true;
3598 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
3599 switch (DECL_FUNCTION_CODE (t
))
3601 /* We cannot inline functions that take a variable number of
3603 case BUILT_IN_VA_START
:
3604 case BUILT_IN_NEXT_ARG
:
3605 case BUILT_IN_VA_END
:
3606 inline_forbidden_reason
3607 = G_("function %q+F can never be inlined because it "
3608 "uses variable argument lists");
3609 *handled_ops_p
= true;
3612 case BUILT_IN_LONGJMP
:
3613 /* We can't inline functions that call __builtin_longjmp at
3614 all. The non-local goto machinery really requires the
3615 destination be in a different function. If we allow the
3616 function calling __builtin_longjmp to be inlined into the
3617 function calling __builtin_setjmp, Things will Go Awry. */
3618 inline_forbidden_reason
3619 = G_("function %q+F can never be inlined because "
3620 "it uses setjmp-longjmp exception handling");
3621 *handled_ops_p
= true;
3624 case BUILT_IN_NONLOCAL_GOTO
:
3626 inline_forbidden_reason
3627 = G_("function %q+F can never be inlined because "
3628 "it uses non-local goto");
3629 *handled_ops_p
= true;
3632 case BUILT_IN_RETURN
:
3633 case BUILT_IN_APPLY_ARGS
:
3634 /* If a __builtin_apply_args caller would be inlined,
3635 it would be saving arguments of the function it has
3636 been inlined into. Similarly __builtin_return would
3637 return from the function the inline has been inlined into. */
3638 inline_forbidden_reason
3639 = G_("function %q+F can never be inlined because "
3640 "it uses __builtin_return or __builtin_apply_args");
3641 *handled_ops_p
= true;
3650 t
= gimple_goto_dest (stmt
);
3652 /* We will not inline a function which uses computed goto. The
3653 addresses of its local labels, which may be tucked into
3654 global storage, are of course not constant across
3655 instantiations, which causes unexpected behavior. */
3656 if (TREE_CODE (t
) != LABEL_DECL
)
3658 inline_forbidden_reason
3659 = G_("function %q+F can never be inlined "
3660 "because it contains a computed goto");
3661 *handled_ops_p
= true;
3670 *handled_ops_p
= false;
3674 /* Return true if FNDECL is a function that cannot be inlined into
3678 inline_forbidden_p (tree fndecl
)
3680 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
3681 struct walk_stmt_info wi
;
3683 bool forbidden_p
= false;
3685 /* First check for shared reasons not to copy the code. */
3686 inline_forbidden_reason
= copy_forbidden (fun
);
3687 if (inline_forbidden_reason
!= NULL
)
3690 /* Next, walk the statements of the function looking for
3691 constraucts we can't handle, or are non-optimal for inlining. */
3692 hash_set
<tree
> visited_nodes
;
3693 memset (&wi
, 0, sizeof (wi
));
3694 wi
.info
= (void *) fndecl
;
3695 wi
.pset
= &visited_nodes
;
3697 FOR_EACH_BB_FN (bb
, fun
)
3700 gimple_seq seq
= bb_seq (bb
);
3701 ret
= walk_gimple_seq (seq
, inline_forbidden_p_stmt
, NULL
, &wi
);
3702 forbidden_p
= (ret
!= NULL
);
3710 /* Return false if the function FNDECL cannot be inlined on account of its
3711 attributes, true otherwise. */
3713 function_attribute_inlinable_p (const_tree fndecl
)
3715 if (targetm
.attribute_table
)
3719 for (a
= DECL_ATTRIBUTES (fndecl
); a
; a
= TREE_CHAIN (a
))
3721 const_tree name
= TREE_PURPOSE (a
);
3724 for (i
= 0; targetm
.attribute_table
[i
].name
!= NULL
; i
++)
3725 if (is_attribute_p (targetm
.attribute_table
[i
].name
, name
))
3726 return targetm
.function_attribute_inlinable_p (fndecl
);
3733 /* Returns nonzero if FN is a function that does not have any
3734 fundamental inline blocking properties. */
3737 tree_inlinable_function_p (tree fn
)
3739 bool inlinable
= true;
3743 /* If we've already decided this function shouldn't be inlined,
3744 there's no need to check again. */
3745 if (DECL_UNINLINABLE (fn
))
3748 /* We only warn for functions declared `inline' by the user. */
3749 do_warning
= (warn_inline
3750 && DECL_DECLARED_INLINE_P (fn
)
3751 && !DECL_NO_INLINE_WARNING_P (fn
)
3752 && !DECL_IN_SYSTEM_HEADER (fn
));
3754 always_inline
= lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
));
3757 && always_inline
== NULL
)
3760 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3761 "is suppressed using -fno-inline", fn
);
3765 else if (!function_attribute_inlinable_p (fn
))
3768 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3769 "uses attributes conflicting with inlining", fn
);
3773 else if (inline_forbidden_p (fn
))
3775 /* See if we should warn about uninlinable functions. Previously,
3776 some of these warnings would be issued while trying to expand
3777 the function inline, but that would cause multiple warnings
3778 about functions that would for example call alloca. But since
3779 this a property of the function, just one warning is enough.
3780 As a bonus we can now give more details about the reason why a
3781 function is not inlinable. */
3783 error (inline_forbidden_reason
, fn
);
3784 else if (do_warning
)
3785 warning (OPT_Winline
, inline_forbidden_reason
, fn
);
3790 /* Squirrel away the result so that we don't have to check again. */
3791 DECL_UNINLINABLE (fn
) = !inlinable
;
3796 /* Estimate the cost of a memory move of type TYPE. Use machine dependent
3797 word size and take possible memcpy call into account and return
3798 cost based on whether optimizing for size or speed according to SPEED_P. */
3801 estimate_move_cost (tree type
, bool ARG_UNUSED (speed_p
))
3805 gcc_assert (!VOID_TYPE_P (type
));
3807 if (TREE_CODE (type
) == VECTOR_TYPE
)
3809 scalar_mode inner
= SCALAR_TYPE_MODE (TREE_TYPE (type
));
3811 = targetm
.vectorize
.preferred_simd_mode (inner
);
3812 int simd_mode_size
= GET_MODE_SIZE (simd
);
3813 return ((GET_MODE_SIZE (TYPE_MODE (type
)) + simd_mode_size
- 1)
3817 size
= int_size_in_bytes (type
);
3819 if (size
< 0 || size
> MOVE_MAX_PIECES
* MOVE_RATIO (speed_p
))
3820 /* Cost of a memcpy call, 3 arguments and the call. */
3823 return ((size
+ MOVE_MAX_PIECES
- 1) / MOVE_MAX_PIECES
);
3826 /* Returns cost of operation CODE, according to WEIGHTS */
3829 estimate_operator_cost (enum tree_code code
, eni_weights
*weights
,
3830 tree op1 ATTRIBUTE_UNUSED
, tree op2
)
3834 /* These are "free" conversions, or their presumed cost
3835 is folded into other operations. */
3840 case VIEW_CONVERT_EXPR
:
3843 /* Assign cost of 1 to usual operations.
3844 ??? We may consider mapping RTL costs to this. */
3850 case POINTER_PLUS_EXPR
:
3853 case MULT_HIGHPART_EXPR
:
3856 case ADDR_SPACE_CONVERT_EXPR
:
3857 case FIXED_CONVERT_EXPR
:
3858 case FIX_TRUNC_EXPR
:
3876 case TRUTH_ANDIF_EXPR
:
3877 case TRUTH_ORIF_EXPR
:
3878 case TRUTH_AND_EXPR
:
3880 case TRUTH_XOR_EXPR
:
3881 case TRUTH_NOT_EXPR
:
3890 case UNORDERED_EXPR
:
3901 case PREDECREMENT_EXPR
:
3902 case PREINCREMENT_EXPR
:
3903 case POSTDECREMENT_EXPR
:
3904 case POSTINCREMENT_EXPR
:
3906 case REALIGN_LOAD_EXPR
:
3908 case REDUC_MAX_EXPR
:
3909 case REDUC_MIN_EXPR
:
3910 case REDUC_PLUS_EXPR
:
3911 case WIDEN_SUM_EXPR
:
3912 case WIDEN_MULT_EXPR
:
3915 case WIDEN_MULT_PLUS_EXPR
:
3916 case WIDEN_MULT_MINUS_EXPR
:
3917 case WIDEN_LSHIFT_EXPR
:
3919 case VEC_WIDEN_MULT_HI_EXPR
:
3920 case VEC_WIDEN_MULT_LO_EXPR
:
3921 case VEC_WIDEN_MULT_EVEN_EXPR
:
3922 case VEC_WIDEN_MULT_ODD_EXPR
:
3923 case VEC_UNPACK_HI_EXPR
:
3924 case VEC_UNPACK_LO_EXPR
:
3925 case VEC_UNPACK_FLOAT_HI_EXPR
:
3926 case VEC_UNPACK_FLOAT_LO_EXPR
:
3927 case VEC_PACK_TRUNC_EXPR
:
3928 case VEC_PACK_SAT_EXPR
:
3929 case VEC_PACK_FIX_TRUNC_EXPR
:
3930 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3931 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3935 /* Few special cases of expensive operations. This is useful
3936 to avoid inlining on functions having too many of these. */
3937 case TRUNC_DIV_EXPR
:
3939 case FLOOR_DIV_EXPR
:
3940 case ROUND_DIV_EXPR
:
3941 case EXACT_DIV_EXPR
:
3942 case TRUNC_MOD_EXPR
:
3944 case FLOOR_MOD_EXPR
:
3945 case ROUND_MOD_EXPR
:
3947 if (TREE_CODE (op2
) != INTEGER_CST
)
3948 return weights
->div_mod_cost
;
3951 /* Bit-field insertion needs several shift and mask operations. */
3952 case BIT_INSERT_EXPR
:
3956 /* We expect a copy assignment with no operator. */
3957 gcc_assert (get_gimple_rhs_class (code
) == GIMPLE_SINGLE_RHS
);
3963 /* Estimate number of instructions that will be created by expanding
3964 the statements in the statement sequence STMTS.
3965 WEIGHTS contains weights attributed to various constructs. */
3968 estimate_num_insns_seq (gimple_seq stmts
, eni_weights
*weights
)
3971 gimple_stmt_iterator gsi
;
3974 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3975 cost
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
3981 /* Estimate number of instructions that will be created by expanding STMT.
3982 WEIGHTS contains weights attributed to various constructs. */
3985 estimate_num_insns (gimple
*stmt
, eni_weights
*weights
)
3988 enum gimple_code code
= gimple_code (stmt
);
3995 /* Try to estimate the cost of assignments. We have three cases to
3997 1) Simple assignments to registers;
3998 2) Stores to things that must live in memory. This includes
3999 "normal" stores to scalars, but also assignments of large
4000 structures, or constructors of big arrays;
4002 Let us look at the first two cases, assuming we have "a = b + C":
4003 <GIMPLE_ASSIGN <var_decl "a">
4004 <plus_expr <var_decl "b"> <constant C>>
4005 If "a" is a GIMPLE register, the assignment to it is free on almost
4006 any target, because "a" usually ends up in a real register. Hence
4007 the only cost of this expression comes from the PLUS_EXPR, and we
4008 can ignore the GIMPLE_ASSIGN.
4009 If "a" is not a GIMPLE register, the assignment to "a" will most
4010 likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost
4011 of moving something into "a", which we compute using the function
4012 estimate_move_cost. */
4013 if (gimple_clobber_p (stmt
))
4014 return 0; /* ={v} {CLOBBER} stmt expands to nothing. */
4016 lhs
= gimple_assign_lhs (stmt
);
4017 rhs
= gimple_assign_rhs1 (stmt
);
4021 /* Account for the cost of moving to / from memory. */
4022 if (gimple_store_p (stmt
))
4023 cost
+= estimate_move_cost (TREE_TYPE (lhs
), weights
->time_based
);
4024 if (gimple_assign_load_p (stmt
))
4025 cost
+= estimate_move_cost (TREE_TYPE (rhs
), weights
->time_based
);
4027 cost
+= estimate_operator_cost (gimple_assign_rhs_code (stmt
), weights
,
4028 gimple_assign_rhs1 (stmt
),
4029 get_gimple_rhs_class (gimple_assign_rhs_code (stmt
))
4030 == GIMPLE_BINARY_RHS
4031 ? gimple_assign_rhs2 (stmt
) : NULL
);
4035 cost
= 1 + estimate_operator_cost (gimple_cond_code (stmt
), weights
,
4036 gimple_op (stmt
, 0),
4037 gimple_op (stmt
, 1));
4042 gswitch
*switch_stmt
= as_a
<gswitch
*> (stmt
);
4043 /* Take into account cost of the switch + guess 2 conditional jumps for
4046 TODO: once the switch expansion logic is sufficiently separated, we can
4047 do better job on estimating cost of the switch. */
4048 if (weights
->time_based
)
4049 cost
= floor_log2 (gimple_switch_num_labels (switch_stmt
)) * 2;
4051 cost
= gimple_switch_num_labels (switch_stmt
) * 2;
4059 if (gimple_call_internal_p (stmt
))
4061 else if ((decl
= gimple_call_fndecl (stmt
))
4062 && DECL_BUILT_IN (decl
))
4064 /* Do not special case builtins where we see the body.
4065 This just confuse inliner. */
4066 struct cgraph_node
*node
;
4067 if (!(node
= cgraph_node::get (decl
))
4068 || node
->definition
)
4070 /* For buitins that are likely expanded to nothing or
4071 inlined do not account operand costs. */
4072 else if (is_simple_builtin (decl
))
4074 else if (is_inexpensive_builtin (decl
))
4075 return weights
->target_builtin_call_cost
;
4076 else if (gimple_call_builtin_p (stmt
, BUILT_IN_NORMAL
))
4078 /* We canonicalize x * x to pow (x, 2.0) with -ffast-math, so
4079 specialize the cheap expansion we do here.
4080 ??? This asks for a more general solution. */
4081 switch (DECL_FUNCTION_CODE (decl
))
4086 if (TREE_CODE (gimple_call_arg (stmt
, 1)) == REAL_CST
4088 (&TREE_REAL_CST (gimple_call_arg (stmt
, 1)),
4090 return estimate_operator_cost
4091 (MULT_EXPR
, weights
, gimple_call_arg (stmt
, 0),
4092 gimple_call_arg (stmt
, 0));
4101 cost
= decl
? weights
->call_cost
: weights
->indirect_call_cost
;
4102 if (gimple_call_lhs (stmt
))
4103 cost
+= estimate_move_cost (TREE_TYPE (gimple_call_lhs (stmt
)),
4104 weights
->time_based
);
4105 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
4107 tree arg
= gimple_call_arg (stmt
, i
);
4108 cost
+= estimate_move_cost (TREE_TYPE (arg
),
4109 weights
->time_based
);
4115 return weights
->return_cost
;
4121 case GIMPLE_PREDICT
:
4127 int count
= asm_str_count (gimple_asm_string (as_a
<gasm
*> (stmt
)));
4128 /* 1000 means infinity. This avoids overflows later
4129 with very long asm statements. */
4136 /* This is either going to be an external function call with one
4137 argument, or two register copy statements plus a goto. */
4140 case GIMPLE_EH_DISPATCH
:
4141 /* ??? This is going to turn into a switch statement. Ideally
4142 we'd have a look at the eh region and estimate the number of
4147 return estimate_num_insns_seq (
4148 gimple_bind_body (as_a
<gbind
*> (stmt
)),
4151 case GIMPLE_EH_FILTER
:
4152 return estimate_num_insns_seq (gimple_eh_filter_failure (stmt
), weights
);
4155 return estimate_num_insns_seq (gimple_catch_handler (
4156 as_a
<gcatch
*> (stmt
)),
4160 return (estimate_num_insns_seq (gimple_try_eval (stmt
), weights
)
4161 + estimate_num_insns_seq (gimple_try_cleanup (stmt
), weights
));
4163 /* OMP directives are generally very expensive. */
4165 case GIMPLE_OMP_RETURN
:
4166 case GIMPLE_OMP_SECTIONS_SWITCH
:
4167 case GIMPLE_OMP_ATOMIC_STORE
:
4168 case GIMPLE_OMP_CONTINUE
:
4169 /* ...except these, which are cheap. */
4172 case GIMPLE_OMP_ATOMIC_LOAD
:
4173 return weights
->omp_cost
;
4175 case GIMPLE_OMP_FOR
:
4176 return (weights
->omp_cost
4177 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
)
4178 + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt
), weights
));
4180 case GIMPLE_OMP_PARALLEL
:
4181 case GIMPLE_OMP_TASK
:
4182 case GIMPLE_OMP_CRITICAL
:
4183 case GIMPLE_OMP_MASTER
:
4184 case GIMPLE_OMP_TASKGROUP
:
4185 case GIMPLE_OMP_ORDERED
:
4186 case GIMPLE_OMP_SECTION
:
4187 case GIMPLE_OMP_SECTIONS
:
4188 case GIMPLE_OMP_SINGLE
:
4189 case GIMPLE_OMP_TARGET
:
4190 case GIMPLE_OMP_TEAMS
:
4191 return (weights
->omp_cost
4192 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
));
4194 case GIMPLE_TRANSACTION
:
4195 return (weights
->tm_cost
4196 + estimate_num_insns_seq (gimple_transaction_body (
4197 as_a
<gtransaction
*> (stmt
)),
4207 /* Estimate number of instructions that will be created by expanding
4208 function FNDECL. WEIGHTS contains weights attributed to various
4212 estimate_num_insns_fn (tree fndecl
, eni_weights
*weights
)
4214 struct function
*my_function
= DECL_STRUCT_FUNCTION (fndecl
);
4215 gimple_stmt_iterator bsi
;
4219 gcc_assert (my_function
&& my_function
->cfg
);
4220 FOR_EACH_BB_FN (bb
, my_function
)
4222 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
4223 n
+= estimate_num_insns (gsi_stmt (bsi
), weights
);
4230 /* Initializes weights used by estimate_num_insns. */
4233 init_inline_once (void)
4235 eni_size_weights
.call_cost
= 1;
4236 eni_size_weights
.indirect_call_cost
= 3;
4237 eni_size_weights
.target_builtin_call_cost
= 1;
4238 eni_size_weights
.div_mod_cost
= 1;
4239 eni_size_weights
.omp_cost
= 40;
4240 eni_size_weights
.tm_cost
= 10;
4241 eni_size_weights
.time_based
= false;
4242 eni_size_weights
.return_cost
= 1;
4244 /* Estimating time for call is difficult, since we have no idea what the
4245 called function does. In the current uses of eni_time_weights,
4246 underestimating the cost does less harm than overestimating it, so
4247 we choose a rather small value here. */
4248 eni_time_weights
.call_cost
= 10;
4249 eni_time_weights
.indirect_call_cost
= 15;
4250 eni_time_weights
.target_builtin_call_cost
= 1;
4251 eni_time_weights
.div_mod_cost
= 10;
4252 eni_time_weights
.omp_cost
= 40;
4253 eni_time_weights
.tm_cost
= 40;
4254 eni_time_weights
.time_based
= true;
4255 eni_time_weights
.return_cost
= 2;
4259 /* Install new lexical TREE_BLOCK underneath 'current_block'. */
4262 prepend_lexical_block (tree current_block
, tree new_block
)
4264 BLOCK_CHAIN (new_block
) = BLOCK_SUBBLOCKS (current_block
);
4265 BLOCK_SUBBLOCKS (current_block
) = new_block
;
4266 BLOCK_SUPERCONTEXT (new_block
) = current_block
;
4269 /* Add local variables from CALLEE to CALLER. */
4272 add_local_variables (struct function
*callee
, struct function
*caller
,
4278 FOR_EACH_LOCAL_DECL (callee
, ix
, var
)
4279 if (!can_be_nonlocal (var
, id
))
4281 tree new_var
= remap_decl (var
, id
);
4283 /* Remap debug-expressions. */
4285 && DECL_HAS_DEBUG_EXPR_P (var
)
4288 tree tem
= DECL_DEBUG_EXPR (var
);
4289 bool old_regimplify
= id
->regimplify
;
4290 id
->remapping_type_depth
++;
4291 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
4292 id
->remapping_type_depth
--;
4293 id
->regimplify
= old_regimplify
;
4294 SET_DECL_DEBUG_EXPR (new_var
, tem
);
4295 DECL_HAS_DEBUG_EXPR_P (new_var
) = 1;
4297 add_local_decl (caller
, new_var
);
4301 /* Add to BINDINGS a debug stmt resetting SRCVAR if inlining might
4302 have brought in or introduced any debug stmts for SRCVAR. */
4305 reset_debug_binding (copy_body_data
*id
, tree srcvar
, gimple_seq
*bindings
)
4307 tree
*remappedvarp
= id
->decl_map
->get (srcvar
);
4312 if (!VAR_P (*remappedvarp
))
4315 if (*remappedvarp
== id
->retvar
|| *remappedvarp
== id
->retbnd
)
4318 tree tvar
= target_for_debug_bind (*remappedvarp
);
4322 gdebug
*stmt
= gimple_build_debug_bind (tvar
, NULL_TREE
,
4324 gimple_seq_add_stmt (bindings
, stmt
);
4327 /* For each inlined variable for which we may have debug bind stmts,
4328 add before GSI a final debug stmt resetting it, marking the end of
4329 its life, so that var-tracking knows it doesn't have to compute
4330 further locations for it. */
4333 reset_debug_bindings (copy_body_data
*id
, gimple_stmt_iterator gsi
)
4337 gimple_seq bindings
= NULL
;
4339 if (!gimple_in_ssa_p (id
->src_cfun
))
4342 if (!opt_for_fn (id
->dst_fn
, flag_var_tracking_assignments
))
4345 for (var
= DECL_ARGUMENTS (id
->src_fn
);
4346 var
; var
= DECL_CHAIN (var
))
4347 reset_debug_binding (id
, var
, &bindings
);
4349 FOR_EACH_LOCAL_DECL (id
->src_cfun
, ix
, var
)
4350 reset_debug_binding (id
, var
, &bindings
);
4352 gsi_insert_seq_before_without_update (&gsi
, bindings
, GSI_SAME_STMT
);
4355 /* If STMT is a GIMPLE_CALL, replace it with its inline expansion. */
4358 expand_call_inline (basic_block bb
, gimple
*stmt
, copy_body_data
*id
)
4362 hash_map
<tree
, tree
> *dst
;
4363 hash_map
<tree
, tree
> *st
= NULL
;
4366 tree return_bounds
= NULL
;
4367 struct cgraph_edge
*cg_edge
;
4368 cgraph_inline_failed_t reason
;
4369 basic_block return_block
;
4371 gimple_stmt_iterator gsi
, stmt_gsi
;
4372 bool successfully_inlined
= false;
4373 bool purge_dead_abnormal_edges
;
4376 unsigned int prop_mask
, src_properties
;
4377 struct function
*dst_cfun
;
4380 gimple
*simtenter_stmt
= NULL
;
4381 vec
<tree
> *simtvars_save
;
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 profile_count 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 profile_count::one (),
4487 profile_count::one (),
4490 edge
->frequency
= freq
;
4491 edge
->count
= count
;
4492 if (id
->src_node
->thunk
.virtual_offset_p
)
4493 virtual_offset
= size_int (id
->src_node
->thunk
.virtual_value
);
4494 op
= create_tmp_reg_fn (cfun
, TREE_TYPE (gimple_call_arg (stmt
, 0)),
4496 gsi_insert_before (&iter
, gimple_build_assign (op
,
4497 gimple_call_arg (stmt
, 0)),
4499 gcc_assert (id
->src_node
->thunk
.this_adjusting
);
4500 op
= thunk_adjust (&iter
, op
, 1, id
->src_node
->thunk
.fixed_offset
,
4503 gimple_call_set_arg (stmt
, 0, op
);
4504 gimple_call_set_fndecl (stmt
, edge
->callee
->decl
);
4506 id
->src_node
->remove ();
4507 expand_call_inline (bb
, stmt
, id
);
4508 maybe_remove_unused_call_args (cfun
, stmt
);
4511 fn
= cg_edge
->callee
->decl
;
4512 cg_edge
->callee
->get_untransformed_body ();
4514 if (flag_checking
&& cg_edge
->callee
->decl
!= id
->dst_node
->decl
)
4515 cg_edge
->callee
->verify ();
4517 /* We will be inlining this callee. */
4518 id
->eh_lp_nr
= lookup_stmt_eh_lp (stmt
);
4519 id
->assign_stmts
.create (0);
4521 /* Update the callers EH personality. */
4522 if (DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->decl
))
4523 DECL_FUNCTION_PERSONALITY (cg_edge
->caller
->decl
)
4524 = DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->decl
);
4526 /* Split the block before the GIMPLE_CALL. */
4527 stmt_gsi
= gsi_for_stmt (stmt
);
4528 gsi_prev (&stmt_gsi
);
4529 e
= split_block (bb
, gsi_end_p (stmt_gsi
) ? NULL
: gsi_stmt (stmt_gsi
));
4531 return_block
= e
->dest
;
4534 /* If the GIMPLE_CALL was in the last statement of BB, it may have
4535 been the source of abnormal edges. In this case, schedule
4536 the removal of dead abnormal edges. */
4537 gsi
= gsi_start_bb (return_block
);
4539 purge_dead_abnormal_edges
= gsi_end_p (gsi
);
4541 stmt_gsi
= gsi_start_bb (return_block
);
4543 /* Build a block containing code to initialize the arguments, the
4544 actual inline expansion of the body, and a label for the return
4545 statements within the function to jump to. The type of the
4546 statement expression is the return type of the function call.
4547 ??? If the call does not have an associated block then we will
4548 remap all callee blocks to NULL, effectively dropping most of
4549 its debug information. This should only happen for calls to
4550 artificial decls inserted by the compiler itself. We need to
4551 either link the inlined blocks into the caller block tree or
4552 not refer to them in any way to not break GC for locations. */
4553 if (gimple_block (stmt
))
4555 id
->block
= make_node (BLOCK
);
4556 BLOCK_ABSTRACT_ORIGIN (id
->block
) = fn
;
4557 BLOCK_SOURCE_LOCATION (id
->block
)
4558 = LOCATION_LOCUS (gimple_location (stmt
));
4559 prepend_lexical_block (gimple_block (stmt
), id
->block
);
4562 /* Local declarations will be replaced by their equivalents in this
4565 id
->decl_map
= new hash_map
<tree
, tree
>;
4566 dst
= id
->debug_map
;
4567 id
->debug_map
= NULL
;
4569 /* Record the function we are about to inline. */
4571 id
->src_cfun
= DECL_STRUCT_FUNCTION (fn
);
4572 id
->call_stmt
= call_stmt
;
4574 /* When inlining into an OpenMP SIMD-on-SIMT loop, arrange for new automatic
4575 variables to be added to IFN_GOMP_SIMT_ENTER argument list. */
4576 dst_cfun
= DECL_STRUCT_FUNCTION (id
->dst_fn
);
4577 simtvars_save
= id
->dst_simt_vars
;
4578 if (!(dst_cfun
->curr_properties
& PROP_gimple_lomp_dev
)
4579 && (simduid
= bb
->loop_father
->simduid
) != NULL_TREE
4580 && (simduid
= ssa_default_def (dst_cfun
, simduid
)) != NULL_TREE
4581 && single_imm_use (simduid
, &use
, &simtenter_stmt
)
4582 && is_gimple_call (simtenter_stmt
)
4583 && gimple_call_internal_p (simtenter_stmt
, IFN_GOMP_SIMT_ENTER
))
4584 vec_alloc (id
->dst_simt_vars
, 0);
4586 id
->dst_simt_vars
= NULL
;
4588 if (profile_status_for_fn (id
->src_cfun
) == PROFILE_ABSENT
)
4589 profile_status_for_fn (dst_cfun
) = PROFILE_ABSENT
;
4591 /* If the src function contains an IFN_VA_ARG, then so will the dst
4592 function after inlining. Likewise for IFN_GOMP_USE_SIMT. */
4593 prop_mask
= PROP_gimple_lva
| PROP_gimple_lomp_dev
;
4594 src_properties
= id
->src_cfun
->curr_properties
& prop_mask
;
4595 if (src_properties
!= prop_mask
)
4596 dst_cfun
->curr_properties
&= src_properties
| ~prop_mask
;
4598 gcc_assert (!id
->src_cfun
->after_inlining
);
4601 if (lookup_attribute ("cold", DECL_ATTRIBUTES (fn
)))
4603 gimple_stmt_iterator si
= gsi_last_bb (bb
);
4604 gsi_insert_after (&si
, gimple_build_predict (PRED_COLD_FUNCTION
,
4608 initialize_inlined_parameters (id
, stmt
, fn
, bb
);
4610 if (DECL_INITIAL (fn
))
4612 if (gimple_block (stmt
))
4616 prepend_lexical_block (id
->block
,
4617 remap_blocks (DECL_INITIAL (fn
), id
));
4618 gcc_checking_assert (BLOCK_SUBBLOCKS (id
->block
)
4619 && (BLOCK_CHAIN (BLOCK_SUBBLOCKS (id
->block
))
4621 /* Move vars for PARM_DECLs from DECL_INITIAL block to id->block,
4622 otherwise for DWARF DW_TAG_formal_parameter will not be children of
4623 DW_TAG_inlined_subroutine, but of a DW_TAG_lexical_block
4624 under it. The parameters can be then evaluated in the debugger,
4625 but don't show in backtraces. */
4626 for (var
= &BLOCK_VARS (BLOCK_SUBBLOCKS (id
->block
)); *var
; )
4627 if (TREE_CODE (DECL_ORIGIN (*var
)) == PARM_DECL
)
4630 *var
= TREE_CHAIN (v
);
4631 TREE_CHAIN (v
) = BLOCK_VARS (id
->block
);
4632 BLOCK_VARS (id
->block
) = v
;
4635 var
= &TREE_CHAIN (*var
);
4638 remap_blocks_to_null (DECL_INITIAL (fn
), id
);
4641 /* Return statements in the function body will be replaced by jumps
4642 to the RET_LABEL. */
4643 gcc_assert (DECL_INITIAL (fn
));
4644 gcc_assert (TREE_CODE (DECL_INITIAL (fn
)) == BLOCK
);
4646 /* Find the LHS to which the result of this call is assigned. */
4648 if (gimple_call_lhs (stmt
))
4650 modify_dest
= gimple_call_lhs (stmt
);
4652 /* Remember where to copy returned bounds. */
4653 if (gimple_call_with_bounds_p (stmt
)
4654 && TREE_CODE (modify_dest
) == SSA_NAME
)
4656 gcall
*retbnd
= chkp_retbnd_call_by_val (modify_dest
);
4659 return_bounds
= gimple_call_lhs (retbnd
);
4660 /* If returned bounds are not used then just
4661 remove unused call. */
4664 gimple_stmt_iterator iter
= gsi_for_stmt (retbnd
);
4665 gsi_remove (&iter
, true);
4670 /* The function which we are inlining might not return a value,
4671 in which case we should issue a warning that the function
4672 does not return a value. In that case the optimizers will
4673 see that the variable to which the value is assigned was not
4674 initialized. We do not want to issue a warning about that
4675 uninitialized variable. */
4676 if (DECL_P (modify_dest
))
4677 TREE_NO_WARNING (modify_dest
) = 1;
4679 if (gimple_call_return_slot_opt_p (call_stmt
))
4681 return_slot
= modify_dest
;
4688 /* If we are inlining a call to the C++ operator new, we don't want
4689 to use type based alias analysis on the return value. Otherwise
4690 we may get confused if the compiler sees that the inlined new
4691 function returns a pointer which was just deleted. See bug
4693 if (DECL_IS_OPERATOR_NEW (fn
))
4699 /* Declare the return variable for the function. */
4700 use_retvar
= declare_return_variable (id
, return_slot
, modify_dest
,
4703 /* Add local vars in this inlined callee to caller. */
4704 add_local_variables (id
->src_cfun
, cfun
, id
);
4706 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4708 fprintf (dump_file
, "Inlining ");
4709 print_generic_expr (dump_file
, id
->src_fn
);
4710 fprintf (dump_file
, " to ");
4711 print_generic_expr (dump_file
, id
->dst_fn
);
4712 fprintf (dump_file
, " with frequency %i\n", cg_edge
->frequency
);
4715 /* This is it. Duplicate the callee body. Assume callee is
4716 pre-gimplified. Note that we must not alter the caller
4717 function in any way before this point, as this CALL_EXPR may be
4718 a self-referential call; if we're calling ourselves, we need to
4719 duplicate our body before altering anything. */
4720 copy_body (id
, cg_edge
->callee
->count
,
4721 bb
, return_block
, NULL
);
4723 reset_debug_bindings (id
, stmt_gsi
);
4725 if (flag_stack_reuse
!= SR_NONE
)
4726 for (tree p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
4727 if (!TREE_THIS_VOLATILE (p
))
4729 tree
*varp
= id
->decl_map
->get (p
);
4730 if (varp
&& VAR_P (*varp
) && !is_gimple_reg (*varp
))
4732 tree clobber
= build_constructor (TREE_TYPE (*varp
), NULL
);
4733 gimple
*clobber_stmt
;
4734 TREE_THIS_VOLATILE (clobber
) = 1;
4735 clobber_stmt
= gimple_build_assign (*varp
, clobber
);
4736 gimple_set_location (clobber_stmt
, gimple_location (stmt
));
4737 gsi_insert_before (&stmt_gsi
, clobber_stmt
, GSI_SAME_STMT
);
4741 /* Reset the escaped solution. */
4742 if (cfun
->gimple_df
)
4743 pt_solution_reset (&cfun
->gimple_df
->escaped
);
4745 /* Add new automatic variables to IFN_GOMP_SIMT_ENTER arguments. */
4746 if (id
->dst_simt_vars
&& id
->dst_simt_vars
->length () > 0)
4748 size_t nargs
= gimple_call_num_args (simtenter_stmt
);
4749 vec
<tree
> *vars
= id
->dst_simt_vars
;
4750 auto_vec
<tree
> newargs (nargs
+ vars
->length ());
4751 for (size_t i
= 0; i
< nargs
; i
++)
4752 newargs
.quick_push (gimple_call_arg (simtenter_stmt
, i
));
4753 for (tree
*pvar
= vars
->begin (); pvar
!= vars
->end (); pvar
++)
4755 tree ptrtype
= build_pointer_type (TREE_TYPE (*pvar
));
4756 newargs
.quick_push (build1 (ADDR_EXPR
, ptrtype
, *pvar
));
4758 gcall
*g
= gimple_build_call_internal_vec (IFN_GOMP_SIMT_ENTER
, newargs
);
4759 gimple_call_set_lhs (g
, gimple_call_lhs (simtenter_stmt
));
4760 gimple_stmt_iterator gsi
= gsi_for_stmt (simtenter_stmt
);
4761 gsi_replace (&gsi
, g
, false);
4763 vec_free (id
->dst_simt_vars
);
4764 id
->dst_simt_vars
= simtvars_save
;
4769 delete id
->debug_map
;
4770 id
->debug_map
= dst
;
4772 delete id
->decl_map
;
4775 /* Unlink the calls virtual operands before replacing it. */
4776 unlink_stmt_vdef (stmt
);
4777 if (gimple_vdef (stmt
)
4778 && TREE_CODE (gimple_vdef (stmt
)) == SSA_NAME
)
4779 release_ssa_name (gimple_vdef (stmt
));
4781 /* If the inlined function returns a result that we care about,
4782 substitute the GIMPLE_CALL with an assignment of the return
4783 variable to the LHS of the call. That is, if STMT was
4784 'a = foo (...)', substitute the call with 'a = USE_RETVAR'. */
4785 if (use_retvar
&& gimple_call_lhs (stmt
))
4787 gimple
*old_stmt
= stmt
;
4788 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), use_retvar
);
4789 gsi_replace (&stmt_gsi
, stmt
, false);
4790 maybe_clean_or_replace_eh_stmt (old_stmt
, stmt
);
4791 /* Append a clobber for id->retvar if easily possible. */
4792 if (flag_stack_reuse
!= SR_NONE
4794 && VAR_P (id
->retvar
)
4795 && id
->retvar
!= return_slot
4796 && id
->retvar
!= modify_dest
4797 && !TREE_THIS_VOLATILE (id
->retvar
)
4798 && !is_gimple_reg (id
->retvar
)
4799 && !stmt_ends_bb_p (stmt
))
4801 tree clobber
= build_constructor (TREE_TYPE (id
->retvar
), NULL
);
4802 gimple
*clobber_stmt
;
4803 TREE_THIS_VOLATILE (clobber
) = 1;
4804 clobber_stmt
= gimple_build_assign (id
->retvar
, clobber
);
4805 gimple_set_location (clobber_stmt
, gimple_location (old_stmt
));
4806 gsi_insert_after (&stmt_gsi
, clobber_stmt
, GSI_SAME_STMT
);
4809 /* Copy bounds if we copy structure with bounds. */
4810 if (chkp_function_instrumented_p (id
->dst_fn
)
4811 && !BOUNDED_P (use_retvar
)
4812 && chkp_type_has_pointer (TREE_TYPE (use_retvar
)))
4813 id
->assign_stmts
.safe_push (stmt
);
4817 /* Handle the case of inlining a function with no return
4818 statement, which causes the return value to become undefined. */
4819 if (gimple_call_lhs (stmt
)
4820 && TREE_CODE (gimple_call_lhs (stmt
)) == SSA_NAME
)
4822 tree name
= gimple_call_lhs (stmt
);
4823 tree var
= SSA_NAME_VAR (name
);
4824 tree def
= var
? ssa_default_def (cfun
, var
) : NULL
;
4828 /* If the variable is used undefined, make this name
4829 undefined via a move. */
4830 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), def
);
4831 gsi_replace (&stmt_gsi
, stmt
, true);
4837 var
= create_tmp_reg_fn (cfun
, TREE_TYPE (name
), NULL
);
4838 SET_SSA_NAME_VAR_OR_IDENTIFIER (name
, var
);
4840 /* Otherwise make this variable undefined. */
4841 gsi_remove (&stmt_gsi
, true);
4842 set_ssa_default_def (cfun
, var
, name
);
4843 SSA_NAME_DEF_STMT (name
) = gimple_build_nop ();
4846 /* Replace with a clobber for id->retvar. */
4847 else if (flag_stack_reuse
!= SR_NONE
4849 && VAR_P (id
->retvar
)
4850 && id
->retvar
!= return_slot
4851 && id
->retvar
!= modify_dest
4852 && !TREE_THIS_VOLATILE (id
->retvar
)
4853 && !is_gimple_reg (id
->retvar
))
4855 tree clobber
= build_constructor (TREE_TYPE (id
->retvar
), NULL
);
4856 gimple
*clobber_stmt
;
4857 TREE_THIS_VOLATILE (clobber
) = 1;
4858 clobber_stmt
= gimple_build_assign (id
->retvar
, clobber
);
4859 gimple_set_location (clobber_stmt
, gimple_location (stmt
));
4860 gsi_replace (&stmt_gsi
, clobber_stmt
, false);
4861 maybe_clean_or_replace_eh_stmt (stmt
, clobber_stmt
);
4864 gsi_remove (&stmt_gsi
, true);
4867 /* Put returned bounds into the correct place if required. */
4870 gimple
*old_stmt
= SSA_NAME_DEF_STMT (return_bounds
);
4871 gimple
*new_stmt
= gimple_build_assign (return_bounds
, id
->retbnd
);
4872 gimple_stmt_iterator bnd_gsi
= gsi_for_stmt (old_stmt
);
4873 unlink_stmt_vdef (old_stmt
);
4874 gsi_replace (&bnd_gsi
, new_stmt
, false);
4875 maybe_clean_or_replace_eh_stmt (old_stmt
, new_stmt
);
4876 cgraph_update_edges_for_call_stmt (old_stmt
,
4877 gimple_call_fndecl (old_stmt
),
4881 if (purge_dead_abnormal_edges
)
4883 gimple_purge_dead_eh_edges (return_block
);
4884 gimple_purge_dead_abnormal_call_edges (return_block
);
4887 /* If the value of the new expression is ignored, that's OK. We
4888 don't warn about this for CALL_EXPRs, so we shouldn't warn about
4889 the equivalent inlined version either. */
4890 if (is_gimple_assign (stmt
))
4892 gcc_assert (gimple_assign_single_p (stmt
)
4893 || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
)));
4894 TREE_USED (gimple_assign_rhs1 (stmt
)) = 1;
4897 /* Copy bounds for all generated assigns that need it. */
4898 for (i
= 0; i
< id
->assign_stmts
.length (); i
++)
4899 chkp_copy_bounds_for_assign (id
->assign_stmts
[i
], cg_edge
);
4900 id
->assign_stmts
.release ();
4902 /* Output the inlining info for this abstract function, since it has been
4903 inlined. If we don't do this now, we can lose the information about the
4904 variables in the function when the blocks get blown away as soon as we
4905 remove the cgraph node. */
4906 if (gimple_block (stmt
))
4907 (*debug_hooks
->outlining_inline_function
) (cg_edge
->callee
->decl
);
4909 /* Update callgraph if needed. */
4910 cg_edge
->callee
->remove ();
4912 id
->block
= NULL_TREE
;
4913 id
->retvar
= NULL_TREE
;
4914 id
->retbnd
= NULL_TREE
;
4915 successfully_inlined
= true;
4918 input_location
= saved_location
;
4919 return successfully_inlined
;
4922 /* Expand call statements reachable from STMT_P.
4923 We can only have CALL_EXPRs as the "toplevel" tree code or nested
4924 in a MODIFY_EXPR. */
4927 gimple_expand_calls_inline (basic_block bb
, copy_body_data
*id
)
4929 gimple_stmt_iterator gsi
;
4930 bool inlined
= false;
4932 for (gsi
= gsi_last_bb (bb
); !gsi_end_p (gsi
);)
4934 gimple
*stmt
= gsi_stmt (gsi
);
4937 if (is_gimple_call (stmt
)
4938 && !gimple_call_internal_p (stmt
))
4939 inlined
|= expand_call_inline (bb
, stmt
, id
);
4946 /* Walk all basic blocks created after FIRST and try to fold every statement
4947 in the STATEMENTS pointer set. */
4950 fold_marked_statements (int first
, hash_set
<gimple
*> *statements
)
4952 for (; first
< n_basic_blocks_for_fn (cfun
); first
++)
4953 if (BASIC_BLOCK_FOR_FN (cfun
, first
))
4955 gimple_stmt_iterator gsi
;
4957 for (gsi
= gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, first
));
4960 if (statements
->contains (gsi_stmt (gsi
)))
4962 gimple
*old_stmt
= gsi_stmt (gsi
);
4963 tree old_decl
= is_gimple_call (old_stmt
) ? gimple_call_fndecl (old_stmt
) : 0;
4965 if (old_decl
&& DECL_BUILT_IN (old_decl
))
4967 /* Folding builtins can create multiple instructions,
4968 we need to look at all of them. */
4969 gimple_stmt_iterator i2
= gsi
;
4971 if (fold_stmt (&gsi
))
4974 /* If a builtin at the end of a bb folded into nothing,
4975 the following loop won't work. */
4976 if (gsi_end_p (gsi
))
4978 cgraph_update_edges_for_call_stmt (old_stmt
,
4983 i2
= gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, first
));
4988 new_stmt
= gsi_stmt (i2
);
4989 update_stmt (new_stmt
);
4990 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4993 if (new_stmt
== gsi_stmt (gsi
))
4995 /* It is okay to check only for the very last
4996 of these statements. If it is a throwing
4997 statement nothing will change. If it isn't
4998 this can remove EH edges. If that weren't
4999 correct then because some intermediate stmts
5000 throw, but not the last one. That would mean
5001 we'd have to split the block, which we can't
5002 here and we'd loose anyway. And as builtins
5003 probably never throw, this all
5005 if (maybe_clean_or_replace_eh_stmt (old_stmt
,
5007 gimple_purge_dead_eh_edges (
5008 BASIC_BLOCK_FOR_FN (cfun
, first
));
5015 else if (fold_stmt (&gsi
))
5017 /* Re-read the statement from GSI as fold_stmt() may
5019 gimple
*new_stmt
= gsi_stmt (gsi
);
5020 update_stmt (new_stmt
);
5022 if (is_gimple_call (old_stmt
)
5023 || is_gimple_call (new_stmt
))
5024 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
5027 if (maybe_clean_or_replace_eh_stmt (old_stmt
, new_stmt
))
5028 gimple_purge_dead_eh_edges (BASIC_BLOCK_FOR_FN (cfun
,
5035 /* Expand calls to inline functions in the body of FN. */
5038 optimize_inline_calls (tree fn
)
5042 int last
= n_basic_blocks_for_fn (cfun
);
5043 bool inlined_p
= false;
5046 memset (&id
, 0, sizeof (id
));
5048 id
.src_node
= id
.dst_node
= cgraph_node::get (fn
);
5049 gcc_assert (id
.dst_node
->definition
);
5051 /* Or any functions that aren't finished yet. */
5052 if (current_function_decl
)
5053 id
.dst_fn
= current_function_decl
;
5055 id
.copy_decl
= copy_decl_maybe_to_var
;
5056 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5057 id
.transform_new_cfg
= false;
5058 id
.transform_return_to_modify
= true;
5059 id
.transform_parameter
= true;
5060 id
.transform_lang_insert_block
= NULL
;
5061 id
.statements_to_fold
= new hash_set
<gimple
*>;
5063 push_gimplify_context ();
5065 /* We make no attempts to keep dominance info up-to-date. */
5066 free_dominance_info (CDI_DOMINATORS
);
5067 free_dominance_info (CDI_POST_DOMINATORS
);
5069 /* Register specific gimple functions. */
5070 gimple_register_cfg_hooks ();
5072 /* Reach the trees by walking over the CFG, and note the
5073 enclosing basic-blocks in the call edges. */
5074 /* We walk the blocks going forward, because inlined function bodies
5075 will split id->current_basic_block, and the new blocks will
5076 follow it; we'll trudge through them, processing their CALL_EXPRs
5078 FOR_EACH_BB_FN (bb
, cfun
)
5079 inlined_p
|= gimple_expand_calls_inline (bb
, &id
);
5081 pop_gimplify_context (NULL
);
5085 struct cgraph_edge
*e
;
5087 id
.dst_node
->verify ();
5089 /* Double check that we inlined everything we are supposed to inline. */
5090 for (e
= id
.dst_node
->callees
; e
; e
= e
->next_callee
)
5091 gcc_assert (e
->inline_failed
);
5094 /* Fold queued statements. */
5096 fold_marked_statements (last
, id
.statements_to_fold
);
5097 delete id
.statements_to_fold
;
5099 gcc_assert (!id
.debug_stmts
.exists ());
5101 /* If we didn't inline into the function there is nothing to do. */
5105 /* Renumber the lexical scoping (non-code) blocks consecutively. */
5108 delete_unreachable_blocks_update_callgraph (&id
);
5110 id
.dst_node
->verify ();
5112 /* It would be nice to check SSA/CFG/statement consistency here, but it is
5113 not possible yet - the IPA passes might make various functions to not
5114 throw and they don't care to proactively update local EH info. This is
5115 done later in fixup_cfg pass that also execute the verification. */
5116 return (TODO_update_ssa
5118 | (gimple_in_ssa_p (cfun
) ? TODO_remove_unused_locals
: 0)
5119 | (gimple_in_ssa_p (cfun
) ? TODO_update_address_taken
: 0)
5120 | (profile_status_for_fn (cfun
) != PROFILE_ABSENT
5121 ? TODO_rebuild_frequencies
: 0));
5124 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
5127 copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
5129 enum tree_code code
= TREE_CODE (*tp
);
5130 enum tree_code_class cl
= TREE_CODE_CLASS (code
);
5132 /* We make copies of most nodes. */
5133 if (IS_EXPR_CODE_CLASS (cl
)
5134 || code
== TREE_LIST
5136 || code
== TYPE_DECL
5137 || code
== OMP_CLAUSE
)
5139 /* Because the chain gets clobbered when we make a copy, we save it
5141 tree chain
= NULL_TREE
, new_tree
;
5143 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
5144 chain
= TREE_CHAIN (*tp
);
5146 /* Copy the node. */
5147 new_tree
= copy_node (*tp
);
5151 /* Now, restore the chain, if appropriate. That will cause
5152 walk_tree to walk into the chain as well. */
5153 if (code
== PARM_DECL
5154 || code
== TREE_LIST
5155 || code
== OMP_CLAUSE
)
5156 TREE_CHAIN (*tp
) = chain
;
5158 /* For now, we don't update BLOCKs when we make copies. So, we
5159 have to nullify all BIND_EXPRs. */
5160 if (TREE_CODE (*tp
) == BIND_EXPR
)
5161 BIND_EXPR_BLOCK (*tp
) = NULL_TREE
;
5163 else if (code
== CONSTRUCTOR
)
5165 /* CONSTRUCTOR nodes need special handling because
5166 we need to duplicate the vector of elements. */
5169 new_tree
= copy_node (*tp
);
5170 CONSTRUCTOR_ELTS (new_tree
) = vec_safe_copy (CONSTRUCTOR_ELTS (*tp
));
5173 else if (code
== STATEMENT_LIST
)
5174 /* We used to just abort on STATEMENT_LIST, but we can run into them
5175 with statement-expressions (c++/40975). */
5176 copy_statement_list (tp
);
5177 else if (TREE_CODE_CLASS (code
) == tcc_type
)
5179 else if (TREE_CODE_CLASS (code
) == tcc_declaration
)
5181 else if (TREE_CODE_CLASS (code
) == tcc_constant
)
5186 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
5187 information indicating to what new SAVE_EXPR this one should be mapped,
5188 use that one. Otherwise, create a new node and enter it in ST. FN is
5189 the function into which the copy will be placed. */
5192 remap_save_expr (tree
*tp
, hash_map
<tree
, tree
> *st
, int *walk_subtrees
)
5197 /* See if we already encountered this SAVE_EXPR. */
5200 /* If we didn't already remap this SAVE_EXPR, do so now. */
5203 t
= copy_node (*tp
);
5205 /* Remember this SAVE_EXPR. */
5207 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
5212 /* We've already walked into this SAVE_EXPR; don't do it again. */
5217 /* Replace this SAVE_EXPR with the copy. */
5221 /* Called via walk_gimple_seq. If *GSIP points to a GIMPLE_LABEL for a local
5222 label, copies the declaration and enters it in the splay_tree in DATA (which
5223 is really a 'copy_body_data *'. */
5226 mark_local_labels_stmt (gimple_stmt_iterator
*gsip
,
5227 bool *handled_ops_p ATTRIBUTE_UNUSED
,
5228 struct walk_stmt_info
*wi
)
5230 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
5231 glabel
*stmt
= dyn_cast
<glabel
*> (gsi_stmt (*gsip
));
5235 tree decl
= gimple_label_label (stmt
);
5237 /* Copy the decl and remember the copy. */
5238 insert_decl_map (id
, decl
, id
->copy_decl (decl
, id
));
5244 static gimple_seq
duplicate_remap_omp_clause_seq (gimple_seq seq
,
5245 struct walk_stmt_info
*wi
);
5247 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
5248 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
5249 remaps all local declarations to appropriate replacements in gimple
5253 replace_locals_op (tree
*tp
, int *walk_subtrees
, void *data
)
5255 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
5256 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
5257 hash_map
<tree
, tree
> *st
= id
->decl_map
;
5261 /* For recursive invocations this is no longer the LHS itself. */
5262 bool is_lhs
= wi
->is_lhs
;
5265 if (TREE_CODE (expr
) == SSA_NAME
)
5267 *tp
= remap_ssa_name (*tp
, id
);
5270 SSA_NAME_DEF_STMT (*tp
) = gsi_stmt (wi
->gsi
);
5272 /* Only a local declaration (variable or label). */
5273 else if ((VAR_P (expr
) && !TREE_STATIC (expr
))
5274 || TREE_CODE (expr
) == LABEL_DECL
)
5276 /* Lookup the declaration. */
5279 /* If it's there, remap it. */
5284 else if (TREE_CODE (expr
) == STATEMENT_LIST
5285 || TREE_CODE (expr
) == BIND_EXPR
5286 || TREE_CODE (expr
) == SAVE_EXPR
)
5288 else if (TREE_CODE (expr
) == TARGET_EXPR
)
5290 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
5291 It's OK for this to happen if it was part of a subtree that
5292 isn't immediately expanded, such as operand 2 of another
5294 if (!TREE_OPERAND (expr
, 1))
5296 TREE_OPERAND (expr
, 1) = TREE_OPERAND (expr
, 3);
5297 TREE_OPERAND (expr
, 3) = NULL_TREE
;
5300 else if (TREE_CODE (expr
) == OMP_CLAUSE
)
5302 /* Before the omplower pass completes, some OMP clauses can contain
5303 sequences that are neither copied by gimple_seq_copy nor walked by
5304 walk_gimple_seq. To make copy_gimple_seq_and_replace_locals work even
5305 in those situations, we have to copy and process them explicitely. */
5307 if (OMP_CLAUSE_CODE (expr
) == OMP_CLAUSE_LASTPRIVATE
)
5309 gimple_seq seq
= OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (expr
);
5310 seq
= duplicate_remap_omp_clause_seq (seq
, wi
);
5311 OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (expr
) = seq
;
5313 else if (OMP_CLAUSE_CODE (expr
) == OMP_CLAUSE_LINEAR
)
5315 gimple_seq seq
= OMP_CLAUSE_LINEAR_GIMPLE_SEQ (expr
);
5316 seq
= duplicate_remap_omp_clause_seq (seq
, wi
);
5317 OMP_CLAUSE_LINEAR_GIMPLE_SEQ (expr
) = seq
;
5319 else if (OMP_CLAUSE_CODE (expr
) == OMP_CLAUSE_REDUCTION
)
5321 gimple_seq seq
= OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr
);
5322 seq
= duplicate_remap_omp_clause_seq (seq
, wi
);
5323 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr
) = seq
;
5324 seq
= OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr
);
5325 seq
= duplicate_remap_omp_clause_seq (seq
, wi
);
5326 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr
) = seq
;
5330 /* Keep iterating. */
5335 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
5336 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
5337 remaps all local declarations to appropriate replacements in gimple
5341 replace_locals_stmt (gimple_stmt_iterator
*gsip
,
5342 bool *handled_ops_p ATTRIBUTE_UNUSED
,
5343 struct walk_stmt_info
*wi
)
5345 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
5346 gimple
*gs
= gsi_stmt (*gsip
);
5348 if (gbind
*stmt
= dyn_cast
<gbind
*> (gs
))
5350 tree block
= gimple_bind_block (stmt
);
5354 remap_block (&block
, id
);
5355 gimple_bind_set_block (stmt
, block
);
5358 /* This will remap a lot of the same decls again, but this should be
5360 if (gimple_bind_vars (stmt
))
5362 tree old_var
, decls
= gimple_bind_vars (stmt
);
5364 for (old_var
= decls
; old_var
; old_var
= DECL_CHAIN (old_var
))
5365 if (!can_be_nonlocal (old_var
, id
)
5366 && ! variably_modified_type_p (TREE_TYPE (old_var
), id
->src_fn
))
5367 remap_decl (old_var
, id
);
5369 gcc_checking_assert (!id
->prevent_decl_creation_for_types
);
5370 id
->prevent_decl_creation_for_types
= true;
5371 gimple_bind_set_vars (stmt
, remap_decls (decls
, NULL
, id
));
5372 id
->prevent_decl_creation_for_types
= false;
5376 /* Keep iterating. */
5380 /* Create a copy of SEQ and remap all decls in it. */
5383 duplicate_remap_omp_clause_seq (gimple_seq seq
, struct walk_stmt_info
*wi
)
5388 /* If there are any labels in OMP sequences, they can be only referred to in
5389 the sequence itself and therefore we can do both here. */
5390 walk_gimple_seq (seq
, mark_local_labels_stmt
, NULL
, wi
);
5391 gimple_seq copy
= gimple_seq_copy (seq
);
5392 walk_gimple_seq (copy
, replace_locals_stmt
, replace_locals_op
, wi
);
5396 /* Copies everything in SEQ and replaces variables and labels local to
5397 current_function_decl. */
5400 copy_gimple_seq_and_replace_locals (gimple_seq seq
)
5403 struct walk_stmt_info wi
;
5406 /* There's nothing to do for NULL_TREE. */
5411 memset (&id
, 0, sizeof (id
));
5412 id
.src_fn
= current_function_decl
;
5413 id
.dst_fn
= current_function_decl
;
5415 id
.decl_map
= new hash_map
<tree
, tree
>;
5416 id
.debug_map
= NULL
;
5418 id
.copy_decl
= copy_decl_no_change
;
5419 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5420 id
.transform_new_cfg
= false;
5421 id
.transform_return_to_modify
= false;
5422 id
.transform_parameter
= false;
5423 id
.transform_lang_insert_block
= NULL
;
5425 /* Walk the tree once to find local labels. */
5426 memset (&wi
, 0, sizeof (wi
));
5427 hash_set
<tree
> visited
;
5430 walk_gimple_seq (seq
, mark_local_labels_stmt
, NULL
, &wi
);
5432 copy
= gimple_seq_copy (seq
);
5434 /* Walk the copy, remapping decls. */
5435 memset (&wi
, 0, sizeof (wi
));
5437 walk_gimple_seq (copy
, replace_locals_stmt
, replace_locals_op
, &wi
);
5442 delete id
.debug_map
;
5443 if (id
.dependence_map
)
5445 delete id
.dependence_map
;
5446 id
.dependence_map
= NULL
;
5453 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
5456 debug_find_tree_1 (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
, void *data
)
5465 debug_find_tree (tree top
, tree search
)
5467 return walk_tree_without_duplicates (&top
, debug_find_tree_1
, search
) != 0;
5471 /* Declare the variables created by the inliner. Add all the variables in
5472 VARS to BIND_EXPR. */
5475 declare_inline_vars (tree block
, tree vars
)
5478 for (t
= vars
; t
; t
= DECL_CHAIN (t
))
5480 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
5481 gcc_assert (!TREE_STATIC (t
) && !TREE_ASM_WRITTEN (t
));
5482 add_local_decl (cfun
, t
);
5486 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), vars
);
5489 /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN,
5490 but now it will be in the TO_FN. PARM_TO_VAR means enable PARM_DECL to
5491 VAR_DECL translation. */
5494 copy_decl_for_dup_finish (copy_body_data
*id
, tree decl
, tree copy
)
5496 /* Don't generate debug information for the copy if we wouldn't have
5497 generated it for the copy either. */
5498 DECL_ARTIFICIAL (copy
) = DECL_ARTIFICIAL (decl
);
5499 DECL_IGNORED_P (copy
) = DECL_IGNORED_P (decl
);
5501 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
5502 declaration inspired this copy. */
5503 DECL_ABSTRACT_ORIGIN (copy
) = DECL_ORIGIN (decl
);
5505 /* The new variable/label has no RTL, yet. */
5506 if (CODE_CONTAINS_STRUCT (TREE_CODE (copy
), TS_DECL_WRTL
)
5507 && !TREE_STATIC (copy
) && !DECL_EXTERNAL (copy
))
5508 SET_DECL_RTL (copy
, 0);
5510 /* These args would always appear unused, if not for this. */
5511 TREE_USED (copy
) = 1;
5513 /* Set the context for the new declaration. */
5514 if (!DECL_CONTEXT (decl
))
5515 /* Globals stay global. */
5517 else if (DECL_CONTEXT (decl
) != id
->src_fn
)
5518 /* Things that weren't in the scope of the function we're inlining
5519 from aren't in the scope we're inlining to, either. */
5521 else if (TREE_STATIC (decl
))
5522 /* Function-scoped static variables should stay in the original
5527 /* Ordinary automatic local variables are now in the scope of the
5529 DECL_CONTEXT (copy
) = id
->dst_fn
;
5530 if (VAR_P (copy
) && id
->dst_simt_vars
&& !is_gimple_reg (copy
))
5532 if (!lookup_attribute ("omp simt private", DECL_ATTRIBUTES (copy
)))
5533 DECL_ATTRIBUTES (copy
)
5534 = tree_cons (get_identifier ("omp simt private"), NULL
,
5535 DECL_ATTRIBUTES (copy
));
5536 id
->dst_simt_vars
->safe_push (copy
);
5544 copy_decl_to_var (tree decl
, copy_body_data
*id
)
5548 gcc_assert (TREE_CODE (decl
) == PARM_DECL
5549 || TREE_CODE (decl
) == RESULT_DECL
);
5551 type
= TREE_TYPE (decl
);
5553 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
5554 VAR_DECL
, DECL_NAME (decl
), type
);
5555 if (DECL_PT_UID_SET_P (decl
))
5556 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
5557 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
5558 TREE_READONLY (copy
) = TREE_READONLY (decl
);
5559 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
5560 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
5562 return copy_decl_for_dup_finish (id
, decl
, copy
);
5565 /* Like copy_decl_to_var, but create a return slot object instead of a
5566 pointer variable for return by invisible reference. */
5569 copy_result_decl_to_var (tree decl
, copy_body_data
*id
)
5573 gcc_assert (TREE_CODE (decl
) == PARM_DECL
5574 || TREE_CODE (decl
) == RESULT_DECL
);
5576 type
= TREE_TYPE (decl
);
5577 if (DECL_BY_REFERENCE (decl
))
5578 type
= TREE_TYPE (type
);
5580 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
5581 VAR_DECL
, DECL_NAME (decl
), type
);
5582 if (DECL_PT_UID_SET_P (decl
))
5583 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
5584 TREE_READONLY (copy
) = TREE_READONLY (decl
);
5585 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
5586 if (!DECL_BY_REFERENCE (decl
))
5588 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
5589 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
5592 return copy_decl_for_dup_finish (id
, decl
, copy
);
5596 copy_decl_no_change (tree decl
, copy_body_data
*id
)
5600 copy
= copy_node (decl
);
5602 /* The COPY is not abstract; it will be generated in DST_FN. */
5603 DECL_ABSTRACT_P (copy
) = false;
5604 lang_hooks
.dup_lang_specific_decl (copy
);
5606 /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
5607 been taken; it's for internal bookkeeping in expand_goto_internal. */
5608 if (TREE_CODE (copy
) == LABEL_DECL
)
5610 TREE_ADDRESSABLE (copy
) = 0;
5611 LABEL_DECL_UID (copy
) = -1;
5614 return copy_decl_for_dup_finish (id
, decl
, copy
);
5618 copy_decl_maybe_to_var (tree decl
, copy_body_data
*id
)
5620 if (TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
)
5621 return copy_decl_to_var (decl
, id
);
5623 return copy_decl_no_change (decl
, id
);
5626 /* Return a copy of the function's argument tree. */
5628 copy_arguments_for_versioning (tree orig_parm
, copy_body_data
* id
,
5629 bitmap args_to_skip
, tree
*vars
)
5632 tree new_parm
= NULL
;
5637 for (arg
= orig_parm
; arg
; arg
= DECL_CHAIN (arg
), i
++)
5638 if (!args_to_skip
|| !bitmap_bit_p (args_to_skip
, i
))
5640 tree new_tree
= remap_decl (arg
, id
);
5641 if (TREE_CODE (new_tree
) != PARM_DECL
)
5642 new_tree
= id
->copy_decl (arg
, id
);
5643 lang_hooks
.dup_lang_specific_decl (new_tree
);
5645 parg
= &DECL_CHAIN (new_tree
);
5647 else if (!id
->decl_map
->get (arg
))
5649 /* Make an equivalent VAR_DECL. If the argument was used
5650 as temporary variable later in function, the uses will be
5651 replaced by local variable. */
5652 tree var
= copy_decl_to_var (arg
, id
);
5653 insert_decl_map (id
, arg
, var
);
5654 /* Declare this new variable. */
5655 DECL_CHAIN (var
) = *vars
;
5661 /* Return a copy of the function's static chain. */
5663 copy_static_chain (tree static_chain
, copy_body_data
* id
)
5665 tree
*chain_copy
, *pvar
;
5667 chain_copy
= &static_chain
;
5668 for (pvar
= chain_copy
; *pvar
; pvar
= &DECL_CHAIN (*pvar
))
5670 tree new_tree
= remap_decl (*pvar
, id
);
5671 lang_hooks
.dup_lang_specific_decl (new_tree
);
5672 DECL_CHAIN (new_tree
) = DECL_CHAIN (*pvar
);
5675 return static_chain
;
5678 /* Return true if the function is allowed to be versioned.
5679 This is a guard for the versioning functionality. */
5682 tree_versionable_function_p (tree fndecl
)
5684 return (!lookup_attribute ("noclone", DECL_ATTRIBUTES (fndecl
))
5685 && copy_forbidden (DECL_STRUCT_FUNCTION (fndecl
)) == NULL
);
5688 /* Delete all unreachable basic blocks and update callgraph.
5689 Doing so is somewhat nontrivial because we need to update all clones and
5690 remove inline function that become unreachable. */
5693 delete_unreachable_blocks_update_callgraph (copy_body_data
*id
)
5695 bool changed
= false;
5696 basic_block b
, next_bb
;
5698 find_unreachable_blocks ();
5700 /* Delete all unreachable basic blocks. */
5702 for (b
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
; b
5703 != EXIT_BLOCK_PTR_FOR_FN (cfun
); b
= next_bb
)
5705 next_bb
= b
->next_bb
;
5707 if (!(b
->flags
& BB_REACHABLE
))
5709 gimple_stmt_iterator bsi
;
5711 for (bsi
= gsi_start_bb (b
); !gsi_end_p (bsi
); gsi_next (&bsi
))
5713 struct cgraph_edge
*e
;
5714 struct cgraph_node
*node
;
5716 id
->dst_node
->remove_stmt_references (gsi_stmt (bsi
));
5718 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
5719 &&(e
= id
->dst_node
->get_edge (gsi_stmt (bsi
))) != NULL
)
5721 if (!e
->inline_failed
)
5722 e
->callee
->remove_symbol_and_inline_clones (id
->dst_node
);
5726 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
5727 && id
->dst_node
->clones
)
5728 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
5730 node
->remove_stmt_references (gsi_stmt (bsi
));
5731 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
5732 && (e
= node
->get_edge (gsi_stmt (bsi
))) != NULL
)
5734 if (!e
->inline_failed
)
5735 e
->callee
->remove_symbol_and_inline_clones (id
->dst_node
);
5741 node
= node
->clones
;
5742 else if (node
->next_sibling_clone
)
5743 node
= node
->next_sibling_clone
;
5746 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5747 node
= node
->clone_of
;
5748 if (node
!= id
->dst_node
)
5749 node
= node
->next_sibling_clone
;
5753 delete_basic_block (b
);
5761 /* Update clone info after duplication. */
5764 update_clone_info (copy_body_data
* id
)
5766 struct cgraph_node
*node
;
5767 if (!id
->dst_node
->clones
)
5769 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
5771 /* First update replace maps to match the new body. */
5772 if (node
->clone
.tree_map
)
5775 for (i
= 0; i
< vec_safe_length (node
->clone
.tree_map
); i
++)
5777 struct ipa_replace_map
*replace_info
;
5778 replace_info
= (*node
->clone
.tree_map
)[i
];
5779 walk_tree (&replace_info
->old_tree
, copy_tree_body_r
, id
, NULL
);
5780 walk_tree (&replace_info
->new_tree
, copy_tree_body_r
, id
, NULL
);
5784 node
= node
->clones
;
5785 else if (node
->next_sibling_clone
)
5786 node
= node
->next_sibling_clone
;
5789 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5790 node
= node
->clone_of
;
5791 if (node
!= id
->dst_node
)
5792 node
= node
->next_sibling_clone
;
5797 /* Create a copy of a function's tree.
5798 OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
5799 of the original function and the new copied function
5800 respectively. In case we want to replace a DECL
5801 tree with another tree while duplicating the function's
5802 body, TREE_MAP represents the mapping between these
5803 trees. If UPDATE_CLONES is set, the call_stmt fields
5804 of edges of clones of the function will be updated.
5806 If non-NULL ARGS_TO_SKIP determine function parameters to remove
5808 If SKIP_RETURN is true, the new version will return void.
5809 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
5810 If non_NULL NEW_ENTRY determine new entry BB of the clone.
5813 tree_function_versioning (tree old_decl
, tree new_decl
,
5814 vec
<ipa_replace_map
*, va_gc
> *tree_map
,
5815 bool update_clones
, bitmap args_to_skip
,
5816 bool skip_return
, bitmap blocks_to_copy
,
5817 basic_block new_entry
)
5819 struct cgraph_node
*old_version_node
;
5820 struct cgraph_node
*new_version_node
;
5824 struct ipa_replace_map
*replace_info
;
5825 basic_block old_entry_block
, bb
;
5826 auto_vec
<gimple
*, 10> init_stmts
;
5827 tree vars
= NULL_TREE
;
5828 bitmap debug_args_to_skip
= args_to_skip
;
5830 gcc_assert (TREE_CODE (old_decl
) == FUNCTION_DECL
5831 && TREE_CODE (new_decl
) == FUNCTION_DECL
);
5832 DECL_POSSIBLY_INLINED (old_decl
) = 1;
5834 old_version_node
= cgraph_node::get (old_decl
);
5835 gcc_checking_assert (old_version_node
);
5836 new_version_node
= cgraph_node::get (new_decl
);
5837 gcc_checking_assert (new_version_node
);
5839 /* Copy over debug args. */
5840 if (DECL_HAS_DEBUG_ARGS_P (old_decl
))
5842 vec
<tree
, va_gc
> **new_debug_args
, **old_debug_args
;
5843 gcc_checking_assert (decl_debug_args_lookup (new_decl
) == NULL
);
5844 DECL_HAS_DEBUG_ARGS_P (new_decl
) = 0;
5845 old_debug_args
= decl_debug_args_lookup (old_decl
);
5848 new_debug_args
= decl_debug_args_insert (new_decl
);
5849 *new_debug_args
= vec_safe_copy (*old_debug_args
);
5853 /* Output the inlining info for this abstract function, since it has been
5854 inlined. If we don't do this now, we can lose the information about the
5855 variables in the function when the blocks get blown away as soon as we
5856 remove the cgraph node. */
5857 (*debug_hooks
->outlining_inline_function
) (old_decl
);
5859 DECL_ARTIFICIAL (new_decl
) = 1;
5860 DECL_ABSTRACT_ORIGIN (new_decl
) = DECL_ORIGIN (old_decl
);
5861 if (DECL_ORIGIN (old_decl
) == old_decl
)
5862 old_version_node
->used_as_abstract_origin
= true;
5863 DECL_FUNCTION_PERSONALITY (new_decl
) = DECL_FUNCTION_PERSONALITY (old_decl
);
5865 /* Prepare the data structures for the tree copy. */
5866 memset (&id
, 0, sizeof (id
));
5868 /* Generate a new name for the new version. */
5869 id
.statements_to_fold
= new hash_set
<gimple
*>;
5871 id
.decl_map
= new hash_map
<tree
, tree
>;
5872 id
.debug_map
= NULL
;
5873 id
.src_fn
= old_decl
;
5874 id
.dst_fn
= new_decl
;
5875 id
.src_node
= old_version_node
;
5876 id
.dst_node
= new_version_node
;
5877 id
.src_cfun
= DECL_STRUCT_FUNCTION (old_decl
);
5878 id
.blocks_to_copy
= blocks_to_copy
;
5880 id
.copy_decl
= copy_decl_no_change
;
5881 id
.transform_call_graph_edges
5882 = update_clones
? CB_CGE_MOVE_CLONES
: CB_CGE_MOVE
;
5883 id
.transform_new_cfg
= true;
5884 id
.transform_return_to_modify
= false;
5885 id
.transform_parameter
= false;
5886 id
.transform_lang_insert_block
= NULL
;
5888 old_entry_block
= ENTRY_BLOCK_PTR_FOR_FN
5889 (DECL_STRUCT_FUNCTION (old_decl
));
5890 DECL_RESULT (new_decl
) = DECL_RESULT (old_decl
);
5891 DECL_ARGUMENTS (new_decl
) = DECL_ARGUMENTS (old_decl
);
5892 initialize_cfun (new_decl
, old_decl
,
5893 old_entry_block
->count
);
5894 if (DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
)
5895 DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
->ipa_pta
5896 = id
.src_cfun
->gimple_df
->ipa_pta
;
5898 /* Copy the function's static chain. */
5899 p
= DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
;
5901 DECL_STRUCT_FUNCTION (new_decl
)->static_chain_decl
5902 = copy_static_chain (p
, &id
);
5904 /* If there's a tree_map, prepare for substitution. */
5906 for (i
= 0; i
< tree_map
->length (); i
++)
5909 replace_info
= (*tree_map
)[i
];
5910 if (replace_info
->replace_p
)
5913 if (!replace_info
->old_tree
)
5915 int p
= replace_info
->parm_num
;
5917 tree req_type
, new_type
;
5919 for (parm
= DECL_ARGUMENTS (old_decl
); p
;
5920 parm
= DECL_CHAIN (parm
))
5922 replace_info
->old_tree
= parm
;
5923 parm_num
= replace_info
->parm_num
;
5924 req_type
= TREE_TYPE (parm
);
5925 new_type
= TREE_TYPE (replace_info
->new_tree
);
5926 if (!useless_type_conversion_p (req_type
, new_type
))
5928 if (fold_convertible_p (req_type
, replace_info
->new_tree
))
5929 replace_info
->new_tree
5930 = fold_build1 (NOP_EXPR
, req_type
,
5931 replace_info
->new_tree
);
5932 else if (TYPE_SIZE (req_type
) == TYPE_SIZE (new_type
))
5933 replace_info
->new_tree
5934 = fold_build1 (VIEW_CONVERT_EXPR
, req_type
,
5935 replace_info
->new_tree
);
5940 fprintf (dump_file
, " const ");
5941 print_generic_expr (dump_file
,
5942 replace_info
->new_tree
);
5944 " can't be converted to param ");
5945 print_generic_expr (dump_file
, parm
);
5946 fprintf (dump_file
, "\n");
5948 replace_info
->old_tree
= NULL
;
5953 gcc_assert (TREE_CODE (replace_info
->old_tree
) == PARM_DECL
);
5954 if (replace_info
->old_tree
)
5956 init
= setup_one_parameter (&id
, replace_info
->old_tree
,
5957 replace_info
->new_tree
, id
.src_fn
,
5961 init_stmts
.safe_push (init
);
5962 if (MAY_HAVE_DEBUG_STMTS
&& args_to_skip
)
5968 for (parm
= DECL_ARGUMENTS (old_decl
), p
= 0; parm
;
5969 parm
= DECL_CHAIN (parm
), p
++)
5970 if (parm
== replace_info
->old_tree
)
5978 if (debug_args_to_skip
== args_to_skip
)
5980 debug_args_to_skip
= BITMAP_ALLOC (NULL
);
5981 bitmap_copy (debug_args_to_skip
, args_to_skip
);
5983 bitmap_clear_bit (debug_args_to_skip
, parm_num
);
5989 /* Copy the function's arguments. */
5990 if (DECL_ARGUMENTS (old_decl
) != NULL_TREE
)
5991 DECL_ARGUMENTS (new_decl
)
5992 = copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl
), &id
,
5993 args_to_skip
, &vars
);
5995 DECL_INITIAL (new_decl
) = remap_blocks (DECL_INITIAL (id
.src_fn
), &id
);
5996 BLOCK_SUPERCONTEXT (DECL_INITIAL (new_decl
)) = new_decl
;
5998 declare_inline_vars (DECL_INITIAL (new_decl
), vars
);
6000 if (!vec_safe_is_empty (DECL_STRUCT_FUNCTION (old_decl
)->local_decls
))
6001 /* Add local vars. */
6002 add_local_variables (DECL_STRUCT_FUNCTION (old_decl
), cfun
, &id
);
6004 if (DECL_RESULT (old_decl
) == NULL_TREE
)
6006 else if (skip_return
&& !VOID_TYPE_P (TREE_TYPE (DECL_RESULT (old_decl
))))
6008 DECL_RESULT (new_decl
)
6009 = build_decl (DECL_SOURCE_LOCATION (DECL_RESULT (old_decl
)),
6010 RESULT_DECL
, NULL_TREE
, void_type_node
);
6011 DECL_CONTEXT (DECL_RESULT (new_decl
)) = new_decl
;
6012 cfun
->returns_struct
= 0;
6013 cfun
->returns_pcc_struct
= 0;
6018 DECL_RESULT (new_decl
) = remap_decl (DECL_RESULT (old_decl
), &id
);
6019 lang_hooks
.dup_lang_specific_decl (DECL_RESULT (new_decl
));
6020 if (gimple_in_ssa_p (id
.src_cfun
)
6021 && DECL_BY_REFERENCE (DECL_RESULT (old_decl
))
6022 && (old_name
= ssa_default_def (id
.src_cfun
, DECL_RESULT (old_decl
))))
6024 tree new_name
= make_ssa_name (DECL_RESULT (new_decl
));
6025 insert_decl_map (&id
, old_name
, new_name
);
6026 SSA_NAME_DEF_STMT (new_name
) = gimple_build_nop ();
6027 set_ssa_default_def (cfun
, DECL_RESULT (new_decl
), new_name
);
6031 /* Set up the destination functions loop tree. */
6032 if (loops_for_fn (DECL_STRUCT_FUNCTION (old_decl
)) != NULL
)
6034 cfun
->curr_properties
&= ~PROP_loops
;
6035 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
6036 cfun
->curr_properties
|= PROP_loops
;
6039 /* Copy the Function's body. */
6040 copy_body (&id
, old_entry_block
->count
,
6041 ENTRY_BLOCK_PTR_FOR_FN (cfun
), EXIT_BLOCK_PTR_FOR_FN (cfun
),
6044 /* Renumber the lexical scoping (non-code) blocks consecutively. */
6045 number_blocks (new_decl
);
6047 /* We want to create the BB unconditionally, so that the addition of
6048 debug stmts doesn't affect BB count, which may in the end cause
6049 codegen differences. */
6050 bb
= split_edge (single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
6051 while (init_stmts
.length ())
6052 insert_init_stmt (&id
, bb
, init_stmts
.pop ());
6053 update_clone_info (&id
);
6055 /* Remap the nonlocal_goto_save_area, if any. */
6056 if (cfun
->nonlocal_goto_save_area
)
6058 struct walk_stmt_info wi
;
6060 memset (&wi
, 0, sizeof (wi
));
6062 walk_tree (&cfun
->nonlocal_goto_save_area
, remap_gimple_op_r
, &wi
, NULL
);
6068 delete id
.debug_map
;
6069 free_dominance_info (CDI_DOMINATORS
);
6070 free_dominance_info (CDI_POST_DOMINATORS
);
6073 fold_marked_statements (0, id
.statements_to_fold
);
6074 delete id
.statements_to_fold
;
6075 delete_unreachable_blocks_update_callgraph (&id
);
6076 if (id
.dst_node
->definition
)
6077 cgraph_edge::rebuild_references ();
6078 if (loops_state_satisfies_p (LOOPS_NEED_FIXUP
))
6080 calculate_dominance_info (CDI_DOMINATORS
);
6081 fix_loop_structure (NULL
);
6083 update_ssa (TODO_update_ssa
);
6085 /* After partial cloning we need to rescale frequencies, so they are
6086 within proper range in the cloned function. */
6089 struct cgraph_edge
*e
;
6090 rebuild_frequencies ();
6092 new_version_node
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
.ipa ();
6093 for (e
= new_version_node
->callees
; e
; e
= e
->next_callee
)
6095 basic_block bb
= gimple_bb (e
->call_stmt
);
6096 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
6098 e
->count
= bb
->count
.ipa ();
6100 for (e
= new_version_node
->indirect_calls
; e
; e
= e
->next_callee
)
6102 basic_block bb
= gimple_bb (e
->call_stmt
);
6103 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
6105 e
->count
= bb
->count
.ipa ();
6109 if (debug_args_to_skip
&& MAY_HAVE_DEBUG_STMTS
)
6112 vec
<tree
, va_gc
> **debug_args
= NULL
;
6113 unsigned int len
= 0;
6114 for (parm
= DECL_ARGUMENTS (old_decl
), i
= 0;
6115 parm
; parm
= DECL_CHAIN (parm
), i
++)
6116 if (bitmap_bit_p (debug_args_to_skip
, i
) && is_gimple_reg (parm
))
6120 if (debug_args
== NULL
)
6122 debug_args
= decl_debug_args_insert (new_decl
);
6123 len
= vec_safe_length (*debug_args
);
6125 ddecl
= make_node (DEBUG_EXPR_DECL
);
6126 DECL_ARTIFICIAL (ddecl
) = 1;
6127 TREE_TYPE (ddecl
) = TREE_TYPE (parm
);
6128 SET_DECL_MODE (ddecl
, DECL_MODE (parm
));
6129 vec_safe_push (*debug_args
, DECL_ORIGIN (parm
));
6130 vec_safe_push (*debug_args
, ddecl
);
6132 if (debug_args
!= NULL
)
6134 /* On the callee side, add
6137 stmts to the first bb where var is a VAR_DECL created for the
6138 optimized away parameter in DECL_INITIAL block. This hints
6139 in the debug info that var (whole DECL_ORIGIN is the parm
6140 PARM_DECL) is optimized away, but could be looked up at the
6141 call site as value of D#X there. */
6142 tree var
= vars
, vexpr
;
6143 gimple_stmt_iterator cgsi
6144 = gsi_after_labels (single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
6147 i
= vec_safe_length (*debug_args
);
6151 while (var
!= NULL_TREE
6152 && DECL_ABSTRACT_ORIGIN (var
) != (**debug_args
)[i
])
6153 var
= TREE_CHAIN (var
);
6154 if (var
== NULL_TREE
)
6156 vexpr
= make_node (DEBUG_EXPR_DECL
);
6157 parm
= (**debug_args
)[i
];
6158 DECL_ARTIFICIAL (vexpr
) = 1;
6159 TREE_TYPE (vexpr
) = TREE_TYPE (parm
);
6160 SET_DECL_MODE (vexpr
, DECL_MODE (parm
));
6161 def_temp
= gimple_build_debug_bind (var
, vexpr
, NULL
);
6162 gsi_insert_before (&cgsi
, def_temp
, GSI_NEW_STMT
);
6163 def_temp
= gimple_build_debug_source_bind (vexpr
, parm
, NULL
);
6164 gsi_insert_before (&cgsi
, def_temp
, GSI_NEW_STMT
);
6170 if (debug_args_to_skip
&& debug_args_to_skip
!= args_to_skip
)
6171 BITMAP_FREE (debug_args_to_skip
);
6172 free_dominance_info (CDI_DOMINATORS
);
6173 free_dominance_info (CDI_POST_DOMINATORS
);
6175 gcc_assert (!id
.debug_stmts
.exists ());
6180 /* EXP is CALL_EXPR present in a GENERIC expression tree. Try to integrate
6181 the callee and return the inlined body on success. */
6184 maybe_inline_call_in_expr (tree exp
)
6186 tree fn
= get_callee_fndecl (exp
);
6188 /* We can only try to inline "const" functions. */
6189 if (fn
&& TREE_READONLY (fn
) && DECL_SAVED_TREE (fn
))
6191 call_expr_arg_iterator iter
;
6194 hash_map
<tree
, tree
> decl_map
;
6196 /* Remap the parameters. */
6197 for (param
= DECL_ARGUMENTS (fn
), arg
= first_call_expr_arg (exp
, &iter
);
6199 param
= DECL_CHAIN (param
), arg
= next_call_expr_arg (&iter
))
6200 decl_map
.put (param
, arg
);
6202 memset (&id
, 0, sizeof (id
));
6204 id
.dst_fn
= current_function_decl
;
6205 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
6206 id
.decl_map
= &decl_map
;
6208 id
.copy_decl
= copy_decl_no_change
;
6209 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
6210 id
.transform_new_cfg
= false;
6211 id
.transform_return_to_modify
= true;
6212 id
.transform_parameter
= true;
6213 id
.transform_lang_insert_block
= NULL
;
6215 /* Make sure not to unshare trees behind the front-end's back
6216 since front-end specific mechanisms may rely on sharing. */
6217 id
.regimplify
= false;
6218 id
.do_not_unshare
= true;
6220 /* We're not inside any EH region. */
6223 t
= copy_tree_body (&id
);
6225 /* We can only return something suitable for use in a GENERIC
6227 if (TREE_CODE (t
) == MODIFY_EXPR
)
6228 return TREE_OPERAND (t
, 1);
6234 /* Duplicate a type, fields and all. */
6237 build_duplicate_type (tree type
)
6239 struct copy_body_data id
;
6241 memset (&id
, 0, sizeof (id
));
6242 id
.src_fn
= current_function_decl
;
6243 id
.dst_fn
= current_function_decl
;
6245 id
.decl_map
= new hash_map
<tree
, tree
>;
6246 id
.debug_map
= NULL
;
6247 id
.copy_decl
= copy_decl_no_change
;
6249 type
= remap_type_1 (type
, &id
);
6253 delete id
.debug_map
;
6255 TYPE_CANONICAL (type
) = type
;
6260 /* Unshare the entire DECL_SAVED_TREE of FN and return the remapped
6261 parameters and RESULT_DECL in PARMS and RESULT. Used by C++ constexpr
6265 copy_fn (tree fn
, tree
& parms
, tree
& result
)
6269 hash_map
<tree
, tree
> decl_map
;
6274 memset (&id
, 0, sizeof (id
));
6276 id
.dst_fn
= current_function_decl
;
6277 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
6278 id
.decl_map
= &decl_map
;
6280 id
.copy_decl
= copy_decl_no_change
;
6281 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
6282 id
.transform_new_cfg
= false;
6283 id
.transform_return_to_modify
= false;
6284 id
.transform_parameter
= true;
6285 id
.transform_lang_insert_block
= NULL
;
6287 /* Make sure not to unshare trees behind the front-end's back
6288 since front-end specific mechanisms may rely on sharing. */
6289 id
.regimplify
= false;
6290 id
.do_not_unshare
= true;
6292 /* We're not inside any EH region. */
6295 /* Remap the parameters and result and return them to the caller. */
6296 for (param
= DECL_ARGUMENTS (fn
);
6298 param
= DECL_CHAIN (param
))
6300 *p
= remap_decl (param
, &id
);
6301 p
= &DECL_CHAIN (*p
);
6304 if (DECL_RESULT (fn
))
6305 result
= remap_decl (DECL_RESULT (fn
), &id
);
6309 return copy_tree_body (&id
);