2 Copyright (C) 2001-2014 Free Software Foundation, Inc.
3 Contributed by Alexandre Oliva <aoliva@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
25 #include "diagnostic-core.h"
27 #include "stor-layout.h"
29 #include "tree-inline.h"
33 #include "insn-config.h"
35 #include "langhooks.h"
40 #include "hard-reg-set.h"
42 #include "dominance.h"
45 #include "basic-block.h"
46 #include "tree-iterator.h"
48 #include "tree-ssa-alias.h"
49 #include "internal-fn.h"
50 #include "gimple-fold.h"
52 #include "gimple-expr.h"
56 #include "gimple-iterator.h"
57 #include "gimplify-me.h"
58 #include "gimple-walk.h"
59 #include "gimple-ssa.h"
61 #include "tree-phinodes.h"
62 #include "ssa-iterators.h"
63 #include "stringpool.h"
64 #include "tree-ssanames.h"
65 #include "tree-into-ssa.h"
69 #include "tree-pretty-print.h"
73 #include "plugin-api.h"
76 #include "alloc-pool.h"
78 #include "value-prof.h"
79 #include "tree-pass.h"
83 #include "tree-chkp.h"
85 #include "rtl.h" /* FIXME: For asm_str_count. */
87 /* I'm not real happy about this, but we need to handle gimple and
90 /* Inlining, Cloning, Versioning, Parallelization
92 Inlining: a function body is duplicated, but the PARM_DECLs are
93 remapped into VAR_DECLs, and non-void RETURN_EXPRs become
94 MODIFY_EXPRs that store to a dedicated returned-value variable.
95 The duplicated eh_region info of the copy will later be appended
96 to the info for the caller; the eh_region info in copied throwing
97 statements and RESX statements are adjusted accordingly.
99 Cloning: (only in C++) We have one body for a con/de/structor, and
100 multiple function decls, each with a unique parameter list.
101 Duplicate the body, using the given splay tree; some parameters
102 will become constants (like 0 or 1).
104 Versioning: a function body is duplicated and the result is a new
105 function rather than into blocks of an existing function as with
106 inlining. Some parameters will become constants.
108 Parallelization: a region of a function is duplicated resulting in
109 a new function. Variables may be replaced with complex expressions
110 to enable shared variable semantics.
112 All of these will simultaneously lookup any callgraph edges. If
113 we're going to inline the duplicated function body, and the given
114 function has some cloned callgraph nodes (one for each place this
115 function will be inlined) those callgraph edges will be duplicated.
116 If we're cloning the body, those callgraph edges will be
117 updated to point into the new body. (Note that the original
118 callgraph node and edge list will not be altered.)
120 See the CALL_EXPR handling case in copy_tree_body_r (). */
124 o In order to make inlining-on-trees work, we pessimized
125 function-local static constants. In particular, they are now
126 always output, even when not addressed. Fix this by treating
127 function-local static constants just like global static
128 constants; the back-end already knows not to output them if they
131 o Provide heuristics to clamp inlining of recursive template
135 /* Weights that estimate_num_insns uses to estimate the size of the
138 eni_weights eni_size_weights
;
140 /* Weights that estimate_num_insns uses to estimate the time necessary
141 to execute the produced code. */
143 eni_weights eni_time_weights
;
147 static tree
declare_return_variable (copy_body_data
*, tree
, tree
, tree
,
149 static void remap_block (tree
*, copy_body_data
*);
150 static void copy_bind_expr (tree
*, int *, copy_body_data
*);
151 static void declare_inline_vars (tree
, tree
);
152 static void remap_save_expr (tree
*, hash_map
<tree
, tree
> *, int *);
153 static void prepend_lexical_block (tree current_block
, tree new_block
);
154 static tree
copy_decl_to_var (tree
, copy_body_data
*);
155 static tree
copy_result_decl_to_var (tree
, copy_body_data
*);
156 static tree
copy_decl_maybe_to_var (tree
, copy_body_data
*);
157 static gimple_seq
remap_gimple_stmt (gimple
, copy_body_data
*);
158 static bool delete_unreachable_blocks_update_callgraph (copy_body_data
*id
);
159 static void insert_init_stmt (copy_body_data
*, basic_block
, gimple
);
161 /* Insert a tree->tree mapping for ID. Despite the name suggests
162 that the trees should be variables, it is used for more than that. */
165 insert_decl_map (copy_body_data
*id
, tree key
, tree value
)
167 id
->decl_map
->put (key
, value
);
169 /* Always insert an identity map as well. If we see this same new
170 node again, we won't want to duplicate it a second time. */
172 id
->decl_map
->put (value
, value
);
175 /* Insert a tree->tree mapping for ID. This is only used for
179 insert_debug_decl_map (copy_body_data
*id
, tree key
, tree value
)
181 if (!gimple_in_ssa_p (id
->src_cfun
))
184 if (!MAY_HAVE_DEBUG_STMTS
)
187 if (!target_for_debug_bind (key
))
190 gcc_assert (TREE_CODE (key
) == PARM_DECL
);
191 gcc_assert (TREE_CODE (value
) == VAR_DECL
);
194 id
->debug_map
= new hash_map
<tree
, tree
>;
196 id
->debug_map
->put (key
, value
);
199 /* If nonzero, we're remapping the contents of inlined debug
200 statements. If negative, an error has occurred, such as a
201 reference to a variable that isn't available in the inlined
203 static int processing_debug_stmt
= 0;
205 /* Construct new SSA name for old NAME. ID is the inline context. */
208 remap_ssa_name (tree name
, copy_body_data
*id
)
213 gcc_assert (TREE_CODE (name
) == SSA_NAME
);
215 n
= id
->decl_map
->get (name
);
217 return unshare_expr (*n
);
219 if (processing_debug_stmt
)
221 if (SSA_NAME_IS_DEFAULT_DEF (name
)
222 && TREE_CODE (SSA_NAME_VAR (name
)) == PARM_DECL
223 && id
->entry_bb
== NULL
224 && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (cfun
)))
226 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
228 gimple_stmt_iterator gsi
;
229 tree val
= SSA_NAME_VAR (name
);
231 n
= id
->decl_map
->get (val
);
234 if (TREE_CODE (val
) != PARM_DECL
)
236 processing_debug_stmt
= -1;
239 def_temp
= gimple_build_debug_source_bind (vexpr
, val
, NULL
);
240 DECL_ARTIFICIAL (vexpr
) = 1;
241 TREE_TYPE (vexpr
) = TREE_TYPE (name
);
242 DECL_MODE (vexpr
) = DECL_MODE (SSA_NAME_VAR (name
));
243 gsi
= gsi_after_labels (single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
244 gsi_insert_before (&gsi
, def_temp
, GSI_SAME_STMT
);
248 processing_debug_stmt
= -1;
252 /* Remap anonymous SSA names or SSA names of anonymous decls. */
253 var
= SSA_NAME_VAR (name
);
255 || (!SSA_NAME_IS_DEFAULT_DEF (name
)
256 && TREE_CODE (var
) == VAR_DECL
257 && !VAR_DECL_IS_VIRTUAL_OPERAND (var
)
258 && DECL_ARTIFICIAL (var
)
259 && DECL_IGNORED_P (var
)
260 && !DECL_NAME (var
)))
262 struct ptr_info_def
*pi
;
263 new_tree
= make_ssa_name (remap_type (TREE_TYPE (name
), id
));
264 if (!var
&& SSA_NAME_IDENTIFIER (name
))
265 SET_SSA_NAME_VAR_OR_IDENTIFIER (new_tree
, SSA_NAME_IDENTIFIER (name
));
266 insert_decl_map (id
, name
, new_tree
);
267 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
268 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
269 /* At least IPA points-to info can be directly transferred. */
270 if (id
->src_cfun
->gimple_df
271 && id
->src_cfun
->gimple_df
->ipa_pta
272 && (pi
= SSA_NAME_PTR_INFO (name
))
275 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
281 /* Do not set DEF_STMT yet as statement is not copied yet. We do that
283 new_tree
= remap_decl (var
, id
);
285 /* We might've substituted constant or another SSA_NAME for
288 Replace the SSA name representing RESULT_DECL by variable during
289 inlining: this saves us from need to introduce PHI node in a case
290 return value is just partly initialized. */
291 if ((TREE_CODE (new_tree
) == VAR_DECL
|| TREE_CODE (new_tree
) == PARM_DECL
)
292 && (!SSA_NAME_VAR (name
)
293 || TREE_CODE (SSA_NAME_VAR (name
)) != RESULT_DECL
294 || !id
->transform_return_to_modify
))
296 struct ptr_info_def
*pi
;
297 new_tree
= make_ssa_name (new_tree
);
298 insert_decl_map (id
, name
, new_tree
);
299 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
300 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
301 /* At least IPA points-to info can be directly transferred. */
302 if (id
->src_cfun
->gimple_df
303 && id
->src_cfun
->gimple_df
->ipa_pta
304 && (pi
= SSA_NAME_PTR_INFO (name
))
307 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
310 if (SSA_NAME_IS_DEFAULT_DEF (name
))
312 /* By inlining function having uninitialized variable, we might
313 extend the lifetime (variable might get reused). This cause
314 ICE in the case we end up extending lifetime of SSA name across
315 abnormal edge, but also increase register pressure.
317 We simply initialize all uninitialized vars by 0 except
318 for case we are inlining to very first BB. We can avoid
319 this for all BBs that are not inside strongly connected
320 regions of the CFG, but this is expensive to test. */
322 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
)
323 && (!SSA_NAME_VAR (name
)
324 || TREE_CODE (SSA_NAME_VAR (name
)) != PARM_DECL
)
325 && (id
->entry_bb
!= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
),
327 || EDGE_COUNT (id
->entry_bb
->preds
) != 1))
329 gimple_stmt_iterator gsi
= gsi_last_bb (id
->entry_bb
);
331 tree zero
= build_zero_cst (TREE_TYPE (new_tree
));
333 init_stmt
= gimple_build_assign (new_tree
, zero
);
334 gsi_insert_after (&gsi
, init_stmt
, GSI_NEW_STMT
);
335 SSA_NAME_IS_DEFAULT_DEF (new_tree
) = 0;
339 SSA_NAME_DEF_STMT (new_tree
) = gimple_build_nop ();
340 set_ssa_default_def (cfun
, SSA_NAME_VAR (new_tree
), new_tree
);
345 insert_decl_map (id
, name
, new_tree
);
349 /* Remap DECL during the copying of the BLOCK tree for the function. */
352 remap_decl (tree decl
, copy_body_data
*id
)
356 /* We only remap local variables in the current function. */
358 /* See if we have remapped this declaration. */
360 n
= id
->decl_map
->get (decl
);
362 if (!n
&& processing_debug_stmt
)
364 processing_debug_stmt
= -1;
368 /* If we didn't already have an equivalent for this declaration,
372 /* Make a copy of the variable or label. */
373 tree t
= id
->copy_decl (decl
, id
);
375 /* Remember it, so that if we encounter this local entity again
376 we can reuse this copy. Do this early because remap_type may
377 need this decl for TYPE_STUB_DECL. */
378 insert_decl_map (id
, decl
, t
);
383 /* Remap types, if necessary. */
384 TREE_TYPE (t
) = remap_type (TREE_TYPE (t
), id
);
385 if (TREE_CODE (t
) == TYPE_DECL
)
386 DECL_ORIGINAL_TYPE (t
) = remap_type (DECL_ORIGINAL_TYPE (t
), id
);
388 /* Remap sizes as necessary. */
389 walk_tree (&DECL_SIZE (t
), copy_tree_body_r
, id
, NULL
);
390 walk_tree (&DECL_SIZE_UNIT (t
), copy_tree_body_r
, id
, NULL
);
392 /* If fields, do likewise for offset and qualifier. */
393 if (TREE_CODE (t
) == FIELD_DECL
)
395 walk_tree (&DECL_FIELD_OFFSET (t
), copy_tree_body_r
, id
, NULL
);
396 if (TREE_CODE (DECL_CONTEXT (t
)) == QUAL_UNION_TYPE
)
397 walk_tree (&DECL_QUALIFIER (t
), copy_tree_body_r
, id
, NULL
);
403 if (id
->do_not_unshare
)
406 return unshare_expr (*n
);
410 remap_type_1 (tree type
, copy_body_data
*id
)
414 /* We do need a copy. build and register it now. If this is a pointer or
415 reference type, remap the designated type and make a new pointer or
417 if (TREE_CODE (type
) == POINTER_TYPE
)
419 new_tree
= build_pointer_type_for_mode (remap_type (TREE_TYPE (type
), id
),
421 TYPE_REF_CAN_ALIAS_ALL (type
));
422 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
423 new_tree
= build_type_attribute_qual_variant (new_tree
,
424 TYPE_ATTRIBUTES (type
),
426 insert_decl_map (id
, type
, new_tree
);
429 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
431 new_tree
= build_reference_type_for_mode (remap_type (TREE_TYPE (type
), id
),
433 TYPE_REF_CAN_ALIAS_ALL (type
));
434 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
435 new_tree
= build_type_attribute_qual_variant (new_tree
,
436 TYPE_ATTRIBUTES (type
),
438 insert_decl_map (id
, type
, new_tree
);
442 new_tree
= copy_node (type
);
444 insert_decl_map (id
, type
, new_tree
);
446 /* This is a new type, not a copy of an old type. Need to reassociate
447 variants. We can handle everything except the main variant lazily. */
448 t
= TYPE_MAIN_VARIANT (type
);
451 t
= remap_type (t
, id
);
452 TYPE_MAIN_VARIANT (new_tree
) = t
;
453 TYPE_NEXT_VARIANT (new_tree
) = TYPE_NEXT_VARIANT (t
);
454 TYPE_NEXT_VARIANT (t
) = new_tree
;
458 TYPE_MAIN_VARIANT (new_tree
) = new_tree
;
459 TYPE_NEXT_VARIANT (new_tree
) = NULL
;
462 if (TYPE_STUB_DECL (type
))
463 TYPE_STUB_DECL (new_tree
) = remap_decl (TYPE_STUB_DECL (type
), id
);
465 /* Lazily create pointer and reference types. */
466 TYPE_POINTER_TO (new_tree
) = NULL
;
467 TYPE_REFERENCE_TO (new_tree
) = NULL
;
469 /* Copy all types that may contain references to local variables; be sure to
470 preserve sharing in between type and its main variant when possible. */
471 switch (TREE_CODE (new_tree
))
475 case FIXED_POINT_TYPE
:
478 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
480 gcc_checking_assert (TYPE_MIN_VALUE (type
) == TYPE_MIN_VALUE (TYPE_MAIN_VARIANT (type
)));
481 gcc_checking_assert (TYPE_MAX_VALUE (type
) == TYPE_MAX_VALUE (TYPE_MAIN_VARIANT (type
)));
483 TYPE_MIN_VALUE (new_tree
) = TYPE_MIN_VALUE (TYPE_MAIN_VARIANT (new_tree
));
484 TYPE_MAX_VALUE (new_tree
) = TYPE_MAX_VALUE (TYPE_MAIN_VARIANT (new_tree
));
488 t
= TYPE_MIN_VALUE (new_tree
);
489 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
490 walk_tree (&TYPE_MIN_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
492 t
= TYPE_MAX_VALUE (new_tree
);
493 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
494 walk_tree (&TYPE_MAX_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
499 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
500 && TREE_TYPE (type
) == TREE_TYPE (TYPE_MAIN_VARIANT (type
)))
501 TREE_TYPE (new_tree
) = TREE_TYPE (TYPE_MAIN_VARIANT (new_tree
));
503 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
504 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
505 && TYPE_ARG_TYPES (type
) == TYPE_ARG_TYPES (TYPE_MAIN_VARIANT (type
)))
506 TYPE_ARG_TYPES (new_tree
) = TYPE_ARG_TYPES (TYPE_MAIN_VARIANT (new_tree
));
508 walk_tree (&TYPE_ARG_TYPES (new_tree
), copy_tree_body_r
, id
, NULL
);
512 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
513 && TREE_TYPE (type
) == TREE_TYPE (TYPE_MAIN_VARIANT (type
)))
514 TREE_TYPE (new_tree
) = TREE_TYPE (TYPE_MAIN_VARIANT (new_tree
));
516 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
518 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
520 gcc_checking_assert (TYPE_DOMAIN (type
) == TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)));
521 TYPE_DOMAIN (new_tree
) = TYPE_DOMAIN (TYPE_MAIN_VARIANT (new_tree
));
524 TYPE_DOMAIN (new_tree
) = remap_type (TYPE_DOMAIN (new_tree
), id
);
529 case QUAL_UNION_TYPE
:
530 if (TYPE_MAIN_VARIANT (type
) != type
531 && TYPE_FIELDS (type
) == TYPE_FIELDS (TYPE_MAIN_VARIANT (type
)))
532 TYPE_FIELDS (new_tree
) = TYPE_FIELDS (TYPE_MAIN_VARIANT (new_tree
));
537 for (f
= TYPE_FIELDS (new_tree
); f
; f
= DECL_CHAIN (f
))
539 t
= remap_decl (f
, id
);
540 DECL_CONTEXT (t
) = new_tree
;
544 TYPE_FIELDS (new_tree
) = nreverse (nf
);
550 /* Shouldn't have been thought variable sized. */
554 /* All variants of type share the same size, so use the already remaped data. */
555 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
557 gcc_checking_assert (TYPE_SIZE (type
) == TYPE_SIZE (TYPE_MAIN_VARIANT (type
)));
558 gcc_checking_assert (TYPE_SIZE_UNIT (type
) == TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type
)));
560 TYPE_SIZE (new_tree
) = TYPE_SIZE (TYPE_MAIN_VARIANT (new_tree
));
561 TYPE_SIZE_UNIT (new_tree
) = TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (new_tree
));
565 walk_tree (&TYPE_SIZE (new_tree
), copy_tree_body_r
, id
, NULL
);
566 walk_tree (&TYPE_SIZE_UNIT (new_tree
), copy_tree_body_r
, id
, NULL
);
573 remap_type (tree type
, copy_body_data
*id
)
581 /* See if we have remapped this type. */
582 node
= id
->decl_map
->get (type
);
586 /* The type only needs remapping if it's variably modified. */
587 if (! variably_modified_type_p (type
, id
->src_fn
))
589 insert_decl_map (id
, type
, type
);
593 id
->remapping_type_depth
++;
594 tmp
= remap_type_1 (type
, id
);
595 id
->remapping_type_depth
--;
600 /* Decide if DECL can be put into BLOCK_NONLOCAL_VARs. */
603 can_be_nonlocal (tree decl
, copy_body_data
*id
)
605 /* We can not duplicate function decls. */
606 if (TREE_CODE (decl
) == FUNCTION_DECL
)
609 /* Local static vars must be non-local or we get multiple declaration
611 if (TREE_CODE (decl
) == VAR_DECL
612 && !auto_var_in_fn_p (decl
, id
->src_fn
))
619 remap_decls (tree decls
, vec
<tree
, va_gc
> **nonlocalized_list
,
623 tree new_decls
= NULL_TREE
;
625 /* Remap its variables. */
626 for (old_var
= decls
; old_var
; old_var
= DECL_CHAIN (old_var
))
630 if (can_be_nonlocal (old_var
, id
))
632 /* We need to add this variable to the local decls as otherwise
633 nothing else will do so. */
634 if (TREE_CODE (old_var
) == VAR_DECL
635 && ! DECL_EXTERNAL (old_var
))
636 add_local_decl (cfun
, old_var
);
637 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
638 && !DECL_IGNORED_P (old_var
)
639 && nonlocalized_list
)
640 vec_safe_push (*nonlocalized_list
, old_var
);
644 /* Remap the variable. */
645 new_var
= remap_decl (old_var
, id
);
647 /* If we didn't remap this variable, we can't mess with its
648 TREE_CHAIN. If we remapped this variable to the return slot, it's
649 already declared somewhere else, so don't declare it here. */
651 if (new_var
== id
->retvar
)
655 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
656 && !DECL_IGNORED_P (old_var
)
657 && nonlocalized_list
)
658 vec_safe_push (*nonlocalized_list
, old_var
);
662 gcc_assert (DECL_P (new_var
));
663 DECL_CHAIN (new_var
) = new_decls
;
666 /* Also copy value-expressions. */
667 if (TREE_CODE (new_var
) == VAR_DECL
668 && DECL_HAS_VALUE_EXPR_P (new_var
))
670 tree tem
= DECL_VALUE_EXPR (new_var
);
671 bool old_regimplify
= id
->regimplify
;
672 id
->remapping_type_depth
++;
673 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
674 id
->remapping_type_depth
--;
675 id
->regimplify
= old_regimplify
;
676 SET_DECL_VALUE_EXPR (new_var
, tem
);
681 return nreverse (new_decls
);
684 /* Copy the BLOCK to contain remapped versions of the variables
685 therein. And hook the new block into the block-tree. */
688 remap_block (tree
*block
, copy_body_data
*id
)
693 /* Make the new block. */
695 new_block
= make_node (BLOCK
);
696 TREE_USED (new_block
) = TREE_USED (old_block
);
697 BLOCK_ABSTRACT_ORIGIN (new_block
) = old_block
;
698 BLOCK_SOURCE_LOCATION (new_block
) = BLOCK_SOURCE_LOCATION (old_block
);
699 BLOCK_NONLOCALIZED_VARS (new_block
)
700 = vec_safe_copy (BLOCK_NONLOCALIZED_VARS (old_block
));
703 /* Remap its variables. */
704 BLOCK_VARS (new_block
) = remap_decls (BLOCK_VARS (old_block
),
705 &BLOCK_NONLOCALIZED_VARS (new_block
),
708 if (id
->transform_lang_insert_block
)
709 id
->transform_lang_insert_block (new_block
);
711 /* Remember the remapped block. */
712 insert_decl_map (id
, old_block
, new_block
);
715 /* Copy the whole block tree and root it in id->block. */
717 remap_blocks (tree block
, copy_body_data
*id
)
720 tree new_tree
= block
;
725 remap_block (&new_tree
, id
);
726 gcc_assert (new_tree
!= block
);
727 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
728 prepend_lexical_block (new_tree
, remap_blocks (t
, id
));
729 /* Blocks are in arbitrary order, but make things slightly prettier and do
730 not swap order when producing a copy. */
731 BLOCK_SUBBLOCKS (new_tree
) = blocks_nreverse (BLOCK_SUBBLOCKS (new_tree
));
735 /* Remap the block tree rooted at BLOCK to nothing. */
737 remap_blocks_to_null (tree block
, copy_body_data
*id
)
740 insert_decl_map (id
, block
, NULL_TREE
);
741 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
742 remap_blocks_to_null (t
, id
);
746 copy_statement_list (tree
*tp
)
748 tree_stmt_iterator oi
, ni
;
751 new_tree
= alloc_stmt_list ();
752 ni
= tsi_start (new_tree
);
753 oi
= tsi_start (*tp
);
754 TREE_TYPE (new_tree
) = TREE_TYPE (*tp
);
757 for (; !tsi_end_p (oi
); tsi_next (&oi
))
759 tree stmt
= tsi_stmt (oi
);
760 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
761 /* This copy is not redundant; tsi_link_after will smash this
762 STATEMENT_LIST into the end of the one we're building, and we
763 don't want to do that with the original. */
764 copy_statement_list (&stmt
);
765 tsi_link_after (&ni
, stmt
, TSI_CONTINUE_LINKING
);
770 copy_bind_expr (tree
*tp
, int *walk_subtrees
, copy_body_data
*id
)
772 tree block
= BIND_EXPR_BLOCK (*tp
);
773 /* Copy (and replace) the statement. */
774 copy_tree_r (tp
, walk_subtrees
, NULL
);
777 remap_block (&block
, id
);
778 BIND_EXPR_BLOCK (*tp
) = block
;
781 if (BIND_EXPR_VARS (*tp
))
782 /* This will remap a lot of the same decls again, but this should be
784 BIND_EXPR_VARS (*tp
) = remap_decls (BIND_EXPR_VARS (*tp
), NULL
, id
);
788 /* Create a new gimple_seq by remapping all the statements in BODY
789 using the inlining information in ID. */
792 remap_gimple_seq (gimple_seq body
, copy_body_data
*id
)
794 gimple_stmt_iterator si
;
795 gimple_seq new_body
= NULL
;
797 for (si
= gsi_start (body
); !gsi_end_p (si
); gsi_next (&si
))
799 gimple_seq new_stmts
= remap_gimple_stmt (gsi_stmt (si
), id
);
800 gimple_seq_add_seq (&new_body
, new_stmts
);
807 /* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its
808 block using the mapping information in ID. */
811 copy_gimple_bind (gbind
*stmt
, copy_body_data
*id
)
814 tree new_block
, new_vars
;
815 gimple_seq body
, new_body
;
817 /* Copy the statement. Note that we purposely don't use copy_stmt
818 here because we need to remap statements as we copy. */
819 body
= gimple_bind_body (stmt
);
820 new_body
= remap_gimple_seq (body
, id
);
822 new_block
= gimple_bind_block (stmt
);
824 remap_block (&new_block
, id
);
826 /* This will remap a lot of the same decls again, but this should be
828 new_vars
= gimple_bind_vars (stmt
);
830 new_vars
= remap_decls (new_vars
, NULL
, id
);
832 new_bind
= gimple_build_bind (new_vars
, new_body
, new_block
);
837 /* Return true if DECL is a parameter or a SSA_NAME for a parameter. */
842 if (TREE_CODE (decl
) == SSA_NAME
)
844 decl
= SSA_NAME_VAR (decl
);
849 return (TREE_CODE (decl
) == PARM_DECL
);
852 /* Remap the dependence CLIQUE from the source to the destination function
853 as specified in ID. */
855 static unsigned short
856 remap_dependence_clique (copy_body_data
*id
, unsigned short clique
)
860 if (!id
->dependence_map
)
862 = new hash_map
<unsigned short, unsigned short, dependence_hasher
>;
864 unsigned short &newc
= id
->dependence_map
->get_or_insert (clique
, &existed
);
866 newc
= ++cfun
->last_clique
;
870 /* Remap the GIMPLE operand pointed to by *TP. DATA is really a
871 'struct walk_stmt_info *'. DATA->INFO is a 'copy_body_data *'.
872 WALK_SUBTREES is used to indicate walk_gimple_op whether to keep
873 recursing into the children nodes of *TP. */
876 remap_gimple_op_r (tree
*tp
, int *walk_subtrees
, void *data
)
878 struct walk_stmt_info
*wi_p
= (struct walk_stmt_info
*) data
;
879 copy_body_data
*id
= (copy_body_data
*) wi_p
->info
;
880 tree fn
= id
->src_fn
;
882 if (TREE_CODE (*tp
) == SSA_NAME
)
884 *tp
= remap_ssa_name (*tp
, id
);
888 else if (auto_var_in_fn_p (*tp
, fn
))
890 /* Local variables and labels need to be replaced by equivalent
891 variables. We don't want to copy static variables; there's
892 only one of those, no matter how many times we inline the
893 containing function. Similarly for globals from an outer
897 /* Remap the declaration. */
898 new_decl
= remap_decl (*tp
, id
);
899 gcc_assert (new_decl
);
900 /* Replace this variable with the copy. */
901 STRIP_TYPE_NOPS (new_decl
);
902 /* ??? The C++ frontend uses void * pointer zero to initialize
903 any other type. This confuses the middle-end type verification.
904 As cloned bodies do not go through gimplification again the fixup
905 there doesn't trigger. */
906 if (TREE_CODE (new_decl
) == INTEGER_CST
907 && !useless_type_conversion_p (TREE_TYPE (*tp
), TREE_TYPE (new_decl
)))
908 new_decl
= fold_convert (TREE_TYPE (*tp
), new_decl
);
912 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
914 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
916 else if (TREE_CODE (*tp
) == LABEL_DECL
917 && (!DECL_CONTEXT (*tp
)
918 || decl_function_context (*tp
) == id
->src_fn
))
919 /* These may need to be remapped for EH handling. */
920 *tp
= remap_decl (*tp
, id
);
921 else if (TREE_CODE (*tp
) == FIELD_DECL
)
923 /* If the enclosing record type is variably_modified_type_p, the field
924 has already been remapped. Otherwise, it need not be. */
925 tree
*n
= id
->decl_map
->get (*tp
);
930 else if (TYPE_P (*tp
))
931 /* Types may need remapping as well. */
932 *tp
= remap_type (*tp
, id
);
933 else if (CONSTANT_CLASS_P (*tp
))
935 /* If this is a constant, we have to copy the node iff the type
936 will be remapped. copy_tree_r will not copy a constant. */
937 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
939 if (new_type
== TREE_TYPE (*tp
))
942 else if (TREE_CODE (*tp
) == INTEGER_CST
)
943 *tp
= wide_int_to_tree (new_type
, *tp
);
946 *tp
= copy_node (*tp
);
947 TREE_TYPE (*tp
) = new_type
;
952 /* Otherwise, just copy the node. Note that copy_tree_r already
953 knows not to copy VAR_DECLs, etc., so this is safe. */
955 if (TREE_CODE (*tp
) == MEM_REF
)
957 /* We need to re-canonicalize MEM_REFs from inline substitutions
958 that can happen when a pointer argument is an ADDR_EXPR.
959 Recurse here manually to allow that. */
960 tree ptr
= TREE_OPERAND (*tp
, 0);
961 tree type
= remap_type (TREE_TYPE (*tp
), id
);
963 walk_tree (&ptr
, remap_gimple_op_r
, data
, NULL
);
964 *tp
= fold_build2 (MEM_REF
, type
, ptr
, TREE_OPERAND (*tp
, 1));
965 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
966 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
967 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
968 if (MR_DEPENDENCE_CLIQUE (old
) != 0)
970 MR_DEPENDENCE_CLIQUE (*tp
)
971 = remap_dependence_clique (id
, MR_DEPENDENCE_CLIQUE (old
));
972 MR_DEPENDENCE_BASE (*tp
) = MR_DEPENDENCE_BASE (old
);
974 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
975 remapped a parameter as the property might be valid only
976 for the parameter itself. */
977 if (TREE_THIS_NOTRAP (old
)
978 && (!is_parm (TREE_OPERAND (old
, 0))
979 || (!id
->transform_parameter
&& is_parm (ptr
))))
980 TREE_THIS_NOTRAP (*tp
) = 1;
985 /* Here is the "usual case". Copy this tree node, and then
986 tweak some special cases. */
987 copy_tree_r (tp
, walk_subtrees
, NULL
);
989 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
990 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
992 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
994 /* The copied TARGET_EXPR has never been expanded, even if the
995 original node was expanded already. */
996 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
997 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
999 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
1001 /* Variable substitution need not be simple. In particular,
1002 the MEM_REF substitution above. Make sure that
1003 TREE_CONSTANT and friends are up-to-date. */
1004 int invariant
= is_gimple_min_invariant (*tp
);
1005 walk_tree (&TREE_OPERAND (*tp
, 0), remap_gimple_op_r
, data
, NULL
);
1006 recompute_tree_invariant_for_addr_expr (*tp
);
1008 /* If this used to be invariant, but is not any longer,
1009 then regimplification is probably needed. */
1010 if (invariant
&& !is_gimple_min_invariant (*tp
))
1011 id
->regimplify
= true;
1017 /* Update the TREE_BLOCK for the cloned expr. */
1020 tree new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
1021 tree old_block
= TREE_BLOCK (*tp
);
1025 n
= id
->decl_map
->get (TREE_BLOCK (*tp
));
1029 TREE_SET_BLOCK (*tp
, new_block
);
1032 /* Keep iterating. */
1037 /* Called from copy_body_id via walk_tree. DATA is really a
1038 `copy_body_data *'. */
1041 copy_tree_body_r (tree
*tp
, int *walk_subtrees
, void *data
)
1043 copy_body_data
*id
= (copy_body_data
*) data
;
1044 tree fn
= id
->src_fn
;
1047 /* Begin by recognizing trees that we'll completely rewrite for the
1048 inlining context. Our output for these trees is completely
1049 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1050 into an edge). Further down, we'll handle trees that get
1051 duplicated and/or tweaked. */
1053 /* When requested, RETURN_EXPRs should be transformed to just the
1054 contained MODIFY_EXPR. The branch semantics of the return will
1055 be handled elsewhere by manipulating the CFG rather than a statement. */
1056 if (TREE_CODE (*tp
) == RETURN_EXPR
&& id
->transform_return_to_modify
)
1058 tree assignment
= TREE_OPERAND (*tp
, 0);
1060 /* If we're returning something, just turn that into an
1061 assignment into the equivalent of the original RESULT_DECL.
1062 If the "assignment" is just the result decl, the result
1063 decl has already been set (e.g. a recent "foo (&result_decl,
1064 ...)"); just toss the entire RETURN_EXPR. */
1065 if (assignment
&& TREE_CODE (assignment
) == MODIFY_EXPR
)
1067 /* Replace the RETURN_EXPR with (a copy of) the
1068 MODIFY_EXPR hanging underneath. */
1069 *tp
= copy_node (assignment
);
1071 else /* Else the RETURN_EXPR returns no value. */
1074 return (tree
) (void *)1;
1077 else if (TREE_CODE (*tp
) == SSA_NAME
)
1079 *tp
= remap_ssa_name (*tp
, id
);
1084 /* Local variables and labels need to be replaced by equivalent
1085 variables. We don't want to copy static variables; there's only
1086 one of those, no matter how many times we inline the containing
1087 function. Similarly for globals from an outer function. */
1088 else if (auto_var_in_fn_p (*tp
, fn
))
1092 /* Remap the declaration. */
1093 new_decl
= remap_decl (*tp
, id
);
1094 gcc_assert (new_decl
);
1095 /* Replace this variable with the copy. */
1096 STRIP_TYPE_NOPS (new_decl
);
1100 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
1101 copy_statement_list (tp
);
1102 else if (TREE_CODE (*tp
) == SAVE_EXPR
1103 || TREE_CODE (*tp
) == TARGET_EXPR
)
1104 remap_save_expr (tp
, id
->decl_map
, walk_subtrees
);
1105 else if (TREE_CODE (*tp
) == LABEL_DECL
1106 && (! DECL_CONTEXT (*tp
)
1107 || decl_function_context (*tp
) == id
->src_fn
))
1108 /* These may need to be remapped for EH handling. */
1109 *tp
= remap_decl (*tp
, id
);
1110 else if (TREE_CODE (*tp
) == BIND_EXPR
)
1111 copy_bind_expr (tp
, walk_subtrees
, id
);
1112 /* Types may need remapping as well. */
1113 else if (TYPE_P (*tp
))
1114 *tp
= remap_type (*tp
, id
);
1116 /* If this is a constant, we have to copy the node iff the type will be
1117 remapped. copy_tree_r will not copy a constant. */
1118 else if (CONSTANT_CLASS_P (*tp
))
1120 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
1122 if (new_type
== TREE_TYPE (*tp
))
1125 else if (TREE_CODE (*tp
) == INTEGER_CST
)
1126 *tp
= wide_int_to_tree (new_type
, *tp
);
1129 *tp
= copy_node (*tp
);
1130 TREE_TYPE (*tp
) = new_type
;
1134 /* Otherwise, just copy the node. Note that copy_tree_r already
1135 knows not to copy VAR_DECLs, etc., so this is safe. */
1138 /* Here we handle trees that are not completely rewritten.
1139 First we detect some inlining-induced bogosities for
1141 if (TREE_CODE (*tp
) == MODIFY_EXPR
1142 && TREE_OPERAND (*tp
, 0) == TREE_OPERAND (*tp
, 1)
1143 && (auto_var_in_fn_p (TREE_OPERAND (*tp
, 0), fn
)))
1145 /* Some assignments VAR = VAR; don't generate any rtl code
1146 and thus don't count as variable modification. Avoid
1147 keeping bogosities like 0 = 0. */
1148 tree decl
= TREE_OPERAND (*tp
, 0), value
;
1151 n
= id
->decl_map
->get (decl
);
1155 STRIP_TYPE_NOPS (value
);
1156 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1158 *tp
= build_empty_stmt (EXPR_LOCATION (*tp
));
1159 return copy_tree_body_r (tp
, walk_subtrees
, data
);
1163 else if (TREE_CODE (*tp
) == INDIRECT_REF
)
1165 /* Get rid of *& from inline substitutions that can happen when a
1166 pointer argument is an ADDR_EXPR. */
1167 tree decl
= TREE_OPERAND (*tp
, 0);
1168 tree
*n
= id
->decl_map
->get (decl
);
1171 /* If we happen to get an ADDR_EXPR in n->value, strip
1172 it manually here as we'll eventually get ADDR_EXPRs
1173 which lie about their types pointed to. In this case
1174 build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
1175 but we absolutely rely on that. As fold_indirect_ref
1176 does other useful transformations, try that first, though. */
1177 tree type
= TREE_TYPE (*tp
);
1178 tree ptr
= id
->do_not_unshare
? *n
: unshare_expr (*n
);
1180 *tp
= gimple_fold_indirect_ref (ptr
);
1183 if (TREE_CODE (ptr
) == ADDR_EXPR
)
1186 = fold_indirect_ref_1 (EXPR_LOCATION (ptr
), type
, ptr
);
1187 /* ??? We should either assert here or build
1188 a VIEW_CONVERT_EXPR instead of blindly leaking
1189 incompatible types to our IL. */
1191 *tp
= TREE_OPERAND (ptr
, 0);
1195 *tp
= build1 (INDIRECT_REF
, type
, ptr
);
1196 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1197 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1198 TREE_READONLY (*tp
) = TREE_READONLY (old
);
1199 /* We cannot propagate the TREE_THIS_NOTRAP flag if we
1200 have remapped a parameter as the property might be
1201 valid only for the parameter itself. */
1202 if (TREE_THIS_NOTRAP (old
)
1203 && (!is_parm (TREE_OPERAND (old
, 0))
1204 || (!id
->transform_parameter
&& is_parm (ptr
))))
1205 TREE_THIS_NOTRAP (*tp
) = 1;
1212 else if (TREE_CODE (*tp
) == MEM_REF
)
1214 /* We need to re-canonicalize MEM_REFs from inline substitutions
1215 that can happen when a pointer argument is an ADDR_EXPR.
1216 Recurse here manually to allow that. */
1217 tree ptr
= TREE_OPERAND (*tp
, 0);
1218 tree type
= remap_type (TREE_TYPE (*tp
), id
);
1220 walk_tree (&ptr
, copy_tree_body_r
, data
, NULL
);
1221 *tp
= fold_build2 (MEM_REF
, type
, ptr
, TREE_OPERAND (*tp
, 1));
1222 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1223 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1224 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
1225 if (MR_DEPENDENCE_CLIQUE (old
) != 0)
1227 MR_DEPENDENCE_CLIQUE (*tp
)
1228 = remap_dependence_clique (id
, MR_DEPENDENCE_CLIQUE (old
));
1229 MR_DEPENDENCE_BASE (*tp
) = MR_DEPENDENCE_BASE (old
);
1231 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
1232 remapped a parameter as the property might be valid only
1233 for the parameter itself. */
1234 if (TREE_THIS_NOTRAP (old
)
1235 && (!is_parm (TREE_OPERAND (old
, 0))
1236 || (!id
->transform_parameter
&& is_parm (ptr
))))
1237 TREE_THIS_NOTRAP (*tp
) = 1;
1242 /* Here is the "usual case". Copy this tree node, and then
1243 tweak some special cases. */
1244 copy_tree_r (tp
, walk_subtrees
, NULL
);
1246 /* If EXPR has block defined, map it to newly constructed block.
1247 When inlining we want EXPRs without block appear in the block
1248 of function call if we are not remapping a type. */
1251 new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
1252 if (TREE_BLOCK (*tp
))
1255 n
= id
->decl_map
->get (TREE_BLOCK (*tp
));
1259 TREE_SET_BLOCK (*tp
, new_block
);
1262 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
1263 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
1265 /* The copied TARGET_EXPR has never been expanded, even if the
1266 original node was expanded already. */
1267 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
1269 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
1270 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
1273 /* Variable substitution need not be simple. In particular, the
1274 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
1275 and friends are up-to-date. */
1276 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
1278 int invariant
= is_gimple_min_invariant (*tp
);
1279 walk_tree (&TREE_OPERAND (*tp
, 0), copy_tree_body_r
, id
, NULL
);
1281 /* Handle the case where we substituted an INDIRECT_REF
1282 into the operand of the ADDR_EXPR. */
1283 if (TREE_CODE (TREE_OPERAND (*tp
, 0)) == INDIRECT_REF
)
1284 *tp
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0);
1286 recompute_tree_invariant_for_addr_expr (*tp
);
1288 /* If this used to be invariant, but is not any longer,
1289 then regimplification is probably needed. */
1290 if (invariant
&& !is_gimple_min_invariant (*tp
))
1291 id
->regimplify
= true;
1297 /* Keep iterating. */
1301 /* Helper for remap_gimple_stmt. Given an EH region number for the
1302 source function, map that to the duplicate EH region number in
1303 the destination function. */
1306 remap_eh_region_nr (int old_nr
, copy_body_data
*id
)
1308 eh_region old_r
, new_r
;
1310 old_r
= get_eh_region_from_number_fn (id
->src_cfun
, old_nr
);
1311 new_r
= static_cast<eh_region
> (*id
->eh_map
->get (old_r
));
1313 return new_r
->index
;
1316 /* Similar, but operate on INTEGER_CSTs. */
1319 remap_eh_region_tree_nr (tree old_t_nr
, copy_body_data
*id
)
1323 old_nr
= tree_to_shwi (old_t_nr
);
1324 new_nr
= remap_eh_region_nr (old_nr
, id
);
1326 return build_int_cst (integer_type_node
, new_nr
);
1329 /* Helper for copy_bb. Remap statement STMT using the inlining
1330 information in ID. Return the new statement copy. */
1333 remap_gimple_stmt (gimple stmt
, copy_body_data
*id
)
1336 struct walk_stmt_info wi
;
1337 bool skip_first
= false;
1338 gimple_seq stmts
= NULL
;
1340 /* Begin by recognizing trees that we'll completely rewrite for the
1341 inlining context. Our output for these trees is completely
1342 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1343 into an edge). Further down, we'll handle trees that get
1344 duplicated and/or tweaked. */
1346 /* When requested, GIMPLE_RETURNs should be transformed to just the
1347 contained GIMPLE_ASSIGN. The branch semantics of the return will
1348 be handled elsewhere by manipulating the CFG rather than the
1350 if (gimple_code (stmt
) == GIMPLE_RETURN
&& id
->transform_return_to_modify
)
1352 tree retval
= gimple_return_retval (as_a
<greturn
*> (stmt
));
1353 tree retbnd
= gimple_return_retbnd (stmt
);
1354 tree bndslot
= id
->retbnd
;
1356 if (retbnd
&& bndslot
)
1358 gimple bndcopy
= gimple_build_assign (bndslot
, retbnd
);
1359 memset (&wi
, 0, sizeof (wi
));
1361 walk_gimple_op (bndcopy
, remap_gimple_op_r
, &wi
);
1362 gimple_seq_add_stmt (&stmts
, bndcopy
);
1365 /* If we're returning something, just turn that into an
1366 assignment into the equivalent of the original RESULT_DECL.
1367 If RETVAL is just the result decl, the result decl has
1368 already been set (e.g. a recent "foo (&result_decl, ...)");
1369 just toss the entire GIMPLE_RETURN. */
1371 && (TREE_CODE (retval
) != RESULT_DECL
1372 && (TREE_CODE (retval
) != SSA_NAME
1373 || ! SSA_NAME_VAR (retval
)
1374 || TREE_CODE (SSA_NAME_VAR (retval
)) != RESULT_DECL
)))
1376 copy
= gimple_build_assign (id
->do_not_unshare
1377 ? id
->retvar
: unshare_expr (id
->retvar
),
1379 /* id->retvar is already substituted. Skip it on later remapping. */
1382 /* We need to copy bounds if return structure with pointers into
1383 instrumented function. */
1384 if (chkp_function_instrumented_p (id
->dst_fn
)
1386 && !BOUNDED_P (id
->retvar
)
1387 && chkp_type_has_pointer (TREE_TYPE (id
->retvar
)))
1388 id
->assign_stmts
.safe_push (copy
);
1394 else if (gimple_has_substatements (stmt
))
1398 /* When cloning bodies from the C++ front end, we will be handed bodies
1399 in High GIMPLE form. Handle here all the High GIMPLE statements that
1400 have embedded statements. */
1401 switch (gimple_code (stmt
))
1404 copy
= copy_gimple_bind (as_a
<gbind
*> (stmt
), id
);
1409 gcatch
*catch_stmt
= as_a
<gcatch
*> (stmt
);
1410 s1
= remap_gimple_seq (gimple_catch_handler (catch_stmt
), id
);
1411 copy
= gimple_build_catch (gimple_catch_types (catch_stmt
), s1
);
1415 case GIMPLE_EH_FILTER
:
1416 s1
= remap_gimple_seq (gimple_eh_filter_failure (stmt
), id
);
1417 copy
= gimple_build_eh_filter (gimple_eh_filter_types (stmt
), s1
);
1421 s1
= remap_gimple_seq (gimple_try_eval (stmt
), id
);
1422 s2
= remap_gimple_seq (gimple_try_cleanup (stmt
), id
);
1423 copy
= gimple_build_try (s1
, s2
, gimple_try_kind (stmt
));
1426 case GIMPLE_WITH_CLEANUP_EXPR
:
1427 s1
= remap_gimple_seq (gimple_wce_cleanup (stmt
), id
);
1428 copy
= gimple_build_wce (s1
);
1431 case GIMPLE_OMP_PARALLEL
:
1433 gomp_parallel
*omp_par_stmt
= as_a
<gomp_parallel
*> (stmt
);
1434 s1
= remap_gimple_seq (gimple_omp_body (omp_par_stmt
), id
);
1435 copy
= gimple_build_omp_parallel
1437 gimple_omp_parallel_clauses (omp_par_stmt
),
1438 gimple_omp_parallel_child_fn (omp_par_stmt
),
1439 gimple_omp_parallel_data_arg (omp_par_stmt
));
1443 case GIMPLE_OMP_TASK
:
1444 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1445 copy
= gimple_build_omp_task
1447 gimple_omp_task_clauses (stmt
),
1448 gimple_omp_task_child_fn (stmt
),
1449 gimple_omp_task_data_arg (stmt
),
1450 gimple_omp_task_copy_fn (stmt
),
1451 gimple_omp_task_arg_size (stmt
),
1452 gimple_omp_task_arg_align (stmt
));
1455 case GIMPLE_OMP_FOR
:
1456 gcc_assert (!is_gimple_omp_oacc_specifically (stmt
));
1457 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1458 s2
= remap_gimple_seq (gimple_omp_for_pre_body (stmt
), id
);
1459 copy
= gimple_build_omp_for (s1
, gimple_omp_for_kind (stmt
),
1460 gimple_omp_for_clauses (stmt
),
1461 gimple_omp_for_collapse (stmt
), s2
);
1464 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1466 gimple_omp_for_set_index (copy
, i
,
1467 gimple_omp_for_index (stmt
, i
));
1468 gimple_omp_for_set_initial (copy
, i
,
1469 gimple_omp_for_initial (stmt
, i
));
1470 gimple_omp_for_set_final (copy
, i
,
1471 gimple_omp_for_final (stmt
, i
));
1472 gimple_omp_for_set_incr (copy
, i
,
1473 gimple_omp_for_incr (stmt
, i
));
1474 gimple_omp_for_set_cond (copy
, i
,
1475 gimple_omp_for_cond (stmt
, i
));
1480 case GIMPLE_OMP_MASTER
:
1481 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1482 copy
= gimple_build_omp_master (s1
);
1485 case GIMPLE_OMP_TASKGROUP
:
1486 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1487 copy
= gimple_build_omp_taskgroup (s1
);
1490 case GIMPLE_OMP_ORDERED
:
1491 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1492 copy
= gimple_build_omp_ordered (s1
);
1495 case GIMPLE_OMP_SECTION
:
1496 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1497 copy
= gimple_build_omp_section (s1
);
1500 case GIMPLE_OMP_SECTIONS
:
1501 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1502 copy
= gimple_build_omp_sections
1503 (s1
, gimple_omp_sections_clauses (stmt
));
1506 case GIMPLE_OMP_SINGLE
:
1507 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1508 copy
= gimple_build_omp_single
1509 (s1
, gimple_omp_single_clauses (stmt
));
1512 case GIMPLE_OMP_TARGET
:
1513 gcc_assert (!is_gimple_omp_oacc_specifically (stmt
));
1514 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1515 copy
= gimple_build_omp_target
1516 (s1
, gimple_omp_target_kind (stmt
),
1517 gimple_omp_target_clauses (stmt
));
1520 case GIMPLE_OMP_TEAMS
:
1521 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1522 copy
= gimple_build_omp_teams
1523 (s1
, gimple_omp_teams_clauses (stmt
));
1526 case GIMPLE_OMP_CRITICAL
:
1527 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1528 copy
= gimple_build_omp_critical (s1
,
1529 gimple_omp_critical_name (
1530 as_a
<gomp_critical
*> (stmt
)));
1533 case GIMPLE_TRANSACTION
:
1535 gtransaction
*old_trans_stmt
= as_a
<gtransaction
*> (stmt
);
1536 gtransaction
*new_trans_stmt
;
1537 s1
= remap_gimple_seq (gimple_transaction_body (old_trans_stmt
),
1539 copy
= new_trans_stmt
1540 = gimple_build_transaction (
1542 gimple_transaction_label (old_trans_stmt
));
1543 gimple_transaction_set_subcode (
1545 gimple_transaction_subcode (old_trans_stmt
));
1555 if (gimple_assign_copy_p (stmt
)
1556 && gimple_assign_lhs (stmt
) == gimple_assign_rhs1 (stmt
)
1557 && auto_var_in_fn_p (gimple_assign_lhs (stmt
), id
->src_fn
))
1559 /* Here we handle statements that are not completely rewritten.
1560 First we detect some inlining-induced bogosities for
1563 /* Some assignments VAR = VAR; don't generate any rtl code
1564 and thus don't count as variable modification. Avoid
1565 keeping bogosities like 0 = 0. */
1566 tree decl
= gimple_assign_lhs (stmt
), value
;
1569 n
= id
->decl_map
->get (decl
);
1573 STRIP_TYPE_NOPS (value
);
1574 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1579 /* For *ptr_N ={v} {CLOBBER}, if ptr_N is SSA_NAME defined
1580 in a block that we aren't copying during tree_function_versioning,
1581 just drop the clobber stmt. */
1582 if (id
->blocks_to_copy
&& gimple_clobber_p (stmt
))
1584 tree lhs
= gimple_assign_lhs (stmt
);
1585 if (TREE_CODE (lhs
) == MEM_REF
1586 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == SSA_NAME
)
1588 gimple def_stmt
= SSA_NAME_DEF_STMT (TREE_OPERAND (lhs
, 0));
1589 if (gimple_bb (def_stmt
)
1590 && !bitmap_bit_p (id
->blocks_to_copy
,
1591 gimple_bb (def_stmt
)->index
))
1596 if (gimple_debug_bind_p (stmt
))
1599 = gimple_build_debug_bind (gimple_debug_bind_get_var (stmt
),
1600 gimple_debug_bind_get_value (stmt
),
1602 id
->debug_stmts
.safe_push (copy
);
1603 gimple_seq_add_stmt (&stmts
, copy
);
1606 if (gimple_debug_source_bind_p (stmt
))
1608 gdebug
*copy
= gimple_build_debug_source_bind
1609 (gimple_debug_source_bind_get_var (stmt
),
1610 gimple_debug_source_bind_get_value (stmt
),
1612 id
->debug_stmts
.safe_push (copy
);
1613 gimple_seq_add_stmt (&stmts
, copy
);
1617 /* Create a new deep copy of the statement. */
1618 copy
= gimple_copy (stmt
);
1620 /* Clear flags that need revisiting. */
1621 if (gcall
*call_stmt
= dyn_cast
<gcall
*> (copy
))
1622 if (gimple_call_tail_p (call_stmt
))
1623 gimple_call_set_tail (call_stmt
, false);
1625 /* Remap the region numbers for __builtin_eh_{pointer,filter},
1626 RESX and EH_DISPATCH. */
1628 switch (gimple_code (copy
))
1632 tree r
, fndecl
= gimple_call_fndecl (copy
);
1633 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
1634 switch (DECL_FUNCTION_CODE (fndecl
))
1636 case BUILT_IN_EH_COPY_VALUES
:
1637 r
= gimple_call_arg (copy
, 1);
1638 r
= remap_eh_region_tree_nr (r
, id
);
1639 gimple_call_set_arg (copy
, 1, r
);
1642 case BUILT_IN_EH_POINTER
:
1643 case BUILT_IN_EH_FILTER
:
1644 r
= gimple_call_arg (copy
, 0);
1645 r
= remap_eh_region_tree_nr (r
, id
);
1646 gimple_call_set_arg (copy
, 0, r
);
1653 /* Reset alias info if we didn't apply measures to
1654 keep it valid over inlining by setting DECL_PT_UID. */
1655 if (!id
->src_cfun
->gimple_df
1656 || !id
->src_cfun
->gimple_df
->ipa_pta
)
1657 gimple_call_reset_alias_info (as_a
<gcall
*> (copy
));
1663 gresx
*resx_stmt
= as_a
<gresx
*> (copy
);
1664 int r
= gimple_resx_region (resx_stmt
);
1665 r
= remap_eh_region_nr (r
, id
);
1666 gimple_resx_set_region (resx_stmt
, r
);
1670 case GIMPLE_EH_DISPATCH
:
1672 geh_dispatch
*eh_dispatch
= as_a
<geh_dispatch
*> (copy
);
1673 int r
= gimple_eh_dispatch_region (eh_dispatch
);
1674 r
= remap_eh_region_nr (r
, id
);
1675 gimple_eh_dispatch_set_region (eh_dispatch
, r
);
1684 /* If STMT has a block defined, map it to the newly constructed
1686 if (gimple_block (copy
))
1689 n
= id
->decl_map
->get (gimple_block (copy
));
1691 gimple_set_block (copy
, *n
);
1694 if (gimple_debug_bind_p (copy
) || gimple_debug_source_bind_p (copy
))
1696 gimple_seq_add_stmt (&stmts
, copy
);
1700 /* Remap all the operands in COPY. */
1701 memset (&wi
, 0, sizeof (wi
));
1704 walk_tree (gimple_op_ptr (copy
, 1), remap_gimple_op_r
, &wi
, NULL
);
1706 walk_gimple_op (copy
, remap_gimple_op_r
, &wi
);
1708 /* Clear the copied virtual operands. We are not remapping them here
1709 but are going to recreate them from scratch. */
1710 if (gimple_has_mem_ops (copy
))
1712 gimple_set_vdef (copy
, NULL_TREE
);
1713 gimple_set_vuse (copy
, NULL_TREE
);
1716 gimple_seq_add_stmt (&stmts
, copy
);
1721 /* Copy basic block, scale profile accordingly. Edges will be taken care of
1725 copy_bb (copy_body_data
*id
, basic_block bb
, int frequency_scale
,
1726 gcov_type count_scale
)
1728 gimple_stmt_iterator gsi
, copy_gsi
, seq_gsi
;
1729 basic_block copy_basic_block
;
1734 /* Search for previous copied basic block. */
1737 prev
= prev
->prev_bb
;
1739 /* create_basic_block() will append every new block to
1740 basic_block_info automatically. */
1741 copy_basic_block
= create_basic_block (NULL
, (void *) 0,
1742 (basic_block
) prev
->aux
);
1743 copy_basic_block
->count
= apply_scale (bb
->count
, count_scale
);
1745 /* We are going to rebuild frequencies from scratch. These values
1746 have just small importance to drive canonicalize_loop_headers. */
1747 freq
= apply_scale ((gcov_type
)bb
->frequency
, frequency_scale
);
1749 /* We recompute frequencies after inlining, so this is quite safe. */
1750 if (freq
> BB_FREQ_MAX
)
1752 copy_basic_block
->frequency
= freq
;
1754 copy_gsi
= gsi_start_bb (copy_basic_block
);
1756 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1759 gimple stmt
= gsi_stmt (gsi
);
1760 gimple orig_stmt
= stmt
;
1761 gimple_stmt_iterator stmts_gsi
;
1762 bool stmt_added
= false;
1764 id
->regimplify
= false;
1765 stmts
= remap_gimple_stmt (stmt
, id
);
1767 if (gimple_seq_empty_p (stmts
))
1772 for (stmts_gsi
= gsi_start (stmts
);
1773 !gsi_end_p (stmts_gsi
); )
1775 stmt
= gsi_stmt (stmts_gsi
);
1777 /* Advance iterator now before stmt is moved to seq_gsi. */
1778 gsi_next (&stmts_gsi
);
1780 if (gimple_nop_p (stmt
))
1783 gimple_duplicate_stmt_histograms (cfun
, stmt
, id
->src_cfun
,
1786 /* With return slot optimization we can end up with
1787 non-gimple (foo *)&this->m, fix that here. */
1788 if (is_gimple_assign (stmt
)
1789 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
))
1790 && !is_gimple_val (gimple_assign_rhs1 (stmt
)))
1793 new_rhs
= force_gimple_operand_gsi (&seq_gsi
,
1794 gimple_assign_rhs1 (stmt
),
1796 GSI_CONTINUE_LINKING
);
1797 gimple_assign_set_rhs1 (stmt
, new_rhs
);
1798 id
->regimplify
= false;
1801 gsi_insert_after (&seq_gsi
, stmt
, GSI_NEW_STMT
);
1804 gimple_regimplify_operands (stmt
, &seq_gsi
);
1812 /* If copy_basic_block has been empty at the start of this iteration,
1813 call gsi_start_bb again to get at the newly added statements. */
1814 if (gsi_end_p (copy_gsi
))
1815 copy_gsi
= gsi_start_bb (copy_basic_block
);
1817 gsi_next (©_gsi
);
1819 /* Process the new statement. The call to gimple_regimplify_operands
1820 possibly turned the statement into multiple statements, we
1821 need to process all of them. */
1827 stmt
= gsi_stmt (copy_gsi
);
1828 call_stmt
= dyn_cast
<gcall
*> (stmt
);
1830 && gimple_call_va_arg_pack_p (call_stmt
)
1833 /* __builtin_va_arg_pack () should be replaced by
1834 all arguments corresponding to ... in the caller. */
1838 size_t nargs
= gimple_call_num_args (id
->call_stmt
);
1839 size_t n
, i
, nargs_to_copy
;
1840 bool remove_bounds
= false;
1842 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1845 /* Bounds should be removed from arg pack in case
1846 we handle not instrumented call in instrumented
1848 nargs_to_copy
= nargs
;
1849 if (gimple_call_with_bounds_p (id
->call_stmt
)
1850 && !gimple_call_with_bounds_p (stmt
))
1852 for (i
= gimple_call_num_args (id
->call_stmt
) - nargs
;
1853 i
< gimple_call_num_args (id
->call_stmt
);
1855 if (POINTER_BOUNDS_P (gimple_call_arg (id
->call_stmt
, i
)))
1857 remove_bounds
= true;
1860 /* Create the new array of arguments. */
1861 n
= nargs_to_copy
+ gimple_call_num_args (call_stmt
);
1862 argarray
.create (n
);
1863 argarray
.safe_grow_cleared (n
);
1865 /* Copy all the arguments before '...' */
1866 memcpy (argarray
.address (),
1867 gimple_call_arg_ptr (call_stmt
, 0),
1868 gimple_call_num_args (call_stmt
) * sizeof (tree
));
1872 /* Append the rest of arguments removing bounds. */
1873 unsigned cur
= gimple_call_num_args (call_stmt
);
1874 i
= gimple_call_num_args (id
->call_stmt
) - nargs
;
1875 for (i
= gimple_call_num_args (id
->call_stmt
) - nargs
;
1876 i
< gimple_call_num_args (id
->call_stmt
);
1878 if (!POINTER_BOUNDS_P (gimple_call_arg (id
->call_stmt
, i
)))
1879 argarray
[cur
++] = gimple_call_arg (id
->call_stmt
, i
);
1880 gcc_assert (cur
== n
);
1884 /* Append the arguments passed in '...' */
1885 memcpy (argarray
.address () + gimple_call_num_args (call_stmt
),
1886 gimple_call_arg_ptr (id
->call_stmt
, 0)
1887 + (gimple_call_num_args (id
->call_stmt
) - nargs
),
1888 nargs
* sizeof (tree
));
1891 new_call
= gimple_build_call_vec (gimple_call_fn (call_stmt
),
1894 argarray
.release ();
1896 /* Copy all GIMPLE_CALL flags, location and block, except
1897 GF_CALL_VA_ARG_PACK. */
1898 gimple_call_copy_flags (new_call
, call_stmt
);
1899 gimple_call_set_va_arg_pack (new_call
, false);
1900 gimple_set_location (new_call
, gimple_location (stmt
));
1901 gimple_set_block (new_call
, gimple_block (stmt
));
1902 gimple_call_set_lhs (new_call
, gimple_call_lhs (call_stmt
));
1904 gsi_replace (©_gsi
, new_call
, false);
1907 else if (is_gimple_call (stmt
)
1909 && (decl
= gimple_call_fndecl (stmt
))
1910 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
1911 && DECL_FUNCTION_CODE (decl
) == BUILT_IN_VA_ARG_PACK_LEN
)
1913 /* __builtin_va_arg_pack_len () should be replaced by
1914 the number of anonymous arguments. */
1915 size_t nargs
= gimple_call_num_args (id
->call_stmt
), i
;
1919 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1922 /* For instrumented calls we should ignore bounds. */
1923 for (i
= gimple_call_num_args (id
->call_stmt
) - nargs
;
1924 i
< gimple_call_num_args (id
->call_stmt
);
1926 if (POINTER_BOUNDS_P (gimple_call_arg (id
->call_stmt
, i
)))
1929 count
= build_int_cst (integer_type_node
, nargs
);
1930 new_stmt
= gimple_build_assign (gimple_call_lhs (stmt
), count
);
1931 gsi_replace (©_gsi
, new_stmt
, false);
1935 /* Statements produced by inlining can be unfolded, especially
1936 when we constant propagated some operands. We can't fold
1937 them right now for two reasons:
1938 1) folding require SSA_NAME_DEF_STMTs to be correct
1939 2) we can't change function calls to builtins.
1940 So we just mark statement for later folding. We mark
1941 all new statements, instead just statements that has changed
1942 by some nontrivial substitution so even statements made
1943 foldable indirectly are updated. If this turns out to be
1944 expensive, copy_body can be told to watch for nontrivial
1946 if (id
->statements_to_fold
)
1947 id
->statements_to_fold
->add (stmt
);
1949 /* We're duplicating a CALL_EXPR. Find any corresponding
1950 callgraph edges and update or duplicate them. */
1951 if (gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
))
1953 struct cgraph_edge
*edge
;
1955 switch (id
->transform_call_graph_edges
)
1957 case CB_CGE_DUPLICATE
:
1958 edge
= id
->src_node
->get_edge (orig_stmt
);
1961 int edge_freq
= edge
->frequency
;
1963 struct cgraph_edge
*old_edge
= edge
;
1964 edge
= edge
->clone (id
->dst_node
, call_stmt
,
1966 REG_BR_PROB_BASE
, CGRAPH_FREQ_BASE
,
1968 /* We could also just rescale the frequency, but
1969 doing so would introduce roundoff errors and make
1970 verifier unhappy. */
1971 new_freq
= compute_call_stmt_bb_frequency (id
->dst_node
->decl
,
1974 /* Speculative calls consist of two edges - direct and indirect.
1975 Duplicate the whole thing and distribute frequencies accordingly. */
1976 if (edge
->speculative
)
1978 struct cgraph_edge
*direct
, *indirect
;
1979 struct ipa_ref
*ref
;
1981 gcc_assert (!edge
->indirect_unknown_callee
);
1982 old_edge
->speculative_call_info (direct
, indirect
, ref
);
1983 indirect
= indirect
->clone (id
->dst_node
, call_stmt
,
1985 REG_BR_PROB_BASE
, CGRAPH_FREQ_BASE
,
1987 if (old_edge
->frequency
+ indirect
->frequency
)
1989 edge
->frequency
= MIN (RDIV ((gcov_type
)new_freq
* old_edge
->frequency
,
1990 (old_edge
->frequency
+ indirect
->frequency
)),
1992 indirect
->frequency
= MIN (RDIV ((gcov_type
)new_freq
* indirect
->frequency
,
1993 (old_edge
->frequency
+ indirect
->frequency
)),
1996 id
->dst_node
->clone_reference (ref
, stmt
);
2000 edge
->frequency
= new_freq
;
2002 && profile_status_for_fn (cfun
) != PROFILE_ABSENT
2003 && (edge_freq
> edge
->frequency
+ 10
2004 || edge_freq
< edge
->frequency
- 10))
2006 fprintf (dump_file
, "Edge frequency estimated by "
2007 "cgraph %i diverge from inliner's estimate %i\n",
2011 "Orig bb: %i, orig bb freq %i, new bb freq %i\n",
2014 copy_basic_block
->frequency
);
2020 case CB_CGE_MOVE_CLONES
:
2021 id
->dst_node
->set_call_stmt_including_clones (orig_stmt
,
2023 edge
= id
->dst_node
->get_edge (stmt
);
2027 edge
= id
->dst_node
->get_edge (orig_stmt
);
2029 edge
->set_call_stmt (call_stmt
);
2036 /* Constant propagation on argument done during inlining
2037 may create new direct call. Produce an edge for it. */
2039 || (edge
->indirect_inlining_edge
2040 && id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
))
2041 && id
->dst_node
->definition
2042 && (fn
= gimple_call_fndecl (stmt
)) != NULL
)
2044 struct cgraph_node
*dest
= cgraph_node::get (fn
);
2046 /* We have missing edge in the callgraph. This can happen
2047 when previous inlining turned an indirect call into a
2048 direct call by constant propagating arguments or we are
2049 producing dead clone (for further cloning). In all
2050 other cases we hit a bug (incorrect node sharing is the
2051 most common reason for missing edges). */
2052 gcc_assert (!dest
->definition
2053 || dest
->address_taken
2054 || !id
->src_node
->definition
2055 || !id
->dst_node
->definition
);
2056 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
)
2057 id
->dst_node
->create_edge_including_clones
2058 (dest
, orig_stmt
, call_stmt
, bb
->count
,
2059 compute_call_stmt_bb_frequency (id
->dst_node
->decl
,
2061 CIF_ORIGINALLY_INDIRECT_CALL
);
2063 id
->dst_node
->create_edge (dest
, call_stmt
,
2065 compute_call_stmt_bb_frequency
2066 (id
->dst_node
->decl
,
2067 copy_basic_block
))->inline_failed
2068 = CIF_ORIGINALLY_INDIRECT_CALL
;
2071 fprintf (dump_file
, "Created new direct edge to %s\n",
2076 notice_special_calls (as_a
<gcall
*> (stmt
));
2079 maybe_duplicate_eh_stmt_fn (cfun
, stmt
, id
->src_cfun
, orig_stmt
,
2080 id
->eh_map
, id
->eh_lp_nr
);
2082 if (gimple_in_ssa_p (cfun
) && !is_gimple_debug (stmt
))
2087 FOR_EACH_SSA_TREE_OPERAND (def
, stmt
, i
, SSA_OP_DEF
)
2088 if (TREE_CODE (def
) == SSA_NAME
)
2089 SSA_NAME_DEF_STMT (def
) = stmt
;
2092 gsi_next (©_gsi
);
2094 while (!gsi_end_p (copy_gsi
));
2096 copy_gsi
= gsi_last_bb (copy_basic_block
);
2099 return copy_basic_block
;
2102 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
2103 form is quite easy, since dominator relationship for old basic blocks does
2106 There is however exception where inlining might change dominator relation
2107 across EH edges from basic block within inlined functions destinating
2108 to landing pads in function we inline into.
2110 The function fills in PHI_RESULTs of such PHI nodes if they refer
2111 to gimple regs. Otherwise, the function mark PHI_RESULT of such
2112 PHI nodes for renaming. For non-gimple regs, renaming is safe: the
2113 EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
2114 set, and this means that there will be no overlapping live ranges
2115 for the underlying symbol.
2117 This might change in future if we allow redirecting of EH edges and
2118 we might want to change way build CFG pre-inlining to include
2119 all the possible edges then. */
2121 update_ssa_across_abnormal_edges (basic_block bb
, basic_block ret_bb
,
2122 bool can_throw
, bool nonlocal_goto
)
2127 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
2129 || ((basic_block
)e
->dest
->aux
)->index
== ENTRY_BLOCK
)
2135 gcc_assert (e
->flags
& EDGE_EH
);
2138 gcc_assert (!(e
->flags
& EDGE_EH
));
2140 for (si
= gsi_start_phis (e
->dest
); !gsi_end_p (si
); gsi_next (&si
))
2146 /* For abnormal goto/call edges the receiver can be the
2147 ENTRY_BLOCK. Do not assert this cannot happen. */
2149 gcc_assert ((e
->flags
& EDGE_EH
)
2150 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi
)));
2152 re
= find_edge (ret_bb
, e
->dest
);
2153 gcc_checking_assert (re
);
2154 gcc_assert ((re
->flags
& (EDGE_EH
| EDGE_ABNORMAL
))
2155 == (e
->flags
& (EDGE_EH
| EDGE_ABNORMAL
)));
2157 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, e
),
2158 USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, re
)));
2164 /* Copy edges from BB into its copy constructed earlier, scale profile
2165 accordingly. Edges will be taken care of later. Assume aux
2166 pointers to point to the copies of each BB. Return true if any
2167 debug stmts are left after a statement that must end the basic block. */
2170 copy_edges_for_bb (basic_block bb
, gcov_type count_scale
, basic_block ret_bb
,
2171 basic_block abnormal_goto_dest
)
2173 basic_block new_bb
= (basic_block
) bb
->aux
;
2176 gimple_stmt_iterator si
;
2178 bool need_debug_cleanup
= false;
2180 /* Use the indices from the original blocks to create edges for the
2182 FOR_EACH_EDGE (old_edge
, ei
, bb
->succs
)
2183 if (!(old_edge
->flags
& EDGE_EH
))
2187 flags
= old_edge
->flags
;
2189 /* Return edges do get a FALLTHRU flag when the get inlined. */
2190 if (old_edge
->dest
->index
== EXIT_BLOCK
2191 && !(old_edge
->flags
& (EDGE_TRUE_VALUE
|EDGE_FALSE_VALUE
|EDGE_FAKE
))
2192 && old_edge
->dest
->aux
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
2193 flags
|= EDGE_FALLTHRU
;
2194 new_edge
= make_edge (new_bb
, (basic_block
) old_edge
->dest
->aux
, flags
);
2195 new_edge
->count
= apply_scale (old_edge
->count
, count_scale
);
2196 new_edge
->probability
= old_edge
->probability
;
2199 if (bb
->index
== ENTRY_BLOCK
|| bb
->index
== EXIT_BLOCK
)
2202 for (si
= gsi_start_bb (new_bb
); !gsi_end_p (si
);)
2205 bool can_throw
, nonlocal_goto
;
2207 copy_stmt
= gsi_stmt (si
);
2208 if (!is_gimple_debug (copy_stmt
))
2209 update_stmt (copy_stmt
);
2211 /* Do this before the possible split_block. */
2214 /* If this tree could throw an exception, there are two
2215 cases where we need to add abnormal edge(s): the
2216 tree wasn't in a region and there is a "current
2217 region" in the caller; or the original tree had
2218 EH edges. In both cases split the block after the tree,
2219 and add abnormal edge(s) as needed; we need both
2220 those from the callee and the caller.
2221 We check whether the copy can throw, because the const
2222 propagation can change an INDIRECT_REF which throws
2223 into a COMPONENT_REF which doesn't. If the copy
2224 can throw, the original could also throw. */
2225 can_throw
= stmt_can_throw_internal (copy_stmt
);
2227 = (stmt_can_make_abnormal_goto (copy_stmt
)
2228 && !computed_goto_p (copy_stmt
));
2230 if (can_throw
|| nonlocal_goto
)
2232 if (!gsi_end_p (si
))
2234 while (!gsi_end_p (si
) && is_gimple_debug (gsi_stmt (si
)))
2237 need_debug_cleanup
= true;
2239 if (!gsi_end_p (si
))
2240 /* Note that bb's predecessor edges aren't necessarily
2241 right at this point; split_block doesn't care. */
2243 edge e
= split_block (new_bb
, copy_stmt
);
2246 new_bb
->aux
= e
->src
->aux
;
2247 si
= gsi_start_bb (new_bb
);
2251 if (gimple_code (copy_stmt
) == GIMPLE_EH_DISPATCH
)
2252 make_eh_dispatch_edges (as_a
<geh_dispatch
*> (copy_stmt
));
2254 make_eh_edges (copy_stmt
);
2256 /* If the call we inline cannot make abnormal goto do not add
2257 additional abnormal edges but only retain those already present
2258 in the original function body. */
2259 if (abnormal_goto_dest
== NULL
)
2260 nonlocal_goto
= false;
2263 basic_block copy_stmt_bb
= gimple_bb (copy_stmt
);
2265 if (get_abnormal_succ_dispatcher (copy_stmt_bb
))
2266 nonlocal_goto
= false;
2267 /* ABNORMAL_DISPATCHER (1) is for longjmp/setjmp or nonlocal gotos
2268 in OpenMP regions which aren't allowed to be left abnormally.
2269 So, no need to add abnormal edge in that case. */
2270 else if (is_gimple_call (copy_stmt
)
2271 && gimple_call_internal_p (copy_stmt
)
2272 && (gimple_call_internal_fn (copy_stmt
)
2273 == IFN_ABNORMAL_DISPATCHER
)
2274 && gimple_call_arg (copy_stmt
, 0) == boolean_true_node
)
2275 nonlocal_goto
= false;
2277 make_edge (copy_stmt_bb
, abnormal_goto_dest
, EDGE_ABNORMAL
);
2280 if ((can_throw
|| nonlocal_goto
)
2281 && gimple_in_ssa_p (cfun
))
2282 update_ssa_across_abnormal_edges (gimple_bb (copy_stmt
), ret_bb
,
2283 can_throw
, nonlocal_goto
);
2285 return need_debug_cleanup
;
2288 /* Copy the PHIs. All blocks and edges are copied, some blocks
2289 was possibly split and new outgoing EH edges inserted.
2290 BB points to the block of original function and AUX pointers links
2291 the original and newly copied blocks. */
2294 copy_phis_for_bb (basic_block bb
, copy_body_data
*id
)
2296 basic_block
const new_bb
= (basic_block
) bb
->aux
;
2301 bool inserted
= false;
2303 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
2309 res
= PHI_RESULT (phi
);
2311 if (!virtual_operand_p (res
))
2313 walk_tree (&new_res
, copy_tree_body_r
, id
, NULL
);
2314 new_phi
= create_phi_node (new_res
, new_bb
);
2315 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2317 edge old_edge
= find_edge ((basic_block
) new_edge
->src
->aux
, bb
);
2323 /* When doing partial cloning, we allow PHIs on the entry block
2324 as long as all the arguments are the same. Find any input
2325 edge to see argument to copy. */
2327 FOR_EACH_EDGE (old_edge
, ei2
, bb
->preds
)
2328 if (!old_edge
->src
->aux
)
2331 arg
= PHI_ARG_DEF_FROM_EDGE (phi
, old_edge
);
2333 walk_tree (&new_arg
, copy_tree_body_r
, id
, NULL
);
2334 gcc_assert (new_arg
);
2335 /* With return slot optimization we can end up with
2336 non-gimple (foo *)&this->m, fix that here. */
2337 if (TREE_CODE (new_arg
) != SSA_NAME
2338 && TREE_CODE (new_arg
) != FUNCTION_DECL
2339 && !is_gimple_val (new_arg
))
2341 gimple_seq stmts
= NULL
;
2342 new_arg
= force_gimple_operand (new_arg
, &stmts
, true, NULL
);
2343 gsi_insert_seq_on_edge (new_edge
, stmts
);
2346 locus
= gimple_phi_arg_location_from_edge (phi
, old_edge
);
2347 if (LOCATION_BLOCK (locus
))
2350 n
= id
->decl_map
->get (LOCATION_BLOCK (locus
));
2353 locus
= COMBINE_LOCATION_DATA (line_table
, locus
, *n
);
2355 locus
= LOCATION_LOCUS (locus
);
2358 locus
= LOCATION_LOCUS (locus
);
2360 add_phi_arg (new_phi
, new_arg
, new_edge
, locus
);
2365 /* Commit the delayed edge insertions. */
2367 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2368 gsi_commit_one_edge_insert (new_edge
, NULL
);
2372 /* Wrapper for remap_decl so it can be used as a callback. */
2375 remap_decl_1 (tree decl
, void *data
)
2377 return remap_decl (decl
, (copy_body_data
*) data
);
2380 /* Build struct function and associated datastructures for the new clone
2381 NEW_FNDECL to be build. CALLEE_FNDECL is the original. Function changes
2382 the cfun to the function of new_fndecl (and current_function_decl too). */
2385 initialize_cfun (tree new_fndecl
, tree callee_fndecl
, gcov_type count
)
2387 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2388 gcov_type count_scale
;
2390 if (!DECL_ARGUMENTS (new_fndecl
))
2391 DECL_ARGUMENTS (new_fndecl
) = DECL_ARGUMENTS (callee_fndecl
);
2392 if (!DECL_RESULT (new_fndecl
))
2393 DECL_RESULT (new_fndecl
) = DECL_RESULT (callee_fndecl
);
2395 if (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
)
2397 = GCOV_COMPUTE_SCALE (count
,
2398 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
);
2400 count_scale
= REG_BR_PROB_BASE
;
2402 /* Register specific tree functions. */
2403 gimple_register_cfg_hooks ();
2405 /* Get clean struct function. */
2406 push_struct_function (new_fndecl
);
2408 /* We will rebuild these, so just sanity check that they are empty. */
2409 gcc_assert (VALUE_HISTOGRAMS (cfun
) == NULL
);
2410 gcc_assert (cfun
->local_decls
== NULL
);
2411 gcc_assert (cfun
->cfg
== NULL
);
2412 gcc_assert (cfun
->decl
== new_fndecl
);
2414 /* Copy items we preserve during cloning. */
2415 cfun
->static_chain_decl
= src_cfun
->static_chain_decl
;
2416 cfun
->nonlocal_goto_save_area
= src_cfun
->nonlocal_goto_save_area
;
2417 cfun
->function_end_locus
= src_cfun
->function_end_locus
;
2418 cfun
->curr_properties
= src_cfun
->curr_properties
;
2419 cfun
->last_verified
= src_cfun
->last_verified
;
2420 cfun
->va_list_gpr_size
= src_cfun
->va_list_gpr_size
;
2421 cfun
->va_list_fpr_size
= src_cfun
->va_list_fpr_size
;
2422 cfun
->has_nonlocal_label
= src_cfun
->has_nonlocal_label
;
2423 cfun
->stdarg
= src_cfun
->stdarg
;
2424 cfun
->after_inlining
= src_cfun
->after_inlining
;
2425 cfun
->can_throw_non_call_exceptions
2426 = src_cfun
->can_throw_non_call_exceptions
;
2427 cfun
->can_delete_dead_exceptions
= src_cfun
->can_delete_dead_exceptions
;
2428 cfun
->returns_struct
= src_cfun
->returns_struct
;
2429 cfun
->returns_pcc_struct
= src_cfun
->returns_pcc_struct
;
2431 init_empty_tree_cfg ();
2433 profile_status_for_fn (cfun
) = profile_status_for_fn (src_cfun
);
2434 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
=
2435 (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
* count_scale
/
2437 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
2438 = ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->frequency
;
2439 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
=
2440 (EXIT_BLOCK_PTR_FOR_FN (src_cfun
)->count
* count_scale
/
2442 EXIT_BLOCK_PTR_FOR_FN (cfun
)->frequency
=
2443 EXIT_BLOCK_PTR_FOR_FN (src_cfun
)->frequency
;
2445 init_eh_for_function ();
2447 if (src_cfun
->gimple_df
)
2449 init_tree_ssa (cfun
);
2450 cfun
->gimple_df
->in_ssa_p
= true;
2451 init_ssa_operands (cfun
);
2455 /* Helper function for copy_cfg_body. Move debug stmts from the end
2456 of NEW_BB to the beginning of successor basic blocks when needed. If the
2457 successor has multiple predecessors, reset them, otherwise keep
2461 maybe_move_debug_stmts_to_successors (copy_body_data
*id
, basic_block new_bb
)
2465 gimple_stmt_iterator si
= gsi_last_nondebug_bb (new_bb
);
2468 || gsi_one_before_end_p (si
)
2469 || !(stmt_can_throw_internal (gsi_stmt (si
))
2470 || stmt_can_make_abnormal_goto (gsi_stmt (si
))))
2473 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
2475 gimple_stmt_iterator ssi
= gsi_last_bb (new_bb
);
2476 gimple_stmt_iterator dsi
= gsi_after_labels (e
->dest
);
2477 while (is_gimple_debug (gsi_stmt (ssi
)))
2479 gimple stmt
= gsi_stmt (ssi
);
2484 /* For the last edge move the debug stmts instead of copying
2486 if (ei_one_before_end_p (ei
))
2490 if (!single_pred_p (e
->dest
) && gimple_debug_bind_p (stmt
))
2491 gimple_debug_bind_reset_value (stmt
);
2492 gsi_remove (&si
, false);
2493 gsi_insert_before (&dsi
, stmt
, GSI_SAME_STMT
);
2497 if (gimple_debug_bind_p (stmt
))
2499 var
= gimple_debug_bind_get_var (stmt
);
2500 if (single_pred_p (e
->dest
))
2502 value
= gimple_debug_bind_get_value (stmt
);
2503 value
= unshare_expr (value
);
2507 new_stmt
= gimple_build_debug_bind (var
, value
, stmt
);
2509 else if (gimple_debug_source_bind_p (stmt
))
2511 var
= gimple_debug_source_bind_get_var (stmt
);
2512 value
= gimple_debug_source_bind_get_value (stmt
);
2513 new_stmt
= gimple_build_debug_source_bind (var
, value
, stmt
);
2517 gsi_insert_before (&dsi
, new_stmt
, GSI_SAME_STMT
);
2518 id
->debug_stmts
.safe_push (new_stmt
);
2524 /* Make a copy of the sub-loops of SRC_PARENT and place them
2525 as siblings of DEST_PARENT. */
2528 copy_loops (copy_body_data
*id
,
2529 struct loop
*dest_parent
, struct loop
*src_parent
)
2531 struct loop
*src_loop
= src_parent
->inner
;
2534 if (!id
->blocks_to_copy
2535 || bitmap_bit_p (id
->blocks_to_copy
, src_loop
->header
->index
))
2537 struct loop
*dest_loop
= alloc_loop ();
2539 /* Assign the new loop its header and latch and associate
2540 those with the new loop. */
2541 dest_loop
->header
= (basic_block
)src_loop
->header
->aux
;
2542 dest_loop
->header
->loop_father
= dest_loop
;
2543 if (src_loop
->latch
!= NULL
)
2545 dest_loop
->latch
= (basic_block
)src_loop
->latch
->aux
;
2546 dest_loop
->latch
->loop_father
= dest_loop
;
2549 /* Copy loop meta-data. */
2550 copy_loop_info (src_loop
, dest_loop
);
2552 /* Finally place it into the loop array and the loop tree. */
2553 place_new_loop (cfun
, dest_loop
);
2554 flow_loop_tree_node_add (dest_parent
, dest_loop
);
2556 dest_loop
->safelen
= src_loop
->safelen
;
2557 dest_loop
->dont_vectorize
= src_loop
->dont_vectorize
;
2558 if (src_loop
->force_vectorize
)
2560 dest_loop
->force_vectorize
= true;
2561 cfun
->has_force_vectorize_loops
= true;
2563 if (src_loop
->simduid
)
2565 dest_loop
->simduid
= remap_decl (src_loop
->simduid
, id
);
2566 cfun
->has_simduid_loops
= true;
2570 copy_loops (id
, dest_loop
, src_loop
);
2572 src_loop
= src_loop
->next
;
2576 /* Call cgraph_redirect_edge_call_stmt_to_callee on all calls in BB */
2579 redirect_all_calls (copy_body_data
* id
, basic_block bb
)
2581 gimple_stmt_iterator si
;
2582 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
2584 if (is_gimple_call (gsi_stmt (si
)))
2586 struct cgraph_edge
*edge
= id
->dst_node
->get_edge (gsi_stmt (si
));
2588 edge
->redirect_call_stmt_to_callee ();
2593 /* Convert estimated frequencies into counts for NODE, scaling COUNT
2594 with each bb's frequency. Used when NODE has a 0-weight entry
2595 but we are about to inline it into a non-zero count call bb.
2596 See the comments for handle_missing_profiles() in predict.c for
2597 when this can happen for COMDATs. */
2600 freqs_to_counts (struct cgraph_node
*node
, gcov_type count
)
2605 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
2607 FOR_ALL_BB_FN(bb
, fn
)
2609 bb
->count
= apply_scale (count
,
2610 GCOV_COMPUTE_SCALE (bb
->frequency
, BB_FREQ_MAX
));
2611 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
2612 e
->count
= apply_probability (e
->src
->count
, e
->probability
);
2616 /* Make a copy of the body of FN so that it can be inserted inline in
2617 another function. Walks FN via CFG, returns new fndecl. */
2620 copy_cfg_body (copy_body_data
* id
, gcov_type count
, int frequency_scale
,
2621 basic_block entry_block_map
, basic_block exit_block_map
,
2622 basic_block new_entry
)
2624 tree callee_fndecl
= id
->src_fn
;
2625 /* Original cfun for the callee, doesn't change. */
2626 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2627 struct function
*cfun_to_copy
;
2629 tree new_fndecl
= NULL
;
2630 bool need_debug_cleanup
= false;
2631 gcov_type count_scale
;
2633 int incoming_frequency
= 0;
2634 gcov_type incoming_count
= 0;
2636 /* This can happen for COMDAT routines that end up with 0 counts
2637 despite being called (see the comments for handle_missing_profiles()
2638 in predict.c as to why). Apply counts to the blocks in the callee
2639 before inlining, using the guessed edge frequencies, so that we don't
2640 end up with a 0-count inline body which can confuse downstream
2641 optimizations such as function splitting. */
2642 if (!ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
&& count
)
2644 /* Apply the larger of the call bb count and the total incoming
2645 call edge count to the callee. */
2646 gcov_type in_count
= 0;
2647 struct cgraph_edge
*in_edge
;
2648 for (in_edge
= id
->src_node
->callers
; in_edge
;
2649 in_edge
= in_edge
->next_caller
)
2650 in_count
+= in_edge
->count
;
2651 freqs_to_counts (id
->src_node
, count
> in_count
? count
: in_count
);
2654 if (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
)
2656 = GCOV_COMPUTE_SCALE (count
,
2657 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
);
2659 count_scale
= REG_BR_PROB_BASE
;
2661 /* Register specific tree functions. */
2662 gimple_register_cfg_hooks ();
2664 /* If we are inlining just region of the function, make sure to connect
2665 new entry to ENTRY_BLOCK_PTR_FOR_FN (cfun). Since new entry can be
2666 part of loop, we must compute frequency and probability of
2667 ENTRY_BLOCK_PTR_FOR_FN (cfun) based on the frequencies and
2668 probabilities of edges incoming from nonduplicated region. */
2674 FOR_EACH_EDGE (e
, ei
, new_entry
->preds
)
2677 incoming_frequency
+= EDGE_FREQUENCY (e
);
2678 incoming_count
+= e
->count
;
2680 incoming_count
= apply_scale (incoming_count
, count_scale
);
2682 = apply_scale ((gcov_type
)incoming_frequency
, frequency_scale
);
2683 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= incoming_count
;
2684 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
= incoming_frequency
;
2687 /* Must have a CFG here at this point. */
2688 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN
2689 (DECL_STRUCT_FUNCTION (callee_fndecl
)));
2691 cfun_to_copy
= id
->src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2693 ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy
)->aux
= entry_block_map
;
2694 EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy
)->aux
= exit_block_map
;
2695 entry_block_map
->aux
= ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy
);
2696 exit_block_map
->aux
= EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy
);
2698 /* Duplicate any exception-handling regions. */
2700 id
->eh_map
= duplicate_eh_regions (cfun_to_copy
, NULL
, id
->eh_lp_nr
,
2703 /* Use aux pointers to map the original blocks to copy. */
2704 FOR_EACH_BB_FN (bb
, cfun_to_copy
)
2705 if (!id
->blocks_to_copy
|| bitmap_bit_p (id
->blocks_to_copy
, bb
->index
))
2707 basic_block new_bb
= copy_bb (id
, bb
, frequency_scale
, count_scale
);
2710 new_bb
->loop_father
= entry_block_map
->loop_father
;
2713 last
= last_basic_block_for_fn (cfun
);
2715 /* Now that we've duplicated the blocks, duplicate their edges. */
2716 basic_block abnormal_goto_dest
= NULL
;
2718 && stmt_can_make_abnormal_goto (id
->call_stmt
))
2720 gimple_stmt_iterator gsi
= gsi_for_stmt (id
->call_stmt
);
2722 bb
= gimple_bb (id
->call_stmt
);
2724 if (gsi_end_p (gsi
))
2725 abnormal_goto_dest
= get_abnormal_succ_dispatcher (bb
);
2727 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2728 if (!id
->blocks_to_copy
2729 || (bb
->index
> 0 && bitmap_bit_p (id
->blocks_to_copy
, bb
->index
)))
2730 need_debug_cleanup
|= copy_edges_for_bb (bb
, count_scale
, exit_block_map
,
2731 abnormal_goto_dest
);
2735 edge e
= make_edge (entry_block_map
, (basic_block
)new_entry
->aux
, EDGE_FALLTHRU
);
2736 e
->probability
= REG_BR_PROB_BASE
;
2737 e
->count
= incoming_count
;
2740 /* Duplicate the loop tree, if available and wanted. */
2741 if (loops_for_fn (src_cfun
) != NULL
2742 && current_loops
!= NULL
)
2744 copy_loops (id
, entry_block_map
->loop_father
,
2745 get_loop (src_cfun
, 0));
2746 /* Defer to cfgcleanup to update loop-father fields of basic-blocks. */
2747 loops_state_set (LOOPS_NEED_FIXUP
);
2750 /* If the loop tree in the source function needed fixup, mark the
2751 destination loop tree for fixup, too. */
2752 if (loops_for_fn (src_cfun
)->state
& LOOPS_NEED_FIXUP
)
2753 loops_state_set (LOOPS_NEED_FIXUP
);
2755 if (gimple_in_ssa_p (cfun
))
2756 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2757 if (!id
->blocks_to_copy
2758 || (bb
->index
> 0 && bitmap_bit_p (id
->blocks_to_copy
, bb
->index
)))
2759 copy_phis_for_bb (bb
, id
);
2761 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2764 if (need_debug_cleanup
2765 && bb
->index
!= ENTRY_BLOCK
2766 && bb
->index
!= EXIT_BLOCK
)
2767 maybe_move_debug_stmts_to_successors (id
, (basic_block
) bb
->aux
);
2768 /* Update call edge destinations. This can not be done before loop
2769 info is updated, because we may split basic blocks. */
2770 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
)
2771 redirect_all_calls (id
, (basic_block
)bb
->aux
);
2772 ((basic_block
)bb
->aux
)->aux
= NULL
;
2776 /* Zero out AUX fields of newly created block during EH edge
2778 for (; last
< last_basic_block_for_fn (cfun
); last
++)
2780 if (need_debug_cleanup
)
2781 maybe_move_debug_stmts_to_successors (id
,
2782 BASIC_BLOCK_FOR_FN (cfun
, last
));
2783 BASIC_BLOCK_FOR_FN (cfun
, last
)->aux
= NULL
;
2784 /* Update call edge destinations. This can not be done before loop
2785 info is updated, because we may split basic blocks. */
2786 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
)
2787 redirect_all_calls (id
, BASIC_BLOCK_FOR_FN (cfun
, last
));
2789 entry_block_map
->aux
= NULL
;
2790 exit_block_map
->aux
= NULL
;
2797 if (id
->dependence_map
)
2799 delete id
->dependence_map
;
2800 id
->dependence_map
= NULL
;
2806 /* Copy the debug STMT using ID. We deal with these statements in a
2807 special way: if any variable in their VALUE expression wasn't
2808 remapped yet, we won't remap it, because that would get decl uids
2809 out of sync, causing codegen differences between -g and -g0. If
2810 this arises, we drop the VALUE expression altogether. */
2813 copy_debug_stmt (gdebug
*stmt
, copy_body_data
*id
)
2816 struct walk_stmt_info wi
;
2818 if (gimple_block (stmt
))
2820 n
= id
->decl_map
->get (gimple_block (stmt
));
2821 gimple_set_block (stmt
, n
? *n
: id
->block
);
2824 /* Remap all the operands in COPY. */
2825 memset (&wi
, 0, sizeof (wi
));
2828 processing_debug_stmt
= 1;
2830 if (gimple_debug_source_bind_p (stmt
))
2831 t
= gimple_debug_source_bind_get_var (stmt
);
2833 t
= gimple_debug_bind_get_var (stmt
);
2835 if (TREE_CODE (t
) == PARM_DECL
&& id
->debug_map
2836 && (n
= id
->debug_map
->get (t
)))
2838 gcc_assert (TREE_CODE (*n
) == VAR_DECL
);
2841 else if (TREE_CODE (t
) == VAR_DECL
2842 && !is_global_var (t
)
2843 && !id
->decl_map
->get (t
))
2844 /* T is a non-localized variable. */;
2846 walk_tree (&t
, remap_gimple_op_r
, &wi
, NULL
);
2848 if (gimple_debug_bind_p (stmt
))
2850 gimple_debug_bind_set_var (stmt
, t
);
2852 if (gimple_debug_bind_has_value_p (stmt
))
2853 walk_tree (gimple_debug_bind_get_value_ptr (stmt
),
2854 remap_gimple_op_r
, &wi
, NULL
);
2856 /* Punt if any decl couldn't be remapped. */
2857 if (processing_debug_stmt
< 0)
2858 gimple_debug_bind_reset_value (stmt
);
2860 else if (gimple_debug_source_bind_p (stmt
))
2862 gimple_debug_source_bind_set_var (stmt
, t
);
2863 walk_tree (gimple_debug_source_bind_get_value_ptr (stmt
),
2864 remap_gimple_op_r
, &wi
, NULL
);
2865 /* When inlining and source bind refers to one of the optimized
2866 away parameters, change the source bind into normal debug bind
2867 referring to the corresponding DEBUG_EXPR_DECL that should have
2868 been bound before the call stmt. */
2869 t
= gimple_debug_source_bind_get_value (stmt
);
2871 && TREE_CODE (t
) == PARM_DECL
2874 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (id
->src_fn
);
2876 if (debug_args
!= NULL
)
2878 for (i
= 0; i
< vec_safe_length (*debug_args
); i
+= 2)
2879 if ((**debug_args
)[i
] == DECL_ORIGIN (t
)
2880 && TREE_CODE ((**debug_args
)[i
+ 1]) == DEBUG_EXPR_DECL
)
2882 t
= (**debug_args
)[i
+ 1];
2883 stmt
->subcode
= GIMPLE_DEBUG_BIND
;
2884 gimple_debug_bind_set_value (stmt
, t
);
2891 processing_debug_stmt
= 0;
2896 /* Process deferred debug stmts. In order to give values better odds
2897 of being successfully remapped, we delay the processing of debug
2898 stmts until all other stmts that might require remapping are
2902 copy_debug_stmts (copy_body_data
*id
)
2907 if (!id
->debug_stmts
.exists ())
2910 FOR_EACH_VEC_ELT (id
->debug_stmts
, i
, stmt
)
2911 copy_debug_stmt (stmt
, id
);
2913 id
->debug_stmts
.release ();
2916 /* Make a copy of the body of SRC_FN so that it can be inserted inline in
2917 another function. */
2920 copy_tree_body (copy_body_data
*id
)
2922 tree fndecl
= id
->src_fn
;
2923 tree body
= DECL_SAVED_TREE (fndecl
);
2925 walk_tree (&body
, copy_tree_body_r
, id
, NULL
);
2930 /* Make a copy of the body of FN so that it can be inserted inline in
2931 another function. */
2934 copy_body (copy_body_data
*id
, gcov_type count
, int frequency_scale
,
2935 basic_block entry_block_map
, basic_block exit_block_map
,
2936 basic_block new_entry
)
2938 tree fndecl
= id
->src_fn
;
2941 /* If this body has a CFG, walk CFG and copy. */
2942 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (fndecl
)));
2943 body
= copy_cfg_body (id
, count
, frequency_scale
, entry_block_map
, exit_block_map
,
2945 copy_debug_stmts (id
);
2950 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
2951 defined in function FN, or of a data member thereof. */
2954 self_inlining_addr_expr (tree value
, tree fn
)
2958 if (TREE_CODE (value
) != ADDR_EXPR
)
2961 var
= get_base_address (TREE_OPERAND (value
, 0));
2963 return var
&& auto_var_in_fn_p (var
, fn
);
2966 /* Append to BB a debug annotation that binds VAR to VALUE, inheriting
2967 lexical block and line number information from base_stmt, if given,
2968 or from the last stmt of the block otherwise. */
2971 insert_init_debug_bind (copy_body_data
*id
,
2972 basic_block bb
, tree var
, tree value
,
2976 gimple_stmt_iterator gsi
;
2979 if (!gimple_in_ssa_p (id
->src_cfun
))
2982 if (!MAY_HAVE_DEBUG_STMTS
)
2985 tracked_var
= target_for_debug_bind (var
);
2991 gsi
= gsi_last_bb (bb
);
2992 if (!base_stmt
&& !gsi_end_p (gsi
))
2993 base_stmt
= gsi_stmt (gsi
);
2996 note
= gimple_build_debug_bind (tracked_var
, value
, base_stmt
);
3000 if (!gsi_end_p (gsi
))
3001 gsi_insert_after (&gsi
, note
, GSI_SAME_STMT
);
3003 gsi_insert_before (&gsi
, note
, GSI_SAME_STMT
);
3010 insert_init_stmt (copy_body_data
*id
, basic_block bb
, gimple init_stmt
)
3012 /* If VAR represents a zero-sized variable, it's possible that the
3013 assignment statement may result in no gimple statements. */
3016 gimple_stmt_iterator si
= gsi_last_bb (bb
);
3018 /* We can end up with init statements that store to a non-register
3019 from a rhs with a conversion. Handle that here by forcing the
3020 rhs into a temporary. gimple_regimplify_operands is not
3021 prepared to do this for us. */
3022 if (!is_gimple_debug (init_stmt
)
3023 && !is_gimple_reg (gimple_assign_lhs (init_stmt
))
3024 && is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (init_stmt
)))
3025 && gimple_assign_rhs_class (init_stmt
) == GIMPLE_UNARY_RHS
)
3027 tree rhs
= build1 (gimple_assign_rhs_code (init_stmt
),
3028 gimple_expr_type (init_stmt
),
3029 gimple_assign_rhs1 (init_stmt
));
3030 rhs
= force_gimple_operand_gsi (&si
, rhs
, true, NULL_TREE
, false,
3032 gimple_assign_set_rhs_code (init_stmt
, TREE_CODE (rhs
));
3033 gimple_assign_set_rhs1 (init_stmt
, rhs
);
3035 gsi_insert_after (&si
, init_stmt
, GSI_NEW_STMT
);
3036 gimple_regimplify_operands (init_stmt
, &si
);
3038 if (!is_gimple_debug (init_stmt
) && MAY_HAVE_DEBUG_STMTS
)
3040 tree def
= gimple_assign_lhs (init_stmt
);
3041 insert_init_debug_bind (id
, bb
, def
, def
, init_stmt
);
3046 /* Initialize parameter P with VALUE. If needed, produce init statement
3047 at the end of BB. When BB is NULL, we return init statement to be
3050 setup_one_parameter (copy_body_data
*id
, tree p
, tree value
, tree fn
,
3051 basic_block bb
, tree
*vars
)
3053 gimple init_stmt
= NULL
;
3056 tree def
= (gimple_in_ssa_p (cfun
)
3057 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
3060 && value
!= error_mark_node
3061 && !useless_type_conversion_p (TREE_TYPE (p
), TREE_TYPE (value
)))
3063 /* If we can match up types by promotion/demotion do so. */
3064 if (fold_convertible_p (TREE_TYPE (p
), value
))
3065 rhs
= fold_convert (TREE_TYPE (p
), value
);
3068 /* ??? For valid programs we should not end up here.
3069 Still if we end up with truly mismatched types here, fall back
3070 to using a VIEW_CONVERT_EXPR or a literal zero to not leak invalid
3071 GIMPLE to the following passes. */
3072 if (!is_gimple_reg_type (TREE_TYPE (value
))
3073 || TYPE_SIZE (TREE_TYPE (p
)) == TYPE_SIZE (TREE_TYPE (value
)))
3074 rhs
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (p
), value
);
3076 rhs
= build_zero_cst (TREE_TYPE (p
));
3080 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
3081 here since the type of this decl must be visible to the calling
3083 var
= copy_decl_to_var (p
, id
);
3085 /* Declare this new variable. */
3086 DECL_CHAIN (var
) = *vars
;
3089 /* Make gimplifier happy about this variable. */
3090 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
3092 /* If the parameter is never assigned to, has no SSA_NAMEs created,
3093 we would not need to create a new variable here at all, if it
3094 weren't for debug info. Still, we can just use the argument
3096 if (TREE_READONLY (p
)
3097 && !TREE_ADDRESSABLE (p
)
3098 && value
&& !TREE_SIDE_EFFECTS (value
)
3101 /* We may produce non-gimple trees by adding NOPs or introduce
3102 invalid sharing when operand is not really constant.
3103 It is not big deal to prohibit constant propagation here as
3104 we will constant propagate in DOM1 pass anyway. */
3105 if (is_gimple_min_invariant (value
)
3106 && useless_type_conversion_p (TREE_TYPE (p
),
3108 /* We have to be very careful about ADDR_EXPR. Make sure
3109 the base variable isn't a local variable of the inlined
3110 function, e.g., when doing recursive inlining, direct or
3111 mutually-recursive or whatever, which is why we don't
3112 just test whether fn == current_function_decl. */
3113 && ! self_inlining_addr_expr (value
, fn
))
3115 insert_decl_map (id
, p
, value
);
3116 insert_debug_decl_map (id
, p
, var
);
3117 return insert_init_debug_bind (id
, bb
, var
, value
, NULL
);
3121 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
3122 that way, when the PARM_DECL is encountered, it will be
3123 automatically replaced by the VAR_DECL. */
3124 insert_decl_map (id
, p
, var
);
3126 /* Even if P was TREE_READONLY, the new VAR should not be.
3127 In the original code, we would have constructed a
3128 temporary, and then the function body would have never
3129 changed the value of P. However, now, we will be
3130 constructing VAR directly. The constructor body may
3131 change its value multiple times as it is being
3132 constructed. Therefore, it must not be TREE_READONLY;
3133 the back-end assumes that TREE_READONLY variable is
3134 assigned to only once. */
3135 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p
)))
3136 TREE_READONLY (var
) = 0;
3138 /* If there is no setup required and we are in SSA, take the easy route
3139 replacing all SSA names representing the function parameter by the
3140 SSA name passed to function.
3142 We need to construct map for the variable anyway as it might be used
3143 in different SSA names when parameter is set in function.
3145 Do replacement at -O0 for const arguments replaced by constant.
3146 This is important for builtin_constant_p and other construct requiring
3147 constant argument to be visible in inlined function body. */
3148 if (gimple_in_ssa_p (cfun
) && rhs
&& def
&& is_gimple_reg (p
)
3150 || (TREE_READONLY (p
)
3151 && is_gimple_min_invariant (rhs
)))
3152 && (TREE_CODE (rhs
) == SSA_NAME
3153 || is_gimple_min_invariant (rhs
))
3154 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
3156 insert_decl_map (id
, def
, rhs
);
3157 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3160 /* If the value of argument is never used, don't care about initializing
3162 if (optimize
&& gimple_in_ssa_p (cfun
) && !def
&& is_gimple_reg (p
))
3164 gcc_assert (!value
|| !TREE_SIDE_EFFECTS (value
));
3165 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3168 /* Initialize this VAR_DECL from the equivalent argument. Convert
3169 the argument to the proper type in case it was promoted. */
3172 if (rhs
== error_mark_node
)
3174 insert_decl_map (id
, p
, var
);
3175 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3178 STRIP_USELESS_TYPE_CONVERSION (rhs
);
3180 /* If we are in SSA form properly remap the default definition
3181 or assign to a dummy SSA name if the parameter is unused and
3182 we are not optimizing. */
3183 if (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
))
3187 def
= remap_ssa_name (def
, id
);
3188 init_stmt
= gimple_build_assign (def
, rhs
);
3189 SSA_NAME_IS_DEFAULT_DEF (def
) = 0;
3190 set_ssa_default_def (cfun
, var
, NULL
);
3194 def
= make_ssa_name (var
);
3195 init_stmt
= gimple_build_assign (def
, rhs
);
3199 init_stmt
= gimple_build_assign (var
, rhs
);
3201 if (bb
&& init_stmt
)
3202 insert_init_stmt (id
, bb
, init_stmt
);
3207 /* Generate code to initialize the parameters of the function at the
3208 top of the stack in ID from the GIMPLE_CALL STMT. */
3211 initialize_inlined_parameters (copy_body_data
*id
, gimple stmt
,
3212 tree fn
, basic_block bb
)
3217 tree vars
= NULL_TREE
;
3218 tree static_chain
= gimple_call_chain (stmt
);
3220 /* Figure out what the parameters are. */
3221 parms
= DECL_ARGUMENTS (fn
);
3223 /* Loop through the parameter declarations, replacing each with an
3224 equivalent VAR_DECL, appropriately initialized. */
3225 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
3228 val
= i
< gimple_call_num_args (stmt
) ? gimple_call_arg (stmt
, i
) : NULL
;
3229 setup_one_parameter (id
, p
, val
, fn
, bb
, &vars
);
3231 /* After remapping parameters remap their types. This has to be done
3232 in a second loop over all parameters to appropriately remap
3233 variable sized arrays when the size is specified in a
3234 parameter following the array. */
3235 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
3237 tree
*varp
= id
->decl_map
->get (p
);
3239 && TREE_CODE (*varp
) == VAR_DECL
)
3241 tree def
= (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
)
3242 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
3244 TREE_TYPE (var
) = remap_type (TREE_TYPE (var
), id
);
3245 /* Also remap the default definition if it was remapped
3246 to the default definition of the parameter replacement
3247 by the parameter setup. */
3250 tree
*defp
= id
->decl_map
->get (def
);
3252 && TREE_CODE (*defp
) == SSA_NAME
3253 && SSA_NAME_VAR (*defp
) == var
)
3254 TREE_TYPE (*defp
) = TREE_TYPE (var
);
3259 /* Initialize the static chain. */
3260 p
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
3261 gcc_assert (fn
!= current_function_decl
);
3264 /* No static chain? Seems like a bug in tree-nested.c. */
3265 gcc_assert (static_chain
);
3267 setup_one_parameter (id
, p
, static_chain
, fn
, bb
, &vars
);
3270 declare_inline_vars (id
->block
, vars
);
3274 /* Declare a return variable to replace the RESULT_DECL for the
3275 function we are calling. An appropriate DECL_STMT is returned.
3276 The USE_STMT is filled to contain a use of the declaration to
3277 indicate the return value of the function.
3279 RETURN_SLOT, if non-null is place where to store the result. It
3280 is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null,
3281 was the LHS of the MODIFY_EXPR to which this call is the RHS.
3283 RETURN_BOUNDS holds a destination for returned bounds.
3285 The return value is a (possibly null) value that holds the result
3286 as seen by the caller. */
3289 declare_return_variable (copy_body_data
*id
, tree return_slot
, tree modify_dest
,
3290 tree return_bounds
, basic_block entry_bb
)
3292 tree callee
= id
->src_fn
;
3293 tree result
= DECL_RESULT (callee
);
3294 tree callee_type
= TREE_TYPE (result
);
3298 /* Handle type-mismatches in the function declaration return type
3299 vs. the call expression. */
3301 caller_type
= TREE_TYPE (modify_dest
);
3303 caller_type
= TREE_TYPE (TREE_TYPE (callee
));
3305 /* We don't need to do anything for functions that don't return anything. */
3306 if (VOID_TYPE_P (callee_type
))
3309 /* If there was a return slot, then the return value is the
3310 dereferenced address of that object. */
3313 /* The front end shouldn't have used both return_slot and
3314 a modify expression. */
3315 gcc_assert (!modify_dest
);
3316 if (DECL_BY_REFERENCE (result
))
3318 tree return_slot_addr
= build_fold_addr_expr (return_slot
);
3319 STRIP_USELESS_TYPE_CONVERSION (return_slot_addr
);
3321 /* We are going to construct *&return_slot and we can't do that
3322 for variables believed to be not addressable.
3324 FIXME: This check possibly can match, because values returned
3325 via return slot optimization are not believed to have address
3326 taken by alias analysis. */
3327 gcc_assert (TREE_CODE (return_slot
) != SSA_NAME
);
3328 var
= return_slot_addr
;
3333 gcc_assert (TREE_CODE (var
) != SSA_NAME
);
3334 if (TREE_ADDRESSABLE (result
))
3335 mark_addressable (var
);
3337 if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
3338 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
3339 && !DECL_GIMPLE_REG_P (result
)
3341 DECL_GIMPLE_REG_P (var
) = 0;
3346 /* All types requiring non-trivial constructors should have been handled. */
3347 gcc_assert (!TREE_ADDRESSABLE (callee_type
));
3349 /* Attempt to avoid creating a new temporary variable. */
3351 && TREE_CODE (modify_dest
) != SSA_NAME
)
3353 bool use_it
= false;
3355 /* We can't use MODIFY_DEST if there's type promotion involved. */
3356 if (!useless_type_conversion_p (callee_type
, caller_type
))
3359 /* ??? If we're assigning to a variable sized type, then we must
3360 reuse the destination variable, because we've no good way to
3361 create variable sized temporaries at this point. */
3362 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type
)) != INTEGER_CST
)
3365 /* If the callee cannot possibly modify MODIFY_DEST, then we can
3366 reuse it as the result of the call directly. Don't do this if
3367 it would promote MODIFY_DEST to addressable. */
3368 else if (TREE_ADDRESSABLE (result
))
3372 tree base_m
= get_base_address (modify_dest
);
3374 /* If the base isn't a decl, then it's a pointer, and we don't
3375 know where that's going to go. */
3376 if (!DECL_P (base_m
))
3378 else if (is_global_var (base_m
))
3380 else if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
3381 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
3382 && !DECL_GIMPLE_REG_P (result
)
3383 && DECL_GIMPLE_REG_P (base_m
))
3385 else if (!TREE_ADDRESSABLE (base_m
))
3397 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type
)) == INTEGER_CST
);
3399 var
= copy_result_decl_to_var (result
, id
);
3400 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
3402 /* Do not have the rest of GCC warn about this variable as it should
3403 not be visible to the user. */
3404 TREE_NO_WARNING (var
) = 1;
3406 declare_inline_vars (id
->block
, var
);
3408 /* Build the use expr. If the return type of the function was
3409 promoted, convert it back to the expected type. */
3411 if (!useless_type_conversion_p (caller_type
, TREE_TYPE (var
)))
3413 /* If we can match up types by promotion/demotion do so. */
3414 if (fold_convertible_p (caller_type
, var
))
3415 use
= fold_convert (caller_type
, var
);
3418 /* ??? For valid programs we should not end up here.
3419 Still if we end up with truly mismatched types here, fall back
3420 to using a MEM_REF to not leak invalid GIMPLE to the following
3422 /* Prevent var from being written into SSA form. */
3423 if (TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
3424 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
)
3425 DECL_GIMPLE_REG_P (var
) = false;
3426 else if (is_gimple_reg_type (TREE_TYPE (var
)))
3427 TREE_ADDRESSABLE (var
) = true;
3428 use
= fold_build2 (MEM_REF
, caller_type
,
3429 build_fold_addr_expr (var
),
3430 build_int_cst (ptr_type_node
, 0));
3434 STRIP_USELESS_TYPE_CONVERSION (use
);
3436 if (DECL_BY_REFERENCE (result
))
3438 TREE_ADDRESSABLE (var
) = 1;
3439 var
= build_fold_addr_expr (var
);
3443 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
3444 way, when the RESULT_DECL is encountered, it will be
3445 automatically replaced by the VAR_DECL.
3447 When returning by reference, ensure that RESULT_DECL remaps to
3449 if (DECL_BY_REFERENCE (result
)
3450 && !is_gimple_val (var
))
3452 tree temp
= create_tmp_var (TREE_TYPE (result
), "retvalptr");
3453 insert_decl_map (id
, result
, temp
);
3454 /* When RESULT_DECL is in SSA form, we need to remap and initialize
3455 it's default_def SSA_NAME. */
3456 if (gimple_in_ssa_p (id
->src_cfun
)
3457 && is_gimple_reg (result
))
3459 temp
= make_ssa_name (temp
);
3460 insert_decl_map (id
, ssa_default_def (id
->src_cfun
, result
), temp
);
3462 insert_init_stmt (id
, entry_bb
, gimple_build_assign (temp
, var
));
3465 insert_decl_map (id
, result
, var
);
3467 /* Remember this so we can ignore it in remap_decls. */
3470 /* If returned bounds are used, then make var for them. */
3473 tree bndtemp
= create_tmp_var (pointer_bounds_type_node
, "retbnd");
3474 DECL_SEEN_IN_BIND_EXPR_P (bndtemp
) = 1;
3475 TREE_NO_WARNING (bndtemp
) = 1;
3476 declare_inline_vars (id
->block
, bndtemp
);
3478 id
->retbnd
= bndtemp
;
3479 insert_init_stmt (id
, entry_bb
,
3480 gimple_build_assign (bndtemp
, chkp_get_zero_bounds_var ()));
3486 /* Callback through walk_tree. Determine if a DECL_INITIAL makes reference
3487 to a local label. */
3490 has_label_address_in_static_1 (tree
*nodep
, int *walk_subtrees
, void *fnp
)
3493 tree fn
= (tree
) fnp
;
3495 if (TREE_CODE (node
) == LABEL_DECL
&& DECL_CONTEXT (node
) == fn
)
3504 /* Determine if the function can be copied. If so return NULL. If
3505 not return a string describng the reason for failure. */
3508 copy_forbidden (struct function
*fun
, tree fndecl
)
3510 const char *reason
= fun
->cannot_be_copied_reason
;
3514 /* Only examine the function once. */
3515 if (fun
->cannot_be_copied_set
)
3518 /* We cannot copy a function that receives a non-local goto
3519 because we cannot remap the destination label used in the
3520 function that is performing the non-local goto. */
3521 /* ??? Actually, this should be possible, if we work at it.
3522 No doubt there's just a handful of places that simply
3523 assume it doesn't happen and don't substitute properly. */
3524 if (fun
->has_nonlocal_label
)
3526 reason
= G_("function %q+F can never be copied "
3527 "because it receives a non-local goto");
3531 FOR_EACH_LOCAL_DECL (fun
, ix
, decl
)
3532 if (TREE_CODE (decl
) == VAR_DECL
3533 && TREE_STATIC (decl
)
3534 && !DECL_EXTERNAL (decl
)
3535 && DECL_INITIAL (decl
)
3536 && walk_tree_without_duplicates (&DECL_INITIAL (decl
),
3537 has_label_address_in_static_1
,
3540 reason
= G_("function %q+F can never be copied because it saves "
3541 "address of local label in a static variable");
3546 fun
->cannot_be_copied_reason
= reason
;
3547 fun
->cannot_be_copied_set
= true;
3552 static const char *inline_forbidden_reason
;
3554 /* A callback for walk_gimple_seq to handle statements. Returns non-null
3555 iff a function can not be inlined. Also sets the reason why. */
3558 inline_forbidden_p_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
3559 struct walk_stmt_info
*wip
)
3561 tree fn
= (tree
) wip
->info
;
3563 gimple stmt
= gsi_stmt (*gsi
);
3565 switch (gimple_code (stmt
))
3568 /* Refuse to inline alloca call unless user explicitly forced so as
3569 this may change program's memory overhead drastically when the
3570 function using alloca is called in loop. In GCC present in
3571 SPEC2000 inlining into schedule_block cause it to require 2GB of
3572 RAM instead of 256MB. Don't do so for alloca calls emitted for
3573 VLA objects as those can't cause unbounded growth (they're always
3574 wrapped inside stack_save/stack_restore regions. */
3575 if (gimple_alloca_call_p (stmt
)
3576 && !gimple_call_alloca_for_var_p (as_a
<gcall
*> (stmt
))
3577 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
3579 inline_forbidden_reason
3580 = G_("function %q+F can never be inlined because it uses "
3581 "alloca (override using the always_inline attribute)");
3582 *handled_ops_p
= true;
3586 t
= gimple_call_fndecl (stmt
);
3590 /* We cannot inline functions that call setjmp. */
3591 if (setjmp_call_p (t
))
3593 inline_forbidden_reason
3594 = G_("function %q+F can never be inlined because it uses setjmp");
3595 *handled_ops_p
= true;
3599 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
3600 switch (DECL_FUNCTION_CODE (t
))
3602 /* We cannot inline functions that take a variable number of
3604 case BUILT_IN_VA_START
:
3605 case BUILT_IN_NEXT_ARG
:
3606 case BUILT_IN_VA_END
:
3607 inline_forbidden_reason
3608 = G_("function %q+F can never be inlined because it "
3609 "uses variable argument lists");
3610 *handled_ops_p
= true;
3613 case BUILT_IN_LONGJMP
:
3614 /* We can't inline functions that call __builtin_longjmp at
3615 all. The non-local goto machinery really requires the
3616 destination be in a different function. If we allow the
3617 function calling __builtin_longjmp to be inlined into the
3618 function calling __builtin_setjmp, Things will Go Awry. */
3619 inline_forbidden_reason
3620 = G_("function %q+F can never be inlined because "
3621 "it uses setjmp-longjmp exception handling");
3622 *handled_ops_p
= true;
3625 case BUILT_IN_NONLOCAL_GOTO
:
3627 inline_forbidden_reason
3628 = G_("function %q+F can never be inlined because "
3629 "it uses non-local goto");
3630 *handled_ops_p
= true;
3633 case BUILT_IN_RETURN
:
3634 case BUILT_IN_APPLY_ARGS
:
3635 /* If a __builtin_apply_args caller would be inlined,
3636 it would be saving arguments of the function it has
3637 been inlined into. Similarly __builtin_return would
3638 return from the function the inline has been inlined into. */
3639 inline_forbidden_reason
3640 = G_("function %q+F can never be inlined because "
3641 "it uses __builtin_return or __builtin_apply_args");
3642 *handled_ops_p
= true;
3651 t
= gimple_goto_dest (stmt
);
3653 /* We will not inline a function which uses computed goto. The
3654 addresses of its local labels, which may be tucked into
3655 global storage, are of course not constant across
3656 instantiations, which causes unexpected behavior. */
3657 if (TREE_CODE (t
) != LABEL_DECL
)
3659 inline_forbidden_reason
3660 = G_("function %q+F can never be inlined "
3661 "because it contains a computed goto");
3662 *handled_ops_p
= true;
3671 *handled_ops_p
= false;
3675 /* Return true if FNDECL is a function that cannot be inlined into
3679 inline_forbidden_p (tree fndecl
)
3681 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
3682 struct walk_stmt_info wi
;
3684 bool forbidden_p
= false;
3686 /* First check for shared reasons not to copy the code. */
3687 inline_forbidden_reason
= copy_forbidden (fun
, fndecl
);
3688 if (inline_forbidden_reason
!= NULL
)
3691 /* Next, walk the statements of the function looking for
3692 constraucts we can't handle, or are non-optimal for inlining. */
3693 hash_set
<tree
> visited_nodes
;
3694 memset (&wi
, 0, sizeof (wi
));
3695 wi
.info
= (void *) fndecl
;
3696 wi
.pset
= &visited_nodes
;
3698 FOR_EACH_BB_FN (bb
, fun
)
3701 gimple_seq seq
= bb_seq (bb
);
3702 ret
= walk_gimple_seq (seq
, inline_forbidden_p_stmt
, NULL
, &wi
);
3703 forbidden_p
= (ret
!= NULL
);
3711 /* Return false if the function FNDECL cannot be inlined on account of its
3712 attributes, true otherwise. */
3714 function_attribute_inlinable_p (const_tree fndecl
)
3716 if (targetm
.attribute_table
)
3720 for (a
= DECL_ATTRIBUTES (fndecl
); a
; a
= TREE_CHAIN (a
))
3722 const_tree name
= TREE_PURPOSE (a
);
3725 for (i
= 0; targetm
.attribute_table
[i
].name
!= NULL
; i
++)
3726 if (is_attribute_p (targetm
.attribute_table
[i
].name
, name
))
3727 return targetm
.function_attribute_inlinable_p (fndecl
);
3734 /* Returns nonzero if FN is a function that does not have any
3735 fundamental inline blocking properties. */
3738 tree_inlinable_function_p (tree fn
)
3740 bool inlinable
= true;
3744 /* If we've already decided this function shouldn't be inlined,
3745 there's no need to check again. */
3746 if (DECL_UNINLINABLE (fn
))
3749 /* We only warn for functions declared `inline' by the user. */
3750 do_warning
= (warn_inline
3751 && DECL_DECLARED_INLINE_P (fn
)
3752 && !DECL_NO_INLINE_WARNING_P (fn
)
3753 && !DECL_IN_SYSTEM_HEADER (fn
));
3755 always_inline
= lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
));
3758 && always_inline
== NULL
)
3761 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3762 "is suppressed using -fno-inline", fn
);
3766 else if (!function_attribute_inlinable_p (fn
))
3769 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3770 "uses attributes conflicting with inlining", fn
);
3774 else if (inline_forbidden_p (fn
))
3776 /* See if we should warn about uninlinable functions. Previously,
3777 some of these warnings would be issued while trying to expand
3778 the function inline, but that would cause multiple warnings
3779 about functions that would for example call alloca. But since
3780 this a property of the function, just one warning is enough.
3781 As a bonus we can now give more details about the reason why a
3782 function is not inlinable. */
3784 error (inline_forbidden_reason
, fn
);
3785 else if (do_warning
)
3786 warning (OPT_Winline
, inline_forbidden_reason
, fn
);
3791 /* Squirrel away the result so that we don't have to check again. */
3792 DECL_UNINLINABLE (fn
) = !inlinable
;
3797 /* Estimate the cost of a memory move of type TYPE. Use machine dependent
3798 word size and take possible memcpy call into account and return
3799 cost based on whether optimizing for size or speed according to SPEED_P. */
3802 estimate_move_cost (tree type
, bool ARG_UNUSED (speed_p
))
3806 gcc_assert (!VOID_TYPE_P (type
));
3808 if (TREE_CODE (type
) == VECTOR_TYPE
)
3810 machine_mode inner
= TYPE_MODE (TREE_TYPE (type
));
3812 = targetm
.vectorize
.preferred_simd_mode (inner
);
3813 int simd_mode_size
= GET_MODE_SIZE (simd
);
3814 return ((GET_MODE_SIZE (TYPE_MODE (type
)) + simd_mode_size
- 1)
3818 size
= int_size_in_bytes (type
);
3820 if (size
< 0 || size
> MOVE_MAX_PIECES
* MOVE_RATIO (speed_p
))
3821 /* Cost of a memcpy call, 3 arguments and the call. */
3824 return ((size
+ MOVE_MAX_PIECES
- 1) / MOVE_MAX_PIECES
);
3827 /* Returns cost of operation CODE, according to WEIGHTS */
3830 estimate_operator_cost (enum tree_code code
, eni_weights
*weights
,
3831 tree op1 ATTRIBUTE_UNUSED
, tree op2
)
3835 /* These are "free" conversions, or their presumed cost
3836 is folded into other operations. */
3841 case VIEW_CONVERT_EXPR
:
3844 /* Assign cost of 1 to usual operations.
3845 ??? We may consider mapping RTL costs to this. */
3851 case POINTER_PLUS_EXPR
:
3854 case MULT_HIGHPART_EXPR
:
3857 case ADDR_SPACE_CONVERT_EXPR
:
3858 case FIXED_CONVERT_EXPR
:
3859 case FIX_TRUNC_EXPR
:
3877 case TRUTH_ANDIF_EXPR
:
3878 case TRUTH_ORIF_EXPR
:
3879 case TRUTH_AND_EXPR
:
3881 case TRUTH_XOR_EXPR
:
3882 case TRUTH_NOT_EXPR
:
3891 case UNORDERED_EXPR
:
3902 case PREDECREMENT_EXPR
:
3903 case PREINCREMENT_EXPR
:
3904 case POSTDECREMENT_EXPR
:
3905 case POSTINCREMENT_EXPR
:
3907 case REALIGN_LOAD_EXPR
:
3909 case REDUC_MAX_EXPR
:
3910 case REDUC_MIN_EXPR
:
3911 case REDUC_PLUS_EXPR
:
3912 case WIDEN_SUM_EXPR
:
3913 case WIDEN_MULT_EXPR
:
3916 case WIDEN_MULT_PLUS_EXPR
:
3917 case WIDEN_MULT_MINUS_EXPR
:
3918 case WIDEN_LSHIFT_EXPR
:
3920 case VEC_WIDEN_MULT_HI_EXPR
:
3921 case VEC_WIDEN_MULT_LO_EXPR
:
3922 case VEC_WIDEN_MULT_EVEN_EXPR
:
3923 case VEC_WIDEN_MULT_ODD_EXPR
:
3924 case VEC_UNPACK_HI_EXPR
:
3925 case VEC_UNPACK_LO_EXPR
:
3926 case VEC_UNPACK_FLOAT_HI_EXPR
:
3927 case VEC_UNPACK_FLOAT_LO_EXPR
:
3928 case VEC_PACK_TRUNC_EXPR
:
3929 case VEC_PACK_SAT_EXPR
:
3930 case VEC_PACK_FIX_TRUNC_EXPR
:
3931 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3932 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3936 /* Few special cases of expensive operations. This is useful
3937 to avoid inlining on functions having too many of these. */
3938 case TRUNC_DIV_EXPR
:
3940 case FLOOR_DIV_EXPR
:
3941 case ROUND_DIV_EXPR
:
3942 case EXACT_DIV_EXPR
:
3943 case TRUNC_MOD_EXPR
:
3945 case FLOOR_MOD_EXPR
:
3946 case ROUND_MOD_EXPR
:
3948 if (TREE_CODE (op2
) != INTEGER_CST
)
3949 return weights
->div_mod_cost
;
3953 /* We expect a copy assignment with no operator. */
3954 gcc_assert (get_gimple_rhs_class (code
) == GIMPLE_SINGLE_RHS
);
3960 /* Estimate number of instructions that will be created by expanding
3961 the statements in the statement sequence STMTS.
3962 WEIGHTS contains weights attributed to various constructs. */
3965 int estimate_num_insns_seq (gimple_seq stmts
, eni_weights
*weights
)
3968 gimple_stmt_iterator gsi
;
3971 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3972 cost
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
3978 /* Estimate number of instructions that will be created by expanding STMT.
3979 WEIGHTS contains weights attributed to various constructs. */
3982 estimate_num_insns (gimple stmt
, eni_weights
*weights
)
3985 enum gimple_code code
= gimple_code (stmt
);
3992 /* Try to estimate the cost of assignments. We have three cases to
3994 1) Simple assignments to registers;
3995 2) Stores to things that must live in memory. This includes
3996 "normal" stores to scalars, but also assignments of large
3997 structures, or constructors of big arrays;
3999 Let us look at the first two cases, assuming we have "a = b + C":
4000 <GIMPLE_ASSIGN <var_decl "a">
4001 <plus_expr <var_decl "b"> <constant C>>
4002 If "a" is a GIMPLE register, the assignment to it is free on almost
4003 any target, because "a" usually ends up in a real register. Hence
4004 the only cost of this expression comes from the PLUS_EXPR, and we
4005 can ignore the GIMPLE_ASSIGN.
4006 If "a" is not a GIMPLE register, the assignment to "a" will most
4007 likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost
4008 of moving something into "a", which we compute using the function
4009 estimate_move_cost. */
4010 if (gimple_clobber_p (stmt
))
4011 return 0; /* ={v} {CLOBBER} stmt expands to nothing. */
4013 lhs
= gimple_assign_lhs (stmt
);
4014 rhs
= gimple_assign_rhs1 (stmt
);
4018 /* Account for the cost of moving to / from memory. */
4019 if (gimple_store_p (stmt
))
4020 cost
+= estimate_move_cost (TREE_TYPE (lhs
), weights
->time_based
);
4021 if (gimple_assign_load_p (stmt
))
4022 cost
+= estimate_move_cost (TREE_TYPE (rhs
), weights
->time_based
);
4024 cost
+= estimate_operator_cost (gimple_assign_rhs_code (stmt
), weights
,
4025 gimple_assign_rhs1 (stmt
),
4026 get_gimple_rhs_class (gimple_assign_rhs_code (stmt
))
4027 == GIMPLE_BINARY_RHS
4028 ? gimple_assign_rhs2 (stmt
) : NULL
);
4032 cost
= 1 + estimate_operator_cost (gimple_cond_code (stmt
), weights
,
4033 gimple_op (stmt
, 0),
4034 gimple_op (stmt
, 1));
4039 gswitch
*switch_stmt
= as_a
<gswitch
*> (stmt
);
4040 /* Take into account cost of the switch + guess 2 conditional jumps for
4043 TODO: once the switch expansion logic is sufficiently separated, we can
4044 do better job on estimating cost of the switch. */
4045 if (weights
->time_based
)
4046 cost
= floor_log2 (gimple_switch_num_labels (switch_stmt
)) * 2;
4048 cost
= gimple_switch_num_labels (switch_stmt
) * 2;
4056 if (gimple_call_internal_p (stmt
))
4058 else if ((decl
= gimple_call_fndecl (stmt
))
4059 && DECL_BUILT_IN (decl
))
4061 /* Do not special case builtins where we see the body.
4062 This just confuse inliner. */
4063 struct cgraph_node
*node
;
4064 if (!(node
= cgraph_node::get (decl
))
4065 || node
->definition
)
4067 /* For buitins that are likely expanded to nothing or
4068 inlined do not account operand costs. */
4069 else if (is_simple_builtin (decl
))
4071 else if (is_inexpensive_builtin (decl
))
4072 return weights
->target_builtin_call_cost
;
4073 else if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
4075 /* We canonicalize x * x to pow (x, 2.0) with -ffast-math, so
4076 specialize the cheap expansion we do here.
4077 ??? This asks for a more general solution. */
4078 switch (DECL_FUNCTION_CODE (decl
))
4083 if (TREE_CODE (gimple_call_arg (stmt
, 1)) == REAL_CST
4084 && REAL_VALUES_EQUAL
4085 (TREE_REAL_CST (gimple_call_arg (stmt
, 1)), dconst2
))
4086 return estimate_operator_cost
4087 (MULT_EXPR
, weights
, gimple_call_arg (stmt
, 0),
4088 gimple_call_arg (stmt
, 0));
4097 cost
= decl
? weights
->call_cost
: weights
->indirect_call_cost
;
4098 if (gimple_call_lhs (stmt
))
4099 cost
+= estimate_move_cost (TREE_TYPE (gimple_call_lhs (stmt
)),
4100 weights
->time_based
);
4101 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
4103 tree arg
= gimple_call_arg (stmt
, i
);
4104 cost
+= estimate_move_cost (TREE_TYPE (arg
),
4105 weights
->time_based
);
4111 return weights
->return_cost
;
4117 case GIMPLE_PREDICT
:
4123 int count
= asm_str_count (gimple_asm_string (as_a
<gasm
*> (stmt
)));
4124 /* 1000 means infinity. This avoids overflows later
4125 with very long asm statements. */
4132 /* This is either going to be an external function call with one
4133 argument, or two register copy statements plus a goto. */
4136 case GIMPLE_EH_DISPATCH
:
4137 /* ??? This is going to turn into a switch statement. Ideally
4138 we'd have a look at the eh region and estimate the number of
4143 return estimate_num_insns_seq (
4144 gimple_bind_body (as_a
<gbind
*> (stmt
)),
4147 case GIMPLE_EH_FILTER
:
4148 return estimate_num_insns_seq (gimple_eh_filter_failure (stmt
), weights
);
4151 return estimate_num_insns_seq (gimple_catch_handler (
4152 as_a
<gcatch
*> (stmt
)),
4156 return (estimate_num_insns_seq (gimple_try_eval (stmt
), weights
)
4157 + estimate_num_insns_seq (gimple_try_cleanup (stmt
), weights
));
4159 /* OpenMP directives are generally very expensive. */
4161 case GIMPLE_OMP_RETURN
:
4162 case GIMPLE_OMP_SECTIONS_SWITCH
:
4163 case GIMPLE_OMP_ATOMIC_STORE
:
4164 case GIMPLE_OMP_CONTINUE
:
4165 /* ...except these, which are cheap. */
4168 case GIMPLE_OMP_ATOMIC_LOAD
:
4169 return weights
->omp_cost
;
4171 case GIMPLE_OMP_FOR
:
4172 return (weights
->omp_cost
4173 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
)
4174 + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt
), weights
));
4176 case GIMPLE_OMP_PARALLEL
:
4177 case GIMPLE_OMP_TASK
:
4178 case GIMPLE_OMP_CRITICAL
:
4179 case GIMPLE_OMP_MASTER
:
4180 case GIMPLE_OMP_TASKGROUP
:
4181 case GIMPLE_OMP_ORDERED
:
4182 case GIMPLE_OMP_SECTION
:
4183 case GIMPLE_OMP_SECTIONS
:
4184 case GIMPLE_OMP_SINGLE
:
4185 case GIMPLE_OMP_TARGET
:
4186 case GIMPLE_OMP_TEAMS
:
4187 return (weights
->omp_cost
4188 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
));
4190 case GIMPLE_TRANSACTION
:
4191 return (weights
->tm_cost
4192 + estimate_num_insns_seq (gimple_transaction_body (
4193 as_a
<gtransaction
*> (stmt
)),
4203 /* Estimate number of instructions that will be created by expanding
4204 function FNDECL. WEIGHTS contains weights attributed to various
4208 estimate_num_insns_fn (tree fndecl
, eni_weights
*weights
)
4210 struct function
*my_function
= DECL_STRUCT_FUNCTION (fndecl
);
4211 gimple_stmt_iterator bsi
;
4215 gcc_assert (my_function
&& my_function
->cfg
);
4216 FOR_EACH_BB_FN (bb
, my_function
)
4218 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
4219 n
+= estimate_num_insns (gsi_stmt (bsi
), weights
);
4226 /* Initializes weights used by estimate_num_insns. */
4229 init_inline_once (void)
4231 eni_size_weights
.call_cost
= 1;
4232 eni_size_weights
.indirect_call_cost
= 3;
4233 eni_size_weights
.target_builtin_call_cost
= 1;
4234 eni_size_weights
.div_mod_cost
= 1;
4235 eni_size_weights
.omp_cost
= 40;
4236 eni_size_weights
.tm_cost
= 10;
4237 eni_size_weights
.time_based
= false;
4238 eni_size_weights
.return_cost
= 1;
4240 /* Estimating time for call is difficult, since we have no idea what the
4241 called function does. In the current uses of eni_time_weights,
4242 underestimating the cost does less harm than overestimating it, so
4243 we choose a rather small value here. */
4244 eni_time_weights
.call_cost
= 10;
4245 eni_time_weights
.indirect_call_cost
= 15;
4246 eni_time_weights
.target_builtin_call_cost
= 1;
4247 eni_time_weights
.div_mod_cost
= 10;
4248 eni_time_weights
.omp_cost
= 40;
4249 eni_time_weights
.tm_cost
= 40;
4250 eni_time_weights
.time_based
= true;
4251 eni_time_weights
.return_cost
= 2;
4254 /* Estimate the number of instructions in a gimple_seq. */
4257 count_insns_seq (gimple_seq seq
, eni_weights
*weights
)
4259 gimple_stmt_iterator gsi
;
4261 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4262 n
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
4268 /* Install new lexical TREE_BLOCK underneath 'current_block'. */
4271 prepend_lexical_block (tree current_block
, tree new_block
)
4273 BLOCK_CHAIN (new_block
) = BLOCK_SUBBLOCKS (current_block
);
4274 BLOCK_SUBBLOCKS (current_block
) = new_block
;
4275 BLOCK_SUPERCONTEXT (new_block
) = current_block
;
4278 /* Add local variables from CALLEE to CALLER. */
4281 add_local_variables (struct function
*callee
, struct function
*caller
,
4287 FOR_EACH_LOCAL_DECL (callee
, ix
, var
)
4288 if (!can_be_nonlocal (var
, id
))
4290 tree new_var
= remap_decl (var
, id
);
4292 /* Remap debug-expressions. */
4293 if (TREE_CODE (new_var
) == VAR_DECL
4294 && DECL_HAS_DEBUG_EXPR_P (var
)
4297 tree tem
= DECL_DEBUG_EXPR (var
);
4298 bool old_regimplify
= id
->regimplify
;
4299 id
->remapping_type_depth
++;
4300 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
4301 id
->remapping_type_depth
--;
4302 id
->regimplify
= old_regimplify
;
4303 SET_DECL_DEBUG_EXPR (new_var
, tem
);
4304 DECL_HAS_DEBUG_EXPR_P (new_var
) = 1;
4306 add_local_decl (caller
, new_var
);
4310 /* If STMT is a GIMPLE_CALL, replace it with its inline expansion. */
4313 expand_call_inline (basic_block bb
, gimple stmt
, copy_body_data
*id
)
4317 hash_map
<tree
, tree
> *dst
;
4318 hash_map
<tree
, tree
> *st
= NULL
;
4321 tree return_bounds
= NULL
;
4322 location_t saved_location
;
4323 struct cgraph_edge
*cg_edge
;
4324 cgraph_inline_failed_t reason
;
4325 basic_block return_block
;
4327 gimple_stmt_iterator gsi
, stmt_gsi
;
4328 bool successfully_inlined
= FALSE
;
4329 bool purge_dead_abnormal_edges
;
4333 /* Set input_location here so we get the right instantiation context
4334 if we call instantiate_decl from inlinable_function_p. */
4335 /* FIXME: instantiate_decl isn't called by inlinable_function_p. */
4336 saved_location
= input_location
;
4337 input_location
= gimple_location (stmt
);
4339 /* From here on, we're only interested in CALL_EXPRs. */
4340 call_stmt
= dyn_cast
<gcall
*> (stmt
);
4344 cg_edge
= id
->dst_node
->get_edge (stmt
);
4345 gcc_checking_assert (cg_edge
);
4346 /* First, see if we can figure out what function is being called.
4347 If we cannot, then there is no hope of inlining the function. */
4348 if (cg_edge
->indirect_unknown_callee
)
4350 fn
= cg_edge
->callee
->decl
;
4351 gcc_checking_assert (fn
);
4353 /* If FN is a declaration of a function in a nested scope that was
4354 globally declared inline, we don't set its DECL_INITIAL.
4355 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
4356 C++ front-end uses it for cdtors to refer to their internal
4357 declarations, that are not real functions. Fortunately those
4358 don't have trees to be saved, so we can tell by checking their
4360 if (!DECL_INITIAL (fn
)
4361 && DECL_ABSTRACT_ORIGIN (fn
)
4362 && gimple_has_body_p (DECL_ABSTRACT_ORIGIN (fn
)))
4363 fn
= DECL_ABSTRACT_ORIGIN (fn
);
4365 /* Don't try to inline functions that are not well-suited to inlining. */
4366 if (cg_edge
->inline_failed
)
4368 reason
= cg_edge
->inline_failed
;
4369 /* If this call was originally indirect, we do not want to emit any
4370 inlining related warnings or sorry messages because there are no
4371 guarantees regarding those. */
4372 if (cg_edge
->indirect_inlining_edge
)
4375 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
))
4376 /* For extern inline functions that get redefined we always
4377 silently ignored always_inline flag. Better behaviour would
4378 be to be able to keep both bodies and use extern inline body
4379 for inlining, but we can't do that because frontends overwrite
4381 && !cg_edge
->callee
->local
.redefined_extern_inline
4382 /* During early inline pass, report only when optimization is
4384 && (symtab
->global_info_ready
4386 || cgraph_inline_failed_type (reason
) == CIF_FINAL_ERROR
)
4387 /* PR 20090218-1_0.c. Body can be provided by another module. */
4388 && (reason
!= CIF_BODY_NOT_AVAILABLE
|| !flag_generate_lto
))
4390 error ("inlining failed in call to always_inline %q+F: %s", fn
,
4391 cgraph_inline_failed_string (reason
));
4392 error ("called from here");
4394 else if (warn_inline
4395 && DECL_DECLARED_INLINE_P (fn
)
4396 && !DECL_NO_INLINE_WARNING_P (fn
)
4397 && !DECL_IN_SYSTEM_HEADER (fn
)
4398 && reason
!= CIF_UNSPECIFIED
4399 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn
))
4400 /* Do not warn about not inlined recursive calls. */
4401 && !cg_edge
->recursive_p ()
4402 /* Avoid warnings during early inline pass. */
4403 && symtab
->global_info_ready
)
4405 warning (OPT_Winline
, "inlining failed in call to %q+F: %s",
4406 fn
, _(cgraph_inline_failed_string (reason
)));
4407 warning (OPT_Winline
, "called from here");
4411 fn
= cg_edge
->callee
->decl
;
4412 cg_edge
->callee
->get_untransformed_body ();
4414 #ifdef ENABLE_CHECKING
4415 if (cg_edge
->callee
->decl
!= id
->dst_node
->decl
)
4416 cg_edge
->callee
->verify ();
4419 /* We will be inlining this callee. */
4420 id
->eh_lp_nr
= lookup_stmt_eh_lp (stmt
);
4421 id
->assign_stmts
.create (0);
4423 /* Update the callers EH personality. */
4424 if (DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->decl
))
4425 DECL_FUNCTION_PERSONALITY (cg_edge
->caller
->decl
)
4426 = DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->decl
);
4428 /* Split the block holding the GIMPLE_CALL. */
4429 e
= split_block (bb
, stmt
);
4431 return_block
= e
->dest
;
4434 /* split_block splits after the statement; work around this by
4435 moving the call into the second block manually. Not pretty,
4436 but seems easier than doing the CFG manipulation by hand
4437 when the GIMPLE_CALL is in the last statement of BB. */
4438 stmt_gsi
= gsi_last_bb (bb
);
4439 gsi_remove (&stmt_gsi
, false);
4441 /* If the GIMPLE_CALL was in the last statement of BB, it may have
4442 been the source of abnormal edges. In this case, schedule
4443 the removal of dead abnormal edges. */
4444 gsi
= gsi_start_bb (return_block
);
4445 if (gsi_end_p (gsi
))
4447 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
4448 purge_dead_abnormal_edges
= true;
4452 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
4453 purge_dead_abnormal_edges
= false;
4456 stmt_gsi
= gsi_start_bb (return_block
);
4458 /* Build a block containing code to initialize the arguments, the
4459 actual inline expansion of the body, and a label for the return
4460 statements within the function to jump to. The type of the
4461 statement expression is the return type of the function call.
4462 ??? If the call does not have an associated block then we will
4463 remap all callee blocks to NULL, effectively dropping most of
4464 its debug information. This should only happen for calls to
4465 artificial decls inserted by the compiler itself. We need to
4466 either link the inlined blocks into the caller block tree or
4467 not refer to them in any way to not break GC for locations. */
4468 if (gimple_block (stmt
))
4470 id
->block
= make_node (BLOCK
);
4471 BLOCK_ABSTRACT_ORIGIN (id
->block
) = fn
;
4472 BLOCK_SOURCE_LOCATION (id
->block
) = LOCATION_LOCUS (input_location
);
4473 prepend_lexical_block (gimple_block (stmt
), id
->block
);
4476 /* Local declarations will be replaced by their equivalents in this
4479 id
->decl_map
= new hash_map
<tree
, tree
>;
4480 dst
= id
->debug_map
;
4481 id
->debug_map
= NULL
;
4483 /* Record the function we are about to inline. */
4485 id
->src_node
= cg_edge
->callee
;
4486 id
->src_cfun
= DECL_STRUCT_FUNCTION (fn
);
4487 id
->call_stmt
= stmt
;
4489 gcc_assert (!id
->src_cfun
->after_inlining
);
4492 if (lookup_attribute ("cold", DECL_ATTRIBUTES (fn
)))
4494 gimple_stmt_iterator si
= gsi_last_bb (bb
);
4495 gsi_insert_after (&si
, gimple_build_predict (PRED_COLD_FUNCTION
,
4499 initialize_inlined_parameters (id
, stmt
, fn
, bb
);
4501 if (DECL_INITIAL (fn
))
4503 if (gimple_block (stmt
))
4507 prepend_lexical_block (id
->block
,
4508 remap_blocks (DECL_INITIAL (fn
), id
));
4509 gcc_checking_assert (BLOCK_SUBBLOCKS (id
->block
)
4510 && (BLOCK_CHAIN (BLOCK_SUBBLOCKS (id
->block
))
4512 /* Move vars for PARM_DECLs from DECL_INITIAL block to id->block,
4513 otherwise for DWARF DW_TAG_formal_parameter will not be children of
4514 DW_TAG_inlined_subroutine, but of a DW_TAG_lexical_block
4515 under it. The parameters can be then evaluated in the debugger,
4516 but don't show in backtraces. */
4517 for (var
= &BLOCK_VARS (BLOCK_SUBBLOCKS (id
->block
)); *var
; )
4518 if (TREE_CODE (DECL_ORIGIN (*var
)) == PARM_DECL
)
4521 *var
= TREE_CHAIN (v
);
4522 TREE_CHAIN (v
) = BLOCK_VARS (id
->block
);
4523 BLOCK_VARS (id
->block
) = v
;
4526 var
= &TREE_CHAIN (*var
);
4529 remap_blocks_to_null (DECL_INITIAL (fn
), id
);
4532 /* Return statements in the function body will be replaced by jumps
4533 to the RET_LABEL. */
4534 gcc_assert (DECL_INITIAL (fn
));
4535 gcc_assert (TREE_CODE (DECL_INITIAL (fn
)) == BLOCK
);
4537 /* Find the LHS to which the result of this call is assigned. */
4539 if (gimple_call_lhs (stmt
))
4541 modify_dest
= gimple_call_lhs (stmt
);
4543 /* Remember where to copy returned bounds. */
4544 if (gimple_call_with_bounds_p (stmt
)
4545 && TREE_CODE (modify_dest
) == SSA_NAME
)
4547 gcall
*retbnd
= chkp_retbnd_call_by_val (modify_dest
);
4550 return_bounds
= gimple_call_lhs (retbnd
);
4551 /* If returned bounds are not used then just
4552 remove unused call. */
4555 gimple_stmt_iterator iter
= gsi_for_stmt (retbnd
);
4556 gsi_remove (&iter
, true);
4561 /* The function which we are inlining might not return a value,
4562 in which case we should issue a warning that the function
4563 does not return a value. In that case the optimizers will
4564 see that the variable to which the value is assigned was not
4565 initialized. We do not want to issue a warning about that
4566 uninitialized variable. */
4567 if (DECL_P (modify_dest
))
4568 TREE_NO_WARNING (modify_dest
) = 1;
4570 if (gimple_call_return_slot_opt_p (call_stmt
))
4572 return_slot
= modify_dest
;
4579 /* If we are inlining a call to the C++ operator new, we don't want
4580 to use type based alias analysis on the return value. Otherwise
4581 we may get confused if the compiler sees that the inlined new
4582 function returns a pointer which was just deleted. See bug
4584 if (DECL_IS_OPERATOR_NEW (fn
))
4590 /* Declare the return variable for the function. */
4591 use_retvar
= declare_return_variable (id
, return_slot
, modify_dest
,
4594 /* Add local vars in this inlined callee to caller. */
4595 add_local_variables (id
->src_cfun
, cfun
, id
);
4597 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4599 fprintf (dump_file
, "Inlining ");
4600 print_generic_expr (dump_file
, id
->src_fn
, 0);
4601 fprintf (dump_file
, " to ");
4602 print_generic_expr (dump_file
, id
->dst_fn
, 0);
4603 fprintf (dump_file
, " with frequency %i\n", cg_edge
->frequency
);
4606 /* This is it. Duplicate the callee body. Assume callee is
4607 pre-gimplified. Note that we must not alter the caller
4608 function in any way before this point, as this CALL_EXPR may be
4609 a self-referential call; if we're calling ourselves, we need to
4610 duplicate our body before altering anything. */
4611 copy_body (id
, cg_edge
->callee
->count
,
4612 GCOV_COMPUTE_SCALE (cg_edge
->frequency
, CGRAPH_FREQ_BASE
),
4613 bb
, return_block
, NULL
);
4615 /* Reset the escaped solution. */
4616 if (cfun
->gimple_df
)
4617 pt_solution_reset (&cfun
->gimple_df
->escaped
);
4622 delete id
->debug_map
;
4623 id
->debug_map
= dst
;
4625 delete id
->decl_map
;
4628 /* Unlink the calls virtual operands before replacing it. */
4629 unlink_stmt_vdef (stmt
);
4630 if (gimple_vdef (stmt
)
4631 && TREE_CODE (gimple_vdef (stmt
)) == SSA_NAME
)
4632 release_ssa_name (gimple_vdef (stmt
));
4634 /* If the inlined function returns a result that we care about,
4635 substitute the GIMPLE_CALL with an assignment of the return
4636 variable to the LHS of the call. That is, if STMT was
4637 'a = foo (...)', substitute the call with 'a = USE_RETVAR'. */
4638 if (use_retvar
&& gimple_call_lhs (stmt
))
4640 gimple old_stmt
= stmt
;
4641 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), use_retvar
);
4642 gsi_replace (&stmt_gsi
, stmt
, false);
4643 maybe_clean_or_replace_eh_stmt (old_stmt
, stmt
);
4645 /* Copy bounds if we copy structure with bounds. */
4646 if (chkp_function_instrumented_p (id
->dst_fn
)
4647 && !BOUNDED_P (use_retvar
)
4648 && chkp_type_has_pointer (TREE_TYPE (use_retvar
)))
4649 id
->assign_stmts
.safe_push (stmt
);
4653 /* Handle the case of inlining a function with no return
4654 statement, which causes the return value to become undefined. */
4655 if (gimple_call_lhs (stmt
)
4656 && TREE_CODE (gimple_call_lhs (stmt
)) == SSA_NAME
)
4658 tree name
= gimple_call_lhs (stmt
);
4659 tree var
= SSA_NAME_VAR (name
);
4660 tree def
= ssa_default_def (cfun
, var
);
4664 /* If the variable is used undefined, make this name
4665 undefined via a move. */
4666 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), def
);
4667 gsi_replace (&stmt_gsi
, stmt
, true);
4671 /* Otherwise make this variable undefined. */
4672 gsi_remove (&stmt_gsi
, true);
4673 set_ssa_default_def (cfun
, var
, name
);
4674 SSA_NAME_DEF_STMT (name
) = gimple_build_nop ();
4678 gsi_remove (&stmt_gsi
, true);
4681 /* Put returned bounds into the correct place if required. */
4684 gimple old_stmt
= SSA_NAME_DEF_STMT (return_bounds
);
4685 gimple new_stmt
= gimple_build_assign (return_bounds
, id
->retbnd
);
4686 gimple_stmt_iterator bnd_gsi
= gsi_for_stmt (old_stmt
);
4687 unlink_stmt_vdef (old_stmt
);
4688 gsi_replace (&bnd_gsi
, new_stmt
, false);
4689 maybe_clean_or_replace_eh_stmt (old_stmt
, new_stmt
);
4690 cgraph_update_edges_for_call_stmt (old_stmt
,
4691 gimple_call_fndecl (old_stmt
),
4695 if (purge_dead_abnormal_edges
)
4697 gimple_purge_dead_eh_edges (return_block
);
4698 gimple_purge_dead_abnormal_call_edges (return_block
);
4701 /* If the value of the new expression is ignored, that's OK. We
4702 don't warn about this for CALL_EXPRs, so we shouldn't warn about
4703 the equivalent inlined version either. */
4704 if (is_gimple_assign (stmt
))
4706 gcc_assert (gimple_assign_single_p (stmt
)
4707 || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
)));
4708 TREE_USED (gimple_assign_rhs1 (stmt
)) = 1;
4711 /* Copy bounds for all generated assigns that need it. */
4712 for (i
= 0; i
< id
->assign_stmts
.length (); i
++)
4713 chkp_copy_bounds_for_assign (id
->assign_stmts
[i
], cg_edge
);
4714 id
->assign_stmts
.release ();
4716 /* Output the inlining info for this abstract function, since it has been
4717 inlined. If we don't do this now, we can lose the information about the
4718 variables in the function when the blocks get blown away as soon as we
4719 remove the cgraph node. */
4720 if (gimple_block (stmt
))
4721 (*debug_hooks
->outlining_inline_function
) (cg_edge
->callee
->decl
);
4723 /* Update callgraph if needed. */
4724 cg_edge
->callee
->remove ();
4726 id
->block
= NULL_TREE
;
4727 successfully_inlined
= TRUE
;
4730 input_location
= saved_location
;
4731 return successfully_inlined
;
4734 /* Expand call statements reachable from STMT_P.
4735 We can only have CALL_EXPRs as the "toplevel" tree code or nested
4736 in a MODIFY_EXPR. */
4739 gimple_expand_calls_inline (basic_block bb
, copy_body_data
*id
)
4741 gimple_stmt_iterator gsi
;
4743 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4745 gimple stmt
= gsi_stmt (gsi
);
4747 if (is_gimple_call (stmt
)
4748 && !gimple_call_internal_p (stmt
)
4749 && expand_call_inline (bb
, stmt
, id
))
4757 /* Walk all basic blocks created after FIRST and try to fold every statement
4758 in the STATEMENTS pointer set. */
4761 fold_marked_statements (int first
, hash_set
<gimple
> *statements
)
4763 for (; first
< n_basic_blocks_for_fn (cfun
); first
++)
4764 if (BASIC_BLOCK_FOR_FN (cfun
, first
))
4766 gimple_stmt_iterator gsi
;
4768 for (gsi
= gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, first
));
4771 if (statements
->contains (gsi_stmt (gsi
)))
4773 gimple old_stmt
= gsi_stmt (gsi
);
4774 tree old_decl
= is_gimple_call (old_stmt
) ? gimple_call_fndecl (old_stmt
) : 0;
4776 if (old_decl
&& DECL_BUILT_IN (old_decl
))
4778 /* Folding builtins can create multiple instructions,
4779 we need to look at all of them. */
4780 gimple_stmt_iterator i2
= gsi
;
4782 if (fold_stmt (&gsi
))
4785 /* If a builtin at the end of a bb folded into nothing,
4786 the following loop won't work. */
4787 if (gsi_end_p (gsi
))
4789 cgraph_update_edges_for_call_stmt (old_stmt
,
4794 i2
= gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, first
));
4799 new_stmt
= gsi_stmt (i2
);
4800 update_stmt (new_stmt
);
4801 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4804 if (new_stmt
== gsi_stmt (gsi
))
4806 /* It is okay to check only for the very last
4807 of these statements. If it is a throwing
4808 statement nothing will change. If it isn't
4809 this can remove EH edges. If that weren't
4810 correct then because some intermediate stmts
4811 throw, but not the last one. That would mean
4812 we'd have to split the block, which we can't
4813 here and we'd loose anyway. And as builtins
4814 probably never throw, this all
4816 if (maybe_clean_or_replace_eh_stmt (old_stmt
,
4818 gimple_purge_dead_eh_edges (
4819 BASIC_BLOCK_FOR_FN (cfun
, first
));
4826 else if (fold_stmt (&gsi
))
4828 /* Re-read the statement from GSI as fold_stmt() may
4830 gimple new_stmt
= gsi_stmt (gsi
);
4831 update_stmt (new_stmt
);
4833 if (is_gimple_call (old_stmt
)
4834 || is_gimple_call (new_stmt
))
4835 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4838 if (maybe_clean_or_replace_eh_stmt (old_stmt
, new_stmt
))
4839 gimple_purge_dead_eh_edges (BASIC_BLOCK_FOR_FN (cfun
,
4846 /* Expand calls to inline functions in the body of FN. */
4849 optimize_inline_calls (tree fn
)
4853 int last
= n_basic_blocks_for_fn (cfun
);
4854 bool inlined_p
= false;
4857 memset (&id
, 0, sizeof (id
));
4859 id
.src_node
= id
.dst_node
= cgraph_node::get (fn
);
4860 gcc_assert (id
.dst_node
->definition
);
4862 /* Or any functions that aren't finished yet. */
4863 if (current_function_decl
)
4864 id
.dst_fn
= current_function_decl
;
4866 id
.copy_decl
= copy_decl_maybe_to_var
;
4867 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
4868 id
.transform_new_cfg
= false;
4869 id
.transform_return_to_modify
= true;
4870 id
.transform_parameter
= true;
4871 id
.transform_lang_insert_block
= NULL
;
4872 id
.statements_to_fold
= new hash_set
<gimple
>;
4874 push_gimplify_context ();
4876 /* We make no attempts to keep dominance info up-to-date. */
4877 free_dominance_info (CDI_DOMINATORS
);
4878 free_dominance_info (CDI_POST_DOMINATORS
);
4880 /* Register specific gimple functions. */
4881 gimple_register_cfg_hooks ();
4883 /* Reach the trees by walking over the CFG, and note the
4884 enclosing basic-blocks in the call edges. */
4885 /* We walk the blocks going forward, because inlined function bodies
4886 will split id->current_basic_block, and the new blocks will
4887 follow it; we'll trudge through them, processing their CALL_EXPRs
4889 FOR_EACH_BB_FN (bb
, cfun
)
4890 inlined_p
|= gimple_expand_calls_inline (bb
, &id
);
4892 pop_gimplify_context (NULL
);
4894 #ifdef ENABLE_CHECKING
4896 struct cgraph_edge
*e
;
4898 id
.dst_node
->verify ();
4900 /* Double check that we inlined everything we are supposed to inline. */
4901 for (e
= id
.dst_node
->callees
; e
; e
= e
->next_callee
)
4902 gcc_assert (e
->inline_failed
);
4906 /* Fold queued statements. */
4907 fold_marked_statements (last
, id
.statements_to_fold
);
4908 delete id
.statements_to_fold
;
4910 gcc_assert (!id
.debug_stmts
.exists ());
4912 /* If we didn't inline into the function there is nothing to do. */
4916 /* Renumber the lexical scoping (non-code) blocks consecutively. */
4919 delete_unreachable_blocks_update_callgraph (&id
);
4920 #ifdef ENABLE_CHECKING
4921 id
.dst_node
->verify ();
4924 /* It would be nice to check SSA/CFG/statement consistency here, but it is
4925 not possible yet - the IPA passes might make various functions to not
4926 throw and they don't care to proactively update local EH info. This is
4927 done later in fixup_cfg pass that also execute the verification. */
4928 return (TODO_update_ssa
4930 | (gimple_in_ssa_p (cfun
) ? TODO_remove_unused_locals
: 0)
4931 | (gimple_in_ssa_p (cfun
) ? TODO_update_address_taken
: 0)
4932 | (profile_status_for_fn (cfun
) != PROFILE_ABSENT
4933 ? TODO_rebuild_frequencies
: 0));
4936 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
4939 copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
4941 enum tree_code code
= TREE_CODE (*tp
);
4942 enum tree_code_class cl
= TREE_CODE_CLASS (code
);
4944 /* We make copies of most nodes. */
4945 if (IS_EXPR_CODE_CLASS (cl
)
4946 || code
== TREE_LIST
4948 || code
== TYPE_DECL
4949 || code
== OMP_CLAUSE
)
4951 /* Because the chain gets clobbered when we make a copy, we save it
4953 tree chain
= NULL_TREE
, new_tree
;
4955 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
4956 chain
= TREE_CHAIN (*tp
);
4958 /* Copy the node. */
4959 new_tree
= copy_node (*tp
);
4963 /* Now, restore the chain, if appropriate. That will cause
4964 walk_tree to walk into the chain as well. */
4965 if (code
== PARM_DECL
4966 || code
== TREE_LIST
4967 || code
== OMP_CLAUSE
)
4968 TREE_CHAIN (*tp
) = chain
;
4970 /* For now, we don't update BLOCKs when we make copies. So, we
4971 have to nullify all BIND_EXPRs. */
4972 if (TREE_CODE (*tp
) == BIND_EXPR
)
4973 BIND_EXPR_BLOCK (*tp
) = NULL_TREE
;
4975 else if (code
== CONSTRUCTOR
)
4977 /* CONSTRUCTOR nodes need special handling because
4978 we need to duplicate the vector of elements. */
4981 new_tree
= copy_node (*tp
);
4982 CONSTRUCTOR_ELTS (new_tree
) = vec_safe_copy (CONSTRUCTOR_ELTS (*tp
));
4985 else if (code
== STATEMENT_LIST
)
4986 /* We used to just abort on STATEMENT_LIST, but we can run into them
4987 with statement-expressions (c++/40975). */
4988 copy_statement_list (tp
);
4989 else if (TREE_CODE_CLASS (code
) == tcc_type
)
4991 else if (TREE_CODE_CLASS (code
) == tcc_declaration
)
4993 else if (TREE_CODE_CLASS (code
) == tcc_constant
)
4998 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
4999 information indicating to what new SAVE_EXPR this one should be mapped,
5000 use that one. Otherwise, create a new node and enter it in ST. FN is
5001 the function into which the copy will be placed. */
5004 remap_save_expr (tree
*tp
, hash_map
<tree
, tree
> *st
, int *walk_subtrees
)
5009 /* See if we already encountered this SAVE_EXPR. */
5012 /* If we didn't already remap this SAVE_EXPR, do so now. */
5015 t
= copy_node (*tp
);
5017 /* Remember this SAVE_EXPR. */
5019 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
5024 /* We've already walked into this SAVE_EXPR; don't do it again. */
5029 /* Replace this SAVE_EXPR with the copy. */
5033 /* Called via walk_gimple_seq. If *GSIP points to a GIMPLE_LABEL for a local
5034 label, copies the declaration and enters it in the splay_tree in DATA (which
5035 is really a 'copy_body_data *'. */
5038 mark_local_labels_stmt (gimple_stmt_iterator
*gsip
,
5039 bool *handled_ops_p ATTRIBUTE_UNUSED
,
5040 struct walk_stmt_info
*wi
)
5042 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
5043 glabel
*stmt
= dyn_cast
<glabel
*> (gsi_stmt (*gsip
));
5047 tree decl
= gimple_label_label (stmt
);
5049 /* Copy the decl and remember the copy. */
5050 insert_decl_map (id
, decl
, id
->copy_decl (decl
, id
));
5057 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
5058 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
5059 remaps all local declarations to appropriate replacements in gimple
5063 replace_locals_op (tree
*tp
, int *walk_subtrees
, void *data
)
5065 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
5066 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
5067 hash_map
<tree
, tree
> *st
= id
->decl_map
;
5071 /* Only a local declaration (variable or label). */
5072 if ((TREE_CODE (expr
) == VAR_DECL
5073 && !TREE_STATIC (expr
))
5074 || TREE_CODE (expr
) == LABEL_DECL
)
5076 /* Lookup the declaration. */
5079 /* If it's there, remap it. */
5084 else if (TREE_CODE (expr
) == STATEMENT_LIST
5085 || TREE_CODE (expr
) == BIND_EXPR
5086 || TREE_CODE (expr
) == SAVE_EXPR
)
5088 else if (TREE_CODE (expr
) == TARGET_EXPR
)
5090 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
5091 It's OK for this to happen if it was part of a subtree that
5092 isn't immediately expanded, such as operand 2 of another
5094 if (!TREE_OPERAND (expr
, 1))
5096 TREE_OPERAND (expr
, 1) = TREE_OPERAND (expr
, 3);
5097 TREE_OPERAND (expr
, 3) = NULL_TREE
;
5101 /* Keep iterating. */
5106 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
5107 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
5108 remaps all local declarations to appropriate replacements in gimple
5112 replace_locals_stmt (gimple_stmt_iterator
*gsip
,
5113 bool *handled_ops_p ATTRIBUTE_UNUSED
,
5114 struct walk_stmt_info
*wi
)
5116 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
5117 gimple gs
= gsi_stmt (*gsip
);
5119 if (gbind
*stmt
= dyn_cast
<gbind
*> (gs
))
5121 tree block
= gimple_bind_block (stmt
);
5125 remap_block (&block
, id
);
5126 gimple_bind_set_block (stmt
, block
);
5129 /* This will remap a lot of the same decls again, but this should be
5131 if (gimple_bind_vars (stmt
))
5132 gimple_bind_set_vars (stmt
, remap_decls (gimple_bind_vars (stmt
),
5136 /* Keep iterating. */
5141 /* Copies everything in SEQ and replaces variables and labels local to
5142 current_function_decl. */
5145 copy_gimple_seq_and_replace_locals (gimple_seq seq
)
5148 struct walk_stmt_info wi
;
5151 /* There's nothing to do for NULL_TREE. */
5156 memset (&id
, 0, sizeof (id
));
5157 id
.src_fn
= current_function_decl
;
5158 id
.dst_fn
= current_function_decl
;
5159 id
.decl_map
= new hash_map
<tree
, tree
>;
5160 id
.debug_map
= NULL
;
5162 id
.copy_decl
= copy_decl_no_change
;
5163 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5164 id
.transform_new_cfg
= false;
5165 id
.transform_return_to_modify
= false;
5166 id
.transform_parameter
= false;
5167 id
.transform_lang_insert_block
= NULL
;
5169 /* Walk the tree once to find local labels. */
5170 memset (&wi
, 0, sizeof (wi
));
5171 hash_set
<tree
> visited
;
5174 walk_gimple_seq (seq
, mark_local_labels_stmt
, NULL
, &wi
);
5176 copy
= gimple_seq_copy (seq
);
5178 /* Walk the copy, remapping decls. */
5179 memset (&wi
, 0, sizeof (wi
));
5181 walk_gimple_seq (copy
, replace_locals_stmt
, replace_locals_op
, &wi
);
5186 delete id
.debug_map
;
5187 if (id
.dependence_map
)
5189 delete id
.dependence_map
;
5190 id
.dependence_map
= NULL
;
5197 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
5200 debug_find_tree_1 (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
, void *data
)
5209 debug_find_tree (tree top
, tree search
)
5211 return walk_tree_without_duplicates (&top
, debug_find_tree_1
, search
) != 0;
5215 /* Declare the variables created by the inliner. Add all the variables in
5216 VARS to BIND_EXPR. */
5219 declare_inline_vars (tree block
, tree vars
)
5222 for (t
= vars
; t
; t
= DECL_CHAIN (t
))
5224 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
5225 gcc_assert (!TREE_STATIC (t
) && !TREE_ASM_WRITTEN (t
));
5226 add_local_decl (cfun
, t
);
5230 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), vars
);
5233 /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN,
5234 but now it will be in the TO_FN. PARM_TO_VAR means enable PARM_DECL to
5235 VAR_DECL translation. */
5238 copy_decl_for_dup_finish (copy_body_data
*id
, tree decl
, tree copy
)
5240 /* Don't generate debug information for the copy if we wouldn't have
5241 generated it for the copy either. */
5242 DECL_ARTIFICIAL (copy
) = DECL_ARTIFICIAL (decl
);
5243 DECL_IGNORED_P (copy
) = DECL_IGNORED_P (decl
);
5245 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
5246 declaration inspired this copy. */
5247 DECL_ABSTRACT_ORIGIN (copy
) = DECL_ORIGIN (decl
);
5249 /* The new variable/label has no RTL, yet. */
5250 if (CODE_CONTAINS_STRUCT (TREE_CODE (copy
), TS_DECL_WRTL
)
5251 && !TREE_STATIC (copy
) && !DECL_EXTERNAL (copy
))
5252 SET_DECL_RTL (copy
, 0);
5254 /* These args would always appear unused, if not for this. */
5255 TREE_USED (copy
) = 1;
5257 /* Set the context for the new declaration. */
5258 if (!DECL_CONTEXT (decl
))
5259 /* Globals stay global. */
5261 else if (DECL_CONTEXT (decl
) != id
->src_fn
)
5262 /* Things that weren't in the scope of the function we're inlining
5263 from aren't in the scope we're inlining to, either. */
5265 else if (TREE_STATIC (decl
))
5266 /* Function-scoped static variables should stay in the original
5270 /* Ordinary automatic local variables are now in the scope of the
5272 DECL_CONTEXT (copy
) = id
->dst_fn
;
5278 copy_decl_to_var (tree decl
, copy_body_data
*id
)
5282 gcc_assert (TREE_CODE (decl
) == PARM_DECL
5283 || TREE_CODE (decl
) == RESULT_DECL
);
5285 type
= TREE_TYPE (decl
);
5287 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
5288 VAR_DECL
, DECL_NAME (decl
), type
);
5289 if (DECL_PT_UID_SET_P (decl
))
5290 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
5291 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
5292 TREE_READONLY (copy
) = TREE_READONLY (decl
);
5293 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
5294 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
5296 return copy_decl_for_dup_finish (id
, decl
, copy
);
5299 /* Like copy_decl_to_var, but create a return slot object instead of a
5300 pointer variable for return by invisible reference. */
5303 copy_result_decl_to_var (tree decl
, copy_body_data
*id
)
5307 gcc_assert (TREE_CODE (decl
) == PARM_DECL
5308 || TREE_CODE (decl
) == RESULT_DECL
);
5310 type
= TREE_TYPE (decl
);
5311 if (DECL_BY_REFERENCE (decl
))
5312 type
= TREE_TYPE (type
);
5314 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
5315 VAR_DECL
, DECL_NAME (decl
), type
);
5316 if (DECL_PT_UID_SET_P (decl
))
5317 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
5318 TREE_READONLY (copy
) = TREE_READONLY (decl
);
5319 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
5320 if (!DECL_BY_REFERENCE (decl
))
5322 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
5323 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
5326 return copy_decl_for_dup_finish (id
, decl
, copy
);
5330 copy_decl_no_change (tree decl
, copy_body_data
*id
)
5334 copy
= copy_node (decl
);
5336 /* The COPY is not abstract; it will be generated in DST_FN. */
5337 DECL_ABSTRACT_P (copy
) = false;
5338 lang_hooks
.dup_lang_specific_decl (copy
);
5340 /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
5341 been taken; it's for internal bookkeeping in expand_goto_internal. */
5342 if (TREE_CODE (copy
) == LABEL_DECL
)
5344 TREE_ADDRESSABLE (copy
) = 0;
5345 LABEL_DECL_UID (copy
) = -1;
5348 return copy_decl_for_dup_finish (id
, decl
, copy
);
5352 copy_decl_maybe_to_var (tree decl
, copy_body_data
*id
)
5354 if (TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
)
5355 return copy_decl_to_var (decl
, id
);
5357 return copy_decl_no_change (decl
, id
);
5360 /* Return a copy of the function's argument tree. */
5362 copy_arguments_for_versioning (tree orig_parm
, copy_body_data
* id
,
5363 bitmap args_to_skip
, tree
*vars
)
5366 tree new_parm
= NULL
;
5371 for (arg
= orig_parm
; arg
; arg
= DECL_CHAIN (arg
), i
++)
5372 if (!args_to_skip
|| !bitmap_bit_p (args_to_skip
, i
))
5374 tree new_tree
= remap_decl (arg
, id
);
5375 if (TREE_CODE (new_tree
) != PARM_DECL
)
5376 new_tree
= id
->copy_decl (arg
, id
);
5377 lang_hooks
.dup_lang_specific_decl (new_tree
);
5379 parg
= &DECL_CHAIN (new_tree
);
5381 else if (!id
->decl_map
->get (arg
))
5383 /* Make an equivalent VAR_DECL. If the argument was used
5384 as temporary variable later in function, the uses will be
5385 replaced by local variable. */
5386 tree var
= copy_decl_to_var (arg
, id
);
5387 insert_decl_map (id
, arg
, var
);
5388 /* Declare this new variable. */
5389 DECL_CHAIN (var
) = *vars
;
5395 /* Return a copy of the function's static chain. */
5397 copy_static_chain (tree static_chain
, copy_body_data
* id
)
5399 tree
*chain_copy
, *pvar
;
5401 chain_copy
= &static_chain
;
5402 for (pvar
= chain_copy
; *pvar
; pvar
= &DECL_CHAIN (*pvar
))
5404 tree new_tree
= remap_decl (*pvar
, id
);
5405 lang_hooks
.dup_lang_specific_decl (new_tree
);
5406 DECL_CHAIN (new_tree
) = DECL_CHAIN (*pvar
);
5409 return static_chain
;
5412 /* Return true if the function is allowed to be versioned.
5413 This is a guard for the versioning functionality. */
5416 tree_versionable_function_p (tree fndecl
)
5418 return (!lookup_attribute ("noclone", DECL_ATTRIBUTES (fndecl
))
5419 && copy_forbidden (DECL_STRUCT_FUNCTION (fndecl
), fndecl
) == NULL
);
5422 /* Delete all unreachable basic blocks and update callgraph.
5423 Doing so is somewhat nontrivial because we need to update all clones and
5424 remove inline function that become unreachable. */
5427 delete_unreachable_blocks_update_callgraph (copy_body_data
*id
)
5429 bool changed
= false;
5430 basic_block b
, next_bb
;
5432 find_unreachable_blocks ();
5434 /* Delete all unreachable basic blocks. */
5436 for (b
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
; b
5437 != EXIT_BLOCK_PTR_FOR_FN (cfun
); b
= next_bb
)
5439 next_bb
= b
->next_bb
;
5441 if (!(b
->flags
& BB_REACHABLE
))
5443 gimple_stmt_iterator bsi
;
5445 for (bsi
= gsi_start_bb (b
); !gsi_end_p (bsi
); gsi_next (&bsi
))
5447 struct cgraph_edge
*e
;
5448 struct cgraph_node
*node
;
5450 id
->dst_node
->remove_stmt_references (gsi_stmt (bsi
));
5452 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
5453 &&(e
= id
->dst_node
->get_edge (gsi_stmt (bsi
))) != NULL
)
5455 if (!e
->inline_failed
)
5456 e
->callee
->remove_symbol_and_inline_clones (id
->dst_node
);
5460 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
5461 && id
->dst_node
->clones
)
5462 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
5464 node
->remove_stmt_references (gsi_stmt (bsi
));
5465 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
5466 && (e
= node
->get_edge (gsi_stmt (bsi
))) != NULL
)
5468 if (!e
->inline_failed
)
5469 e
->callee
->remove_symbol_and_inline_clones (id
->dst_node
);
5475 node
= node
->clones
;
5476 else if (node
->next_sibling_clone
)
5477 node
= node
->next_sibling_clone
;
5480 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5481 node
= node
->clone_of
;
5482 if (node
!= id
->dst_node
)
5483 node
= node
->next_sibling_clone
;
5487 delete_basic_block (b
);
5495 /* Update clone info after duplication. */
5498 update_clone_info (copy_body_data
* id
)
5500 struct cgraph_node
*node
;
5501 if (!id
->dst_node
->clones
)
5503 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
5505 /* First update replace maps to match the new body. */
5506 if (node
->clone
.tree_map
)
5509 for (i
= 0; i
< vec_safe_length (node
->clone
.tree_map
); i
++)
5511 struct ipa_replace_map
*replace_info
;
5512 replace_info
= (*node
->clone
.tree_map
)[i
];
5513 walk_tree (&replace_info
->old_tree
, copy_tree_body_r
, id
, NULL
);
5514 walk_tree (&replace_info
->new_tree
, copy_tree_body_r
, id
, NULL
);
5518 node
= node
->clones
;
5519 else if (node
->next_sibling_clone
)
5520 node
= node
->next_sibling_clone
;
5523 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5524 node
= node
->clone_of
;
5525 if (node
!= id
->dst_node
)
5526 node
= node
->next_sibling_clone
;
5531 /* Create a copy of a function's tree.
5532 OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
5533 of the original function and the new copied function
5534 respectively. In case we want to replace a DECL
5535 tree with another tree while duplicating the function's
5536 body, TREE_MAP represents the mapping between these
5537 trees. If UPDATE_CLONES is set, the call_stmt fields
5538 of edges of clones of the function will be updated.
5540 If non-NULL ARGS_TO_SKIP determine function parameters to remove
5542 If SKIP_RETURN is true, the new version will return void.
5543 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
5544 If non_NULL NEW_ENTRY determine new entry BB of the clone.
5547 tree_function_versioning (tree old_decl
, tree new_decl
,
5548 vec
<ipa_replace_map
*, va_gc
> *tree_map
,
5549 bool update_clones
, bitmap args_to_skip
,
5550 bool skip_return
, bitmap blocks_to_copy
,
5551 basic_block new_entry
)
5553 struct cgraph_node
*old_version_node
;
5554 struct cgraph_node
*new_version_node
;
5558 struct ipa_replace_map
*replace_info
;
5559 basic_block old_entry_block
, bb
;
5560 auto_vec
<gimple
, 10> init_stmts
;
5561 tree vars
= NULL_TREE
;
5563 gcc_assert (TREE_CODE (old_decl
) == FUNCTION_DECL
5564 && TREE_CODE (new_decl
) == FUNCTION_DECL
);
5565 DECL_POSSIBLY_INLINED (old_decl
) = 1;
5567 old_version_node
= cgraph_node::get (old_decl
);
5568 gcc_checking_assert (old_version_node
);
5569 new_version_node
= cgraph_node::get (new_decl
);
5570 gcc_checking_assert (new_version_node
);
5572 /* Copy over debug args. */
5573 if (DECL_HAS_DEBUG_ARGS_P (old_decl
))
5575 vec
<tree
, va_gc
> **new_debug_args
, **old_debug_args
;
5576 gcc_checking_assert (decl_debug_args_lookup (new_decl
) == NULL
);
5577 DECL_HAS_DEBUG_ARGS_P (new_decl
) = 0;
5578 old_debug_args
= decl_debug_args_lookup (old_decl
);
5581 new_debug_args
= decl_debug_args_insert (new_decl
);
5582 *new_debug_args
= vec_safe_copy (*old_debug_args
);
5586 /* Output the inlining info for this abstract function, since it has been
5587 inlined. If we don't do this now, we can lose the information about the
5588 variables in the function when the blocks get blown away as soon as we
5589 remove the cgraph node. */
5590 (*debug_hooks
->outlining_inline_function
) (old_decl
);
5592 DECL_ARTIFICIAL (new_decl
) = 1;
5593 DECL_ABSTRACT_ORIGIN (new_decl
) = DECL_ORIGIN (old_decl
);
5594 if (DECL_ORIGIN (old_decl
) == old_decl
)
5595 old_version_node
->used_as_abstract_origin
= true;
5596 DECL_FUNCTION_PERSONALITY (new_decl
) = DECL_FUNCTION_PERSONALITY (old_decl
);
5598 /* Prepare the data structures for the tree copy. */
5599 memset (&id
, 0, sizeof (id
));
5601 /* Generate a new name for the new version. */
5602 id
.statements_to_fold
= new hash_set
<gimple
>;
5604 id
.decl_map
= new hash_map
<tree
, tree
>;
5605 id
.debug_map
= NULL
;
5606 id
.src_fn
= old_decl
;
5607 id
.dst_fn
= new_decl
;
5608 id
.src_node
= old_version_node
;
5609 id
.dst_node
= new_version_node
;
5610 id
.src_cfun
= DECL_STRUCT_FUNCTION (old_decl
);
5611 id
.blocks_to_copy
= blocks_to_copy
;
5613 id
.copy_decl
= copy_decl_no_change
;
5614 id
.transform_call_graph_edges
5615 = update_clones
? CB_CGE_MOVE_CLONES
: CB_CGE_MOVE
;
5616 id
.transform_new_cfg
= true;
5617 id
.transform_return_to_modify
= false;
5618 id
.transform_parameter
= false;
5619 id
.transform_lang_insert_block
= NULL
;
5621 old_entry_block
= ENTRY_BLOCK_PTR_FOR_FN
5622 (DECL_STRUCT_FUNCTION (old_decl
));
5623 DECL_RESULT (new_decl
) = DECL_RESULT (old_decl
);
5624 DECL_ARGUMENTS (new_decl
) = DECL_ARGUMENTS (old_decl
);
5625 initialize_cfun (new_decl
, old_decl
,
5626 old_entry_block
->count
);
5627 if (DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
)
5628 DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
->ipa_pta
5629 = id
.src_cfun
->gimple_df
->ipa_pta
;
5631 /* Copy the function's static chain. */
5632 p
= DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
;
5634 DECL_STRUCT_FUNCTION (new_decl
)->static_chain_decl
=
5635 copy_static_chain (DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
,
5638 /* If there's a tree_map, prepare for substitution. */
5640 for (i
= 0; i
< tree_map
->length (); i
++)
5643 replace_info
= (*tree_map
)[i
];
5644 if (replace_info
->replace_p
)
5646 if (!replace_info
->old_tree
)
5648 int i
= replace_info
->parm_num
;
5652 for (parm
= DECL_ARGUMENTS (old_decl
); i
; parm
= DECL_CHAIN (parm
))
5654 replace_info
->old_tree
= parm
;
5655 req_type
= TREE_TYPE (parm
);
5656 if (!useless_type_conversion_p (req_type
, TREE_TYPE (replace_info
->new_tree
)))
5658 if (fold_convertible_p (req_type
, replace_info
->new_tree
))
5659 replace_info
->new_tree
= fold_build1 (NOP_EXPR
, req_type
, replace_info
->new_tree
);
5660 else if (TYPE_SIZE (req_type
) == TYPE_SIZE (TREE_TYPE (replace_info
->new_tree
)))
5661 replace_info
->new_tree
= fold_build1 (VIEW_CONVERT_EXPR
, req_type
, replace_info
->new_tree
);
5666 fprintf (dump_file
, " const ");
5667 print_generic_expr (dump_file
, replace_info
->new_tree
, 0);
5668 fprintf (dump_file
, " can't be converted to param ");
5669 print_generic_expr (dump_file
, parm
, 0);
5670 fprintf (dump_file
, "\n");
5672 replace_info
->old_tree
= NULL
;
5677 gcc_assert (TREE_CODE (replace_info
->old_tree
) == PARM_DECL
);
5678 if (replace_info
->old_tree
)
5680 init
= setup_one_parameter (&id
, replace_info
->old_tree
,
5681 replace_info
->new_tree
, id
.src_fn
,
5685 init_stmts
.safe_push (init
);
5689 /* Copy the function's arguments. */
5690 if (DECL_ARGUMENTS (old_decl
) != NULL_TREE
)
5691 DECL_ARGUMENTS (new_decl
) =
5692 copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl
), &id
,
5693 args_to_skip
, &vars
);
5695 DECL_INITIAL (new_decl
) = remap_blocks (DECL_INITIAL (id
.src_fn
), &id
);
5696 BLOCK_SUPERCONTEXT (DECL_INITIAL (new_decl
)) = new_decl
;
5698 declare_inline_vars (DECL_INITIAL (new_decl
), vars
);
5700 if (!vec_safe_is_empty (DECL_STRUCT_FUNCTION (old_decl
)->local_decls
))
5701 /* Add local vars. */
5702 add_local_variables (DECL_STRUCT_FUNCTION (old_decl
), cfun
, &id
);
5704 if (DECL_RESULT (old_decl
) == NULL_TREE
)
5706 else if (skip_return
&& !VOID_TYPE_P (TREE_TYPE (DECL_RESULT (old_decl
))))
5708 DECL_RESULT (new_decl
)
5709 = build_decl (DECL_SOURCE_LOCATION (DECL_RESULT (old_decl
)),
5710 RESULT_DECL
, NULL_TREE
, void_type_node
);
5711 DECL_CONTEXT (DECL_RESULT (new_decl
)) = new_decl
;
5712 cfun
->returns_struct
= 0;
5713 cfun
->returns_pcc_struct
= 0;
5718 DECL_RESULT (new_decl
) = remap_decl (DECL_RESULT (old_decl
), &id
);
5719 lang_hooks
.dup_lang_specific_decl (DECL_RESULT (new_decl
));
5720 if (gimple_in_ssa_p (id
.src_cfun
)
5721 && DECL_BY_REFERENCE (DECL_RESULT (old_decl
))
5722 && (old_name
= ssa_default_def (id
.src_cfun
, DECL_RESULT (old_decl
))))
5724 tree new_name
= make_ssa_name (DECL_RESULT (new_decl
));
5725 insert_decl_map (&id
, old_name
, new_name
);
5726 SSA_NAME_DEF_STMT (new_name
) = gimple_build_nop ();
5727 set_ssa_default_def (cfun
, DECL_RESULT (new_decl
), new_name
);
5731 /* Set up the destination functions loop tree. */
5732 if (loops_for_fn (DECL_STRUCT_FUNCTION (old_decl
)) != NULL
)
5734 cfun
->curr_properties
&= ~PROP_loops
;
5735 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
5736 cfun
->curr_properties
|= PROP_loops
;
5739 /* Copy the Function's body. */
5740 copy_body (&id
, old_entry_block
->count
, REG_BR_PROB_BASE
,
5741 ENTRY_BLOCK_PTR_FOR_FN (cfun
), EXIT_BLOCK_PTR_FOR_FN (cfun
),
5744 /* Renumber the lexical scoping (non-code) blocks consecutively. */
5745 number_blocks (new_decl
);
5747 /* We want to create the BB unconditionally, so that the addition of
5748 debug stmts doesn't affect BB count, which may in the end cause
5749 codegen differences. */
5750 bb
= split_edge (single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
5751 while (init_stmts
.length ())
5752 insert_init_stmt (&id
, bb
, init_stmts
.pop ());
5753 update_clone_info (&id
);
5755 /* Remap the nonlocal_goto_save_area, if any. */
5756 if (cfun
->nonlocal_goto_save_area
)
5758 struct walk_stmt_info wi
;
5760 memset (&wi
, 0, sizeof (wi
));
5762 walk_tree (&cfun
->nonlocal_goto_save_area
, remap_gimple_op_r
, &wi
, NULL
);
5768 delete id
.debug_map
;
5769 free_dominance_info (CDI_DOMINATORS
);
5770 free_dominance_info (CDI_POST_DOMINATORS
);
5772 fold_marked_statements (0, id
.statements_to_fold
);
5773 delete id
.statements_to_fold
;
5774 fold_cond_expr_cond ();
5775 delete_unreachable_blocks_update_callgraph (&id
);
5776 if (id
.dst_node
->definition
)
5777 cgraph_edge::rebuild_references ();
5778 if (loops_state_satisfies_p (LOOPS_NEED_FIXUP
))
5780 calculate_dominance_info (CDI_DOMINATORS
);
5781 fix_loop_structure (NULL
);
5783 update_ssa (TODO_update_ssa
);
5785 /* After partial cloning we need to rescale frequencies, so they are
5786 within proper range in the cloned function. */
5789 struct cgraph_edge
*e
;
5790 rebuild_frequencies ();
5792 new_version_node
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5793 for (e
= new_version_node
->callees
; e
; e
= e
->next_callee
)
5795 basic_block bb
= gimple_bb (e
->call_stmt
);
5796 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
5798 e
->count
= bb
->count
;
5800 for (e
= new_version_node
->indirect_calls
; e
; e
= e
->next_callee
)
5802 basic_block bb
= gimple_bb (e
->call_stmt
);
5803 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
5805 e
->count
= bb
->count
;
5809 free_dominance_info (CDI_DOMINATORS
);
5810 free_dominance_info (CDI_POST_DOMINATORS
);
5812 gcc_assert (!id
.debug_stmts
.exists ());
5817 /* EXP is CALL_EXPR present in a GENERIC expression tree. Try to integrate
5818 the callee and return the inlined body on success. */
5821 maybe_inline_call_in_expr (tree exp
)
5823 tree fn
= get_callee_fndecl (exp
);
5825 /* We can only try to inline "const" functions. */
5826 if (fn
&& TREE_READONLY (fn
) && DECL_SAVED_TREE (fn
))
5828 call_expr_arg_iterator iter
;
5831 hash_map
<tree
, tree
> decl_map
;
5833 /* Remap the parameters. */
5834 for (param
= DECL_ARGUMENTS (fn
), arg
= first_call_expr_arg (exp
, &iter
);
5836 param
= DECL_CHAIN (param
), arg
= next_call_expr_arg (&iter
))
5837 decl_map
.put (param
, arg
);
5839 memset (&id
, 0, sizeof (id
));
5841 id
.dst_fn
= current_function_decl
;
5842 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
5843 id
.decl_map
= &decl_map
;
5845 id
.copy_decl
= copy_decl_no_change
;
5846 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5847 id
.transform_new_cfg
= false;
5848 id
.transform_return_to_modify
= true;
5849 id
.transform_parameter
= true;
5850 id
.transform_lang_insert_block
= NULL
;
5852 /* Make sure not to unshare trees behind the front-end's back
5853 since front-end specific mechanisms may rely on sharing. */
5854 id
.regimplify
= false;
5855 id
.do_not_unshare
= true;
5857 /* We're not inside any EH region. */
5860 t
= copy_tree_body (&id
);
5862 /* We can only return something suitable for use in a GENERIC
5864 if (TREE_CODE (t
) == MODIFY_EXPR
)
5865 return TREE_OPERAND (t
, 1);
5871 /* Duplicate a type, fields and all. */
5874 build_duplicate_type (tree type
)
5876 struct copy_body_data id
;
5878 memset (&id
, 0, sizeof (id
));
5879 id
.src_fn
= current_function_decl
;
5880 id
.dst_fn
= current_function_decl
;
5882 id
.decl_map
= new hash_map
<tree
, tree
>;
5883 id
.debug_map
= NULL
;
5884 id
.copy_decl
= copy_decl_no_change
;
5886 type
= remap_type_1 (type
, &id
);
5890 delete id
.debug_map
;
5892 TYPE_CANONICAL (type
) = type
;
5897 /* Unshare the entire DECL_SAVED_TREE of FN and return the remapped
5898 parameters and RESULT_DECL in PARMS and RESULT. Used by C++ constexpr
5902 copy_fn (tree fn
, tree
& parms
, tree
& result
)
5906 hash_map
<tree
, tree
> decl_map
;
5911 memset (&id
, 0, sizeof (id
));
5913 id
.dst_fn
= current_function_decl
;
5914 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
5915 id
.decl_map
= &decl_map
;
5917 id
.copy_decl
= copy_decl_no_change
;
5918 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5919 id
.transform_new_cfg
= false;
5920 id
.transform_return_to_modify
= false;
5921 id
.transform_parameter
= true;
5922 id
.transform_lang_insert_block
= NULL
;
5924 /* Make sure not to unshare trees behind the front-end's back
5925 since front-end specific mechanisms may rely on sharing. */
5926 id
.regimplify
= false;
5927 id
.do_not_unshare
= true;
5929 /* We're not inside any EH region. */
5932 /* Remap the parameters and result and return them to the caller. */
5933 for (param
= DECL_ARGUMENTS (fn
);
5935 param
= DECL_CHAIN (param
))
5937 *p
= remap_decl (param
, &id
);
5938 p
= &DECL_CHAIN (*p
);
5941 if (DECL_RESULT (fn
))
5942 result
= remap_decl (DECL_RESULT (fn
), &id
);
5946 return copy_tree_body (&id
);