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"
62 /* I'm not real happy about this, but we need to handle gimple and
65 /* Inlining, Cloning, Versioning, Parallelization
67 Inlining: a function body is duplicated, but the PARM_DECLs are
68 remapped into VAR_DECLs, and non-void RETURN_EXPRs become
69 MODIFY_EXPRs that store to a dedicated returned-value variable.
70 The duplicated eh_region info of the copy will later be appended
71 to the info for the caller; the eh_region info in copied throwing
72 statements and RESX statements are adjusted accordingly.
74 Cloning: (only in C++) We have one body for a con/de/structor, and
75 multiple function decls, each with a unique parameter list.
76 Duplicate the body, using the given splay tree; some parameters
77 will become constants (like 0 or 1).
79 Versioning: a function body is duplicated and the result is a new
80 function rather than into blocks of an existing function as with
81 inlining. Some parameters will become constants.
83 Parallelization: a region of a function is duplicated resulting in
84 a new function. Variables may be replaced with complex expressions
85 to enable shared variable semantics.
87 All of these will simultaneously lookup any callgraph edges. If
88 we're going to inline the duplicated function body, and the given
89 function has some cloned callgraph nodes (one for each place this
90 function will be inlined) those callgraph edges will be duplicated.
91 If we're cloning the body, those callgraph edges will be
92 updated to point into the new body. (Note that the original
93 callgraph node and edge list will not be altered.)
95 See the CALL_EXPR handling case in copy_tree_body_r (). */
99 o In order to make inlining-on-trees work, we pessimized
100 function-local static constants. In particular, they are now
101 always output, even when not addressed. Fix this by treating
102 function-local static constants just like global static
103 constants; the back-end already knows not to output them if they
106 o Provide heuristics to clamp inlining of recursive template
110 /* Weights that estimate_num_insns uses to estimate the size of the
113 eni_weights eni_size_weights
;
115 /* Weights that estimate_num_insns uses to estimate the time necessary
116 to execute the produced code. */
118 eni_weights eni_time_weights
;
122 static tree
declare_return_variable (copy_body_data
*, tree
, tree
, tree
,
124 static void remap_block (tree
*, copy_body_data
*);
125 static void copy_bind_expr (tree
*, int *, copy_body_data
*);
126 static void declare_inline_vars (tree
, tree
);
127 static void remap_save_expr (tree
*, hash_map
<tree
, tree
> *, int *);
128 static void prepend_lexical_block (tree current_block
, tree new_block
);
129 static tree
copy_decl_to_var (tree
, copy_body_data
*);
130 static tree
copy_result_decl_to_var (tree
, copy_body_data
*);
131 static tree
copy_decl_maybe_to_var (tree
, copy_body_data
*);
132 static gimple_seq
remap_gimple_stmt (gimple
*, copy_body_data
*);
133 static bool delete_unreachable_blocks_update_callgraph (copy_body_data
*id
);
134 static void insert_init_stmt (copy_body_data
*, basic_block
, gimple
*);
136 /* Insert a tree->tree mapping for ID. Despite the name suggests
137 that the trees should be variables, it is used for more than that. */
140 insert_decl_map (copy_body_data
*id
, tree key
, tree value
)
142 id
->decl_map
->put (key
, value
);
144 /* Always insert an identity map as well. If we see this same new
145 node again, we won't want to duplicate it a second time. */
147 id
->decl_map
->put (value
, value
);
150 /* Insert a tree->tree mapping for ID. This is only used for
154 insert_debug_decl_map (copy_body_data
*id
, tree key
, tree value
)
156 if (!gimple_in_ssa_p (id
->src_cfun
))
159 if (!opt_for_fn (id
->dst_fn
, flag_var_tracking_assignments
))
162 if (!target_for_debug_bind (key
))
165 gcc_assert (TREE_CODE (key
) == PARM_DECL
);
166 gcc_assert (VAR_P (value
));
169 id
->debug_map
= new hash_map
<tree
, tree
>;
171 id
->debug_map
->put (key
, value
);
174 /* If nonzero, we're remapping the contents of inlined debug
175 statements. If negative, an error has occurred, such as a
176 reference to a variable that isn't available in the inlined
178 static int processing_debug_stmt
= 0;
180 /* Construct new SSA name for old NAME. ID is the inline context. */
183 remap_ssa_name (tree name
, copy_body_data
*id
)
188 gcc_assert (TREE_CODE (name
) == SSA_NAME
);
190 n
= id
->decl_map
->get (name
);
192 return unshare_expr (*n
);
194 if (processing_debug_stmt
)
196 if (SSA_NAME_IS_DEFAULT_DEF (name
)
197 && TREE_CODE (SSA_NAME_VAR (name
)) == PARM_DECL
198 && id
->entry_bb
== NULL
199 && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (cfun
)))
201 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
203 gimple_stmt_iterator gsi
;
204 tree val
= SSA_NAME_VAR (name
);
206 n
= id
->decl_map
->get (val
);
209 if (TREE_CODE (val
) != PARM_DECL
)
211 processing_debug_stmt
= -1;
214 def_temp
= gimple_build_debug_source_bind (vexpr
, val
, NULL
);
215 DECL_ARTIFICIAL (vexpr
) = 1;
216 TREE_TYPE (vexpr
) = TREE_TYPE (name
);
217 SET_DECL_MODE (vexpr
, DECL_MODE (SSA_NAME_VAR (name
)));
218 gsi
= gsi_after_labels (single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
219 gsi_insert_before (&gsi
, def_temp
, GSI_SAME_STMT
);
223 processing_debug_stmt
= -1;
227 /* Remap anonymous SSA names or SSA names of anonymous decls. */
228 var
= SSA_NAME_VAR (name
);
230 || (!SSA_NAME_IS_DEFAULT_DEF (name
)
232 && !VAR_DECL_IS_VIRTUAL_OPERAND (var
)
233 && DECL_ARTIFICIAL (var
)
234 && DECL_IGNORED_P (var
)
235 && !DECL_NAME (var
)))
237 struct ptr_info_def
*pi
;
238 new_tree
= make_ssa_name (remap_type (TREE_TYPE (name
), id
));
239 if (!var
&& SSA_NAME_IDENTIFIER (name
))
240 SET_SSA_NAME_VAR_OR_IDENTIFIER (new_tree
, SSA_NAME_IDENTIFIER (name
));
241 insert_decl_map (id
, name
, new_tree
);
242 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
243 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
244 /* At least IPA points-to info can be directly transferred. */
245 if (id
->src_cfun
->gimple_df
246 && id
->src_cfun
->gimple_df
->ipa_pta
247 && POINTER_TYPE_P (TREE_TYPE (name
))
248 && (pi
= SSA_NAME_PTR_INFO (name
))
251 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
257 /* Do not set DEF_STMT yet as statement is not copied yet. We do that
259 new_tree
= remap_decl (var
, id
);
261 /* We might've substituted constant or another SSA_NAME for
264 Replace the SSA name representing RESULT_DECL by variable during
265 inlining: this saves us from need to introduce PHI node in a case
266 return value is just partly initialized. */
267 if ((VAR_P (new_tree
) || TREE_CODE (new_tree
) == PARM_DECL
)
268 && (!SSA_NAME_VAR (name
)
269 || TREE_CODE (SSA_NAME_VAR (name
)) != RESULT_DECL
270 || !id
->transform_return_to_modify
))
272 struct ptr_info_def
*pi
;
273 new_tree
= make_ssa_name (new_tree
);
274 insert_decl_map (id
, name
, new_tree
);
275 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
276 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
277 /* At least IPA points-to info can be directly transferred. */
278 if (id
->src_cfun
->gimple_df
279 && id
->src_cfun
->gimple_df
->ipa_pta
280 && POINTER_TYPE_P (TREE_TYPE (name
))
281 && (pi
= SSA_NAME_PTR_INFO (name
))
284 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
287 if (SSA_NAME_IS_DEFAULT_DEF (name
))
289 /* By inlining function having uninitialized variable, we might
290 extend the lifetime (variable might get reused). This cause
291 ICE in the case we end up extending lifetime of SSA name across
292 abnormal edge, but also increase register pressure.
294 We simply initialize all uninitialized vars by 0 except
295 for case we are inlining to very first BB. We can avoid
296 this for all BBs that are not inside strongly connected
297 regions of the CFG, but this is expensive to test. */
299 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
)
300 && (!SSA_NAME_VAR (name
)
301 || TREE_CODE (SSA_NAME_VAR (name
)) != PARM_DECL
)
302 && (id
->entry_bb
!= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
),
304 || EDGE_COUNT (id
->entry_bb
->preds
) != 1))
306 gimple_stmt_iterator gsi
= gsi_last_bb (id
->entry_bb
);
308 tree zero
= build_zero_cst (TREE_TYPE (new_tree
));
310 init_stmt
= gimple_build_assign (new_tree
, zero
);
311 gsi_insert_after (&gsi
, init_stmt
, GSI_NEW_STMT
);
312 SSA_NAME_IS_DEFAULT_DEF (new_tree
) = 0;
316 SSA_NAME_DEF_STMT (new_tree
) = gimple_build_nop ();
317 set_ssa_default_def (cfun
, SSA_NAME_VAR (new_tree
), new_tree
);
322 insert_decl_map (id
, name
, new_tree
);
326 /* Remap DECL during the copying of the BLOCK tree for the function. */
329 remap_decl (tree decl
, copy_body_data
*id
)
333 /* We only remap local variables in the current function. */
335 /* See if we have remapped this declaration. */
337 n
= id
->decl_map
->get (decl
);
339 if (!n
&& processing_debug_stmt
)
341 processing_debug_stmt
= -1;
345 /* When remapping a type within copy_gimple_seq_and_replace_locals, all
346 necessary DECLs have already been remapped and we do not want to duplicate
347 a decl coming from outside of the sequence we are copying. */
349 && id
->prevent_decl_creation_for_types
350 && id
->remapping_type_depth
> 0
351 && (VAR_P (decl
) || TREE_CODE (decl
) == PARM_DECL
))
354 /* If we didn't already have an equivalent for this declaration, create one
358 /* Make a copy of the variable or label. */
359 tree t
= id
->copy_decl (decl
, id
);
361 /* Remember it, so that if we encounter this local entity again
362 we can reuse this copy. Do this early because remap_type may
363 need this decl for TYPE_STUB_DECL. */
364 insert_decl_map (id
, decl
, t
);
369 /* Remap types, if necessary. */
370 TREE_TYPE (t
) = remap_type (TREE_TYPE (t
), id
);
371 if (TREE_CODE (t
) == TYPE_DECL
)
373 DECL_ORIGINAL_TYPE (t
) = remap_type (DECL_ORIGINAL_TYPE (t
), id
);
375 /* Preserve the invariant that DECL_ORIGINAL_TYPE != TREE_TYPE,
376 which is enforced in gen_typedef_die when DECL_ABSTRACT_ORIGIN
377 is not set on the TYPE_DECL, for example in LTO mode. */
378 if (DECL_ORIGINAL_TYPE (t
) == TREE_TYPE (t
))
380 tree x
= build_variant_type_copy (TREE_TYPE (t
));
381 TYPE_STUB_DECL (x
) = TYPE_STUB_DECL (TREE_TYPE (t
));
382 TYPE_NAME (x
) = TYPE_NAME (TREE_TYPE (t
));
383 DECL_ORIGINAL_TYPE (t
) = x
;
387 /* Remap sizes as necessary. */
388 walk_tree (&DECL_SIZE (t
), copy_tree_body_r
, id
, NULL
);
389 walk_tree (&DECL_SIZE_UNIT (t
), copy_tree_body_r
, id
, NULL
);
391 /* If fields, do likewise for offset and qualifier. */
392 if (TREE_CODE (t
) == FIELD_DECL
)
394 walk_tree (&DECL_FIELD_OFFSET (t
), copy_tree_body_r
, id
, NULL
);
395 if (TREE_CODE (DECL_CONTEXT (t
)) == QUAL_UNION_TYPE
)
396 walk_tree (&DECL_QUALIFIER (t
), copy_tree_body_r
, id
, NULL
);
402 if (id
->do_not_unshare
)
405 return unshare_expr (*n
);
409 remap_type_1 (tree type
, copy_body_data
*id
)
413 /* We do need a copy. build and register it now. If this is a pointer or
414 reference type, remap the designated type and make a new pointer or
416 if (TREE_CODE (type
) == POINTER_TYPE
)
418 new_tree
= build_pointer_type_for_mode (remap_type (TREE_TYPE (type
), id
),
420 TYPE_REF_CAN_ALIAS_ALL (type
));
421 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
422 new_tree
= build_type_attribute_qual_variant (new_tree
,
423 TYPE_ATTRIBUTES (type
),
425 insert_decl_map (id
, type
, new_tree
);
428 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
430 new_tree
= build_reference_type_for_mode (remap_type (TREE_TYPE (type
), id
),
432 TYPE_REF_CAN_ALIAS_ALL (type
));
433 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
434 new_tree
= build_type_attribute_qual_variant (new_tree
,
435 TYPE_ATTRIBUTES (type
),
437 insert_decl_map (id
, type
, new_tree
);
441 new_tree
= copy_node (type
);
443 insert_decl_map (id
, type
, new_tree
);
445 /* This is a new type, not a copy of an old type. Need to reassociate
446 variants. We can handle everything except the main variant lazily. */
447 t
= TYPE_MAIN_VARIANT (type
);
450 t
= remap_type (t
, id
);
451 TYPE_MAIN_VARIANT (new_tree
) = t
;
452 TYPE_NEXT_VARIANT (new_tree
) = TYPE_NEXT_VARIANT (t
);
453 TYPE_NEXT_VARIANT (t
) = new_tree
;
457 TYPE_MAIN_VARIANT (new_tree
) = new_tree
;
458 TYPE_NEXT_VARIANT (new_tree
) = NULL
;
461 if (TYPE_STUB_DECL (type
))
462 TYPE_STUB_DECL (new_tree
) = remap_decl (TYPE_STUB_DECL (type
), id
);
464 /* Lazily create pointer and reference types. */
465 TYPE_POINTER_TO (new_tree
) = NULL
;
466 TYPE_REFERENCE_TO (new_tree
) = NULL
;
468 /* Copy all types that may contain references to local variables; be sure to
469 preserve sharing in between type and its main variant when possible. */
470 switch (TREE_CODE (new_tree
))
474 case FIXED_POINT_TYPE
:
477 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
479 gcc_checking_assert (TYPE_MIN_VALUE (type
) == TYPE_MIN_VALUE (TYPE_MAIN_VARIANT (type
)));
480 gcc_checking_assert (TYPE_MAX_VALUE (type
) == TYPE_MAX_VALUE (TYPE_MAIN_VARIANT (type
)));
482 TYPE_MIN_VALUE (new_tree
) = TYPE_MIN_VALUE (TYPE_MAIN_VARIANT (new_tree
));
483 TYPE_MAX_VALUE (new_tree
) = TYPE_MAX_VALUE (TYPE_MAIN_VARIANT (new_tree
));
487 t
= TYPE_MIN_VALUE (new_tree
);
488 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
489 walk_tree (&TYPE_MIN_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
491 t
= TYPE_MAX_VALUE (new_tree
);
492 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
493 walk_tree (&TYPE_MAX_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
498 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
499 && TREE_TYPE (type
) == TREE_TYPE (TYPE_MAIN_VARIANT (type
)))
500 TREE_TYPE (new_tree
) = TREE_TYPE (TYPE_MAIN_VARIANT (new_tree
));
502 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
503 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
504 && TYPE_ARG_TYPES (type
) == TYPE_ARG_TYPES (TYPE_MAIN_VARIANT (type
)))
505 TYPE_ARG_TYPES (new_tree
) = TYPE_ARG_TYPES (TYPE_MAIN_VARIANT (new_tree
));
507 walk_tree (&TYPE_ARG_TYPES (new_tree
), copy_tree_body_r
, id
, NULL
);
511 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
512 && TREE_TYPE (type
) == TREE_TYPE (TYPE_MAIN_VARIANT (type
)))
513 TREE_TYPE (new_tree
) = TREE_TYPE (TYPE_MAIN_VARIANT (new_tree
));
515 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
517 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
519 gcc_checking_assert (TYPE_DOMAIN (type
) == TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)));
520 TYPE_DOMAIN (new_tree
) = TYPE_DOMAIN (TYPE_MAIN_VARIANT (new_tree
));
523 TYPE_DOMAIN (new_tree
) = remap_type (TYPE_DOMAIN (new_tree
), id
);
528 case QUAL_UNION_TYPE
:
529 if (TYPE_MAIN_VARIANT (type
) != type
530 && TYPE_FIELDS (type
) == TYPE_FIELDS (TYPE_MAIN_VARIANT (type
)))
531 TYPE_FIELDS (new_tree
) = TYPE_FIELDS (TYPE_MAIN_VARIANT (new_tree
));
536 for (f
= TYPE_FIELDS (new_tree
); f
; f
= DECL_CHAIN (f
))
538 t
= remap_decl (f
, id
);
539 DECL_CONTEXT (t
) = new_tree
;
543 TYPE_FIELDS (new_tree
) = nreverse (nf
);
549 /* Shouldn't have been thought variable sized. */
553 /* All variants of type share the same size, so use the already remaped data. */
554 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
556 gcc_checking_assert (TYPE_SIZE (type
) == TYPE_SIZE (TYPE_MAIN_VARIANT (type
)));
557 gcc_checking_assert (TYPE_SIZE_UNIT (type
) == TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type
)));
559 TYPE_SIZE (new_tree
) = TYPE_SIZE (TYPE_MAIN_VARIANT (new_tree
));
560 TYPE_SIZE_UNIT (new_tree
) = TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (new_tree
));
564 walk_tree (&TYPE_SIZE (new_tree
), copy_tree_body_r
, id
, NULL
);
565 walk_tree (&TYPE_SIZE_UNIT (new_tree
), copy_tree_body_r
, id
, NULL
);
572 remap_type (tree type
, copy_body_data
*id
)
580 /* See if we have remapped this type. */
581 node
= id
->decl_map
->get (type
);
585 /* The type only needs remapping if it's variably modified. */
586 if (! variably_modified_type_p (type
, id
->src_fn
))
588 insert_decl_map (id
, type
, type
);
592 id
->remapping_type_depth
++;
593 tmp
= remap_type_1 (type
, id
);
594 id
->remapping_type_depth
--;
599 /* Decide if DECL can be put into BLOCK_NONLOCAL_VARs. */
602 can_be_nonlocal (tree decl
, copy_body_data
*id
)
604 /* We can not duplicate function decls. */
605 if (TREE_CODE (decl
) == FUNCTION_DECL
)
608 /* Local static vars must be non-local or we get multiple declaration
610 if (VAR_P (decl
) && !auto_var_in_fn_p (decl
, id
->src_fn
))
617 remap_decls (tree decls
, vec
<tree
, va_gc
> **nonlocalized_list
,
621 tree new_decls
= NULL_TREE
;
623 /* Remap its variables. */
624 for (old_var
= decls
; old_var
; old_var
= DECL_CHAIN (old_var
))
628 if (can_be_nonlocal (old_var
, id
))
630 /* We need to add this variable to the local decls as otherwise
631 nothing else will do so. */
632 if (VAR_P (old_var
) && ! DECL_EXTERNAL (old_var
) && cfun
)
633 add_local_decl (cfun
, old_var
);
634 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
635 && !DECL_IGNORED_P (old_var
)
636 && nonlocalized_list
)
637 vec_safe_push (*nonlocalized_list
, old_var
);
641 /* Remap the variable. */
642 new_var
= remap_decl (old_var
, id
);
644 /* If we didn't remap this variable, we can't mess with its
645 TREE_CHAIN. If we remapped this variable to the return slot, it's
646 already declared somewhere else, so don't declare it here. */
648 if (new_var
== id
->retvar
)
652 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
653 && !DECL_IGNORED_P (old_var
)
654 && nonlocalized_list
)
655 vec_safe_push (*nonlocalized_list
, old_var
);
659 gcc_assert (DECL_P (new_var
));
660 DECL_CHAIN (new_var
) = new_decls
;
663 /* Also copy value-expressions. */
664 if (VAR_P (new_var
) && DECL_HAS_VALUE_EXPR_P (new_var
))
666 tree tem
= DECL_VALUE_EXPR (new_var
);
667 bool old_regimplify
= id
->regimplify
;
668 id
->remapping_type_depth
++;
669 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
670 id
->remapping_type_depth
--;
671 id
->regimplify
= old_regimplify
;
672 SET_DECL_VALUE_EXPR (new_var
, tem
);
677 return nreverse (new_decls
);
680 /* Copy the BLOCK to contain remapped versions of the variables
681 therein. And hook the new block into the block-tree. */
684 remap_block (tree
*block
, copy_body_data
*id
)
689 /* Make the new block. */
691 new_block
= make_node (BLOCK
);
692 TREE_USED (new_block
) = TREE_USED (old_block
);
693 BLOCK_ABSTRACT_ORIGIN (new_block
) = old_block
;
694 BLOCK_SOURCE_LOCATION (new_block
) = BLOCK_SOURCE_LOCATION (old_block
);
695 BLOCK_NONLOCALIZED_VARS (new_block
)
696 = vec_safe_copy (BLOCK_NONLOCALIZED_VARS (old_block
));
699 /* Remap its variables. */
700 BLOCK_VARS (new_block
) = remap_decls (BLOCK_VARS (old_block
),
701 &BLOCK_NONLOCALIZED_VARS (new_block
),
704 if (id
->transform_lang_insert_block
)
705 id
->transform_lang_insert_block (new_block
);
707 /* Remember the remapped block. */
708 insert_decl_map (id
, old_block
, new_block
);
711 /* Copy the whole block tree and root it in id->block. */
713 remap_blocks (tree block
, copy_body_data
*id
)
716 tree new_tree
= block
;
721 remap_block (&new_tree
, id
);
722 gcc_assert (new_tree
!= block
);
723 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
724 prepend_lexical_block (new_tree
, remap_blocks (t
, id
));
725 /* Blocks are in arbitrary order, but make things slightly prettier and do
726 not swap order when producing a copy. */
727 BLOCK_SUBBLOCKS (new_tree
) = blocks_nreverse (BLOCK_SUBBLOCKS (new_tree
));
731 /* Remap the block tree rooted at BLOCK to nothing. */
733 remap_blocks_to_null (tree block
, copy_body_data
*id
)
736 insert_decl_map (id
, block
, NULL_TREE
);
737 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
738 remap_blocks_to_null (t
, id
);
742 copy_statement_list (tree
*tp
)
744 tree_stmt_iterator oi
, ni
;
747 new_tree
= alloc_stmt_list ();
748 ni
= tsi_start (new_tree
);
749 oi
= tsi_start (*tp
);
750 TREE_TYPE (new_tree
) = TREE_TYPE (*tp
);
753 for (; !tsi_end_p (oi
); tsi_next (&oi
))
755 tree stmt
= tsi_stmt (oi
);
756 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
757 /* This copy is not redundant; tsi_link_after will smash this
758 STATEMENT_LIST into the end of the one we're building, and we
759 don't want to do that with the original. */
760 copy_statement_list (&stmt
);
761 tsi_link_after (&ni
, stmt
, TSI_CONTINUE_LINKING
);
766 copy_bind_expr (tree
*tp
, int *walk_subtrees
, copy_body_data
*id
)
768 tree block
= BIND_EXPR_BLOCK (*tp
);
769 /* Copy (and replace) the statement. */
770 copy_tree_r (tp
, walk_subtrees
, NULL
);
773 remap_block (&block
, id
);
774 BIND_EXPR_BLOCK (*tp
) = block
;
777 if (BIND_EXPR_VARS (*tp
))
778 /* This will remap a lot of the same decls again, but this should be
780 BIND_EXPR_VARS (*tp
) = remap_decls (BIND_EXPR_VARS (*tp
), NULL
, id
);
784 /* Create a new gimple_seq by remapping all the statements in BODY
785 using the inlining information in ID. */
788 remap_gimple_seq (gimple_seq body
, copy_body_data
*id
)
790 gimple_stmt_iterator si
;
791 gimple_seq new_body
= NULL
;
793 for (si
= gsi_start (body
); !gsi_end_p (si
); gsi_next (&si
))
795 gimple_seq new_stmts
= remap_gimple_stmt (gsi_stmt (si
), id
);
796 gimple_seq_add_seq (&new_body
, new_stmts
);
803 /* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its
804 block using the mapping information in ID. */
807 copy_gimple_bind (gbind
*stmt
, copy_body_data
*id
)
810 tree new_block
, new_vars
;
811 gimple_seq body
, new_body
;
813 /* Copy the statement. Note that we purposely don't use copy_stmt
814 here because we need to remap statements as we copy. */
815 body
= gimple_bind_body (stmt
);
816 new_body
= remap_gimple_seq (body
, id
);
818 new_block
= gimple_bind_block (stmt
);
820 remap_block (&new_block
, id
);
822 /* This will remap a lot of the same decls again, but this should be
824 new_vars
= gimple_bind_vars (stmt
);
826 new_vars
= remap_decls (new_vars
, NULL
, id
);
828 new_bind
= gimple_build_bind (new_vars
, new_body
, new_block
);
833 /* Return true if DECL is a parameter or a SSA_NAME for a parameter. */
838 if (TREE_CODE (decl
) == SSA_NAME
)
840 decl
= SSA_NAME_VAR (decl
);
845 return (TREE_CODE (decl
) == PARM_DECL
);
848 /* Remap the dependence CLIQUE from the source to the destination function
849 as specified in ID. */
851 static unsigned short
852 remap_dependence_clique (copy_body_data
*id
, unsigned short clique
)
854 if (clique
== 0 || processing_debug_stmt
)
856 if (!id
->dependence_map
)
857 id
->dependence_map
= new hash_map
<dependence_hash
, unsigned short>;
859 unsigned short &newc
= id
->dependence_map
->get_or_insert (clique
, &existed
);
861 newc
= ++cfun
->last_clique
;
865 /* Remap the GIMPLE operand pointed to by *TP. DATA is really a
866 'struct walk_stmt_info *'. DATA->INFO is a 'copy_body_data *'.
867 WALK_SUBTREES is used to indicate walk_gimple_op whether to keep
868 recursing into the children nodes of *TP. */
871 remap_gimple_op_r (tree
*tp
, int *walk_subtrees
, void *data
)
873 struct walk_stmt_info
*wi_p
= (struct walk_stmt_info
*) data
;
874 copy_body_data
*id
= (copy_body_data
*) wi_p
->info
;
875 tree fn
= id
->src_fn
;
877 /* For recursive invocations this is no longer the LHS itself. */
878 bool is_lhs
= wi_p
->is_lhs
;
879 wi_p
->is_lhs
= false;
881 if (TREE_CODE (*tp
) == SSA_NAME
)
883 *tp
= remap_ssa_name (*tp
, id
);
886 SSA_NAME_DEF_STMT (*tp
) = wi_p
->stmt
;
889 else if (auto_var_in_fn_p (*tp
, fn
))
891 /* Local variables and labels need to be replaced by equivalent
892 variables. We don't want to copy static variables; there's
893 only one of those, no matter how many times we inline the
894 containing function. Similarly for globals from an outer
898 /* Remap the declaration. */
899 new_decl
= remap_decl (*tp
, id
);
900 gcc_assert (new_decl
);
901 /* Replace this variable with the copy. */
902 STRIP_TYPE_NOPS (new_decl
);
903 /* ??? The C++ frontend uses void * pointer zero to initialize
904 any other type. This confuses the middle-end type verification.
905 As cloned bodies do not go through gimplification again the fixup
906 there doesn't trigger. */
907 if (TREE_CODE (new_decl
) == INTEGER_CST
908 && !useless_type_conversion_p (TREE_TYPE (*tp
), TREE_TYPE (new_decl
)))
909 new_decl
= fold_convert (TREE_TYPE (*tp
), new_decl
);
913 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
915 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
917 else if (TREE_CODE (*tp
) == LABEL_DECL
918 && (!DECL_CONTEXT (*tp
)
919 || decl_function_context (*tp
) == id
->src_fn
))
920 /* These may need to be remapped for EH handling. */
921 *tp
= remap_decl (*tp
, id
);
922 else if (TREE_CODE (*tp
) == FIELD_DECL
)
924 /* If the enclosing record type is variably_modified_type_p, the field
925 has already been remapped. Otherwise, it need not be. */
926 tree
*n
= id
->decl_map
->get (*tp
);
931 else if (TYPE_P (*tp
))
932 /* Types may need remapping as well. */
933 *tp
= remap_type (*tp
, id
);
934 else if (CONSTANT_CLASS_P (*tp
))
936 /* If this is a constant, we have to copy the node iff the type
937 will be remapped. copy_tree_r will not copy a constant. */
938 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
940 if (new_type
== TREE_TYPE (*tp
))
943 else if (TREE_CODE (*tp
) == INTEGER_CST
)
944 *tp
= wide_int_to_tree (new_type
, *tp
);
947 *tp
= copy_node (*tp
);
948 TREE_TYPE (*tp
) = new_type
;
953 /* Otherwise, just copy the node. Note that copy_tree_r already
954 knows not to copy VAR_DECLs, etc., so this is safe. */
956 if (TREE_CODE (*tp
) == MEM_REF
)
958 /* We need to re-canonicalize MEM_REFs from inline substitutions
959 that can happen when a pointer argument is an ADDR_EXPR.
960 Recurse here manually to allow that. */
961 tree ptr
= TREE_OPERAND (*tp
, 0);
962 tree type
= remap_type (TREE_TYPE (*tp
), id
);
964 walk_tree (&ptr
, remap_gimple_op_r
, data
, NULL
);
965 *tp
= fold_build2 (MEM_REF
, type
, ptr
, TREE_OPERAND (*tp
, 1));
966 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
967 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
968 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
969 if (MR_DEPENDENCE_CLIQUE (old
) != 0)
971 MR_DEPENDENCE_CLIQUE (*tp
)
972 = remap_dependence_clique (id
, MR_DEPENDENCE_CLIQUE (old
));
973 MR_DEPENDENCE_BASE (*tp
) = MR_DEPENDENCE_BASE (old
);
975 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
976 remapped a parameter as the property might be valid only
977 for the parameter itself. */
978 if (TREE_THIS_NOTRAP (old
)
979 && (!is_parm (TREE_OPERAND (old
, 0))
980 || (!id
->transform_parameter
&& is_parm (ptr
))))
981 TREE_THIS_NOTRAP (*tp
) = 1;
982 REF_REVERSE_STORAGE_ORDER (*tp
) = REF_REVERSE_STORAGE_ORDER (old
);
987 /* Here is the "usual case". Copy this tree node, and then
988 tweak some special cases. */
989 copy_tree_r (tp
, walk_subtrees
, NULL
);
991 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
992 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
994 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
996 /* The copied TARGET_EXPR has never been expanded, even if the
997 original node was expanded already. */
998 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
999 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
1001 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
1003 /* Variable substitution need not be simple. In particular,
1004 the MEM_REF substitution above. Make sure that
1005 TREE_CONSTANT and friends are up-to-date. */
1006 int invariant
= is_gimple_min_invariant (*tp
);
1007 walk_tree (&TREE_OPERAND (*tp
, 0), remap_gimple_op_r
, data
, NULL
);
1008 recompute_tree_invariant_for_addr_expr (*tp
);
1010 /* If this used to be invariant, but is not any longer,
1011 then regimplification is probably needed. */
1012 if (invariant
&& !is_gimple_min_invariant (*tp
))
1013 id
->regimplify
= true;
1019 /* Update the TREE_BLOCK for the cloned expr. */
1022 tree new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
1023 tree old_block
= TREE_BLOCK (*tp
);
1027 n
= id
->decl_map
->get (TREE_BLOCK (*tp
));
1031 TREE_SET_BLOCK (*tp
, new_block
);
1034 /* Keep iterating. */
1039 /* Called from copy_body_id via walk_tree. DATA is really a
1040 `copy_body_data *'. */
1043 copy_tree_body_r (tree
*tp
, int *walk_subtrees
, void *data
)
1045 copy_body_data
*id
= (copy_body_data
*) data
;
1046 tree fn
= id
->src_fn
;
1049 /* Begin by recognizing trees that we'll completely rewrite for the
1050 inlining context. Our output for these trees is completely
1051 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1052 into an edge). Further down, we'll handle trees that get
1053 duplicated and/or tweaked. */
1055 /* When requested, RETURN_EXPRs should be transformed to just the
1056 contained MODIFY_EXPR. The branch semantics of the return will
1057 be handled elsewhere by manipulating the CFG rather than a statement. */
1058 if (TREE_CODE (*tp
) == RETURN_EXPR
&& id
->transform_return_to_modify
)
1060 tree assignment
= TREE_OPERAND (*tp
, 0);
1062 /* If we're returning something, just turn that into an
1063 assignment into the equivalent of the original RESULT_DECL.
1064 If the "assignment" is just the result decl, the result
1065 decl has already been set (e.g. a recent "foo (&result_decl,
1066 ...)"); just toss the entire RETURN_EXPR. */
1067 if (assignment
&& TREE_CODE (assignment
) == MODIFY_EXPR
)
1069 /* Replace the RETURN_EXPR with (a copy of) the
1070 MODIFY_EXPR hanging underneath. */
1071 *tp
= copy_node (assignment
);
1073 else /* Else the RETURN_EXPR returns no value. */
1076 return (tree
) (void *)1;
1079 else if (TREE_CODE (*tp
) == SSA_NAME
)
1081 *tp
= remap_ssa_name (*tp
, id
);
1086 /* Local variables and labels need to be replaced by equivalent
1087 variables. We don't want to copy static variables; there's only
1088 one of those, no matter how many times we inline the containing
1089 function. Similarly for globals from an outer function. */
1090 else if (auto_var_in_fn_p (*tp
, fn
))
1094 /* Remap the declaration. */
1095 new_decl
= remap_decl (*tp
, id
);
1096 gcc_assert (new_decl
);
1097 /* Replace this variable with the copy. */
1098 STRIP_TYPE_NOPS (new_decl
);
1102 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
1103 copy_statement_list (tp
);
1104 else if (TREE_CODE (*tp
) == SAVE_EXPR
1105 || TREE_CODE (*tp
) == TARGET_EXPR
)
1106 remap_save_expr (tp
, id
->decl_map
, walk_subtrees
);
1107 else if (TREE_CODE (*tp
) == LABEL_DECL
1108 && (! DECL_CONTEXT (*tp
)
1109 || decl_function_context (*tp
) == id
->src_fn
))
1110 /* These may need to be remapped for EH handling. */
1111 *tp
= remap_decl (*tp
, id
);
1112 else if (TREE_CODE (*tp
) == BIND_EXPR
)
1113 copy_bind_expr (tp
, walk_subtrees
, id
);
1114 /* Types may need remapping as well. */
1115 else if (TYPE_P (*tp
))
1116 *tp
= remap_type (*tp
, id
);
1118 /* If this is a constant, we have to copy the node iff the type will be
1119 remapped. copy_tree_r will not copy a constant. */
1120 else if (CONSTANT_CLASS_P (*tp
))
1122 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
1124 if (new_type
== TREE_TYPE (*tp
))
1127 else if (TREE_CODE (*tp
) == INTEGER_CST
)
1128 *tp
= wide_int_to_tree (new_type
, *tp
);
1131 *tp
= copy_node (*tp
);
1132 TREE_TYPE (*tp
) = new_type
;
1136 /* Otherwise, just copy the node. Note that copy_tree_r already
1137 knows not to copy VAR_DECLs, etc., so this is safe. */
1140 /* Here we handle trees that are not completely rewritten.
1141 First we detect some inlining-induced bogosities for
1143 if (TREE_CODE (*tp
) == MODIFY_EXPR
1144 && TREE_OPERAND (*tp
, 0) == TREE_OPERAND (*tp
, 1)
1145 && (auto_var_in_fn_p (TREE_OPERAND (*tp
, 0), fn
)))
1147 /* Some assignments VAR = VAR; don't generate any rtl code
1148 and thus don't count as variable modification. Avoid
1149 keeping bogosities like 0 = 0. */
1150 tree decl
= TREE_OPERAND (*tp
, 0), value
;
1153 n
= id
->decl_map
->get (decl
);
1157 STRIP_TYPE_NOPS (value
);
1158 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1160 *tp
= build_empty_stmt (EXPR_LOCATION (*tp
));
1161 return copy_tree_body_r (tp
, walk_subtrees
, data
);
1165 else if (TREE_CODE (*tp
) == INDIRECT_REF
)
1167 /* Get rid of *& from inline substitutions that can happen when a
1168 pointer argument is an ADDR_EXPR. */
1169 tree decl
= TREE_OPERAND (*tp
, 0);
1170 tree
*n
= id
->decl_map
->get (decl
);
1173 /* If we happen to get an ADDR_EXPR in n->value, strip
1174 it manually here as we'll eventually get ADDR_EXPRs
1175 which lie about their types pointed to. In this case
1176 build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
1177 but we absolutely rely on that. As fold_indirect_ref
1178 does other useful transformations, try that first, though. */
1179 tree type
= TREE_TYPE (*tp
);
1180 tree ptr
= id
->do_not_unshare
? *n
: unshare_expr (*n
);
1182 *tp
= gimple_fold_indirect_ref (ptr
);
1185 if (TREE_CODE (ptr
) == ADDR_EXPR
)
1188 = fold_indirect_ref_1 (EXPR_LOCATION (ptr
), type
, ptr
);
1189 /* ??? We should either assert here or build
1190 a VIEW_CONVERT_EXPR instead of blindly leaking
1191 incompatible types to our IL. */
1193 *tp
= TREE_OPERAND (ptr
, 0);
1197 *tp
= build1 (INDIRECT_REF
, type
, ptr
);
1198 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1199 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1200 TREE_READONLY (*tp
) = TREE_READONLY (old
);
1201 /* We cannot propagate the TREE_THIS_NOTRAP flag if we
1202 have remapped a parameter as the property might be
1203 valid only for the parameter itself. */
1204 if (TREE_THIS_NOTRAP (old
)
1205 && (!is_parm (TREE_OPERAND (old
, 0))
1206 || (!id
->transform_parameter
&& is_parm (ptr
))))
1207 TREE_THIS_NOTRAP (*tp
) = 1;
1214 else if (TREE_CODE (*tp
) == MEM_REF
)
1216 /* We need to re-canonicalize MEM_REFs from inline substitutions
1217 that can happen when a pointer argument is an ADDR_EXPR.
1218 Recurse here manually to allow that. */
1219 tree ptr
= TREE_OPERAND (*tp
, 0);
1220 tree type
= remap_type (TREE_TYPE (*tp
), id
);
1222 walk_tree (&ptr
, copy_tree_body_r
, data
, NULL
);
1223 *tp
= fold_build2 (MEM_REF
, type
, ptr
, TREE_OPERAND (*tp
, 1));
1224 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1225 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1226 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
1227 if (MR_DEPENDENCE_CLIQUE (old
) != 0)
1229 MR_DEPENDENCE_CLIQUE (*tp
)
1230 = remap_dependence_clique (id
, MR_DEPENDENCE_CLIQUE (old
));
1231 MR_DEPENDENCE_BASE (*tp
) = MR_DEPENDENCE_BASE (old
);
1233 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
1234 remapped a parameter as the property might be valid only
1235 for the parameter itself. */
1236 if (TREE_THIS_NOTRAP (old
)
1237 && (!is_parm (TREE_OPERAND (old
, 0))
1238 || (!id
->transform_parameter
&& is_parm (ptr
))))
1239 TREE_THIS_NOTRAP (*tp
) = 1;
1240 REF_REVERSE_STORAGE_ORDER (*tp
) = REF_REVERSE_STORAGE_ORDER (old
);
1245 /* Here is the "usual case". Copy this tree node, and then
1246 tweak some special cases. */
1247 copy_tree_r (tp
, walk_subtrees
, NULL
);
1249 /* If EXPR has block defined, map it to newly constructed block.
1250 When inlining we want EXPRs without block appear in the block
1251 of function call if we are not remapping a type. */
1254 new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
1255 if (TREE_BLOCK (*tp
))
1258 n
= id
->decl_map
->get (TREE_BLOCK (*tp
));
1262 TREE_SET_BLOCK (*tp
, new_block
);
1265 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
1266 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
1268 /* The copied TARGET_EXPR has never been expanded, even if the
1269 original node was expanded already. */
1270 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
1272 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
1273 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
1276 /* Variable substitution need not be simple. In particular, the
1277 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
1278 and friends are up-to-date. */
1279 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
1281 int invariant
= is_gimple_min_invariant (*tp
);
1282 walk_tree (&TREE_OPERAND (*tp
, 0), copy_tree_body_r
, id
, NULL
);
1284 /* Handle the case where we substituted an INDIRECT_REF
1285 into the operand of the ADDR_EXPR. */
1286 if (TREE_CODE (TREE_OPERAND (*tp
, 0)) == INDIRECT_REF
)
1288 tree t
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0);
1289 if (TREE_TYPE (t
) != TREE_TYPE (*tp
))
1290 t
= fold_convert (remap_type (TREE_TYPE (*tp
), id
), t
);
1294 recompute_tree_invariant_for_addr_expr (*tp
);
1296 /* If this used to be invariant, but is not any longer,
1297 then regimplification is probably needed. */
1298 if (invariant
&& !is_gimple_min_invariant (*tp
))
1299 id
->regimplify
= true;
1305 /* Keep iterating. */
1309 /* Helper for remap_gimple_stmt. Given an EH region number for the
1310 source function, map that to the duplicate EH region number in
1311 the destination function. */
1314 remap_eh_region_nr (int old_nr
, copy_body_data
*id
)
1316 eh_region old_r
, new_r
;
1318 old_r
= get_eh_region_from_number_fn (id
->src_cfun
, old_nr
);
1319 new_r
= static_cast<eh_region
> (*id
->eh_map
->get (old_r
));
1321 return new_r
->index
;
1324 /* Similar, but operate on INTEGER_CSTs. */
1327 remap_eh_region_tree_nr (tree old_t_nr
, copy_body_data
*id
)
1331 old_nr
= tree_to_shwi (old_t_nr
);
1332 new_nr
= remap_eh_region_nr (old_nr
, id
);
1334 return build_int_cst (integer_type_node
, new_nr
);
1337 /* Helper for copy_bb. Remap statement STMT using the inlining
1338 information in ID. Return the new statement copy. */
1341 remap_gimple_stmt (gimple
*stmt
, copy_body_data
*id
)
1343 gimple
*copy
= NULL
;
1344 struct walk_stmt_info wi
;
1345 bool skip_first
= false;
1346 gimple_seq stmts
= NULL
;
1348 if (is_gimple_debug (stmt
)
1349 && !opt_for_fn (id
->dst_fn
, flag_var_tracking_assignments
))
1352 /* Begin by recognizing trees that we'll completely rewrite for the
1353 inlining context. Our output for these trees is completely
1354 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1355 into an edge). Further down, we'll handle trees that get
1356 duplicated and/or tweaked. */
1358 /* When requested, GIMPLE_RETURNs should be transformed to just the
1359 contained GIMPLE_ASSIGN. The branch semantics of the return will
1360 be handled elsewhere by manipulating the CFG rather than the
1362 if (gimple_code (stmt
) == GIMPLE_RETURN
&& id
->transform_return_to_modify
)
1364 tree retval
= gimple_return_retval (as_a
<greturn
*> (stmt
));
1365 tree retbnd
= gimple_return_retbnd (stmt
);
1366 tree bndslot
= id
->retbnd
;
1368 if (retbnd
&& bndslot
)
1370 gimple
*bndcopy
= gimple_build_assign (bndslot
, retbnd
);
1371 memset (&wi
, 0, sizeof (wi
));
1373 walk_gimple_op (bndcopy
, remap_gimple_op_r
, &wi
);
1374 gimple_seq_add_stmt (&stmts
, bndcopy
);
1377 /* If we're returning something, just turn that into an
1378 assignment into the equivalent of the original RESULT_DECL.
1379 If RETVAL is just the result decl, the result decl has
1380 already been set (e.g. a recent "foo (&result_decl, ...)");
1381 just toss the entire GIMPLE_RETURN. */
1383 && (TREE_CODE (retval
) != RESULT_DECL
1384 && (TREE_CODE (retval
) != SSA_NAME
1385 || ! SSA_NAME_VAR (retval
)
1386 || TREE_CODE (SSA_NAME_VAR (retval
)) != RESULT_DECL
)))
1388 copy
= gimple_build_assign (id
->do_not_unshare
1389 ? id
->retvar
: unshare_expr (id
->retvar
),
1391 /* id->retvar is already substituted. Skip it on later remapping. */
1394 /* We need to copy bounds if return structure with pointers into
1395 instrumented function. */
1396 if (chkp_function_instrumented_p (id
->dst_fn
)
1398 && !BOUNDED_P (id
->retvar
)
1399 && chkp_type_has_pointer (TREE_TYPE (id
->retvar
)))
1400 id
->assign_stmts
.safe_push (copy
);
1406 else if (gimple_has_substatements (stmt
))
1410 /* When cloning bodies from the C++ front end, we will be handed bodies
1411 in High GIMPLE form. Handle here all the High GIMPLE statements that
1412 have embedded statements. */
1413 switch (gimple_code (stmt
))
1416 copy
= copy_gimple_bind (as_a
<gbind
*> (stmt
), id
);
1421 gcatch
*catch_stmt
= as_a
<gcatch
*> (stmt
);
1422 s1
= remap_gimple_seq (gimple_catch_handler (catch_stmt
), id
);
1423 copy
= gimple_build_catch (gimple_catch_types (catch_stmt
), s1
);
1427 case GIMPLE_EH_FILTER
:
1428 s1
= remap_gimple_seq (gimple_eh_filter_failure (stmt
), id
);
1429 copy
= gimple_build_eh_filter (gimple_eh_filter_types (stmt
), s1
);
1433 s1
= remap_gimple_seq (gimple_try_eval (stmt
), id
);
1434 s2
= remap_gimple_seq (gimple_try_cleanup (stmt
), id
);
1435 copy
= gimple_build_try (s1
, s2
, gimple_try_kind (stmt
));
1438 case GIMPLE_WITH_CLEANUP_EXPR
:
1439 s1
= remap_gimple_seq (gimple_wce_cleanup (stmt
), id
);
1440 copy
= gimple_build_wce (s1
);
1443 case GIMPLE_OMP_PARALLEL
:
1445 gomp_parallel
*omp_par_stmt
= as_a
<gomp_parallel
*> (stmt
);
1446 s1
= remap_gimple_seq (gimple_omp_body (omp_par_stmt
), id
);
1447 copy
= gimple_build_omp_parallel
1449 gimple_omp_parallel_clauses (omp_par_stmt
),
1450 gimple_omp_parallel_child_fn (omp_par_stmt
),
1451 gimple_omp_parallel_data_arg (omp_par_stmt
));
1455 case GIMPLE_OMP_TASK
:
1456 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1457 copy
= gimple_build_omp_task
1459 gimple_omp_task_clauses (stmt
),
1460 gimple_omp_task_child_fn (stmt
),
1461 gimple_omp_task_data_arg (stmt
),
1462 gimple_omp_task_copy_fn (stmt
),
1463 gimple_omp_task_arg_size (stmt
),
1464 gimple_omp_task_arg_align (stmt
));
1467 case GIMPLE_OMP_FOR
:
1468 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1469 s2
= remap_gimple_seq (gimple_omp_for_pre_body (stmt
), id
);
1470 copy
= gimple_build_omp_for (s1
, gimple_omp_for_kind (stmt
),
1471 gimple_omp_for_clauses (stmt
),
1472 gimple_omp_for_collapse (stmt
), s2
);
1475 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1477 gimple_omp_for_set_index (copy
, i
,
1478 gimple_omp_for_index (stmt
, i
));
1479 gimple_omp_for_set_initial (copy
, i
,
1480 gimple_omp_for_initial (stmt
, i
));
1481 gimple_omp_for_set_final (copy
, i
,
1482 gimple_omp_for_final (stmt
, i
));
1483 gimple_omp_for_set_incr (copy
, i
,
1484 gimple_omp_for_incr (stmt
, i
));
1485 gimple_omp_for_set_cond (copy
, i
,
1486 gimple_omp_for_cond (stmt
, i
));
1491 case GIMPLE_OMP_MASTER
:
1492 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1493 copy
= gimple_build_omp_master (s1
);
1496 case GIMPLE_OMP_TASKGROUP
:
1497 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1498 copy
= gimple_build_omp_taskgroup (s1
);
1501 case GIMPLE_OMP_ORDERED
:
1502 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1503 copy
= gimple_build_omp_ordered
1505 gimple_omp_ordered_clauses (as_a
<gomp_ordered
*> (stmt
)));
1508 case GIMPLE_OMP_SECTION
:
1509 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1510 copy
= gimple_build_omp_section (s1
);
1513 case GIMPLE_OMP_SECTIONS
:
1514 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1515 copy
= gimple_build_omp_sections
1516 (s1
, gimple_omp_sections_clauses (stmt
));
1519 case GIMPLE_OMP_SINGLE
:
1520 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1521 copy
= gimple_build_omp_single
1522 (s1
, gimple_omp_single_clauses (stmt
));
1525 case GIMPLE_OMP_TARGET
:
1526 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1527 copy
= gimple_build_omp_target
1528 (s1
, gimple_omp_target_kind (stmt
),
1529 gimple_omp_target_clauses (stmt
));
1532 case GIMPLE_OMP_TEAMS
:
1533 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1534 copy
= gimple_build_omp_teams
1535 (s1
, gimple_omp_teams_clauses (stmt
));
1538 case GIMPLE_OMP_CRITICAL
:
1539 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1540 copy
= gimple_build_omp_critical (s1
,
1541 gimple_omp_critical_name
1542 (as_a
<gomp_critical
*> (stmt
)),
1543 gimple_omp_critical_clauses
1544 (as_a
<gomp_critical
*> (stmt
)));
1547 case GIMPLE_TRANSACTION
:
1549 gtransaction
*old_trans_stmt
= as_a
<gtransaction
*> (stmt
);
1550 gtransaction
*new_trans_stmt
;
1551 s1
= remap_gimple_seq (gimple_transaction_body (old_trans_stmt
),
1553 copy
= new_trans_stmt
= gimple_build_transaction (s1
);
1554 gimple_transaction_set_subcode (new_trans_stmt
,
1555 gimple_transaction_subcode (old_trans_stmt
));
1556 gimple_transaction_set_label_norm (new_trans_stmt
,
1557 gimple_transaction_label_norm (old_trans_stmt
));
1558 gimple_transaction_set_label_uninst (new_trans_stmt
,
1559 gimple_transaction_label_uninst (old_trans_stmt
));
1560 gimple_transaction_set_label_over (new_trans_stmt
,
1561 gimple_transaction_label_over (old_trans_stmt
));
1571 if (gimple_assign_copy_p (stmt
)
1572 && gimple_assign_lhs (stmt
) == gimple_assign_rhs1 (stmt
)
1573 && auto_var_in_fn_p (gimple_assign_lhs (stmt
), id
->src_fn
))
1575 /* Here we handle statements that are not completely rewritten.
1576 First we detect some inlining-induced bogosities for
1579 /* Some assignments VAR = VAR; don't generate any rtl code
1580 and thus don't count as variable modification. Avoid
1581 keeping bogosities like 0 = 0. */
1582 tree decl
= gimple_assign_lhs (stmt
), value
;
1585 n
= id
->decl_map
->get (decl
);
1589 STRIP_TYPE_NOPS (value
);
1590 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1595 /* For *ptr_N ={v} {CLOBBER}, if ptr_N is SSA_NAME defined
1596 in a block that we aren't copying during tree_function_versioning,
1597 just drop the clobber stmt. */
1598 if (id
->blocks_to_copy
&& gimple_clobber_p (stmt
))
1600 tree lhs
= gimple_assign_lhs (stmt
);
1601 if (TREE_CODE (lhs
) == MEM_REF
1602 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == SSA_NAME
)
1604 gimple
*def_stmt
= SSA_NAME_DEF_STMT (TREE_OPERAND (lhs
, 0));
1605 if (gimple_bb (def_stmt
)
1606 && !bitmap_bit_p (id
->blocks_to_copy
,
1607 gimple_bb (def_stmt
)->index
))
1612 if (gimple_debug_bind_p (stmt
))
1615 = gimple_build_debug_bind (gimple_debug_bind_get_var (stmt
),
1616 gimple_debug_bind_get_value (stmt
),
1618 id
->debug_stmts
.safe_push (copy
);
1619 gimple_seq_add_stmt (&stmts
, copy
);
1622 if (gimple_debug_source_bind_p (stmt
))
1624 gdebug
*copy
= gimple_build_debug_source_bind
1625 (gimple_debug_source_bind_get_var (stmt
),
1626 gimple_debug_source_bind_get_value (stmt
),
1628 id
->debug_stmts
.safe_push (copy
);
1629 gimple_seq_add_stmt (&stmts
, copy
);
1633 /* Create a new deep copy of the statement. */
1634 copy
= gimple_copy (stmt
);
1636 /* Clear flags that need revisiting. */
1637 if (gcall
*call_stmt
= dyn_cast
<gcall
*> (copy
))
1639 if (gimple_call_tail_p (call_stmt
))
1640 gimple_call_set_tail (call_stmt
, false);
1641 if (gimple_call_from_thunk_p (call_stmt
))
1642 gimple_call_set_from_thunk (call_stmt
, false);
1643 if (gimple_call_internal_p (call_stmt
))
1644 switch (gimple_call_internal_fn (call_stmt
))
1646 case IFN_GOMP_SIMD_LANE
:
1647 case IFN_GOMP_SIMD_VF
:
1648 case IFN_GOMP_SIMD_LAST_LANE
:
1649 case IFN_GOMP_SIMD_ORDERED_START
:
1650 case IFN_GOMP_SIMD_ORDERED_END
:
1651 DECL_STRUCT_FUNCTION (id
->dst_fn
)->has_simduid_loops
= true;
1658 /* Remap the region numbers for __builtin_eh_{pointer,filter},
1659 RESX and EH_DISPATCH. */
1661 switch (gimple_code (copy
))
1665 tree r
, fndecl
= gimple_call_fndecl (copy
);
1666 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
1667 switch (DECL_FUNCTION_CODE (fndecl
))
1669 case BUILT_IN_EH_COPY_VALUES
:
1670 r
= gimple_call_arg (copy
, 1);
1671 r
= remap_eh_region_tree_nr (r
, id
);
1672 gimple_call_set_arg (copy
, 1, r
);
1675 case BUILT_IN_EH_POINTER
:
1676 case BUILT_IN_EH_FILTER
:
1677 r
= gimple_call_arg (copy
, 0);
1678 r
= remap_eh_region_tree_nr (r
, id
);
1679 gimple_call_set_arg (copy
, 0, r
);
1686 /* Reset alias info if we didn't apply measures to
1687 keep it valid over inlining by setting DECL_PT_UID. */
1688 if (!id
->src_cfun
->gimple_df
1689 || !id
->src_cfun
->gimple_df
->ipa_pta
)
1690 gimple_call_reset_alias_info (as_a
<gcall
*> (copy
));
1696 gresx
*resx_stmt
= as_a
<gresx
*> (copy
);
1697 int r
= gimple_resx_region (resx_stmt
);
1698 r
= remap_eh_region_nr (r
, id
);
1699 gimple_resx_set_region (resx_stmt
, r
);
1703 case GIMPLE_EH_DISPATCH
:
1705 geh_dispatch
*eh_dispatch
= as_a
<geh_dispatch
*> (copy
);
1706 int r
= gimple_eh_dispatch_region (eh_dispatch
);
1707 r
= remap_eh_region_nr (r
, id
);
1708 gimple_eh_dispatch_set_region (eh_dispatch
, r
);
1717 /* If STMT has a block defined, map it to the newly constructed
1719 if (gimple_block (copy
))
1722 n
= id
->decl_map
->get (gimple_block (copy
));
1724 gimple_set_block (copy
, *n
);
1727 if (gimple_debug_bind_p (copy
) || gimple_debug_source_bind_p (copy
))
1729 gimple_seq_add_stmt (&stmts
, copy
);
1733 /* Remap all the operands in COPY. */
1734 memset (&wi
, 0, sizeof (wi
));
1737 walk_tree (gimple_op_ptr (copy
, 1), remap_gimple_op_r
, &wi
, NULL
);
1739 walk_gimple_op (copy
, remap_gimple_op_r
, &wi
);
1741 /* Clear the copied virtual operands. We are not remapping them here
1742 but are going to recreate them from scratch. */
1743 if (gimple_has_mem_ops (copy
))
1745 gimple_set_vdef (copy
, NULL_TREE
);
1746 gimple_set_vuse (copy
, NULL_TREE
);
1749 gimple_seq_add_stmt (&stmts
, copy
);
1754 /* Copy basic block, scale profile accordingly. Edges will be taken care of
1758 copy_bb (copy_body_data
*id
, basic_block bb
, int frequency_scale
,
1759 profile_count num
, profile_count den
)
1761 gimple_stmt_iterator gsi
, copy_gsi
, seq_gsi
;
1762 basic_block copy_basic_block
;
1766 bool scale
= num
.initialized_p ()
1767 && (den
> 0 || num
== profile_count::zero ());
1769 /* Search for previous copied basic block. */
1772 prev
= prev
->prev_bb
;
1774 /* create_basic_block() will append every new block to
1775 basic_block_info automatically. */
1776 copy_basic_block
= create_basic_block (NULL
, (basic_block
) prev
->aux
);
1778 copy_basic_block
->count
= bb
->count
.apply_scale (num
, den
);
1780 /* We are going to rebuild frequencies from scratch. These values
1781 have just small importance to drive canonicalize_loop_headers. */
1782 freq
= apply_scale ((gcov_type
)bb
->frequency
, frequency_scale
);
1784 /* We recompute frequencies after inlining, so this is quite safe. */
1785 if (freq
> BB_FREQ_MAX
)
1787 copy_basic_block
->frequency
= freq
;
1789 copy_gsi
= gsi_start_bb (copy_basic_block
);
1791 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1794 gimple
*stmt
= gsi_stmt (gsi
);
1795 gimple
*orig_stmt
= stmt
;
1796 gimple_stmt_iterator stmts_gsi
;
1797 bool stmt_added
= false;
1799 id
->regimplify
= false;
1800 stmts
= remap_gimple_stmt (stmt
, id
);
1802 if (gimple_seq_empty_p (stmts
))
1807 for (stmts_gsi
= gsi_start (stmts
);
1808 !gsi_end_p (stmts_gsi
); )
1810 stmt
= gsi_stmt (stmts_gsi
);
1812 /* Advance iterator now before stmt is moved to seq_gsi. */
1813 gsi_next (&stmts_gsi
);
1815 if (gimple_nop_p (stmt
))
1818 gimple_duplicate_stmt_histograms (cfun
, stmt
, id
->src_cfun
,
1821 /* With return slot optimization we can end up with
1822 non-gimple (foo *)&this->m, fix that here. */
1823 if (is_gimple_assign (stmt
)
1824 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
))
1825 && !is_gimple_val (gimple_assign_rhs1 (stmt
)))
1828 new_rhs
= force_gimple_operand_gsi (&seq_gsi
,
1829 gimple_assign_rhs1 (stmt
),
1831 GSI_CONTINUE_LINKING
);
1832 gimple_assign_set_rhs1 (stmt
, new_rhs
);
1833 id
->regimplify
= false;
1836 gsi_insert_after (&seq_gsi
, stmt
, GSI_NEW_STMT
);
1839 gimple_regimplify_operands (stmt
, &seq_gsi
);
1847 /* If copy_basic_block has been empty at the start of this iteration,
1848 call gsi_start_bb again to get at the newly added statements. */
1849 if (gsi_end_p (copy_gsi
))
1850 copy_gsi
= gsi_start_bb (copy_basic_block
);
1852 gsi_next (©_gsi
);
1854 /* Process the new statement. The call to gimple_regimplify_operands
1855 possibly turned the statement into multiple statements, we
1856 need to process all of them. */
1862 stmt
= gsi_stmt (copy_gsi
);
1863 call_stmt
= dyn_cast
<gcall
*> (stmt
);
1865 && gimple_call_va_arg_pack_p (call_stmt
)
1867 && ! gimple_call_va_arg_pack_p (id
->call_stmt
))
1869 /* __builtin_va_arg_pack () should be replaced by
1870 all arguments corresponding to ... in the caller. */
1874 size_t nargs
= gimple_call_num_args (id
->call_stmt
);
1875 size_t n
, i
, nargs_to_copy
;
1876 bool remove_bounds
= false;
1878 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1881 /* Bounds should be removed from arg pack in case
1882 we handle not instrumented call in instrumented
1884 nargs_to_copy
= nargs
;
1885 if (gimple_call_with_bounds_p (id
->call_stmt
)
1886 && !gimple_call_with_bounds_p (stmt
))
1888 for (i
= gimple_call_num_args (id
->call_stmt
) - nargs
;
1889 i
< gimple_call_num_args (id
->call_stmt
);
1891 if (POINTER_BOUNDS_P (gimple_call_arg (id
->call_stmt
, i
)))
1893 remove_bounds
= true;
1896 /* Create the new array of arguments. */
1897 n
= nargs_to_copy
+ gimple_call_num_args (call_stmt
);
1898 argarray
.create (n
);
1899 argarray
.safe_grow_cleared (n
);
1901 /* Copy all the arguments before '...' */
1902 memcpy (argarray
.address (),
1903 gimple_call_arg_ptr (call_stmt
, 0),
1904 gimple_call_num_args (call_stmt
) * sizeof (tree
));
1908 /* Append the rest of arguments removing bounds. */
1909 unsigned cur
= gimple_call_num_args (call_stmt
);
1910 i
= gimple_call_num_args (id
->call_stmt
) - nargs
;
1911 for (i
= gimple_call_num_args (id
->call_stmt
) - nargs
;
1912 i
< gimple_call_num_args (id
->call_stmt
);
1914 if (!POINTER_BOUNDS_P (gimple_call_arg (id
->call_stmt
, i
)))
1915 argarray
[cur
++] = gimple_call_arg (id
->call_stmt
, i
);
1916 gcc_assert (cur
== n
);
1920 /* Append the arguments passed in '...' */
1921 memcpy (argarray
.address () + gimple_call_num_args (call_stmt
),
1922 gimple_call_arg_ptr (id
->call_stmt
, 0)
1923 + (gimple_call_num_args (id
->call_stmt
) - nargs
),
1924 nargs
* sizeof (tree
));
1927 new_call
= gimple_build_call_vec (gimple_call_fn (call_stmt
),
1930 argarray
.release ();
1932 /* Copy all GIMPLE_CALL flags, location and block, except
1933 GF_CALL_VA_ARG_PACK. */
1934 gimple_call_copy_flags (new_call
, call_stmt
);
1935 gimple_call_set_va_arg_pack (new_call
, false);
1936 gimple_set_location (new_call
, gimple_location (stmt
));
1937 gimple_set_block (new_call
, gimple_block (stmt
));
1938 gimple_call_set_lhs (new_call
, gimple_call_lhs (call_stmt
));
1940 gsi_replace (©_gsi
, new_call
, false);
1945 && (decl
= gimple_call_fndecl (stmt
))
1946 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
1947 && DECL_FUNCTION_CODE (decl
) == BUILT_IN_VA_ARG_PACK_LEN
1948 && ! gimple_call_va_arg_pack_p (id
->call_stmt
))
1950 /* __builtin_va_arg_pack_len () should be replaced by
1951 the number of anonymous arguments. */
1952 size_t nargs
= gimple_call_num_args (id
->call_stmt
), i
;
1956 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1959 /* For instrumented calls we should ignore bounds. */
1960 for (i
= gimple_call_num_args (id
->call_stmt
) - nargs
;
1961 i
< gimple_call_num_args (id
->call_stmt
);
1963 if (POINTER_BOUNDS_P (gimple_call_arg (id
->call_stmt
, i
)))
1966 count
= build_int_cst (integer_type_node
, nargs
);
1967 new_stmt
= gimple_build_assign (gimple_call_lhs (stmt
), count
);
1968 gsi_replace (©_gsi
, new_stmt
, false);
1973 && gimple_call_internal_p (stmt
)
1974 && gimple_call_internal_fn (stmt
) == IFN_TSAN_FUNC_EXIT
)
1976 /* Drop TSAN_FUNC_EXIT () internal calls during inlining. */
1977 gsi_remove (©_gsi
, false);
1981 /* Statements produced by inlining can be unfolded, especially
1982 when we constant propagated some operands. We can't fold
1983 them right now for two reasons:
1984 1) folding require SSA_NAME_DEF_STMTs to be correct
1985 2) we can't change function calls to builtins.
1986 So we just mark statement for later folding. We mark
1987 all new statements, instead just statements that has changed
1988 by some nontrivial substitution so even statements made
1989 foldable indirectly are updated. If this turns out to be
1990 expensive, copy_body can be told to watch for nontrivial
1992 if (id
->statements_to_fold
)
1993 id
->statements_to_fold
->add (stmt
);
1995 /* We're duplicating a CALL_EXPR. Find any corresponding
1996 callgraph edges and update or duplicate them. */
1997 if (gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
))
1999 struct cgraph_edge
*edge
;
2001 switch (id
->transform_call_graph_edges
)
2003 case CB_CGE_DUPLICATE
:
2004 edge
= id
->src_node
->get_edge (orig_stmt
);
2007 int edge_freq
= edge
->frequency
;
2009 struct cgraph_edge
*old_edge
= edge
;
2010 edge
= edge
->clone (id
->dst_node
, call_stmt
,
2012 profile_count::one (),
2013 profile_count::one (),
2016 /* We could also just rescale the frequency, but
2017 doing so would introduce roundoff errors and make
2018 verifier unhappy. */
2019 new_freq
= compute_call_stmt_bb_frequency (id
->dst_node
->decl
,
2022 /* Speculative calls consist of two edges - direct and indirect.
2023 Duplicate the whole thing and distribute frequencies accordingly. */
2024 if (edge
->speculative
)
2026 struct cgraph_edge
*direct
, *indirect
;
2027 struct ipa_ref
*ref
;
2029 gcc_assert (!edge
->indirect_unknown_callee
);
2030 old_edge
->speculative_call_info (direct
, indirect
, ref
);
2031 indirect
= indirect
->clone (id
->dst_node
, call_stmt
,
2033 profile_count::one (),
2034 profile_count::one (),
2037 if (old_edge
->frequency
+ indirect
->frequency
)
2039 edge
->frequency
= MIN (RDIV ((gcov_type
)new_freq
* old_edge
->frequency
,
2040 (old_edge
->frequency
+ indirect
->frequency
)),
2042 indirect
->frequency
= MIN (RDIV ((gcov_type
)new_freq
* indirect
->frequency
,
2043 (old_edge
->frequency
+ indirect
->frequency
)),
2046 id
->dst_node
->clone_reference (ref
, stmt
);
2050 edge
->frequency
= new_freq
;
2052 && profile_status_for_fn (cfun
) != PROFILE_ABSENT
2053 && (edge_freq
> edge
->frequency
+ 10
2054 || edge_freq
< edge
->frequency
- 10))
2056 fprintf (dump_file
, "Edge frequency estimated by "
2057 "cgraph %i diverge from inliner's estimate %i\n",
2061 "Orig bb: %i, orig bb freq %i, new bb freq %i\n",
2064 copy_basic_block
->frequency
);
2070 case CB_CGE_MOVE_CLONES
:
2071 id
->dst_node
->set_call_stmt_including_clones (orig_stmt
,
2073 edge
= id
->dst_node
->get_edge (stmt
);
2077 edge
= id
->dst_node
->get_edge (orig_stmt
);
2079 edge
->set_call_stmt (call_stmt
);
2086 /* Constant propagation on argument done during inlining
2087 may create new direct call. Produce an edge for it. */
2089 || (edge
->indirect_inlining_edge
2090 && id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
))
2091 && id
->dst_node
->definition
2092 && (fn
= gimple_call_fndecl (stmt
)) != NULL
)
2094 struct cgraph_node
*dest
= cgraph_node::get_create (fn
);
2096 /* We have missing edge in the callgraph. This can happen
2097 when previous inlining turned an indirect call into a
2098 direct call by constant propagating arguments or we are
2099 producing dead clone (for further cloning). In all
2100 other cases we hit a bug (incorrect node sharing is the
2101 most common reason for missing edges). */
2102 gcc_assert (!dest
->definition
2103 || dest
->address_taken
2104 || !id
->src_node
->definition
2105 || !id
->dst_node
->definition
);
2106 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
)
2107 id
->dst_node
->create_edge_including_clones
2108 (dest
, orig_stmt
, call_stmt
, bb
->count
,
2109 compute_call_stmt_bb_frequency (id
->dst_node
->decl
,
2111 CIF_ORIGINALLY_INDIRECT_CALL
);
2113 id
->dst_node
->create_edge (dest
, call_stmt
,
2115 compute_call_stmt_bb_frequency
2116 (id
->dst_node
->decl
,
2117 copy_basic_block
))->inline_failed
2118 = CIF_ORIGINALLY_INDIRECT_CALL
;
2121 fprintf (dump_file
, "Created new direct edge to %s\n",
2126 notice_special_calls (as_a
<gcall
*> (stmt
));
2129 maybe_duplicate_eh_stmt_fn (cfun
, stmt
, id
->src_cfun
, orig_stmt
,
2130 id
->eh_map
, id
->eh_lp_nr
);
2132 gsi_next (©_gsi
);
2134 while (!gsi_end_p (copy_gsi
));
2136 copy_gsi
= gsi_last_bb (copy_basic_block
);
2139 return copy_basic_block
;
2142 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
2143 form is quite easy, since dominator relationship for old basic blocks does
2146 There is however exception where inlining might change dominator relation
2147 across EH edges from basic block within inlined functions destinating
2148 to landing pads in function we inline into.
2150 The function fills in PHI_RESULTs of such PHI nodes if they refer
2151 to gimple regs. Otherwise, the function mark PHI_RESULT of such
2152 PHI nodes for renaming. For non-gimple regs, renaming is safe: the
2153 EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
2154 set, and this means that there will be no overlapping live ranges
2155 for the underlying symbol.
2157 This might change in future if we allow redirecting of EH edges and
2158 we might want to change way build CFG pre-inlining to include
2159 all the possible edges then. */
2161 update_ssa_across_abnormal_edges (basic_block bb
, basic_block ret_bb
,
2162 bool can_throw
, bool nonlocal_goto
)
2167 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
2169 || ((basic_block
)e
->dest
->aux
)->index
== ENTRY_BLOCK
)
2175 gcc_assert (e
->flags
& EDGE_EH
);
2178 gcc_assert (!(e
->flags
& EDGE_EH
));
2180 for (si
= gsi_start_phis (e
->dest
); !gsi_end_p (si
); gsi_next (&si
))
2186 /* For abnormal goto/call edges the receiver can be the
2187 ENTRY_BLOCK. Do not assert this cannot happen. */
2189 gcc_assert ((e
->flags
& EDGE_EH
)
2190 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi
)));
2192 re
= find_edge (ret_bb
, e
->dest
);
2193 gcc_checking_assert (re
);
2194 gcc_assert ((re
->flags
& (EDGE_EH
| EDGE_ABNORMAL
))
2195 == (e
->flags
& (EDGE_EH
| EDGE_ABNORMAL
)));
2197 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, e
),
2198 USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, re
)));
2204 /* Copy edges from BB into its copy constructed earlier, scale profile
2205 accordingly. Edges will be taken care of later. Assume aux
2206 pointers to point to the copies of each BB. Return true if any
2207 debug stmts are left after a statement that must end the basic block. */
2210 copy_edges_for_bb (basic_block bb
, profile_count num
, profile_count den
,
2211 basic_block ret_bb
, basic_block abnormal_goto_dest
)
2213 basic_block new_bb
= (basic_block
) bb
->aux
;
2216 gimple_stmt_iterator si
;
2218 bool need_debug_cleanup
= false;
2219 bool scale
= num
.initialized_p ()
2220 && (den
> 0 || num
== profile_count::zero ());
2222 /* Use the indices from the original blocks to create edges for the
2224 FOR_EACH_EDGE (old_edge
, ei
, bb
->succs
)
2225 if (!(old_edge
->flags
& EDGE_EH
))
2229 flags
= old_edge
->flags
;
2231 /* Return edges do get a FALLTHRU flag when the get inlined. */
2232 if (old_edge
->dest
->index
== EXIT_BLOCK
2233 && !(old_edge
->flags
& (EDGE_TRUE_VALUE
|EDGE_FALSE_VALUE
|EDGE_FAKE
))
2234 && old_edge
->dest
->aux
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
2235 flags
|= EDGE_FALLTHRU
;
2236 new_edge
= make_edge (new_bb
, (basic_block
) old_edge
->dest
->aux
, flags
);
2238 new_edge
->count
= old_edge
->count
.apply_scale (num
, den
);
2239 new_edge
->probability
= old_edge
->probability
;
2242 if (bb
->index
== ENTRY_BLOCK
|| bb
->index
== EXIT_BLOCK
)
2245 for (si
= gsi_start_bb (new_bb
); !gsi_end_p (si
);)
2248 bool can_throw
, nonlocal_goto
;
2250 copy_stmt
= gsi_stmt (si
);
2251 if (!is_gimple_debug (copy_stmt
))
2252 update_stmt (copy_stmt
);
2254 /* Do this before the possible split_block. */
2257 /* If this tree could throw an exception, there are two
2258 cases where we need to add abnormal edge(s): the
2259 tree wasn't in a region and there is a "current
2260 region" in the caller; or the original tree had
2261 EH edges. In both cases split the block after the tree,
2262 and add abnormal edge(s) as needed; we need both
2263 those from the callee and the caller.
2264 We check whether the copy can throw, because the const
2265 propagation can change an INDIRECT_REF which throws
2266 into a COMPONENT_REF which doesn't. If the copy
2267 can throw, the original could also throw. */
2268 can_throw
= stmt_can_throw_internal (copy_stmt
);
2270 = (stmt_can_make_abnormal_goto (copy_stmt
)
2271 && !computed_goto_p (copy_stmt
));
2273 if (can_throw
|| nonlocal_goto
)
2275 if (!gsi_end_p (si
))
2277 while (!gsi_end_p (si
) && is_gimple_debug (gsi_stmt (si
)))
2280 need_debug_cleanup
= true;
2282 if (!gsi_end_p (si
))
2283 /* Note that bb's predecessor edges aren't necessarily
2284 right at this point; split_block doesn't care. */
2286 edge e
= split_block (new_bb
, copy_stmt
);
2289 new_bb
->aux
= e
->src
->aux
;
2290 si
= gsi_start_bb (new_bb
);
2294 if (gimple_code (copy_stmt
) == GIMPLE_EH_DISPATCH
)
2295 make_eh_dispatch_edges (as_a
<geh_dispatch
*> (copy_stmt
));
2297 make_eh_edges (copy_stmt
);
2299 /* If the call we inline cannot make abnormal goto do not add
2300 additional abnormal edges but only retain those already present
2301 in the original function body. */
2302 if (abnormal_goto_dest
== NULL
)
2303 nonlocal_goto
= false;
2306 basic_block copy_stmt_bb
= gimple_bb (copy_stmt
);
2308 if (get_abnormal_succ_dispatcher (copy_stmt_bb
))
2309 nonlocal_goto
= false;
2310 /* ABNORMAL_DISPATCHER (1) is for longjmp/setjmp or nonlocal gotos
2311 in OpenMP regions which aren't allowed to be left abnormally.
2312 So, no need to add abnormal edge in that case. */
2313 else if (is_gimple_call (copy_stmt
)
2314 && gimple_call_internal_p (copy_stmt
)
2315 && (gimple_call_internal_fn (copy_stmt
)
2316 == IFN_ABNORMAL_DISPATCHER
)
2317 && gimple_call_arg (copy_stmt
, 0) == boolean_true_node
)
2318 nonlocal_goto
= false;
2320 make_edge (copy_stmt_bb
, abnormal_goto_dest
, EDGE_ABNORMAL
);
2323 if ((can_throw
|| nonlocal_goto
)
2324 && gimple_in_ssa_p (cfun
))
2325 update_ssa_across_abnormal_edges (gimple_bb (copy_stmt
), ret_bb
,
2326 can_throw
, nonlocal_goto
);
2328 return need_debug_cleanup
;
2331 /* Copy the PHIs. All blocks and edges are copied, some blocks
2332 was possibly split and new outgoing EH edges inserted.
2333 BB points to the block of original function and AUX pointers links
2334 the original and newly copied blocks. */
2337 copy_phis_for_bb (basic_block bb
, copy_body_data
*id
)
2339 basic_block
const new_bb
= (basic_block
) bb
->aux
;
2344 bool inserted
= false;
2346 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
2352 res
= PHI_RESULT (phi
);
2354 if (!virtual_operand_p (res
))
2356 walk_tree (&new_res
, copy_tree_body_r
, id
, NULL
);
2357 if (EDGE_COUNT (new_bb
->preds
) == 0)
2359 /* Technically we'd want a SSA_DEFAULT_DEF here... */
2360 SSA_NAME_DEF_STMT (new_res
) = gimple_build_nop ();
2364 new_phi
= create_phi_node (new_res
, new_bb
);
2365 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2367 edge old_edge
= find_edge ((basic_block
) new_edge
->src
->aux
,
2374 /* When doing partial cloning, we allow PHIs on the entry
2375 block as long as all the arguments are the same.
2376 Find any input edge to see argument to copy. */
2378 FOR_EACH_EDGE (old_edge
, ei2
, bb
->preds
)
2379 if (!old_edge
->src
->aux
)
2382 arg
= PHI_ARG_DEF_FROM_EDGE (phi
, old_edge
);
2384 walk_tree (&new_arg
, copy_tree_body_r
, id
, NULL
);
2385 gcc_assert (new_arg
);
2386 /* With return slot optimization we can end up with
2387 non-gimple (foo *)&this->m, fix that here. */
2388 if (TREE_CODE (new_arg
) != SSA_NAME
2389 && TREE_CODE (new_arg
) != FUNCTION_DECL
2390 && !is_gimple_val (new_arg
))
2392 gimple_seq stmts
= NULL
;
2393 new_arg
= force_gimple_operand (new_arg
, &stmts
, true,
2395 gsi_insert_seq_on_edge (new_edge
, stmts
);
2398 locus
= gimple_phi_arg_location_from_edge (phi
, old_edge
);
2399 if (LOCATION_BLOCK (locus
))
2402 n
= id
->decl_map
->get (LOCATION_BLOCK (locus
));
2404 locus
= set_block (locus
, *n
);
2407 locus
= LOCATION_LOCUS (locus
);
2409 add_phi_arg (new_phi
, new_arg
, new_edge
, locus
);
2415 /* Commit the delayed edge insertions. */
2417 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2418 gsi_commit_one_edge_insert (new_edge
, NULL
);
2422 /* Wrapper for remap_decl so it can be used as a callback. */
2425 remap_decl_1 (tree decl
, void *data
)
2427 return remap_decl (decl
, (copy_body_data
*) data
);
2430 /* Build struct function and associated datastructures for the new clone
2431 NEW_FNDECL to be build. CALLEE_FNDECL is the original. Function changes
2432 the cfun to the function of new_fndecl (and current_function_decl too). */
2435 initialize_cfun (tree new_fndecl
, tree callee_fndecl
, profile_count count
)
2437 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2439 if (!DECL_ARGUMENTS (new_fndecl
))
2440 DECL_ARGUMENTS (new_fndecl
) = DECL_ARGUMENTS (callee_fndecl
);
2441 if (!DECL_RESULT (new_fndecl
))
2442 DECL_RESULT (new_fndecl
) = DECL_RESULT (callee_fndecl
);
2444 /* Register specific tree functions. */
2445 gimple_register_cfg_hooks ();
2447 /* Get clean struct function. */
2448 push_struct_function (new_fndecl
);
2450 /* We will rebuild these, so just sanity check that they are empty. */
2451 gcc_assert (VALUE_HISTOGRAMS (cfun
) == NULL
);
2452 gcc_assert (cfun
->local_decls
== NULL
);
2453 gcc_assert (cfun
->cfg
== NULL
);
2454 gcc_assert (cfun
->decl
== new_fndecl
);
2456 /* Copy items we preserve during cloning. */
2457 cfun
->static_chain_decl
= src_cfun
->static_chain_decl
;
2458 cfun
->nonlocal_goto_save_area
= src_cfun
->nonlocal_goto_save_area
;
2459 cfun
->function_end_locus
= src_cfun
->function_end_locus
;
2460 cfun
->curr_properties
= src_cfun
->curr_properties
;
2461 cfun
->last_verified
= src_cfun
->last_verified
;
2462 cfun
->va_list_gpr_size
= src_cfun
->va_list_gpr_size
;
2463 cfun
->va_list_fpr_size
= src_cfun
->va_list_fpr_size
;
2464 cfun
->has_nonlocal_label
= src_cfun
->has_nonlocal_label
;
2465 cfun
->stdarg
= src_cfun
->stdarg
;
2466 cfun
->after_inlining
= src_cfun
->after_inlining
;
2467 cfun
->can_throw_non_call_exceptions
2468 = src_cfun
->can_throw_non_call_exceptions
;
2469 cfun
->can_delete_dead_exceptions
= src_cfun
->can_delete_dead_exceptions
;
2470 cfun
->returns_struct
= src_cfun
->returns_struct
;
2471 cfun
->returns_pcc_struct
= src_cfun
->returns_pcc_struct
;
2473 init_empty_tree_cfg ();
2475 profile_status_for_fn (cfun
) = profile_status_for_fn (src_cfun
);
2477 /* FIXME: When all counts are known to be zero, scaling is also meaningful.
2479 if (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
.initialized_p ()
2480 && count
.initialized_p ()
2481 && ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
.initialized_p ())
2483 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
=
2484 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
.apply_scale (count
,
2485 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
);
2486 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
=
2487 EXIT_BLOCK_PTR_FOR_FN (src_cfun
)->count
.apply_scale (count
,
2488 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
);
2490 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
2491 = ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->frequency
;
2492 EXIT_BLOCK_PTR_FOR_FN (cfun
)->frequency
=
2493 EXIT_BLOCK_PTR_FOR_FN (src_cfun
)->frequency
;
2495 init_eh_for_function ();
2497 if (src_cfun
->gimple_df
)
2499 init_tree_ssa (cfun
);
2500 cfun
->gimple_df
->in_ssa_p
= src_cfun
->gimple_df
->in_ssa_p
;
2501 if (cfun
->gimple_df
->in_ssa_p
)
2502 init_ssa_operands (cfun
);
2506 /* Helper function for copy_cfg_body. Move debug stmts from the end
2507 of NEW_BB to the beginning of successor basic blocks when needed. If the
2508 successor has multiple predecessors, reset them, otherwise keep
2512 maybe_move_debug_stmts_to_successors (copy_body_data
*id
, basic_block new_bb
)
2516 gimple_stmt_iterator si
= gsi_last_nondebug_bb (new_bb
);
2519 || gsi_one_before_end_p (si
)
2520 || !(stmt_can_throw_internal (gsi_stmt (si
))
2521 || stmt_can_make_abnormal_goto (gsi_stmt (si
))))
2524 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
2526 gimple_stmt_iterator ssi
= gsi_last_bb (new_bb
);
2527 gimple_stmt_iterator dsi
= gsi_after_labels (e
->dest
);
2528 while (is_gimple_debug (gsi_stmt (ssi
)))
2530 gimple
*stmt
= gsi_stmt (ssi
);
2535 /* For the last edge move the debug stmts instead of copying
2537 if (ei_one_before_end_p (ei
))
2541 if (!single_pred_p (e
->dest
) && gimple_debug_bind_p (stmt
))
2542 gimple_debug_bind_reset_value (stmt
);
2543 gsi_remove (&si
, false);
2544 gsi_insert_before (&dsi
, stmt
, GSI_SAME_STMT
);
2548 if (gimple_debug_bind_p (stmt
))
2550 var
= gimple_debug_bind_get_var (stmt
);
2551 if (single_pred_p (e
->dest
))
2553 value
= gimple_debug_bind_get_value (stmt
);
2554 value
= unshare_expr (value
);
2558 new_stmt
= gimple_build_debug_bind (var
, value
, stmt
);
2560 else if (gimple_debug_source_bind_p (stmt
))
2562 var
= gimple_debug_source_bind_get_var (stmt
);
2563 value
= gimple_debug_source_bind_get_value (stmt
);
2564 new_stmt
= gimple_build_debug_source_bind (var
, value
, stmt
);
2568 gsi_insert_before (&dsi
, new_stmt
, GSI_SAME_STMT
);
2569 id
->debug_stmts
.safe_push (new_stmt
);
2575 /* Make a copy of the sub-loops of SRC_PARENT and place them
2576 as siblings of DEST_PARENT. */
2579 copy_loops (copy_body_data
*id
,
2580 struct loop
*dest_parent
, struct loop
*src_parent
)
2582 struct loop
*src_loop
= src_parent
->inner
;
2585 if (!id
->blocks_to_copy
2586 || bitmap_bit_p (id
->blocks_to_copy
, src_loop
->header
->index
))
2588 struct loop
*dest_loop
= alloc_loop ();
2590 /* Assign the new loop its header and latch and associate
2591 those with the new loop. */
2592 dest_loop
->header
= (basic_block
)src_loop
->header
->aux
;
2593 dest_loop
->header
->loop_father
= dest_loop
;
2594 if (src_loop
->latch
!= NULL
)
2596 dest_loop
->latch
= (basic_block
)src_loop
->latch
->aux
;
2597 dest_loop
->latch
->loop_father
= dest_loop
;
2600 /* Copy loop meta-data. */
2601 copy_loop_info (src_loop
, dest_loop
);
2603 /* Finally place it into the loop array and the loop tree. */
2604 place_new_loop (cfun
, dest_loop
);
2605 flow_loop_tree_node_add (dest_parent
, dest_loop
);
2607 dest_loop
->safelen
= src_loop
->safelen
;
2608 dest_loop
->dont_vectorize
= src_loop
->dont_vectorize
;
2609 if (src_loop
->force_vectorize
)
2611 dest_loop
->force_vectorize
= true;
2612 cfun
->has_force_vectorize_loops
= true;
2614 if (src_loop
->simduid
)
2616 dest_loop
->simduid
= remap_decl (src_loop
->simduid
, id
);
2617 cfun
->has_simduid_loops
= true;
2621 copy_loops (id
, dest_loop
, src_loop
);
2623 src_loop
= src_loop
->next
;
2627 /* Call cgraph_redirect_edge_call_stmt_to_callee on all calls in BB */
2630 redirect_all_calls (copy_body_data
* id
, basic_block bb
)
2632 gimple_stmt_iterator si
;
2633 gimple
*last
= last_stmt (bb
);
2634 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
2636 gimple
*stmt
= gsi_stmt (si
);
2637 if (is_gimple_call (stmt
))
2639 struct cgraph_edge
*edge
= id
->dst_node
->get_edge (stmt
);
2642 edge
->redirect_call_stmt_to_callee ();
2643 if (stmt
== last
&& id
->call_stmt
&& maybe_clean_eh_stmt (stmt
))
2644 gimple_purge_dead_eh_edges (bb
);
2650 /* Convert estimated frequencies into counts for NODE, scaling COUNT
2651 with each bb's frequency. Used when NODE has a 0-weight entry
2652 but we are about to inline it into a non-zero count call bb.
2653 See the comments for handle_missing_profiles() in predict.c for
2654 when this can happen for COMDATs. */
2657 freqs_to_counts (struct cgraph_node
*node
, profile_count count
)
2662 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
2664 FOR_ALL_BB_FN(bb
, fn
)
2666 bb
->count
= count
.apply_scale (bb
->frequency
, BB_FREQ_MAX
);
2667 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
2668 e
->count
= e
->src
->count
.apply_probability (e
->probability
);
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 count
, int frequency_scale
,
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 int incoming_frequency
= 0;
2689 profile_count incoming_count
= profile_count::zero ();
2690 profile_count num
= count
;
2691 profile_count den
= ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
;
2692 bool scale
= num
.initialized_p ()
2693 && (den
> 0 || num
== profile_count::zero ());
2695 /* This can happen for COMDAT routines that end up with 0 counts
2696 despite being called (see the comments for handle_missing_profiles()
2697 in predict.c as to why). Apply counts to the blocks in the callee
2698 before inlining, using the guessed edge frequencies, so that we don't
2699 end up with a 0-count inline body which can confuse downstream
2700 optimizations such as function splitting. */
2701 if (!(ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
> 0) && count
> 0)
2703 /* Apply the larger of the call bb count and the total incoming
2704 call edge count to the callee. */
2705 profile_count in_count
= profile_count::zero ();
2706 struct cgraph_edge
*in_edge
;
2707 for (in_edge
= id
->src_node
->callers
; in_edge
;
2708 in_edge
= in_edge
->next_caller
)
2709 if (in_edge
->count
.initialized_p ())
2710 in_count
+= in_edge
->count
;
2711 freqs_to_counts (id
->src_node
, count
> in_count
? count
: in_count
);
2714 /* Register specific tree functions. */
2715 gimple_register_cfg_hooks ();
2717 /* If we are inlining just region of the function, make sure to connect
2718 new entry to ENTRY_BLOCK_PTR_FOR_FN (cfun). Since new entry can be
2719 part of loop, we must compute frequency and probability of
2720 ENTRY_BLOCK_PTR_FOR_FN (cfun) based on the frequencies and
2721 probabilities of edges incoming from nonduplicated region. */
2727 FOR_EACH_EDGE (e
, ei
, new_entry
->preds
)
2730 incoming_frequency
+= EDGE_FREQUENCY (e
);
2731 incoming_count
+= e
->count
;
2734 incoming_count
= incoming_count
.apply_scale (num
, den
);
2736 incoming_count
= profile_count::uninitialized ();
2738 = apply_scale ((gcov_type
)incoming_frequency
, frequency_scale
);
2739 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= incoming_count
;
2740 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
= incoming_frequency
;
2743 /* Must have a CFG here at this point. */
2744 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN
2745 (DECL_STRUCT_FUNCTION (callee_fndecl
)));
2747 cfun_to_copy
= id
->src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2749 ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy
)->aux
= entry_block_map
;
2750 EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy
)->aux
= exit_block_map
;
2751 entry_block_map
->aux
= ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy
);
2752 exit_block_map
->aux
= EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy
);
2754 /* Duplicate any exception-handling regions. */
2756 id
->eh_map
= duplicate_eh_regions (cfun_to_copy
, NULL
, id
->eh_lp_nr
,
2759 /* Use aux pointers to map the original blocks to copy. */
2760 FOR_EACH_BB_FN (bb
, cfun_to_copy
)
2761 if (!id
->blocks_to_copy
|| bitmap_bit_p (id
->blocks_to_copy
, bb
->index
))
2763 basic_block new_bb
= copy_bb (id
, bb
, frequency_scale
, num
, den
);
2766 new_bb
->loop_father
= entry_block_map
->loop_father
;
2769 last
= last_basic_block_for_fn (cfun
);
2771 /* Now that we've duplicated the blocks, duplicate their edges. */
2772 basic_block abnormal_goto_dest
= NULL
;
2774 && stmt_can_make_abnormal_goto (id
->call_stmt
))
2776 gimple_stmt_iterator gsi
= gsi_for_stmt (id
->call_stmt
);
2778 bb
= gimple_bb (id
->call_stmt
);
2780 if (gsi_end_p (gsi
))
2781 abnormal_goto_dest
= get_abnormal_succ_dispatcher (bb
);
2783 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2784 if (!id
->blocks_to_copy
2785 || (bb
->index
> 0 && bitmap_bit_p (id
->blocks_to_copy
, bb
->index
)))
2786 need_debug_cleanup
|= copy_edges_for_bb (bb
, num
, den
, exit_block_map
,
2787 abnormal_goto_dest
);
2791 edge e
= make_edge (entry_block_map
, (basic_block
)new_entry
->aux
, EDGE_FALLTHRU
);
2792 e
->probability
= REG_BR_PROB_BASE
;
2793 e
->count
= incoming_count
;
2796 /* Duplicate the loop tree, if available and wanted. */
2797 if (loops_for_fn (src_cfun
) != NULL
2798 && current_loops
!= NULL
)
2800 copy_loops (id
, entry_block_map
->loop_father
,
2801 get_loop (src_cfun
, 0));
2802 /* Defer to cfgcleanup to update loop-father fields of basic-blocks. */
2803 loops_state_set (LOOPS_NEED_FIXUP
);
2806 /* If the loop tree in the source function needed fixup, mark the
2807 destination loop tree for fixup, too. */
2808 if (loops_for_fn (src_cfun
)->state
& LOOPS_NEED_FIXUP
)
2809 loops_state_set (LOOPS_NEED_FIXUP
);
2811 if (gimple_in_ssa_p (cfun
))
2812 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2813 if (!id
->blocks_to_copy
2814 || (bb
->index
> 0 && bitmap_bit_p (id
->blocks_to_copy
, bb
->index
)))
2815 copy_phis_for_bb (bb
, id
);
2817 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2820 if (need_debug_cleanup
2821 && bb
->index
!= ENTRY_BLOCK
2822 && bb
->index
!= EXIT_BLOCK
)
2823 maybe_move_debug_stmts_to_successors (id
, (basic_block
) bb
->aux
);
2824 /* Update call edge destinations. This can not be done before loop
2825 info is updated, because we may split basic blocks. */
2826 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
2827 && bb
->index
!= ENTRY_BLOCK
2828 && bb
->index
!= EXIT_BLOCK
)
2829 redirect_all_calls (id
, (basic_block
)bb
->aux
);
2830 ((basic_block
)bb
->aux
)->aux
= NULL
;
2834 /* Zero out AUX fields of newly created block during EH edge
2836 for (; last
< last_basic_block_for_fn (cfun
); last
++)
2838 if (need_debug_cleanup
)
2839 maybe_move_debug_stmts_to_successors (id
,
2840 BASIC_BLOCK_FOR_FN (cfun
, last
));
2841 BASIC_BLOCK_FOR_FN (cfun
, last
)->aux
= NULL
;
2842 /* Update call edge destinations. This can not be done before loop
2843 info is updated, because we may split basic blocks. */
2844 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
)
2845 redirect_all_calls (id
, BASIC_BLOCK_FOR_FN (cfun
, last
));
2847 entry_block_map
->aux
= NULL
;
2848 exit_block_map
->aux
= NULL
;
2855 if (id
->dependence_map
)
2857 delete id
->dependence_map
;
2858 id
->dependence_map
= NULL
;
2864 /* Copy the debug STMT using ID. We deal with these statements in a
2865 special way: if any variable in their VALUE expression wasn't
2866 remapped yet, we won't remap it, because that would get decl uids
2867 out of sync, causing codegen differences between -g and -g0. If
2868 this arises, we drop the VALUE expression altogether. */
2871 copy_debug_stmt (gdebug
*stmt
, copy_body_data
*id
)
2874 struct walk_stmt_info wi
;
2876 if (gimple_block (stmt
))
2878 n
= id
->decl_map
->get (gimple_block (stmt
));
2879 gimple_set_block (stmt
, n
? *n
: id
->block
);
2882 /* Remap all the operands in COPY. */
2883 memset (&wi
, 0, sizeof (wi
));
2886 processing_debug_stmt
= 1;
2888 if (gimple_debug_source_bind_p (stmt
))
2889 t
= gimple_debug_source_bind_get_var (stmt
);
2891 t
= gimple_debug_bind_get_var (stmt
);
2893 if (TREE_CODE (t
) == PARM_DECL
&& id
->debug_map
2894 && (n
= id
->debug_map
->get (t
)))
2896 gcc_assert (VAR_P (*n
));
2899 else if (VAR_P (t
) && !is_global_var (t
) && !id
->decl_map
->get (t
))
2900 /* T is a non-localized variable. */;
2902 walk_tree (&t
, remap_gimple_op_r
, &wi
, NULL
);
2904 if (gimple_debug_bind_p (stmt
))
2906 gimple_debug_bind_set_var (stmt
, t
);
2908 if (gimple_debug_bind_has_value_p (stmt
))
2909 walk_tree (gimple_debug_bind_get_value_ptr (stmt
),
2910 remap_gimple_op_r
, &wi
, NULL
);
2912 /* Punt if any decl couldn't be remapped. */
2913 if (processing_debug_stmt
< 0)
2914 gimple_debug_bind_reset_value (stmt
);
2916 else if (gimple_debug_source_bind_p (stmt
))
2918 gimple_debug_source_bind_set_var (stmt
, t
);
2919 /* When inlining and source bind refers to one of the optimized
2920 away parameters, change the source bind into normal debug bind
2921 referring to the corresponding DEBUG_EXPR_DECL that should have
2922 been bound before the call stmt. */
2923 t
= gimple_debug_source_bind_get_value (stmt
);
2925 && TREE_CODE (t
) == PARM_DECL
2928 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (id
->src_fn
);
2930 if (debug_args
!= NULL
)
2932 for (i
= 0; i
< vec_safe_length (*debug_args
); i
+= 2)
2933 if ((**debug_args
)[i
] == DECL_ORIGIN (t
)
2934 && TREE_CODE ((**debug_args
)[i
+ 1]) == DEBUG_EXPR_DECL
)
2936 t
= (**debug_args
)[i
+ 1];
2937 stmt
->subcode
= GIMPLE_DEBUG_BIND
;
2938 gimple_debug_bind_set_value (stmt
, t
);
2943 if (gimple_debug_source_bind_p (stmt
))
2944 walk_tree (gimple_debug_source_bind_get_value_ptr (stmt
),
2945 remap_gimple_op_r
, &wi
, NULL
);
2948 processing_debug_stmt
= 0;
2953 /* Process deferred debug stmts. In order to give values better odds
2954 of being successfully remapped, we delay the processing of debug
2955 stmts until all other stmts that might require remapping are
2959 copy_debug_stmts (copy_body_data
*id
)
2964 if (!id
->debug_stmts
.exists ())
2967 FOR_EACH_VEC_ELT (id
->debug_stmts
, i
, stmt
)
2968 copy_debug_stmt (stmt
, id
);
2970 id
->debug_stmts
.release ();
2973 /* Make a copy of the body of SRC_FN so that it can be inserted inline in
2974 another function. */
2977 copy_tree_body (copy_body_data
*id
)
2979 tree fndecl
= id
->src_fn
;
2980 tree body
= DECL_SAVED_TREE (fndecl
);
2982 walk_tree (&body
, copy_tree_body_r
, id
, NULL
);
2987 /* Make a copy of the body of FN so that it can be inserted inline in
2988 another function. */
2991 copy_body (copy_body_data
*id
, profile_count count
, int frequency_scale
,
2992 basic_block entry_block_map
, basic_block exit_block_map
,
2993 basic_block new_entry
)
2995 tree fndecl
= id
->src_fn
;
2998 /* If this body has a CFG, walk CFG and copy. */
2999 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (fndecl
)));
3000 body
= copy_cfg_body (id
, count
, frequency_scale
, entry_block_map
, exit_block_map
,
3002 copy_debug_stmts (id
);
3007 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
3008 defined in function FN, or of a data member thereof. */
3011 self_inlining_addr_expr (tree value
, tree fn
)
3015 if (TREE_CODE (value
) != ADDR_EXPR
)
3018 var
= get_base_address (TREE_OPERAND (value
, 0));
3020 return var
&& auto_var_in_fn_p (var
, fn
);
3023 /* Append to BB a debug annotation that binds VAR to VALUE, inheriting
3024 lexical block and line number information from base_stmt, if given,
3025 or from the last stmt of the block otherwise. */
3028 insert_init_debug_bind (copy_body_data
*id
,
3029 basic_block bb
, tree var
, tree value
,
3033 gimple_stmt_iterator gsi
;
3036 if (!gimple_in_ssa_p (id
->src_cfun
))
3039 if (!opt_for_fn (id
->dst_fn
, flag_var_tracking_assignments
))
3042 tracked_var
= target_for_debug_bind (var
);
3048 gsi
= gsi_last_bb (bb
);
3049 if (!base_stmt
&& !gsi_end_p (gsi
))
3050 base_stmt
= gsi_stmt (gsi
);
3053 note
= gimple_build_debug_bind (tracked_var
, unshare_expr (value
), base_stmt
);
3057 if (!gsi_end_p (gsi
))
3058 gsi_insert_after (&gsi
, note
, GSI_SAME_STMT
);
3060 gsi_insert_before (&gsi
, note
, GSI_SAME_STMT
);
3067 insert_init_stmt (copy_body_data
*id
, basic_block bb
, gimple
*init_stmt
)
3069 /* If VAR represents a zero-sized variable, it's possible that the
3070 assignment statement may result in no gimple statements. */
3073 gimple_stmt_iterator si
= gsi_last_bb (bb
);
3075 /* We can end up with init statements that store to a non-register
3076 from a rhs with a conversion. Handle that here by forcing the
3077 rhs into a temporary. gimple_regimplify_operands is not
3078 prepared to do this for us. */
3079 if (!is_gimple_debug (init_stmt
)
3080 && !is_gimple_reg (gimple_assign_lhs (init_stmt
))
3081 && is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (init_stmt
)))
3082 && gimple_assign_rhs_class (init_stmt
) == GIMPLE_UNARY_RHS
)
3084 tree rhs
= build1 (gimple_assign_rhs_code (init_stmt
),
3085 gimple_expr_type (init_stmt
),
3086 gimple_assign_rhs1 (init_stmt
));
3087 rhs
= force_gimple_operand_gsi (&si
, rhs
, true, NULL_TREE
, false,
3089 gimple_assign_set_rhs_code (init_stmt
, TREE_CODE (rhs
));
3090 gimple_assign_set_rhs1 (init_stmt
, rhs
);
3092 gsi_insert_after (&si
, init_stmt
, GSI_NEW_STMT
);
3093 gimple_regimplify_operands (init_stmt
, &si
);
3095 if (!is_gimple_debug (init_stmt
))
3097 tree def
= gimple_assign_lhs (init_stmt
);
3098 insert_init_debug_bind (id
, bb
, def
, def
, init_stmt
);
3103 /* Initialize parameter P with VALUE. If needed, produce init statement
3104 at the end of BB. When BB is NULL, we return init statement to be
3107 setup_one_parameter (copy_body_data
*id
, tree p
, tree value
, tree fn
,
3108 basic_block bb
, tree
*vars
)
3110 gimple
*init_stmt
= NULL
;
3113 tree def
= (gimple_in_ssa_p (cfun
)
3114 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
3117 && value
!= error_mark_node
3118 && !useless_type_conversion_p (TREE_TYPE (p
), TREE_TYPE (value
)))
3120 /* If we can match up types by promotion/demotion do so. */
3121 if (fold_convertible_p (TREE_TYPE (p
), value
))
3122 rhs
= fold_convert (TREE_TYPE (p
), value
);
3125 /* ??? For valid programs we should not end up here.
3126 Still if we end up with truly mismatched types here, fall back
3127 to using a VIEW_CONVERT_EXPR or a literal zero to not leak invalid
3128 GIMPLE to the following passes. */
3129 if (!is_gimple_reg_type (TREE_TYPE (value
))
3130 || TYPE_SIZE (TREE_TYPE (p
)) == TYPE_SIZE (TREE_TYPE (value
)))
3131 rhs
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (p
), value
);
3133 rhs
= build_zero_cst (TREE_TYPE (p
));
3137 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
3138 here since the type of this decl must be visible to the calling
3140 var
= copy_decl_to_var (p
, id
);
3142 /* Declare this new variable. */
3143 DECL_CHAIN (var
) = *vars
;
3146 /* Make gimplifier happy about this variable. */
3147 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
3149 /* If the parameter is never assigned to, has no SSA_NAMEs created,
3150 we would not need to create a new variable here at all, if it
3151 weren't for debug info. Still, we can just use the argument
3153 if (TREE_READONLY (p
)
3154 && !TREE_ADDRESSABLE (p
)
3155 && value
&& !TREE_SIDE_EFFECTS (value
)
3158 /* We may produce non-gimple trees by adding NOPs or introduce
3159 invalid sharing when operand is not really constant.
3160 It is not big deal to prohibit constant propagation here as
3161 we will constant propagate in DOM1 pass anyway. */
3162 if (is_gimple_min_invariant (value
)
3163 && useless_type_conversion_p (TREE_TYPE (p
),
3165 /* We have to be very careful about ADDR_EXPR. Make sure
3166 the base variable isn't a local variable of the inlined
3167 function, e.g., when doing recursive inlining, direct or
3168 mutually-recursive or whatever, which is why we don't
3169 just test whether fn == current_function_decl. */
3170 && ! self_inlining_addr_expr (value
, fn
))
3172 insert_decl_map (id
, p
, value
);
3173 insert_debug_decl_map (id
, p
, var
);
3174 return insert_init_debug_bind (id
, bb
, var
, value
, NULL
);
3178 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
3179 that way, when the PARM_DECL is encountered, it will be
3180 automatically replaced by the VAR_DECL. */
3181 insert_decl_map (id
, p
, var
);
3183 /* Even if P was TREE_READONLY, the new VAR should not be.
3184 In the original code, we would have constructed a
3185 temporary, and then the function body would have never
3186 changed the value of P. However, now, we will be
3187 constructing VAR directly. The constructor body may
3188 change its value multiple times as it is being
3189 constructed. Therefore, it must not be TREE_READONLY;
3190 the back-end assumes that TREE_READONLY variable is
3191 assigned to only once. */
3192 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p
)))
3193 TREE_READONLY (var
) = 0;
3195 /* If there is no setup required and we are in SSA, take the easy route
3196 replacing all SSA names representing the function parameter by the
3197 SSA name passed to function.
3199 We need to construct map for the variable anyway as it might be used
3200 in different SSA names when parameter is set in function.
3202 Do replacement at -O0 for const arguments replaced by constant.
3203 This is important for builtin_constant_p and other construct requiring
3204 constant argument to be visible in inlined function body. */
3205 if (gimple_in_ssa_p (cfun
) && rhs
&& def
&& is_gimple_reg (p
)
3207 || (TREE_READONLY (p
)
3208 && is_gimple_min_invariant (rhs
)))
3209 && (TREE_CODE (rhs
) == SSA_NAME
3210 || is_gimple_min_invariant (rhs
))
3211 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
3213 insert_decl_map (id
, def
, rhs
);
3214 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3217 /* If the value of argument is never used, don't care about initializing
3219 if (optimize
&& gimple_in_ssa_p (cfun
) && !def
&& is_gimple_reg (p
))
3221 gcc_assert (!value
|| !TREE_SIDE_EFFECTS (value
));
3222 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3225 /* Initialize this VAR_DECL from the equivalent argument. Convert
3226 the argument to the proper type in case it was promoted. */
3229 if (rhs
== error_mark_node
)
3231 insert_decl_map (id
, p
, var
);
3232 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3235 STRIP_USELESS_TYPE_CONVERSION (rhs
);
3237 /* If we are in SSA form properly remap the default definition
3238 or assign to a dummy SSA name if the parameter is unused and
3239 we are not optimizing. */
3240 if (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
))
3244 def
= remap_ssa_name (def
, id
);
3245 init_stmt
= gimple_build_assign (def
, rhs
);
3246 SSA_NAME_IS_DEFAULT_DEF (def
) = 0;
3247 set_ssa_default_def (cfun
, var
, NULL
);
3251 def
= make_ssa_name (var
);
3252 init_stmt
= gimple_build_assign (def
, rhs
);
3256 init_stmt
= gimple_build_assign (var
, rhs
);
3258 if (bb
&& init_stmt
)
3259 insert_init_stmt (id
, bb
, init_stmt
);
3264 /* Generate code to initialize the parameters of the function at the
3265 top of the stack in ID from the GIMPLE_CALL STMT. */
3268 initialize_inlined_parameters (copy_body_data
*id
, gimple
*stmt
,
3269 tree fn
, basic_block bb
)
3274 tree vars
= NULL_TREE
;
3275 tree static_chain
= gimple_call_chain (stmt
);
3277 /* Figure out what the parameters are. */
3278 parms
= DECL_ARGUMENTS (fn
);
3280 /* Loop through the parameter declarations, replacing each with an
3281 equivalent VAR_DECL, appropriately initialized. */
3282 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
3285 val
= i
< gimple_call_num_args (stmt
) ? gimple_call_arg (stmt
, i
) : NULL
;
3286 setup_one_parameter (id
, p
, val
, fn
, bb
, &vars
);
3288 /* After remapping parameters remap their types. This has to be done
3289 in a second loop over all parameters to appropriately remap
3290 variable sized arrays when the size is specified in a
3291 parameter following the array. */
3292 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
3294 tree
*varp
= id
->decl_map
->get (p
);
3295 if (varp
&& VAR_P (*varp
))
3297 tree def
= (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
)
3298 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
3300 TREE_TYPE (var
) = remap_type (TREE_TYPE (var
), id
);
3301 /* Also remap the default definition if it was remapped
3302 to the default definition of the parameter replacement
3303 by the parameter setup. */
3306 tree
*defp
= id
->decl_map
->get (def
);
3308 && TREE_CODE (*defp
) == SSA_NAME
3309 && SSA_NAME_VAR (*defp
) == var
)
3310 TREE_TYPE (*defp
) = TREE_TYPE (var
);
3315 /* Initialize the static chain. */
3316 p
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
3317 gcc_assert (fn
!= current_function_decl
);
3320 /* No static chain? Seems like a bug in tree-nested.c. */
3321 gcc_assert (static_chain
);
3323 setup_one_parameter (id
, p
, static_chain
, fn
, bb
, &vars
);
3326 declare_inline_vars (id
->block
, vars
);
3330 /* Declare a return variable to replace the RESULT_DECL for the
3331 function we are calling. An appropriate DECL_STMT is returned.
3332 The USE_STMT is filled to contain a use of the declaration to
3333 indicate the return value of the function.
3335 RETURN_SLOT, if non-null is place where to store the result. It
3336 is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null,
3337 was the LHS of the MODIFY_EXPR to which this call is the RHS.
3339 RETURN_BOUNDS holds a destination for returned bounds.
3341 The return value is a (possibly null) value that holds the result
3342 as seen by the caller. */
3345 declare_return_variable (copy_body_data
*id
, tree return_slot
, tree modify_dest
,
3346 tree return_bounds
, basic_block entry_bb
)
3348 tree callee
= id
->src_fn
;
3349 tree result
= DECL_RESULT (callee
);
3350 tree callee_type
= TREE_TYPE (result
);
3354 /* Handle type-mismatches in the function declaration return type
3355 vs. the call expression. */
3357 caller_type
= TREE_TYPE (modify_dest
);
3359 caller_type
= TREE_TYPE (TREE_TYPE (callee
));
3361 /* We don't need to do anything for functions that don't return anything. */
3362 if (VOID_TYPE_P (callee_type
))
3365 /* If there was a return slot, then the return value is the
3366 dereferenced address of that object. */
3369 /* The front end shouldn't have used both return_slot and
3370 a modify expression. */
3371 gcc_assert (!modify_dest
);
3372 if (DECL_BY_REFERENCE (result
))
3374 tree return_slot_addr
= build_fold_addr_expr (return_slot
);
3375 STRIP_USELESS_TYPE_CONVERSION (return_slot_addr
);
3377 /* We are going to construct *&return_slot and we can't do that
3378 for variables believed to be not addressable.
3380 FIXME: This check possibly can match, because values returned
3381 via return slot optimization are not believed to have address
3382 taken by alias analysis. */
3383 gcc_assert (TREE_CODE (return_slot
) != SSA_NAME
);
3384 var
= return_slot_addr
;
3389 gcc_assert (TREE_CODE (var
) != SSA_NAME
);
3390 if (TREE_ADDRESSABLE (result
))
3391 mark_addressable (var
);
3393 if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
3394 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
3395 && !DECL_GIMPLE_REG_P (result
)
3397 DECL_GIMPLE_REG_P (var
) = 0;
3402 /* All types requiring non-trivial constructors should have been handled. */
3403 gcc_assert (!TREE_ADDRESSABLE (callee_type
));
3405 /* Attempt to avoid creating a new temporary variable. */
3407 && TREE_CODE (modify_dest
) != SSA_NAME
)
3409 bool use_it
= false;
3411 /* We can't use MODIFY_DEST if there's type promotion involved. */
3412 if (!useless_type_conversion_p (callee_type
, caller_type
))
3415 /* ??? If we're assigning to a variable sized type, then we must
3416 reuse the destination variable, because we've no good way to
3417 create variable sized temporaries at this point. */
3418 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type
)) != INTEGER_CST
)
3421 /* If the callee cannot possibly modify MODIFY_DEST, then we can
3422 reuse it as the result of the call directly. Don't do this if
3423 it would promote MODIFY_DEST to addressable. */
3424 else if (TREE_ADDRESSABLE (result
))
3428 tree base_m
= get_base_address (modify_dest
);
3430 /* If the base isn't a decl, then it's a pointer, and we don't
3431 know where that's going to go. */
3432 if (!DECL_P (base_m
))
3434 else if (is_global_var (base_m
))
3436 else if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
3437 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
3438 && !DECL_GIMPLE_REG_P (result
)
3439 && DECL_GIMPLE_REG_P (base_m
))
3441 else if (!TREE_ADDRESSABLE (base_m
))
3453 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type
)) == INTEGER_CST
);
3455 var
= copy_result_decl_to_var (result
, id
);
3456 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
3458 /* Do not have the rest of GCC warn about this variable as it should
3459 not be visible to the user. */
3460 TREE_NO_WARNING (var
) = 1;
3462 declare_inline_vars (id
->block
, var
);
3464 /* Build the use expr. If the return type of the function was
3465 promoted, convert it back to the expected type. */
3467 if (!useless_type_conversion_p (caller_type
, TREE_TYPE (var
)))
3469 /* If we can match up types by promotion/demotion do so. */
3470 if (fold_convertible_p (caller_type
, var
))
3471 use
= fold_convert (caller_type
, var
);
3474 /* ??? For valid programs we should not end up here.
3475 Still if we end up with truly mismatched types here, fall back
3476 to using a MEM_REF to not leak invalid GIMPLE to the following
3478 /* Prevent var from being written into SSA form. */
3479 if (TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
3480 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
)
3481 DECL_GIMPLE_REG_P (var
) = false;
3482 else if (is_gimple_reg_type (TREE_TYPE (var
)))
3483 TREE_ADDRESSABLE (var
) = true;
3484 use
= fold_build2 (MEM_REF
, caller_type
,
3485 build_fold_addr_expr (var
),
3486 build_int_cst (ptr_type_node
, 0));
3490 STRIP_USELESS_TYPE_CONVERSION (use
);
3492 if (DECL_BY_REFERENCE (result
))
3494 TREE_ADDRESSABLE (var
) = 1;
3495 var
= build_fold_addr_expr (var
);
3499 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
3500 way, when the RESULT_DECL is encountered, it will be
3501 automatically replaced by the VAR_DECL.
3503 When returning by reference, ensure that RESULT_DECL remaps to
3505 if (DECL_BY_REFERENCE (result
)
3506 && !is_gimple_val (var
))
3508 tree temp
= create_tmp_var (TREE_TYPE (result
), "retvalptr");
3509 insert_decl_map (id
, result
, temp
);
3510 /* When RESULT_DECL is in SSA form, we need to remap and initialize
3511 it's default_def SSA_NAME. */
3512 if (gimple_in_ssa_p (id
->src_cfun
)
3513 && is_gimple_reg (result
))
3515 temp
= make_ssa_name (temp
);
3516 insert_decl_map (id
, ssa_default_def (id
->src_cfun
, result
), temp
);
3518 insert_init_stmt (id
, entry_bb
, gimple_build_assign (temp
, var
));
3521 insert_decl_map (id
, result
, var
);
3523 /* Remember this so we can ignore it in remap_decls. */
3526 /* If returned bounds are used, then make var for them. */
3529 tree bndtemp
= create_tmp_var (pointer_bounds_type_node
, "retbnd");
3530 DECL_SEEN_IN_BIND_EXPR_P (bndtemp
) = 1;
3531 TREE_NO_WARNING (bndtemp
) = 1;
3532 declare_inline_vars (id
->block
, bndtemp
);
3534 id
->retbnd
= bndtemp
;
3535 insert_init_stmt (id
, entry_bb
,
3536 gimple_build_assign (bndtemp
, chkp_get_zero_bounds_var ()));
3542 /* Determine if the function can be copied. If so return NULL. If
3543 not return a string describng the reason for failure. */
3546 copy_forbidden (struct function
*fun
)
3548 const char *reason
= fun
->cannot_be_copied_reason
;
3550 /* Only examine the function once. */
3551 if (fun
->cannot_be_copied_set
)
3554 /* We cannot copy a function that receives a non-local goto
3555 because we cannot remap the destination label used in the
3556 function that is performing the non-local goto. */
3557 /* ??? Actually, this should be possible, if we work at it.
3558 No doubt there's just a handful of places that simply
3559 assume it doesn't happen and don't substitute properly. */
3560 if (fun
->has_nonlocal_label
)
3562 reason
= G_("function %q+F can never be copied "
3563 "because it receives a non-local goto");
3567 if (fun
->has_forced_label_in_static
)
3569 reason
= G_("function %q+F can never be copied because it saves "
3570 "address of local label in a static variable");
3575 fun
->cannot_be_copied_reason
= reason
;
3576 fun
->cannot_be_copied_set
= true;
3581 static const char *inline_forbidden_reason
;
3583 /* A callback for walk_gimple_seq to handle statements. Returns non-null
3584 iff a function can not be inlined. Also sets the reason why. */
3587 inline_forbidden_p_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
3588 struct walk_stmt_info
*wip
)
3590 tree fn
= (tree
) wip
->info
;
3592 gimple
*stmt
= gsi_stmt (*gsi
);
3594 switch (gimple_code (stmt
))
3597 /* Refuse to inline alloca call unless user explicitly forced so as
3598 this may change program's memory overhead drastically when the
3599 function using alloca is called in loop. In GCC present in
3600 SPEC2000 inlining into schedule_block cause it to require 2GB of
3601 RAM instead of 256MB. Don't do so for alloca calls emitted for
3602 VLA objects as those can't cause unbounded growth (they're always
3603 wrapped inside stack_save/stack_restore regions. */
3604 if (gimple_maybe_alloca_call_p (stmt
)
3605 && !gimple_call_alloca_for_var_p (as_a
<gcall
*> (stmt
))
3606 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
3608 inline_forbidden_reason
3609 = G_("function %q+F can never be inlined because it uses "
3610 "alloca (override using the always_inline attribute)");
3611 *handled_ops_p
= true;
3615 t
= gimple_call_fndecl (stmt
);
3619 /* We cannot inline functions that call setjmp. */
3620 if (setjmp_call_p (t
))
3622 inline_forbidden_reason
3623 = G_("function %q+F can never be inlined because it uses setjmp");
3624 *handled_ops_p
= true;
3628 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
3629 switch (DECL_FUNCTION_CODE (t
))
3631 /* We cannot inline functions that take a variable number of
3633 case BUILT_IN_VA_START
:
3634 case BUILT_IN_NEXT_ARG
:
3635 case BUILT_IN_VA_END
:
3636 inline_forbidden_reason
3637 = G_("function %q+F can never be inlined because it "
3638 "uses variable argument lists");
3639 *handled_ops_p
= true;
3642 case BUILT_IN_LONGJMP
:
3643 /* We can't inline functions that call __builtin_longjmp at
3644 all. The non-local goto machinery really requires the
3645 destination be in a different function. If we allow the
3646 function calling __builtin_longjmp to be inlined into the
3647 function calling __builtin_setjmp, Things will Go Awry. */
3648 inline_forbidden_reason
3649 = G_("function %q+F can never be inlined because "
3650 "it uses setjmp-longjmp exception handling");
3651 *handled_ops_p
= true;
3654 case BUILT_IN_NONLOCAL_GOTO
:
3656 inline_forbidden_reason
3657 = G_("function %q+F can never be inlined because "
3658 "it uses non-local goto");
3659 *handled_ops_p
= true;
3662 case BUILT_IN_RETURN
:
3663 case BUILT_IN_APPLY_ARGS
:
3664 /* If a __builtin_apply_args caller would be inlined,
3665 it would be saving arguments of the function it has
3666 been inlined into. Similarly __builtin_return would
3667 return from the function the inline has been inlined into. */
3668 inline_forbidden_reason
3669 = G_("function %q+F can never be inlined because "
3670 "it uses __builtin_return or __builtin_apply_args");
3671 *handled_ops_p
= true;
3680 t
= gimple_goto_dest (stmt
);
3682 /* We will not inline a function which uses computed goto. The
3683 addresses of its local labels, which may be tucked into
3684 global storage, are of course not constant across
3685 instantiations, which causes unexpected behavior. */
3686 if (TREE_CODE (t
) != LABEL_DECL
)
3688 inline_forbidden_reason
3689 = G_("function %q+F can never be inlined "
3690 "because it contains a computed goto");
3691 *handled_ops_p
= true;
3700 *handled_ops_p
= false;
3704 /* Return true if FNDECL is a function that cannot be inlined into
3708 inline_forbidden_p (tree fndecl
)
3710 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
3711 struct walk_stmt_info wi
;
3713 bool forbidden_p
= false;
3715 /* First check for shared reasons not to copy the code. */
3716 inline_forbidden_reason
= copy_forbidden (fun
);
3717 if (inline_forbidden_reason
!= NULL
)
3720 /* Next, walk the statements of the function looking for
3721 constraucts we can't handle, or are non-optimal for inlining. */
3722 hash_set
<tree
> visited_nodes
;
3723 memset (&wi
, 0, sizeof (wi
));
3724 wi
.info
= (void *) fndecl
;
3725 wi
.pset
= &visited_nodes
;
3727 FOR_EACH_BB_FN (bb
, fun
)
3730 gimple_seq seq
= bb_seq (bb
);
3731 ret
= walk_gimple_seq (seq
, inline_forbidden_p_stmt
, NULL
, &wi
);
3732 forbidden_p
= (ret
!= NULL
);
3740 /* Return false if the function FNDECL cannot be inlined on account of its
3741 attributes, true otherwise. */
3743 function_attribute_inlinable_p (const_tree fndecl
)
3745 if (targetm
.attribute_table
)
3749 for (a
= DECL_ATTRIBUTES (fndecl
); a
; a
= TREE_CHAIN (a
))
3751 const_tree name
= TREE_PURPOSE (a
);
3754 for (i
= 0; targetm
.attribute_table
[i
].name
!= NULL
; i
++)
3755 if (is_attribute_p (targetm
.attribute_table
[i
].name
, name
))
3756 return targetm
.function_attribute_inlinable_p (fndecl
);
3763 /* Returns nonzero if FN is a function that does not have any
3764 fundamental inline blocking properties. */
3767 tree_inlinable_function_p (tree fn
)
3769 bool inlinable
= true;
3773 /* If we've already decided this function shouldn't be inlined,
3774 there's no need to check again. */
3775 if (DECL_UNINLINABLE (fn
))
3778 /* We only warn for functions declared `inline' by the user. */
3779 do_warning
= (warn_inline
3780 && DECL_DECLARED_INLINE_P (fn
)
3781 && !DECL_NO_INLINE_WARNING_P (fn
)
3782 && !DECL_IN_SYSTEM_HEADER (fn
));
3784 always_inline
= lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
));
3787 && always_inline
== NULL
)
3790 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3791 "is suppressed using -fno-inline", fn
);
3795 else if (!function_attribute_inlinable_p (fn
))
3798 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3799 "uses attributes conflicting with inlining", fn
);
3803 else if (inline_forbidden_p (fn
))
3805 /* See if we should warn about uninlinable functions. Previously,
3806 some of these warnings would be issued while trying to expand
3807 the function inline, but that would cause multiple warnings
3808 about functions that would for example call alloca. But since
3809 this a property of the function, just one warning is enough.
3810 As a bonus we can now give more details about the reason why a
3811 function is not inlinable. */
3813 error (inline_forbidden_reason
, fn
);
3814 else if (do_warning
)
3815 warning (OPT_Winline
, inline_forbidden_reason
, fn
);
3820 /* Squirrel away the result so that we don't have to check again. */
3821 DECL_UNINLINABLE (fn
) = !inlinable
;
3826 /* Estimate the cost of a memory move of type TYPE. Use machine dependent
3827 word size and take possible memcpy call into account and return
3828 cost based on whether optimizing for size or speed according to SPEED_P. */
3831 estimate_move_cost (tree type
, bool ARG_UNUSED (speed_p
))
3835 gcc_assert (!VOID_TYPE_P (type
));
3837 if (TREE_CODE (type
) == VECTOR_TYPE
)
3839 machine_mode inner
= TYPE_MODE (TREE_TYPE (type
));
3841 = targetm
.vectorize
.preferred_simd_mode (inner
);
3842 int simd_mode_size
= GET_MODE_SIZE (simd
);
3843 return ((GET_MODE_SIZE (TYPE_MODE (type
)) + simd_mode_size
- 1)
3847 size
= int_size_in_bytes (type
);
3849 if (size
< 0 || size
> MOVE_MAX_PIECES
* MOVE_RATIO (speed_p
))
3850 /* Cost of a memcpy call, 3 arguments and the call. */
3853 return ((size
+ MOVE_MAX_PIECES
- 1) / MOVE_MAX_PIECES
);
3856 /* Returns cost of operation CODE, according to WEIGHTS */
3859 estimate_operator_cost (enum tree_code code
, eni_weights
*weights
,
3860 tree op1 ATTRIBUTE_UNUSED
, tree op2
)
3864 /* These are "free" conversions, or their presumed cost
3865 is folded into other operations. */
3870 case VIEW_CONVERT_EXPR
:
3873 /* Assign cost of 1 to usual operations.
3874 ??? We may consider mapping RTL costs to this. */
3880 case POINTER_PLUS_EXPR
:
3883 case MULT_HIGHPART_EXPR
:
3886 case ADDR_SPACE_CONVERT_EXPR
:
3887 case FIXED_CONVERT_EXPR
:
3888 case FIX_TRUNC_EXPR
:
3906 case TRUTH_ANDIF_EXPR
:
3907 case TRUTH_ORIF_EXPR
:
3908 case TRUTH_AND_EXPR
:
3910 case TRUTH_XOR_EXPR
:
3911 case TRUTH_NOT_EXPR
:
3920 case UNORDERED_EXPR
:
3931 case PREDECREMENT_EXPR
:
3932 case PREINCREMENT_EXPR
:
3933 case POSTDECREMENT_EXPR
:
3934 case POSTINCREMENT_EXPR
:
3936 case REALIGN_LOAD_EXPR
:
3938 case REDUC_MAX_EXPR
:
3939 case REDUC_MIN_EXPR
:
3940 case REDUC_PLUS_EXPR
:
3941 case WIDEN_SUM_EXPR
:
3942 case WIDEN_MULT_EXPR
:
3945 case WIDEN_MULT_PLUS_EXPR
:
3946 case WIDEN_MULT_MINUS_EXPR
:
3947 case WIDEN_LSHIFT_EXPR
:
3949 case VEC_WIDEN_MULT_HI_EXPR
:
3950 case VEC_WIDEN_MULT_LO_EXPR
:
3951 case VEC_WIDEN_MULT_EVEN_EXPR
:
3952 case VEC_WIDEN_MULT_ODD_EXPR
:
3953 case VEC_UNPACK_HI_EXPR
:
3954 case VEC_UNPACK_LO_EXPR
:
3955 case VEC_UNPACK_FLOAT_HI_EXPR
:
3956 case VEC_UNPACK_FLOAT_LO_EXPR
:
3957 case VEC_PACK_TRUNC_EXPR
:
3958 case VEC_PACK_SAT_EXPR
:
3959 case VEC_PACK_FIX_TRUNC_EXPR
:
3960 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3961 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3965 /* Few special cases of expensive operations. This is useful
3966 to avoid inlining on functions having too many of these. */
3967 case TRUNC_DIV_EXPR
:
3969 case FLOOR_DIV_EXPR
:
3970 case ROUND_DIV_EXPR
:
3971 case EXACT_DIV_EXPR
:
3972 case TRUNC_MOD_EXPR
:
3974 case FLOOR_MOD_EXPR
:
3975 case ROUND_MOD_EXPR
:
3977 if (TREE_CODE (op2
) != INTEGER_CST
)
3978 return weights
->div_mod_cost
;
3981 /* Bit-field insertion needs several shift and mask operations. */
3982 case BIT_INSERT_EXPR
:
3986 /* We expect a copy assignment with no operator. */
3987 gcc_assert (get_gimple_rhs_class (code
) == GIMPLE_SINGLE_RHS
);
3993 /* Estimate number of instructions that will be created by expanding
3994 the statements in the statement sequence STMTS.
3995 WEIGHTS contains weights attributed to various constructs. */
3998 estimate_num_insns_seq (gimple_seq stmts
, eni_weights
*weights
)
4001 gimple_stmt_iterator gsi
;
4004 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4005 cost
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
4011 /* Estimate number of instructions that will be created by expanding STMT.
4012 WEIGHTS contains weights attributed to various constructs. */
4015 estimate_num_insns (gimple
*stmt
, eni_weights
*weights
)
4018 enum gimple_code code
= gimple_code (stmt
);
4025 /* Try to estimate the cost of assignments. We have three cases to
4027 1) Simple assignments to registers;
4028 2) Stores to things that must live in memory. This includes
4029 "normal" stores to scalars, but also assignments of large
4030 structures, or constructors of big arrays;
4032 Let us look at the first two cases, assuming we have "a = b + C":
4033 <GIMPLE_ASSIGN <var_decl "a">
4034 <plus_expr <var_decl "b"> <constant C>>
4035 If "a" is a GIMPLE register, the assignment to it is free on almost
4036 any target, because "a" usually ends up in a real register. Hence
4037 the only cost of this expression comes from the PLUS_EXPR, and we
4038 can ignore the GIMPLE_ASSIGN.
4039 If "a" is not a GIMPLE register, the assignment to "a" will most
4040 likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost
4041 of moving something into "a", which we compute using the function
4042 estimate_move_cost. */
4043 if (gimple_clobber_p (stmt
))
4044 return 0; /* ={v} {CLOBBER} stmt expands to nothing. */
4046 lhs
= gimple_assign_lhs (stmt
);
4047 rhs
= gimple_assign_rhs1 (stmt
);
4051 /* Account for the cost of moving to / from memory. */
4052 if (gimple_store_p (stmt
))
4053 cost
+= estimate_move_cost (TREE_TYPE (lhs
), weights
->time_based
);
4054 if (gimple_assign_load_p (stmt
))
4055 cost
+= estimate_move_cost (TREE_TYPE (rhs
), weights
->time_based
);
4057 cost
+= estimate_operator_cost (gimple_assign_rhs_code (stmt
), weights
,
4058 gimple_assign_rhs1 (stmt
),
4059 get_gimple_rhs_class (gimple_assign_rhs_code (stmt
))
4060 == GIMPLE_BINARY_RHS
4061 ? gimple_assign_rhs2 (stmt
) : NULL
);
4065 cost
= 1 + estimate_operator_cost (gimple_cond_code (stmt
), weights
,
4066 gimple_op (stmt
, 0),
4067 gimple_op (stmt
, 1));
4072 gswitch
*switch_stmt
= as_a
<gswitch
*> (stmt
);
4073 /* Take into account cost of the switch + guess 2 conditional jumps for
4076 TODO: once the switch expansion logic is sufficiently separated, we can
4077 do better job on estimating cost of the switch. */
4078 if (weights
->time_based
)
4079 cost
= floor_log2 (gimple_switch_num_labels (switch_stmt
)) * 2;
4081 cost
= gimple_switch_num_labels (switch_stmt
) * 2;
4089 if (gimple_call_internal_p (stmt
))
4091 else if ((decl
= gimple_call_fndecl (stmt
))
4092 && DECL_BUILT_IN (decl
))
4094 /* Do not special case builtins where we see the body.
4095 This just confuse inliner. */
4096 struct cgraph_node
*node
;
4097 if (!(node
= cgraph_node::get (decl
))
4098 || node
->definition
)
4100 /* For buitins that are likely expanded to nothing or
4101 inlined do not account operand costs. */
4102 else if (is_simple_builtin (decl
))
4104 else if (is_inexpensive_builtin (decl
))
4105 return weights
->target_builtin_call_cost
;
4106 else if (gimple_call_builtin_p (stmt
, BUILT_IN_NORMAL
))
4108 /* We canonicalize x * x to pow (x, 2.0) with -ffast-math, so
4109 specialize the cheap expansion we do here.
4110 ??? This asks for a more general solution. */
4111 switch (DECL_FUNCTION_CODE (decl
))
4116 if (TREE_CODE (gimple_call_arg (stmt
, 1)) == REAL_CST
4118 (&TREE_REAL_CST (gimple_call_arg (stmt
, 1)),
4120 return estimate_operator_cost
4121 (MULT_EXPR
, weights
, gimple_call_arg (stmt
, 0),
4122 gimple_call_arg (stmt
, 0));
4131 cost
= decl
? weights
->call_cost
: weights
->indirect_call_cost
;
4132 if (gimple_call_lhs (stmt
))
4133 cost
+= estimate_move_cost (TREE_TYPE (gimple_call_lhs (stmt
)),
4134 weights
->time_based
);
4135 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
4137 tree arg
= gimple_call_arg (stmt
, i
);
4138 cost
+= estimate_move_cost (TREE_TYPE (arg
),
4139 weights
->time_based
);
4145 return weights
->return_cost
;
4151 case GIMPLE_PREDICT
:
4157 int count
= asm_str_count (gimple_asm_string (as_a
<gasm
*> (stmt
)));
4158 /* 1000 means infinity. This avoids overflows later
4159 with very long asm statements. */
4166 /* This is either going to be an external function call with one
4167 argument, or two register copy statements plus a goto. */
4170 case GIMPLE_EH_DISPATCH
:
4171 /* ??? This is going to turn into a switch statement. Ideally
4172 we'd have a look at the eh region and estimate the number of
4177 return estimate_num_insns_seq (
4178 gimple_bind_body (as_a
<gbind
*> (stmt
)),
4181 case GIMPLE_EH_FILTER
:
4182 return estimate_num_insns_seq (gimple_eh_filter_failure (stmt
), weights
);
4185 return estimate_num_insns_seq (gimple_catch_handler (
4186 as_a
<gcatch
*> (stmt
)),
4190 return (estimate_num_insns_seq (gimple_try_eval (stmt
), weights
)
4191 + estimate_num_insns_seq (gimple_try_cleanup (stmt
), weights
));
4193 /* OMP directives are generally very expensive. */
4195 case GIMPLE_OMP_RETURN
:
4196 case GIMPLE_OMP_SECTIONS_SWITCH
:
4197 case GIMPLE_OMP_ATOMIC_STORE
:
4198 case GIMPLE_OMP_CONTINUE
:
4199 /* ...except these, which are cheap. */
4202 case GIMPLE_OMP_ATOMIC_LOAD
:
4203 return weights
->omp_cost
;
4205 case GIMPLE_OMP_FOR
:
4206 return (weights
->omp_cost
4207 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
)
4208 + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt
), weights
));
4210 case GIMPLE_OMP_PARALLEL
:
4211 case GIMPLE_OMP_TASK
:
4212 case GIMPLE_OMP_CRITICAL
:
4213 case GIMPLE_OMP_MASTER
:
4214 case GIMPLE_OMP_TASKGROUP
:
4215 case GIMPLE_OMP_ORDERED
:
4216 case GIMPLE_OMP_SECTION
:
4217 case GIMPLE_OMP_SECTIONS
:
4218 case GIMPLE_OMP_SINGLE
:
4219 case GIMPLE_OMP_TARGET
:
4220 case GIMPLE_OMP_TEAMS
:
4221 return (weights
->omp_cost
4222 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
));
4224 case GIMPLE_TRANSACTION
:
4225 return (weights
->tm_cost
4226 + estimate_num_insns_seq (gimple_transaction_body (
4227 as_a
<gtransaction
*> (stmt
)),
4237 /* Estimate number of instructions that will be created by expanding
4238 function FNDECL. WEIGHTS contains weights attributed to various
4242 estimate_num_insns_fn (tree fndecl
, eni_weights
*weights
)
4244 struct function
*my_function
= DECL_STRUCT_FUNCTION (fndecl
);
4245 gimple_stmt_iterator bsi
;
4249 gcc_assert (my_function
&& my_function
->cfg
);
4250 FOR_EACH_BB_FN (bb
, my_function
)
4252 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
4253 n
+= estimate_num_insns (gsi_stmt (bsi
), weights
);
4260 /* Initializes weights used by estimate_num_insns. */
4263 init_inline_once (void)
4265 eni_size_weights
.call_cost
= 1;
4266 eni_size_weights
.indirect_call_cost
= 3;
4267 eni_size_weights
.target_builtin_call_cost
= 1;
4268 eni_size_weights
.div_mod_cost
= 1;
4269 eni_size_weights
.omp_cost
= 40;
4270 eni_size_weights
.tm_cost
= 10;
4271 eni_size_weights
.time_based
= false;
4272 eni_size_weights
.return_cost
= 1;
4274 /* Estimating time for call is difficult, since we have no idea what the
4275 called function does. In the current uses of eni_time_weights,
4276 underestimating the cost does less harm than overestimating it, so
4277 we choose a rather small value here. */
4278 eni_time_weights
.call_cost
= 10;
4279 eni_time_weights
.indirect_call_cost
= 15;
4280 eni_time_weights
.target_builtin_call_cost
= 1;
4281 eni_time_weights
.div_mod_cost
= 10;
4282 eni_time_weights
.omp_cost
= 40;
4283 eni_time_weights
.tm_cost
= 40;
4284 eni_time_weights
.time_based
= true;
4285 eni_time_weights
.return_cost
= 2;
4289 /* Install new lexical TREE_BLOCK underneath 'current_block'. */
4292 prepend_lexical_block (tree current_block
, tree new_block
)
4294 BLOCK_CHAIN (new_block
) = BLOCK_SUBBLOCKS (current_block
);
4295 BLOCK_SUBBLOCKS (current_block
) = new_block
;
4296 BLOCK_SUPERCONTEXT (new_block
) = current_block
;
4299 /* Add local variables from CALLEE to CALLER. */
4302 add_local_variables (struct function
*callee
, struct function
*caller
,
4308 FOR_EACH_LOCAL_DECL (callee
, ix
, var
)
4309 if (!can_be_nonlocal (var
, id
))
4311 tree new_var
= remap_decl (var
, id
);
4313 /* Remap debug-expressions. */
4315 && DECL_HAS_DEBUG_EXPR_P (var
)
4318 tree tem
= DECL_DEBUG_EXPR (var
);
4319 bool old_regimplify
= id
->regimplify
;
4320 id
->remapping_type_depth
++;
4321 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
4322 id
->remapping_type_depth
--;
4323 id
->regimplify
= old_regimplify
;
4324 SET_DECL_DEBUG_EXPR (new_var
, tem
);
4325 DECL_HAS_DEBUG_EXPR_P (new_var
) = 1;
4327 add_local_decl (caller
, new_var
);
4331 /* Add to BINDINGS a debug stmt resetting SRCVAR if inlining might
4332 have brought in or introduced any debug stmts for SRCVAR. */
4335 reset_debug_binding (copy_body_data
*id
, tree srcvar
, gimple_seq
*bindings
)
4337 tree
*remappedvarp
= id
->decl_map
->get (srcvar
);
4342 if (!VAR_P (*remappedvarp
))
4345 if (*remappedvarp
== id
->retvar
|| *remappedvarp
== id
->retbnd
)
4348 tree tvar
= target_for_debug_bind (*remappedvarp
);
4352 gdebug
*stmt
= gimple_build_debug_bind (tvar
, NULL_TREE
,
4354 gimple_seq_add_stmt (bindings
, stmt
);
4357 /* For each inlined variable for which we may have debug bind stmts,
4358 add before GSI a final debug stmt resetting it, marking the end of
4359 its life, so that var-tracking knows it doesn't have to compute
4360 further locations for it. */
4363 reset_debug_bindings (copy_body_data
*id
, gimple_stmt_iterator gsi
)
4367 gimple_seq bindings
= NULL
;
4369 if (!gimple_in_ssa_p (id
->src_cfun
))
4372 if (!opt_for_fn (id
->dst_fn
, flag_var_tracking_assignments
))
4375 for (var
= DECL_ARGUMENTS (id
->src_fn
);
4376 var
; var
= DECL_CHAIN (var
))
4377 reset_debug_binding (id
, var
, &bindings
);
4379 FOR_EACH_LOCAL_DECL (id
->src_cfun
, ix
, var
)
4380 reset_debug_binding (id
, var
, &bindings
);
4382 gsi_insert_seq_before_without_update (&gsi
, bindings
, GSI_SAME_STMT
);
4385 /* If STMT is a GIMPLE_CALL, replace it with its inline expansion. */
4388 expand_call_inline (basic_block bb
, gimple
*stmt
, copy_body_data
*id
)
4392 hash_map
<tree
, tree
> *dst
;
4393 hash_map
<tree
, tree
> *st
= NULL
;
4396 tree return_bounds
= NULL
;
4397 struct cgraph_edge
*cg_edge
;
4398 cgraph_inline_failed_t reason
;
4399 basic_block return_block
;
4401 gimple_stmt_iterator gsi
, stmt_gsi
;
4402 bool successfully_inlined
= false;
4403 bool purge_dead_abnormal_edges
;
4406 unsigned int prop_mask
, src_properties
;
4407 struct function
*dst_cfun
;
4410 gimple
*simtenter_stmt
= NULL
;
4411 vec
<tree
> *simtvars_save
;
4413 /* The gimplifier uses input_location in too many places, such as
4414 internal_get_tmp_var (). */
4415 location_t saved_location
= input_location
;
4416 input_location
= gimple_location (stmt
);
4418 /* From here on, we're only interested in CALL_EXPRs. */
4419 call_stmt
= dyn_cast
<gcall
*> (stmt
);
4423 cg_edge
= id
->dst_node
->get_edge (stmt
);
4424 gcc_checking_assert (cg_edge
);
4425 /* First, see if we can figure out what function is being called.
4426 If we cannot, then there is no hope of inlining the function. */
4427 if (cg_edge
->indirect_unknown_callee
)
4429 fn
= cg_edge
->callee
->decl
;
4430 gcc_checking_assert (fn
);
4432 /* If FN is a declaration of a function in a nested scope that was
4433 globally declared inline, we don't set its DECL_INITIAL.
4434 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
4435 C++ front-end uses it for cdtors to refer to their internal
4436 declarations, that are not real functions. Fortunately those
4437 don't have trees to be saved, so we can tell by checking their
4439 if (!DECL_INITIAL (fn
)
4440 && DECL_ABSTRACT_ORIGIN (fn
)
4441 && gimple_has_body_p (DECL_ABSTRACT_ORIGIN (fn
)))
4442 fn
= DECL_ABSTRACT_ORIGIN (fn
);
4444 /* Don't try to inline functions that are not well-suited to inlining. */
4445 if (cg_edge
->inline_failed
)
4447 reason
= cg_edge
->inline_failed
;
4448 /* If this call was originally indirect, we do not want to emit any
4449 inlining related warnings or sorry messages because there are no
4450 guarantees regarding those. */
4451 if (cg_edge
->indirect_inlining_edge
)
4454 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
))
4455 /* For extern inline functions that get redefined we always
4456 silently ignored always_inline flag. Better behavior would
4457 be to be able to keep both bodies and use extern inline body
4458 for inlining, but we can't do that because frontends overwrite
4460 && !cg_edge
->callee
->local
.redefined_extern_inline
4461 /* During early inline pass, report only when optimization is
4463 && (symtab
->global_info_ready
4465 || cgraph_inline_failed_type (reason
) == CIF_FINAL_ERROR
)
4466 /* PR 20090218-1_0.c. Body can be provided by another module. */
4467 && (reason
!= CIF_BODY_NOT_AVAILABLE
|| !flag_generate_lto
))
4469 error ("inlining failed in call to always_inline %q+F: %s", fn
,
4470 cgraph_inline_failed_string (reason
));
4471 if (gimple_location (stmt
) != UNKNOWN_LOCATION
)
4472 inform (gimple_location (stmt
), "called from here");
4473 else if (DECL_SOURCE_LOCATION (cfun
->decl
) != UNKNOWN_LOCATION
)
4474 inform (DECL_SOURCE_LOCATION (cfun
->decl
),
4475 "called from this function");
4477 else if (warn_inline
4478 && DECL_DECLARED_INLINE_P (fn
)
4479 && !DECL_NO_INLINE_WARNING_P (fn
)
4480 && !DECL_IN_SYSTEM_HEADER (fn
)
4481 && reason
!= CIF_UNSPECIFIED
4482 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn
))
4483 /* Do not warn about not inlined recursive calls. */
4484 && !cg_edge
->recursive_p ()
4485 /* Avoid warnings during early inline pass. */
4486 && symtab
->global_info_ready
)
4488 if (warning (OPT_Winline
, "inlining failed in call to %q+F: %s",
4489 fn
, _(cgraph_inline_failed_string (reason
))))
4491 if (gimple_location (stmt
) != UNKNOWN_LOCATION
)
4492 inform (gimple_location (stmt
), "called from here");
4493 else if (DECL_SOURCE_LOCATION (cfun
->decl
) != UNKNOWN_LOCATION
)
4494 inform (DECL_SOURCE_LOCATION (cfun
->decl
),
4495 "called from this function");
4500 id
->src_node
= cg_edge
->callee
;
4502 /* If callee is thunk, all we need is to adjust the THIS pointer
4503 and redirect to function being thunked. */
4504 if (id
->src_node
->thunk
.thunk_p
)
4507 tree virtual_offset
= NULL
;
4508 int freq
= cg_edge
->frequency
;
4509 profile_count count
= cg_edge
->count
;
4511 gimple_stmt_iterator iter
= gsi_for_stmt (stmt
);
4514 edge
= id
->src_node
->callees
->clone (id
->dst_node
, call_stmt
,
4516 profile_count::one (),
4517 profile_count::one (),
4520 edge
->frequency
= freq
;
4521 edge
->count
= count
;
4522 if (id
->src_node
->thunk
.virtual_offset_p
)
4523 virtual_offset
= size_int (id
->src_node
->thunk
.virtual_value
);
4524 op
= create_tmp_reg_fn (cfun
, TREE_TYPE (gimple_call_arg (stmt
, 0)),
4526 gsi_insert_before (&iter
, gimple_build_assign (op
,
4527 gimple_call_arg (stmt
, 0)),
4529 gcc_assert (id
->src_node
->thunk
.this_adjusting
);
4530 op
= thunk_adjust (&iter
, op
, 1, id
->src_node
->thunk
.fixed_offset
,
4533 gimple_call_set_arg (stmt
, 0, op
);
4534 gimple_call_set_fndecl (stmt
, edge
->callee
->decl
);
4536 id
->src_node
->remove ();
4537 expand_call_inline (bb
, stmt
, id
);
4538 maybe_remove_unused_call_args (cfun
, stmt
);
4541 fn
= cg_edge
->callee
->decl
;
4542 cg_edge
->callee
->get_untransformed_body ();
4544 if (flag_checking
&& cg_edge
->callee
->decl
!= id
->dst_node
->decl
)
4545 cg_edge
->callee
->verify ();
4547 /* We will be inlining this callee. */
4548 id
->eh_lp_nr
= lookup_stmt_eh_lp (stmt
);
4549 id
->assign_stmts
.create (0);
4551 /* Update the callers EH personality. */
4552 if (DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->decl
))
4553 DECL_FUNCTION_PERSONALITY (cg_edge
->caller
->decl
)
4554 = DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->decl
);
4556 /* Split the block before the GIMPLE_CALL. */
4557 stmt_gsi
= gsi_for_stmt (stmt
);
4558 gsi_prev (&stmt_gsi
);
4559 e
= split_block (bb
, gsi_end_p (stmt_gsi
) ? NULL
: gsi_stmt (stmt_gsi
));
4561 return_block
= e
->dest
;
4564 /* If the GIMPLE_CALL was in the last statement of BB, it may have
4565 been the source of abnormal edges. In this case, schedule
4566 the removal of dead abnormal edges. */
4567 gsi
= gsi_start_bb (return_block
);
4569 purge_dead_abnormal_edges
= gsi_end_p (gsi
);
4571 stmt_gsi
= gsi_start_bb (return_block
);
4573 /* Build a block containing code to initialize the arguments, the
4574 actual inline expansion of the body, and a label for the return
4575 statements within the function to jump to. The type of the
4576 statement expression is the return type of the function call.
4577 ??? If the call does not have an associated block then we will
4578 remap all callee blocks to NULL, effectively dropping most of
4579 its debug information. This should only happen for calls to
4580 artificial decls inserted by the compiler itself. We need to
4581 either link the inlined blocks into the caller block tree or
4582 not refer to them in any way to not break GC for locations. */
4583 if (gimple_block (stmt
))
4585 id
->block
= make_node (BLOCK
);
4586 BLOCK_ABSTRACT_ORIGIN (id
->block
) = fn
;
4587 BLOCK_SOURCE_LOCATION (id
->block
)
4588 = LOCATION_LOCUS (gimple_location (stmt
));
4589 prepend_lexical_block (gimple_block (stmt
), id
->block
);
4592 /* Local declarations will be replaced by their equivalents in this
4595 id
->decl_map
= new hash_map
<tree
, tree
>;
4596 dst
= id
->debug_map
;
4597 id
->debug_map
= NULL
;
4599 /* Record the function we are about to inline. */
4601 id
->src_cfun
= DECL_STRUCT_FUNCTION (fn
);
4602 id
->call_stmt
= call_stmt
;
4604 /* When inlining into an OpenMP SIMD-on-SIMT loop, arrange for new automatic
4605 variables to be added to IFN_GOMP_SIMT_ENTER argument list. */
4606 dst_cfun
= DECL_STRUCT_FUNCTION (id
->dst_fn
);
4607 simtvars_save
= id
->dst_simt_vars
;
4608 if (!(dst_cfun
->curr_properties
& PROP_gimple_lomp_dev
)
4609 && (simduid
= bb
->loop_father
->simduid
) != NULL_TREE
4610 && (simduid
= ssa_default_def (dst_cfun
, simduid
)) != NULL_TREE
4611 && single_imm_use (simduid
, &use
, &simtenter_stmt
)
4612 && is_gimple_call (simtenter_stmt
)
4613 && gimple_call_internal_p (simtenter_stmt
, IFN_GOMP_SIMT_ENTER
))
4614 vec_alloc (id
->dst_simt_vars
, 0);
4616 id
->dst_simt_vars
= NULL
;
4618 /* If the src function contains an IFN_VA_ARG, then so will the dst
4619 function after inlining. Likewise for IFN_GOMP_USE_SIMT. */
4620 prop_mask
= PROP_gimple_lva
| PROP_gimple_lomp_dev
;
4621 src_properties
= id
->src_cfun
->curr_properties
& prop_mask
;
4622 if (src_properties
!= prop_mask
)
4623 dst_cfun
->curr_properties
&= src_properties
| ~prop_mask
;
4625 gcc_assert (!id
->src_cfun
->after_inlining
);
4628 if (lookup_attribute ("cold", DECL_ATTRIBUTES (fn
)))
4630 gimple_stmt_iterator si
= gsi_last_bb (bb
);
4631 gsi_insert_after (&si
, gimple_build_predict (PRED_COLD_FUNCTION
,
4635 initialize_inlined_parameters (id
, stmt
, fn
, bb
);
4637 if (DECL_INITIAL (fn
))
4639 if (gimple_block (stmt
))
4643 prepend_lexical_block (id
->block
,
4644 remap_blocks (DECL_INITIAL (fn
), id
));
4645 gcc_checking_assert (BLOCK_SUBBLOCKS (id
->block
)
4646 && (BLOCK_CHAIN (BLOCK_SUBBLOCKS (id
->block
))
4648 /* Move vars for PARM_DECLs from DECL_INITIAL block to id->block,
4649 otherwise for DWARF DW_TAG_formal_parameter will not be children of
4650 DW_TAG_inlined_subroutine, but of a DW_TAG_lexical_block
4651 under it. The parameters can be then evaluated in the debugger,
4652 but don't show in backtraces. */
4653 for (var
= &BLOCK_VARS (BLOCK_SUBBLOCKS (id
->block
)); *var
; )
4654 if (TREE_CODE (DECL_ORIGIN (*var
)) == PARM_DECL
)
4657 *var
= TREE_CHAIN (v
);
4658 TREE_CHAIN (v
) = BLOCK_VARS (id
->block
);
4659 BLOCK_VARS (id
->block
) = v
;
4662 var
= &TREE_CHAIN (*var
);
4665 remap_blocks_to_null (DECL_INITIAL (fn
), id
);
4668 /* Return statements in the function body will be replaced by jumps
4669 to the RET_LABEL. */
4670 gcc_assert (DECL_INITIAL (fn
));
4671 gcc_assert (TREE_CODE (DECL_INITIAL (fn
)) == BLOCK
);
4673 /* Find the LHS to which the result of this call is assigned. */
4675 if (gimple_call_lhs (stmt
))
4677 modify_dest
= gimple_call_lhs (stmt
);
4679 /* Remember where to copy returned bounds. */
4680 if (gimple_call_with_bounds_p (stmt
)
4681 && TREE_CODE (modify_dest
) == SSA_NAME
)
4683 gcall
*retbnd
= chkp_retbnd_call_by_val (modify_dest
);
4686 return_bounds
= gimple_call_lhs (retbnd
);
4687 /* If returned bounds are not used then just
4688 remove unused call. */
4691 gimple_stmt_iterator iter
= gsi_for_stmt (retbnd
);
4692 gsi_remove (&iter
, true);
4697 /* The function which we are inlining might not return a value,
4698 in which case we should issue a warning that the function
4699 does not return a value. In that case the optimizers will
4700 see that the variable to which the value is assigned was not
4701 initialized. We do not want to issue a warning about that
4702 uninitialized variable. */
4703 if (DECL_P (modify_dest
))
4704 TREE_NO_WARNING (modify_dest
) = 1;
4706 if (gimple_call_return_slot_opt_p (call_stmt
))
4708 return_slot
= modify_dest
;
4715 /* If we are inlining a call to the C++ operator new, we don't want
4716 to use type based alias analysis on the return value. Otherwise
4717 we may get confused if the compiler sees that the inlined new
4718 function returns a pointer which was just deleted. See bug
4720 if (DECL_IS_OPERATOR_NEW (fn
))
4726 /* Declare the return variable for the function. */
4727 use_retvar
= declare_return_variable (id
, return_slot
, modify_dest
,
4730 /* Add local vars in this inlined callee to caller. */
4731 add_local_variables (id
->src_cfun
, cfun
, id
);
4733 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4735 fprintf (dump_file
, "Inlining ");
4736 print_generic_expr (dump_file
, id
->src_fn
);
4737 fprintf (dump_file
, " to ");
4738 print_generic_expr (dump_file
, id
->dst_fn
);
4739 fprintf (dump_file
, " with frequency %i\n", cg_edge
->frequency
);
4742 /* This is it. Duplicate the callee body. Assume callee is
4743 pre-gimplified. Note that we must not alter the caller
4744 function in any way before this point, as this CALL_EXPR may be
4745 a self-referential call; if we're calling ourselves, we need to
4746 duplicate our body before altering anything. */
4747 copy_body (id
, cg_edge
->callee
->count
,
4748 GCOV_COMPUTE_SCALE (cg_edge
->frequency
, CGRAPH_FREQ_BASE
),
4749 bb
, return_block
, NULL
);
4751 reset_debug_bindings (id
, stmt_gsi
);
4753 /* Reset the escaped solution. */
4754 if (cfun
->gimple_df
)
4755 pt_solution_reset (&cfun
->gimple_df
->escaped
);
4757 /* Add new automatic variables to IFN_GOMP_SIMT_ENTER arguments. */
4758 if (id
->dst_simt_vars
&& id
->dst_simt_vars
->length () > 0)
4760 size_t nargs
= gimple_call_num_args (simtenter_stmt
);
4761 vec
<tree
> *vars
= id
->dst_simt_vars
;
4762 auto_vec
<tree
> newargs (nargs
+ vars
->length ());
4763 for (size_t i
= 0; i
< nargs
; i
++)
4764 newargs
.quick_push (gimple_call_arg (simtenter_stmt
, i
));
4765 for (tree
*pvar
= vars
->begin (); pvar
!= vars
->end (); pvar
++)
4767 tree ptrtype
= build_pointer_type (TREE_TYPE (*pvar
));
4768 newargs
.quick_push (build1 (ADDR_EXPR
, ptrtype
, *pvar
));
4770 gcall
*g
= gimple_build_call_internal_vec (IFN_GOMP_SIMT_ENTER
, newargs
);
4771 gimple_call_set_lhs (g
, gimple_call_lhs (simtenter_stmt
));
4772 gimple_stmt_iterator gsi
= gsi_for_stmt (simtenter_stmt
);
4773 gsi_replace (&gsi
, g
, false);
4775 vec_free (id
->dst_simt_vars
);
4776 id
->dst_simt_vars
= simtvars_save
;
4781 delete id
->debug_map
;
4782 id
->debug_map
= dst
;
4784 delete id
->decl_map
;
4787 /* Unlink the calls virtual operands before replacing it. */
4788 unlink_stmt_vdef (stmt
);
4789 if (gimple_vdef (stmt
)
4790 && TREE_CODE (gimple_vdef (stmt
)) == SSA_NAME
)
4791 release_ssa_name (gimple_vdef (stmt
));
4793 /* If the inlined function returns a result that we care about,
4794 substitute the GIMPLE_CALL with an assignment of the return
4795 variable to the LHS of the call. That is, if STMT was
4796 'a = foo (...)', substitute the call with 'a = USE_RETVAR'. */
4797 if (use_retvar
&& gimple_call_lhs (stmt
))
4799 gimple
*old_stmt
= stmt
;
4800 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), use_retvar
);
4801 gsi_replace (&stmt_gsi
, stmt
, false);
4802 maybe_clean_or_replace_eh_stmt (old_stmt
, stmt
);
4804 /* Copy bounds if we copy structure with bounds. */
4805 if (chkp_function_instrumented_p (id
->dst_fn
)
4806 && !BOUNDED_P (use_retvar
)
4807 && chkp_type_has_pointer (TREE_TYPE (use_retvar
)))
4808 id
->assign_stmts
.safe_push (stmt
);
4812 /* Handle the case of inlining a function with no return
4813 statement, which causes the return value to become undefined. */
4814 if (gimple_call_lhs (stmt
)
4815 && TREE_CODE (gimple_call_lhs (stmt
)) == SSA_NAME
)
4817 tree name
= gimple_call_lhs (stmt
);
4818 tree var
= SSA_NAME_VAR (name
);
4819 tree def
= var
? ssa_default_def (cfun
, var
) : NULL
;
4823 /* If the variable is used undefined, make this name
4824 undefined via a move. */
4825 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), def
);
4826 gsi_replace (&stmt_gsi
, stmt
, true);
4832 var
= create_tmp_reg_fn (cfun
, TREE_TYPE (name
), NULL
);
4833 SET_SSA_NAME_VAR_OR_IDENTIFIER (name
, var
);
4835 /* Otherwise make this variable undefined. */
4836 gsi_remove (&stmt_gsi
, true);
4837 set_ssa_default_def (cfun
, var
, name
);
4838 SSA_NAME_DEF_STMT (name
) = gimple_build_nop ();
4842 gsi_remove (&stmt_gsi
, true);
4845 /* Put returned bounds into the correct place if required. */
4848 gimple
*old_stmt
= SSA_NAME_DEF_STMT (return_bounds
);
4849 gimple
*new_stmt
= gimple_build_assign (return_bounds
, id
->retbnd
);
4850 gimple_stmt_iterator bnd_gsi
= gsi_for_stmt (old_stmt
);
4851 unlink_stmt_vdef (old_stmt
);
4852 gsi_replace (&bnd_gsi
, new_stmt
, false);
4853 maybe_clean_or_replace_eh_stmt (old_stmt
, new_stmt
);
4854 cgraph_update_edges_for_call_stmt (old_stmt
,
4855 gimple_call_fndecl (old_stmt
),
4859 if (purge_dead_abnormal_edges
)
4861 gimple_purge_dead_eh_edges (return_block
);
4862 gimple_purge_dead_abnormal_call_edges (return_block
);
4865 /* If the value of the new expression is ignored, that's OK. We
4866 don't warn about this for CALL_EXPRs, so we shouldn't warn about
4867 the equivalent inlined version either. */
4868 if (is_gimple_assign (stmt
))
4870 gcc_assert (gimple_assign_single_p (stmt
)
4871 || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
)));
4872 TREE_USED (gimple_assign_rhs1 (stmt
)) = 1;
4875 /* Copy bounds for all generated assigns that need it. */
4876 for (i
= 0; i
< id
->assign_stmts
.length (); i
++)
4877 chkp_copy_bounds_for_assign (id
->assign_stmts
[i
], cg_edge
);
4878 id
->assign_stmts
.release ();
4880 /* Output the inlining info for this abstract function, since it has been
4881 inlined. If we don't do this now, we can lose the information about the
4882 variables in the function when the blocks get blown away as soon as we
4883 remove the cgraph node. */
4884 if (gimple_block (stmt
))
4885 (*debug_hooks
->outlining_inline_function
) (cg_edge
->callee
->decl
);
4887 /* Update callgraph if needed. */
4888 cg_edge
->callee
->remove ();
4890 id
->block
= NULL_TREE
;
4891 successfully_inlined
= true;
4894 input_location
= saved_location
;
4895 return successfully_inlined
;
4898 /* Expand call statements reachable from STMT_P.
4899 We can only have CALL_EXPRs as the "toplevel" tree code or nested
4900 in a MODIFY_EXPR. */
4903 gimple_expand_calls_inline (basic_block bb
, copy_body_data
*id
)
4905 gimple_stmt_iterator gsi
;
4906 bool inlined
= false;
4908 for (gsi
= gsi_last_bb (bb
); !gsi_end_p (gsi
);)
4910 gimple
*stmt
= gsi_stmt (gsi
);
4913 if (is_gimple_call (stmt
)
4914 && !gimple_call_internal_p (stmt
))
4915 inlined
|= expand_call_inline (bb
, stmt
, id
);
4922 /* Walk all basic blocks created after FIRST and try to fold every statement
4923 in the STATEMENTS pointer set. */
4926 fold_marked_statements (int first
, hash_set
<gimple
*> *statements
)
4928 for (; first
< n_basic_blocks_for_fn (cfun
); first
++)
4929 if (BASIC_BLOCK_FOR_FN (cfun
, first
))
4931 gimple_stmt_iterator gsi
;
4933 for (gsi
= gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, first
));
4936 if (statements
->contains (gsi_stmt (gsi
)))
4938 gimple
*old_stmt
= gsi_stmt (gsi
);
4939 tree old_decl
= is_gimple_call (old_stmt
) ? gimple_call_fndecl (old_stmt
) : 0;
4941 if (old_decl
&& DECL_BUILT_IN (old_decl
))
4943 /* Folding builtins can create multiple instructions,
4944 we need to look at all of them. */
4945 gimple_stmt_iterator i2
= gsi
;
4947 if (fold_stmt (&gsi
))
4950 /* If a builtin at the end of a bb folded into nothing,
4951 the following loop won't work. */
4952 if (gsi_end_p (gsi
))
4954 cgraph_update_edges_for_call_stmt (old_stmt
,
4959 i2
= gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, first
));
4964 new_stmt
= gsi_stmt (i2
);
4965 update_stmt (new_stmt
);
4966 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4969 if (new_stmt
== gsi_stmt (gsi
))
4971 /* It is okay to check only for the very last
4972 of these statements. If it is a throwing
4973 statement nothing will change. If it isn't
4974 this can remove EH edges. If that weren't
4975 correct then because some intermediate stmts
4976 throw, but not the last one. That would mean
4977 we'd have to split the block, which we can't
4978 here and we'd loose anyway. And as builtins
4979 probably never throw, this all
4981 if (maybe_clean_or_replace_eh_stmt (old_stmt
,
4983 gimple_purge_dead_eh_edges (
4984 BASIC_BLOCK_FOR_FN (cfun
, first
));
4991 else if (fold_stmt (&gsi
))
4993 /* Re-read the statement from GSI as fold_stmt() may
4995 gimple
*new_stmt
= gsi_stmt (gsi
);
4996 update_stmt (new_stmt
);
4998 if (is_gimple_call (old_stmt
)
4999 || is_gimple_call (new_stmt
))
5000 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
5003 if (maybe_clean_or_replace_eh_stmt (old_stmt
, new_stmt
))
5004 gimple_purge_dead_eh_edges (BASIC_BLOCK_FOR_FN (cfun
,
5011 /* Expand calls to inline functions in the body of FN. */
5014 optimize_inline_calls (tree fn
)
5018 int last
= n_basic_blocks_for_fn (cfun
);
5019 bool inlined_p
= false;
5022 memset (&id
, 0, sizeof (id
));
5024 id
.src_node
= id
.dst_node
= cgraph_node::get (fn
);
5025 gcc_assert (id
.dst_node
->definition
);
5027 /* Or any functions that aren't finished yet. */
5028 if (current_function_decl
)
5029 id
.dst_fn
= current_function_decl
;
5031 id
.copy_decl
= copy_decl_maybe_to_var
;
5032 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5033 id
.transform_new_cfg
= false;
5034 id
.transform_return_to_modify
= true;
5035 id
.transform_parameter
= true;
5036 id
.transform_lang_insert_block
= NULL
;
5037 id
.statements_to_fold
= new hash_set
<gimple
*>;
5039 push_gimplify_context ();
5041 /* We make no attempts to keep dominance info up-to-date. */
5042 free_dominance_info (CDI_DOMINATORS
);
5043 free_dominance_info (CDI_POST_DOMINATORS
);
5045 /* Register specific gimple functions. */
5046 gimple_register_cfg_hooks ();
5048 /* Reach the trees by walking over the CFG, and note the
5049 enclosing basic-blocks in the call edges. */
5050 /* We walk the blocks going forward, because inlined function bodies
5051 will split id->current_basic_block, and the new blocks will
5052 follow it; we'll trudge through them, processing their CALL_EXPRs
5054 FOR_EACH_BB_FN (bb
, cfun
)
5055 inlined_p
|= gimple_expand_calls_inline (bb
, &id
);
5057 pop_gimplify_context (NULL
);
5061 struct cgraph_edge
*e
;
5063 id
.dst_node
->verify ();
5065 /* Double check that we inlined everything we are supposed to inline. */
5066 for (e
= id
.dst_node
->callees
; e
; e
= e
->next_callee
)
5067 gcc_assert (e
->inline_failed
);
5070 /* Fold queued statements. */
5071 fold_marked_statements (last
, id
.statements_to_fold
);
5072 delete id
.statements_to_fold
;
5074 gcc_assert (!id
.debug_stmts
.exists ());
5076 /* If we didn't inline into the function there is nothing to do. */
5080 /* Renumber the lexical scoping (non-code) blocks consecutively. */
5083 delete_unreachable_blocks_update_callgraph (&id
);
5085 id
.dst_node
->verify ();
5087 /* It would be nice to check SSA/CFG/statement consistency here, but it is
5088 not possible yet - the IPA passes might make various functions to not
5089 throw and they don't care to proactively update local EH info. This is
5090 done later in fixup_cfg pass that also execute the verification. */
5091 return (TODO_update_ssa
5093 | (gimple_in_ssa_p (cfun
) ? TODO_remove_unused_locals
: 0)
5094 | (gimple_in_ssa_p (cfun
) ? TODO_update_address_taken
: 0)
5095 | (profile_status_for_fn (cfun
) != PROFILE_ABSENT
5096 ? TODO_rebuild_frequencies
: 0));
5099 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
5102 copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
5104 enum tree_code code
= TREE_CODE (*tp
);
5105 enum tree_code_class cl
= TREE_CODE_CLASS (code
);
5107 /* We make copies of most nodes. */
5108 if (IS_EXPR_CODE_CLASS (cl
)
5109 || code
== TREE_LIST
5111 || code
== TYPE_DECL
5112 || code
== OMP_CLAUSE
)
5114 /* Because the chain gets clobbered when we make a copy, we save it
5116 tree chain
= NULL_TREE
, new_tree
;
5118 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
5119 chain
= TREE_CHAIN (*tp
);
5121 /* Copy the node. */
5122 new_tree
= copy_node (*tp
);
5126 /* Now, restore the chain, if appropriate. That will cause
5127 walk_tree to walk into the chain as well. */
5128 if (code
== PARM_DECL
5129 || code
== TREE_LIST
5130 || code
== OMP_CLAUSE
)
5131 TREE_CHAIN (*tp
) = chain
;
5133 /* For now, we don't update BLOCKs when we make copies. So, we
5134 have to nullify all BIND_EXPRs. */
5135 if (TREE_CODE (*tp
) == BIND_EXPR
)
5136 BIND_EXPR_BLOCK (*tp
) = NULL_TREE
;
5138 else if (code
== CONSTRUCTOR
)
5140 /* CONSTRUCTOR nodes need special handling because
5141 we need to duplicate the vector of elements. */
5144 new_tree
= copy_node (*tp
);
5145 CONSTRUCTOR_ELTS (new_tree
) = vec_safe_copy (CONSTRUCTOR_ELTS (*tp
));
5148 else if (code
== STATEMENT_LIST
)
5149 /* We used to just abort on STATEMENT_LIST, but we can run into them
5150 with statement-expressions (c++/40975). */
5151 copy_statement_list (tp
);
5152 else if (TREE_CODE_CLASS (code
) == tcc_type
)
5154 else if (TREE_CODE_CLASS (code
) == tcc_declaration
)
5156 else if (TREE_CODE_CLASS (code
) == tcc_constant
)
5161 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
5162 information indicating to what new SAVE_EXPR this one should be mapped,
5163 use that one. Otherwise, create a new node and enter it in ST. FN is
5164 the function into which the copy will be placed. */
5167 remap_save_expr (tree
*tp
, hash_map
<tree
, tree
> *st
, int *walk_subtrees
)
5172 /* See if we already encountered this SAVE_EXPR. */
5175 /* If we didn't already remap this SAVE_EXPR, do so now. */
5178 t
= copy_node (*tp
);
5180 /* Remember this SAVE_EXPR. */
5182 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
5187 /* We've already walked into this SAVE_EXPR; don't do it again. */
5192 /* Replace this SAVE_EXPR with the copy. */
5196 /* Called via walk_gimple_seq. If *GSIP points to a GIMPLE_LABEL for a local
5197 label, copies the declaration and enters it in the splay_tree in DATA (which
5198 is really a 'copy_body_data *'. */
5201 mark_local_labels_stmt (gimple_stmt_iterator
*gsip
,
5202 bool *handled_ops_p ATTRIBUTE_UNUSED
,
5203 struct walk_stmt_info
*wi
)
5205 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
5206 glabel
*stmt
= dyn_cast
<glabel
*> (gsi_stmt (*gsip
));
5210 tree decl
= gimple_label_label (stmt
);
5212 /* Copy the decl and remember the copy. */
5213 insert_decl_map (id
, decl
, id
->copy_decl (decl
, id
));
5219 static gimple_seq
duplicate_remap_omp_clause_seq (gimple_seq seq
,
5220 struct walk_stmt_info
*wi
);
5222 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
5223 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
5224 remaps all local declarations to appropriate replacements in gimple
5228 replace_locals_op (tree
*tp
, int *walk_subtrees
, void *data
)
5230 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
5231 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
5232 hash_map
<tree
, tree
> *st
= id
->decl_map
;
5236 /* For recursive invocations this is no longer the LHS itself. */
5237 bool is_lhs
= wi
->is_lhs
;
5240 if (TREE_CODE (expr
) == SSA_NAME
)
5242 *tp
= remap_ssa_name (*tp
, id
);
5245 SSA_NAME_DEF_STMT (*tp
) = gsi_stmt (wi
->gsi
);
5247 /* Only a local declaration (variable or label). */
5248 else if ((VAR_P (expr
) && !TREE_STATIC (expr
))
5249 || TREE_CODE (expr
) == LABEL_DECL
)
5251 /* Lookup the declaration. */
5254 /* If it's there, remap it. */
5259 else if (TREE_CODE (expr
) == STATEMENT_LIST
5260 || TREE_CODE (expr
) == BIND_EXPR
5261 || TREE_CODE (expr
) == SAVE_EXPR
)
5263 else if (TREE_CODE (expr
) == TARGET_EXPR
)
5265 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
5266 It's OK for this to happen if it was part of a subtree that
5267 isn't immediately expanded, such as operand 2 of another
5269 if (!TREE_OPERAND (expr
, 1))
5271 TREE_OPERAND (expr
, 1) = TREE_OPERAND (expr
, 3);
5272 TREE_OPERAND (expr
, 3) = NULL_TREE
;
5275 else if (TREE_CODE (expr
) == OMP_CLAUSE
)
5277 /* Before the omplower pass completes, some OMP clauses can contain
5278 sequences that are neither copied by gimple_seq_copy nor walked by
5279 walk_gimple_seq. To make copy_gimple_seq_and_replace_locals work even
5280 in those situations, we have to copy and process them explicitely. */
5282 if (OMP_CLAUSE_CODE (expr
) == OMP_CLAUSE_LASTPRIVATE
)
5284 gimple_seq seq
= OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (expr
);
5285 seq
= duplicate_remap_omp_clause_seq (seq
, wi
);
5286 OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (expr
) = seq
;
5288 else if (OMP_CLAUSE_CODE (expr
) == OMP_CLAUSE_LINEAR
)
5290 gimple_seq seq
= OMP_CLAUSE_LINEAR_GIMPLE_SEQ (expr
);
5291 seq
= duplicate_remap_omp_clause_seq (seq
, wi
);
5292 OMP_CLAUSE_LINEAR_GIMPLE_SEQ (expr
) = seq
;
5294 else if (OMP_CLAUSE_CODE (expr
) == OMP_CLAUSE_REDUCTION
)
5296 gimple_seq seq
= OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr
);
5297 seq
= duplicate_remap_omp_clause_seq (seq
, wi
);
5298 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr
) = seq
;
5299 seq
= OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr
);
5300 seq
= duplicate_remap_omp_clause_seq (seq
, wi
);
5301 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr
) = seq
;
5305 /* Keep iterating. */
5310 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
5311 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
5312 remaps all local declarations to appropriate replacements in gimple
5316 replace_locals_stmt (gimple_stmt_iterator
*gsip
,
5317 bool *handled_ops_p ATTRIBUTE_UNUSED
,
5318 struct walk_stmt_info
*wi
)
5320 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
5321 gimple
*gs
= gsi_stmt (*gsip
);
5323 if (gbind
*stmt
= dyn_cast
<gbind
*> (gs
))
5325 tree block
= gimple_bind_block (stmt
);
5329 remap_block (&block
, id
);
5330 gimple_bind_set_block (stmt
, block
);
5333 /* This will remap a lot of the same decls again, but this should be
5335 if (gimple_bind_vars (stmt
))
5337 tree old_var
, decls
= gimple_bind_vars (stmt
);
5339 for (old_var
= decls
; old_var
; old_var
= DECL_CHAIN (old_var
))
5340 if (!can_be_nonlocal (old_var
, id
)
5341 && ! variably_modified_type_p (TREE_TYPE (old_var
), id
->src_fn
))
5342 remap_decl (old_var
, id
);
5344 gcc_checking_assert (!id
->prevent_decl_creation_for_types
);
5345 id
->prevent_decl_creation_for_types
= true;
5346 gimple_bind_set_vars (stmt
, remap_decls (decls
, NULL
, id
));
5347 id
->prevent_decl_creation_for_types
= false;
5351 /* Keep iterating. */
5355 /* Create a copy of SEQ and remap all decls in it. */
5358 duplicate_remap_omp_clause_seq (gimple_seq seq
, struct walk_stmt_info
*wi
)
5363 /* If there are any labels in OMP sequences, they can be only referred to in
5364 the sequence itself and therefore we can do both here. */
5365 walk_gimple_seq (seq
, mark_local_labels_stmt
, NULL
, wi
);
5366 gimple_seq copy
= gimple_seq_copy (seq
);
5367 walk_gimple_seq (copy
, replace_locals_stmt
, replace_locals_op
, wi
);
5371 /* Copies everything in SEQ and replaces variables and labels local to
5372 current_function_decl. */
5375 copy_gimple_seq_and_replace_locals (gimple_seq seq
)
5378 struct walk_stmt_info wi
;
5381 /* There's nothing to do for NULL_TREE. */
5386 memset (&id
, 0, sizeof (id
));
5387 id
.src_fn
= current_function_decl
;
5388 id
.dst_fn
= current_function_decl
;
5390 id
.decl_map
= new hash_map
<tree
, tree
>;
5391 id
.debug_map
= NULL
;
5393 id
.copy_decl
= copy_decl_no_change
;
5394 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5395 id
.transform_new_cfg
= false;
5396 id
.transform_return_to_modify
= false;
5397 id
.transform_parameter
= false;
5398 id
.transform_lang_insert_block
= NULL
;
5400 /* Walk the tree once to find local labels. */
5401 memset (&wi
, 0, sizeof (wi
));
5402 hash_set
<tree
> visited
;
5405 walk_gimple_seq (seq
, mark_local_labels_stmt
, NULL
, &wi
);
5407 copy
= gimple_seq_copy (seq
);
5409 /* Walk the copy, remapping decls. */
5410 memset (&wi
, 0, sizeof (wi
));
5412 walk_gimple_seq (copy
, replace_locals_stmt
, replace_locals_op
, &wi
);
5417 delete id
.debug_map
;
5418 if (id
.dependence_map
)
5420 delete id
.dependence_map
;
5421 id
.dependence_map
= NULL
;
5428 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
5431 debug_find_tree_1 (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
, void *data
)
5440 debug_find_tree (tree top
, tree search
)
5442 return walk_tree_without_duplicates (&top
, debug_find_tree_1
, search
) != 0;
5446 /* Declare the variables created by the inliner. Add all the variables in
5447 VARS to BIND_EXPR. */
5450 declare_inline_vars (tree block
, tree vars
)
5453 for (t
= vars
; t
; t
= DECL_CHAIN (t
))
5455 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
5456 gcc_assert (!TREE_STATIC (t
) && !TREE_ASM_WRITTEN (t
));
5457 add_local_decl (cfun
, t
);
5461 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), vars
);
5464 /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN,
5465 but now it will be in the TO_FN. PARM_TO_VAR means enable PARM_DECL to
5466 VAR_DECL translation. */
5469 copy_decl_for_dup_finish (copy_body_data
*id
, tree decl
, tree copy
)
5471 /* Don't generate debug information for the copy if we wouldn't have
5472 generated it for the copy either. */
5473 DECL_ARTIFICIAL (copy
) = DECL_ARTIFICIAL (decl
);
5474 DECL_IGNORED_P (copy
) = DECL_IGNORED_P (decl
);
5476 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
5477 declaration inspired this copy. */
5478 DECL_ABSTRACT_ORIGIN (copy
) = DECL_ORIGIN (decl
);
5480 /* The new variable/label has no RTL, yet. */
5481 if (CODE_CONTAINS_STRUCT (TREE_CODE (copy
), TS_DECL_WRTL
)
5482 && !TREE_STATIC (copy
) && !DECL_EXTERNAL (copy
))
5483 SET_DECL_RTL (copy
, 0);
5485 /* These args would always appear unused, if not for this. */
5486 TREE_USED (copy
) = 1;
5488 /* Set the context for the new declaration. */
5489 if (!DECL_CONTEXT (decl
))
5490 /* Globals stay global. */
5492 else if (DECL_CONTEXT (decl
) != id
->src_fn
)
5493 /* Things that weren't in the scope of the function we're inlining
5494 from aren't in the scope we're inlining to, either. */
5496 else if (TREE_STATIC (decl
))
5497 /* Function-scoped static variables should stay in the original
5502 /* Ordinary automatic local variables are now in the scope of the
5504 DECL_CONTEXT (copy
) = id
->dst_fn
;
5505 if (VAR_P (copy
) && id
->dst_simt_vars
&& !is_gimple_reg (copy
))
5507 if (!lookup_attribute ("omp simt private", DECL_ATTRIBUTES (copy
)))
5508 DECL_ATTRIBUTES (copy
)
5509 = tree_cons (get_identifier ("omp simt private"), NULL
,
5510 DECL_ATTRIBUTES (copy
));
5511 id
->dst_simt_vars
->safe_push (copy
);
5519 copy_decl_to_var (tree decl
, copy_body_data
*id
)
5523 gcc_assert (TREE_CODE (decl
) == PARM_DECL
5524 || TREE_CODE (decl
) == RESULT_DECL
);
5526 type
= TREE_TYPE (decl
);
5528 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
5529 VAR_DECL
, DECL_NAME (decl
), type
);
5530 if (DECL_PT_UID_SET_P (decl
))
5531 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
5532 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
5533 TREE_READONLY (copy
) = TREE_READONLY (decl
);
5534 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
5535 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
5537 return copy_decl_for_dup_finish (id
, decl
, copy
);
5540 /* Like copy_decl_to_var, but create a return slot object instead of a
5541 pointer variable for return by invisible reference. */
5544 copy_result_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
);
5552 if (DECL_BY_REFERENCE (decl
))
5553 type
= TREE_TYPE (type
);
5555 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
5556 VAR_DECL
, DECL_NAME (decl
), type
);
5557 if (DECL_PT_UID_SET_P (decl
))
5558 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
5559 TREE_READONLY (copy
) = TREE_READONLY (decl
);
5560 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
5561 if (!DECL_BY_REFERENCE (decl
))
5563 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
5564 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
5567 return copy_decl_for_dup_finish (id
, decl
, copy
);
5571 copy_decl_no_change (tree decl
, copy_body_data
*id
)
5575 copy
= copy_node (decl
);
5577 /* The COPY is not abstract; it will be generated in DST_FN. */
5578 DECL_ABSTRACT_P (copy
) = false;
5579 lang_hooks
.dup_lang_specific_decl (copy
);
5581 /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
5582 been taken; it's for internal bookkeeping in expand_goto_internal. */
5583 if (TREE_CODE (copy
) == LABEL_DECL
)
5585 TREE_ADDRESSABLE (copy
) = 0;
5586 LABEL_DECL_UID (copy
) = -1;
5589 return copy_decl_for_dup_finish (id
, decl
, copy
);
5593 copy_decl_maybe_to_var (tree decl
, copy_body_data
*id
)
5595 if (TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
)
5596 return copy_decl_to_var (decl
, id
);
5598 return copy_decl_no_change (decl
, id
);
5601 /* Return a copy of the function's argument tree. */
5603 copy_arguments_for_versioning (tree orig_parm
, copy_body_data
* id
,
5604 bitmap args_to_skip
, tree
*vars
)
5607 tree new_parm
= NULL
;
5612 for (arg
= orig_parm
; arg
; arg
= DECL_CHAIN (arg
), i
++)
5613 if (!args_to_skip
|| !bitmap_bit_p (args_to_skip
, i
))
5615 tree new_tree
= remap_decl (arg
, id
);
5616 if (TREE_CODE (new_tree
) != PARM_DECL
)
5617 new_tree
= id
->copy_decl (arg
, id
);
5618 lang_hooks
.dup_lang_specific_decl (new_tree
);
5620 parg
= &DECL_CHAIN (new_tree
);
5622 else if (!id
->decl_map
->get (arg
))
5624 /* Make an equivalent VAR_DECL. If the argument was used
5625 as temporary variable later in function, the uses will be
5626 replaced by local variable. */
5627 tree var
= copy_decl_to_var (arg
, id
);
5628 insert_decl_map (id
, arg
, var
);
5629 /* Declare this new variable. */
5630 DECL_CHAIN (var
) = *vars
;
5636 /* Return a copy of the function's static chain. */
5638 copy_static_chain (tree static_chain
, copy_body_data
* id
)
5640 tree
*chain_copy
, *pvar
;
5642 chain_copy
= &static_chain
;
5643 for (pvar
= chain_copy
; *pvar
; pvar
= &DECL_CHAIN (*pvar
))
5645 tree new_tree
= remap_decl (*pvar
, id
);
5646 lang_hooks
.dup_lang_specific_decl (new_tree
);
5647 DECL_CHAIN (new_tree
) = DECL_CHAIN (*pvar
);
5650 return static_chain
;
5653 /* Return true if the function is allowed to be versioned.
5654 This is a guard for the versioning functionality. */
5657 tree_versionable_function_p (tree fndecl
)
5659 return (!lookup_attribute ("noclone", DECL_ATTRIBUTES (fndecl
))
5660 && copy_forbidden (DECL_STRUCT_FUNCTION (fndecl
)) == NULL
);
5663 /* Delete all unreachable basic blocks and update callgraph.
5664 Doing so is somewhat nontrivial because we need to update all clones and
5665 remove inline function that become unreachable. */
5668 delete_unreachable_blocks_update_callgraph (copy_body_data
*id
)
5670 bool changed
= false;
5671 basic_block b
, next_bb
;
5673 find_unreachable_blocks ();
5675 /* Delete all unreachable basic blocks. */
5677 for (b
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
; b
5678 != EXIT_BLOCK_PTR_FOR_FN (cfun
); b
= next_bb
)
5680 next_bb
= b
->next_bb
;
5682 if (!(b
->flags
& BB_REACHABLE
))
5684 gimple_stmt_iterator bsi
;
5686 for (bsi
= gsi_start_bb (b
); !gsi_end_p (bsi
); gsi_next (&bsi
))
5688 struct cgraph_edge
*e
;
5689 struct cgraph_node
*node
;
5691 id
->dst_node
->remove_stmt_references (gsi_stmt (bsi
));
5693 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
5694 &&(e
= id
->dst_node
->get_edge (gsi_stmt (bsi
))) != NULL
)
5696 if (!e
->inline_failed
)
5697 e
->callee
->remove_symbol_and_inline_clones (id
->dst_node
);
5701 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
5702 && id
->dst_node
->clones
)
5703 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
5705 node
->remove_stmt_references (gsi_stmt (bsi
));
5706 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
5707 && (e
= node
->get_edge (gsi_stmt (bsi
))) != NULL
)
5709 if (!e
->inline_failed
)
5710 e
->callee
->remove_symbol_and_inline_clones (id
->dst_node
);
5716 node
= node
->clones
;
5717 else if (node
->next_sibling_clone
)
5718 node
= node
->next_sibling_clone
;
5721 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5722 node
= node
->clone_of
;
5723 if (node
!= id
->dst_node
)
5724 node
= node
->next_sibling_clone
;
5728 delete_basic_block (b
);
5736 /* Update clone info after duplication. */
5739 update_clone_info (copy_body_data
* id
)
5741 struct cgraph_node
*node
;
5742 if (!id
->dst_node
->clones
)
5744 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
5746 /* First update replace maps to match the new body. */
5747 if (node
->clone
.tree_map
)
5750 for (i
= 0; i
< vec_safe_length (node
->clone
.tree_map
); i
++)
5752 struct ipa_replace_map
*replace_info
;
5753 replace_info
= (*node
->clone
.tree_map
)[i
];
5754 walk_tree (&replace_info
->old_tree
, copy_tree_body_r
, id
, NULL
);
5755 walk_tree (&replace_info
->new_tree
, copy_tree_body_r
, id
, NULL
);
5759 node
= node
->clones
;
5760 else if (node
->next_sibling_clone
)
5761 node
= node
->next_sibling_clone
;
5764 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5765 node
= node
->clone_of
;
5766 if (node
!= id
->dst_node
)
5767 node
= node
->next_sibling_clone
;
5772 /* Create a copy of a function's tree.
5773 OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
5774 of the original function and the new copied function
5775 respectively. In case we want to replace a DECL
5776 tree with another tree while duplicating the function's
5777 body, TREE_MAP represents the mapping between these
5778 trees. If UPDATE_CLONES is set, the call_stmt fields
5779 of edges of clones of the function will be updated.
5781 If non-NULL ARGS_TO_SKIP determine function parameters to remove
5783 If SKIP_RETURN is true, the new version will return void.
5784 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
5785 If non_NULL NEW_ENTRY determine new entry BB of the clone.
5788 tree_function_versioning (tree old_decl
, tree new_decl
,
5789 vec
<ipa_replace_map
*, va_gc
> *tree_map
,
5790 bool update_clones
, bitmap args_to_skip
,
5791 bool skip_return
, bitmap blocks_to_copy
,
5792 basic_block new_entry
)
5794 struct cgraph_node
*old_version_node
;
5795 struct cgraph_node
*new_version_node
;
5799 struct ipa_replace_map
*replace_info
;
5800 basic_block old_entry_block
, bb
;
5801 auto_vec
<gimple
*, 10> init_stmts
;
5802 tree vars
= NULL_TREE
;
5803 bitmap debug_args_to_skip
= args_to_skip
;
5805 gcc_assert (TREE_CODE (old_decl
) == FUNCTION_DECL
5806 && TREE_CODE (new_decl
) == FUNCTION_DECL
);
5807 DECL_POSSIBLY_INLINED (old_decl
) = 1;
5809 old_version_node
= cgraph_node::get (old_decl
);
5810 gcc_checking_assert (old_version_node
);
5811 new_version_node
= cgraph_node::get (new_decl
);
5812 gcc_checking_assert (new_version_node
);
5814 /* Copy over debug args. */
5815 if (DECL_HAS_DEBUG_ARGS_P (old_decl
))
5817 vec
<tree
, va_gc
> **new_debug_args
, **old_debug_args
;
5818 gcc_checking_assert (decl_debug_args_lookup (new_decl
) == NULL
);
5819 DECL_HAS_DEBUG_ARGS_P (new_decl
) = 0;
5820 old_debug_args
= decl_debug_args_lookup (old_decl
);
5823 new_debug_args
= decl_debug_args_insert (new_decl
);
5824 *new_debug_args
= vec_safe_copy (*old_debug_args
);
5828 /* Output the inlining info for this abstract function, since it has been
5829 inlined. If we don't do this now, we can lose the information about the
5830 variables in the function when the blocks get blown away as soon as we
5831 remove the cgraph node. */
5832 (*debug_hooks
->outlining_inline_function
) (old_decl
);
5834 DECL_ARTIFICIAL (new_decl
) = 1;
5835 DECL_ABSTRACT_ORIGIN (new_decl
) = DECL_ORIGIN (old_decl
);
5836 if (DECL_ORIGIN (old_decl
) == old_decl
)
5837 old_version_node
->used_as_abstract_origin
= true;
5838 DECL_FUNCTION_PERSONALITY (new_decl
) = DECL_FUNCTION_PERSONALITY (old_decl
);
5840 /* Prepare the data structures for the tree copy. */
5841 memset (&id
, 0, sizeof (id
));
5843 /* Generate a new name for the new version. */
5844 id
.statements_to_fold
= new hash_set
<gimple
*>;
5846 id
.decl_map
= new hash_map
<tree
, tree
>;
5847 id
.debug_map
= NULL
;
5848 id
.src_fn
= old_decl
;
5849 id
.dst_fn
= new_decl
;
5850 id
.src_node
= old_version_node
;
5851 id
.dst_node
= new_version_node
;
5852 id
.src_cfun
= DECL_STRUCT_FUNCTION (old_decl
);
5853 id
.blocks_to_copy
= blocks_to_copy
;
5855 id
.copy_decl
= copy_decl_no_change
;
5856 id
.transform_call_graph_edges
5857 = update_clones
? CB_CGE_MOVE_CLONES
: CB_CGE_MOVE
;
5858 id
.transform_new_cfg
= true;
5859 id
.transform_return_to_modify
= false;
5860 id
.transform_parameter
= false;
5861 id
.transform_lang_insert_block
= NULL
;
5863 old_entry_block
= ENTRY_BLOCK_PTR_FOR_FN
5864 (DECL_STRUCT_FUNCTION (old_decl
));
5865 DECL_RESULT (new_decl
) = DECL_RESULT (old_decl
);
5866 DECL_ARGUMENTS (new_decl
) = DECL_ARGUMENTS (old_decl
);
5867 initialize_cfun (new_decl
, old_decl
,
5868 old_entry_block
->count
);
5869 if (DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
)
5870 DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
->ipa_pta
5871 = id
.src_cfun
->gimple_df
->ipa_pta
;
5873 /* Copy the function's static chain. */
5874 p
= DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
;
5876 DECL_STRUCT_FUNCTION (new_decl
)->static_chain_decl
5877 = copy_static_chain (p
, &id
);
5879 /* If there's a tree_map, prepare for substitution. */
5881 for (i
= 0; i
< tree_map
->length (); i
++)
5884 replace_info
= (*tree_map
)[i
];
5885 if (replace_info
->replace_p
)
5888 if (!replace_info
->old_tree
)
5890 int p
= replace_info
->parm_num
;
5892 tree req_type
, new_type
;
5894 for (parm
= DECL_ARGUMENTS (old_decl
); p
;
5895 parm
= DECL_CHAIN (parm
))
5897 replace_info
->old_tree
= parm
;
5898 parm_num
= replace_info
->parm_num
;
5899 req_type
= TREE_TYPE (parm
);
5900 new_type
= TREE_TYPE (replace_info
->new_tree
);
5901 if (!useless_type_conversion_p (req_type
, new_type
))
5903 if (fold_convertible_p (req_type
, replace_info
->new_tree
))
5904 replace_info
->new_tree
5905 = fold_build1 (NOP_EXPR
, req_type
,
5906 replace_info
->new_tree
);
5907 else if (TYPE_SIZE (req_type
) == TYPE_SIZE (new_type
))
5908 replace_info
->new_tree
5909 = fold_build1 (VIEW_CONVERT_EXPR
, req_type
,
5910 replace_info
->new_tree
);
5915 fprintf (dump_file
, " const ");
5916 print_generic_expr (dump_file
,
5917 replace_info
->new_tree
);
5919 " can't be converted to param ");
5920 print_generic_expr (dump_file
, parm
);
5921 fprintf (dump_file
, "\n");
5923 replace_info
->old_tree
= NULL
;
5928 gcc_assert (TREE_CODE (replace_info
->old_tree
) == PARM_DECL
);
5929 if (replace_info
->old_tree
)
5931 init
= setup_one_parameter (&id
, replace_info
->old_tree
,
5932 replace_info
->new_tree
, id
.src_fn
,
5936 init_stmts
.safe_push (init
);
5937 if (MAY_HAVE_DEBUG_STMTS
&& args_to_skip
)
5943 for (parm
= DECL_ARGUMENTS (old_decl
), p
= 0; parm
;
5944 parm
= DECL_CHAIN (parm
), p
++)
5945 if (parm
== replace_info
->old_tree
)
5953 if (debug_args_to_skip
== args_to_skip
)
5955 debug_args_to_skip
= BITMAP_ALLOC (NULL
);
5956 bitmap_copy (debug_args_to_skip
, args_to_skip
);
5958 bitmap_clear_bit (debug_args_to_skip
, parm_num
);
5964 /* Copy the function's arguments. */
5965 if (DECL_ARGUMENTS (old_decl
) != NULL_TREE
)
5966 DECL_ARGUMENTS (new_decl
)
5967 = copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl
), &id
,
5968 args_to_skip
, &vars
);
5970 DECL_INITIAL (new_decl
) = remap_blocks (DECL_INITIAL (id
.src_fn
), &id
);
5971 BLOCK_SUPERCONTEXT (DECL_INITIAL (new_decl
)) = new_decl
;
5973 declare_inline_vars (DECL_INITIAL (new_decl
), vars
);
5975 if (!vec_safe_is_empty (DECL_STRUCT_FUNCTION (old_decl
)->local_decls
))
5976 /* Add local vars. */
5977 add_local_variables (DECL_STRUCT_FUNCTION (old_decl
), cfun
, &id
);
5979 if (DECL_RESULT (old_decl
) == NULL_TREE
)
5981 else if (skip_return
&& !VOID_TYPE_P (TREE_TYPE (DECL_RESULT (old_decl
))))
5983 DECL_RESULT (new_decl
)
5984 = build_decl (DECL_SOURCE_LOCATION (DECL_RESULT (old_decl
)),
5985 RESULT_DECL
, NULL_TREE
, void_type_node
);
5986 DECL_CONTEXT (DECL_RESULT (new_decl
)) = new_decl
;
5987 cfun
->returns_struct
= 0;
5988 cfun
->returns_pcc_struct
= 0;
5993 DECL_RESULT (new_decl
) = remap_decl (DECL_RESULT (old_decl
), &id
);
5994 lang_hooks
.dup_lang_specific_decl (DECL_RESULT (new_decl
));
5995 if (gimple_in_ssa_p (id
.src_cfun
)
5996 && DECL_BY_REFERENCE (DECL_RESULT (old_decl
))
5997 && (old_name
= ssa_default_def (id
.src_cfun
, DECL_RESULT (old_decl
))))
5999 tree new_name
= make_ssa_name (DECL_RESULT (new_decl
));
6000 insert_decl_map (&id
, old_name
, new_name
);
6001 SSA_NAME_DEF_STMT (new_name
) = gimple_build_nop ();
6002 set_ssa_default_def (cfun
, DECL_RESULT (new_decl
), new_name
);
6006 /* Set up the destination functions loop tree. */
6007 if (loops_for_fn (DECL_STRUCT_FUNCTION (old_decl
)) != NULL
)
6009 cfun
->curr_properties
&= ~PROP_loops
;
6010 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
6011 cfun
->curr_properties
|= PROP_loops
;
6014 /* Copy the Function's body. */
6015 copy_body (&id
, old_entry_block
->count
, REG_BR_PROB_BASE
,
6016 ENTRY_BLOCK_PTR_FOR_FN (cfun
), EXIT_BLOCK_PTR_FOR_FN (cfun
),
6019 /* Renumber the lexical scoping (non-code) blocks consecutively. */
6020 number_blocks (new_decl
);
6022 /* We want to create the BB unconditionally, so that the addition of
6023 debug stmts doesn't affect BB count, which may in the end cause
6024 codegen differences. */
6025 bb
= split_edge (single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
6026 while (init_stmts
.length ())
6027 insert_init_stmt (&id
, bb
, init_stmts
.pop ());
6028 update_clone_info (&id
);
6030 /* Remap the nonlocal_goto_save_area, if any. */
6031 if (cfun
->nonlocal_goto_save_area
)
6033 struct walk_stmt_info wi
;
6035 memset (&wi
, 0, sizeof (wi
));
6037 walk_tree (&cfun
->nonlocal_goto_save_area
, remap_gimple_op_r
, &wi
, NULL
);
6043 delete id
.debug_map
;
6044 free_dominance_info (CDI_DOMINATORS
);
6045 free_dominance_info (CDI_POST_DOMINATORS
);
6047 fold_marked_statements (0, id
.statements_to_fold
);
6048 delete id
.statements_to_fold
;
6049 delete_unreachable_blocks_update_callgraph (&id
);
6050 if (id
.dst_node
->definition
)
6051 cgraph_edge::rebuild_references ();
6052 if (loops_state_satisfies_p (LOOPS_NEED_FIXUP
))
6054 calculate_dominance_info (CDI_DOMINATORS
);
6055 fix_loop_structure (NULL
);
6057 update_ssa (TODO_update_ssa
);
6059 /* After partial cloning we need to rescale frequencies, so they are
6060 within proper range in the cloned function. */
6063 struct cgraph_edge
*e
;
6064 rebuild_frequencies ();
6066 new_version_node
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
6067 for (e
= new_version_node
->callees
; e
; e
= e
->next_callee
)
6069 basic_block bb
= gimple_bb (e
->call_stmt
);
6070 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
6072 e
->count
= bb
->count
;
6074 for (e
= new_version_node
->indirect_calls
; e
; e
= e
->next_callee
)
6076 basic_block bb
= gimple_bb (e
->call_stmt
);
6077 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
6079 e
->count
= bb
->count
;
6083 if (debug_args_to_skip
&& MAY_HAVE_DEBUG_STMTS
)
6086 vec
<tree
, va_gc
> **debug_args
= NULL
;
6087 unsigned int len
= 0;
6088 for (parm
= DECL_ARGUMENTS (old_decl
), i
= 0;
6089 parm
; parm
= DECL_CHAIN (parm
), i
++)
6090 if (bitmap_bit_p (debug_args_to_skip
, i
) && is_gimple_reg (parm
))
6094 if (debug_args
== NULL
)
6096 debug_args
= decl_debug_args_insert (new_decl
);
6097 len
= vec_safe_length (*debug_args
);
6099 ddecl
= make_node (DEBUG_EXPR_DECL
);
6100 DECL_ARTIFICIAL (ddecl
) = 1;
6101 TREE_TYPE (ddecl
) = TREE_TYPE (parm
);
6102 SET_DECL_MODE (ddecl
, DECL_MODE (parm
));
6103 vec_safe_push (*debug_args
, DECL_ORIGIN (parm
));
6104 vec_safe_push (*debug_args
, ddecl
);
6106 if (debug_args
!= NULL
)
6108 /* On the callee side, add
6111 stmts to the first bb where var is a VAR_DECL created for the
6112 optimized away parameter in DECL_INITIAL block. This hints
6113 in the debug info that var (whole DECL_ORIGIN is the parm
6114 PARM_DECL) is optimized away, but could be looked up at the
6115 call site as value of D#X there. */
6116 tree var
= vars
, vexpr
;
6117 gimple_stmt_iterator cgsi
6118 = gsi_after_labels (single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
6121 i
= vec_safe_length (*debug_args
);
6125 while (var
!= NULL_TREE
6126 && DECL_ABSTRACT_ORIGIN (var
) != (**debug_args
)[i
])
6127 var
= TREE_CHAIN (var
);
6128 if (var
== NULL_TREE
)
6130 vexpr
= make_node (DEBUG_EXPR_DECL
);
6131 parm
= (**debug_args
)[i
];
6132 DECL_ARTIFICIAL (vexpr
) = 1;
6133 TREE_TYPE (vexpr
) = TREE_TYPE (parm
);
6134 SET_DECL_MODE (vexpr
, DECL_MODE (parm
));
6135 def_temp
= gimple_build_debug_bind (var
, vexpr
, NULL
);
6136 gsi_insert_before (&cgsi
, def_temp
, GSI_NEW_STMT
);
6137 def_temp
= gimple_build_debug_source_bind (vexpr
, parm
, NULL
);
6138 gsi_insert_before (&cgsi
, def_temp
, GSI_NEW_STMT
);
6144 if (debug_args_to_skip
&& debug_args_to_skip
!= args_to_skip
)
6145 BITMAP_FREE (debug_args_to_skip
);
6146 free_dominance_info (CDI_DOMINATORS
);
6147 free_dominance_info (CDI_POST_DOMINATORS
);
6149 gcc_assert (!id
.debug_stmts
.exists ());
6154 /* EXP is CALL_EXPR present in a GENERIC expression tree. Try to integrate
6155 the callee and return the inlined body on success. */
6158 maybe_inline_call_in_expr (tree exp
)
6160 tree fn
= get_callee_fndecl (exp
);
6162 /* We can only try to inline "const" functions. */
6163 if (fn
&& TREE_READONLY (fn
) && DECL_SAVED_TREE (fn
))
6165 call_expr_arg_iterator iter
;
6168 hash_map
<tree
, tree
> decl_map
;
6170 /* Remap the parameters. */
6171 for (param
= DECL_ARGUMENTS (fn
), arg
= first_call_expr_arg (exp
, &iter
);
6173 param
= DECL_CHAIN (param
), arg
= next_call_expr_arg (&iter
))
6174 decl_map
.put (param
, arg
);
6176 memset (&id
, 0, sizeof (id
));
6178 id
.dst_fn
= current_function_decl
;
6179 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
6180 id
.decl_map
= &decl_map
;
6182 id
.copy_decl
= copy_decl_no_change
;
6183 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
6184 id
.transform_new_cfg
= false;
6185 id
.transform_return_to_modify
= true;
6186 id
.transform_parameter
= true;
6187 id
.transform_lang_insert_block
= NULL
;
6189 /* Make sure not to unshare trees behind the front-end's back
6190 since front-end specific mechanisms may rely on sharing. */
6191 id
.regimplify
= false;
6192 id
.do_not_unshare
= true;
6194 /* We're not inside any EH region. */
6197 t
= copy_tree_body (&id
);
6199 /* We can only return something suitable for use in a GENERIC
6201 if (TREE_CODE (t
) == MODIFY_EXPR
)
6202 return TREE_OPERAND (t
, 1);
6208 /* Duplicate a type, fields and all. */
6211 build_duplicate_type (tree type
)
6213 struct copy_body_data id
;
6215 memset (&id
, 0, sizeof (id
));
6216 id
.src_fn
= current_function_decl
;
6217 id
.dst_fn
= current_function_decl
;
6219 id
.decl_map
= new hash_map
<tree
, tree
>;
6220 id
.debug_map
= NULL
;
6221 id
.copy_decl
= copy_decl_no_change
;
6223 type
= remap_type_1 (type
, &id
);
6227 delete id
.debug_map
;
6229 TYPE_CANONICAL (type
) = type
;
6234 /* Unshare the entire DECL_SAVED_TREE of FN and return the remapped
6235 parameters and RESULT_DECL in PARMS and RESULT. Used by C++ constexpr
6239 copy_fn (tree fn
, tree
& parms
, tree
& result
)
6243 hash_map
<tree
, tree
> decl_map
;
6248 memset (&id
, 0, sizeof (id
));
6250 id
.dst_fn
= current_function_decl
;
6251 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
6252 id
.decl_map
= &decl_map
;
6254 id
.copy_decl
= copy_decl_no_change
;
6255 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
6256 id
.transform_new_cfg
= false;
6257 id
.transform_return_to_modify
= false;
6258 id
.transform_parameter
= true;
6259 id
.transform_lang_insert_block
= NULL
;
6261 /* Make sure not to unshare trees behind the front-end's back
6262 since front-end specific mechanisms may rely on sharing. */
6263 id
.regimplify
= false;
6264 id
.do_not_unshare
= true;
6266 /* We're not inside any EH region. */
6269 /* Remap the parameters and result and return them to the caller. */
6270 for (param
= DECL_ARGUMENTS (fn
);
6272 param
= DECL_CHAIN (param
))
6274 *p
= remap_decl (param
, &id
);
6275 p
= &DECL_CHAIN (*p
);
6278 if (DECL_RESULT (fn
))
6279 result
= remap_decl (DECL_RESULT (fn
), &id
);
6283 return copy_tree_body (&id
);