2 Copyright (C) 2001-2013 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 "tree-inline.h"
31 #include "insn-config.h"
33 #include "langhooks.h"
34 #include "basic-block.h"
35 #include "tree-iterator.h"
38 #include "tree-mudflap.h"
39 #include "tree-flow.h"
41 #include "tree-flow.h"
42 #include "tree-pretty-print.h"
45 #include "pointer-set.h"
47 #include "value-prof.h"
48 #include "tree-pass.h"
51 #include "rtl.h" /* FIXME: For asm_str_count. */
53 /* I'm not real happy about this, but we need to handle gimple and
57 /* Inlining, Cloning, Versioning, Parallelization
59 Inlining: a function body is duplicated, but the PARM_DECLs are
60 remapped into VAR_DECLs, and non-void RETURN_EXPRs become
61 MODIFY_EXPRs that store to a dedicated returned-value variable.
62 The duplicated eh_region info of the copy will later be appended
63 to the info for the caller; the eh_region info in copied throwing
64 statements and RESX statements are adjusted accordingly.
66 Cloning: (only in C++) We have one body for a con/de/structor, and
67 multiple function decls, each with a unique parameter list.
68 Duplicate the body, using the given splay tree; some parameters
69 will become constants (like 0 or 1).
71 Versioning: a function body is duplicated and the result is a new
72 function rather than into blocks of an existing function as with
73 inlining. Some parameters will become constants.
75 Parallelization: a region of a function is duplicated resulting in
76 a new function. Variables may be replaced with complex expressions
77 to enable shared variable semantics.
79 All of these will simultaneously lookup any callgraph edges. If
80 we're going to inline the duplicated function body, and the given
81 function has some cloned callgraph nodes (one for each place this
82 function will be inlined) those callgraph edges will be duplicated.
83 If we're cloning the body, those callgraph edges will be
84 updated to point into the new body. (Note that the original
85 callgraph node and edge list will not be altered.)
87 See the CALL_EXPR handling case in copy_tree_body_r (). */
91 o In order to make inlining-on-trees work, we pessimized
92 function-local static constants. In particular, they are now
93 always output, even when not addressed. Fix this by treating
94 function-local static constants just like global static
95 constants; the back-end already knows not to output them if they
98 o Provide heuristics to clamp inlining of recursive template
102 /* Weights that estimate_num_insns uses to estimate the size of the
105 eni_weights eni_size_weights
;
107 /* Weights that estimate_num_insns uses to estimate the time necessary
108 to execute the produced code. */
110 eni_weights eni_time_weights
;
114 static tree
declare_return_variable (copy_body_data
*, tree
, tree
, basic_block
);
115 static void remap_block (tree
*, copy_body_data
*);
116 static void copy_bind_expr (tree
*, int *, copy_body_data
*);
117 static void declare_inline_vars (tree
, tree
);
118 static void remap_save_expr (tree
*, void *, int *);
119 static void prepend_lexical_block (tree current_block
, tree new_block
);
120 static tree
copy_decl_to_var (tree
, copy_body_data
*);
121 static tree
copy_result_decl_to_var (tree
, copy_body_data
*);
122 static tree
copy_decl_maybe_to_var (tree
, copy_body_data
*);
123 static gimple
remap_gimple_stmt (gimple
, copy_body_data
*);
124 static bool delete_unreachable_blocks_update_callgraph (copy_body_data
*id
);
126 /* Insert a tree->tree mapping for ID. Despite the name suggests
127 that the trees should be variables, it is used for more than that. */
130 insert_decl_map (copy_body_data
*id
, tree key
, tree value
)
132 *pointer_map_insert (id
->decl_map
, key
) = value
;
134 /* Always insert an identity map as well. If we see this same new
135 node again, we won't want to duplicate it a second time. */
137 *pointer_map_insert (id
->decl_map
, value
) = value
;
140 /* Insert a tree->tree mapping for ID. This is only used for
144 insert_debug_decl_map (copy_body_data
*id
, tree key
, tree value
)
146 if (!gimple_in_ssa_p (id
->src_cfun
))
149 if (!MAY_HAVE_DEBUG_STMTS
)
152 if (!target_for_debug_bind (key
))
155 gcc_assert (TREE_CODE (key
) == PARM_DECL
);
156 gcc_assert (TREE_CODE (value
) == VAR_DECL
);
159 id
->debug_map
= pointer_map_create ();
161 *pointer_map_insert (id
->debug_map
, key
) = value
;
164 /* If nonzero, we're remapping the contents of inlined debug
165 statements. If negative, an error has occurred, such as a
166 reference to a variable that isn't available in the inlined
168 static int processing_debug_stmt
= 0;
170 /* Construct new SSA name for old NAME. ID is the inline context. */
173 remap_ssa_name (tree name
, copy_body_data
*id
)
178 gcc_assert (TREE_CODE (name
) == SSA_NAME
);
180 n
= (tree
*) pointer_map_contains (id
->decl_map
, name
);
182 return unshare_expr (*n
);
184 if (processing_debug_stmt
)
186 if (SSA_NAME_IS_DEFAULT_DEF (name
)
187 && TREE_CODE (SSA_NAME_VAR (name
)) == PARM_DECL
188 && id
->entry_bb
== NULL
189 && single_succ_p (ENTRY_BLOCK_PTR
))
191 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
193 gimple_stmt_iterator gsi
;
194 tree val
= SSA_NAME_VAR (name
);
196 n
= (tree
*) pointer_map_contains (id
->decl_map
, val
);
199 if (TREE_CODE (val
) != PARM_DECL
)
201 processing_debug_stmt
= -1;
204 def_temp
= gimple_build_debug_source_bind (vexpr
, val
, NULL
);
205 DECL_ARTIFICIAL (vexpr
) = 1;
206 TREE_TYPE (vexpr
) = TREE_TYPE (name
);
207 DECL_MODE (vexpr
) = DECL_MODE (SSA_NAME_VAR (name
));
208 gsi
= gsi_after_labels (single_succ (ENTRY_BLOCK_PTR
));
209 gsi_insert_before (&gsi
, def_temp
, GSI_SAME_STMT
);
213 processing_debug_stmt
= -1;
217 /* Remap anonymous SSA names or SSA names of anonymous decls. */
218 var
= SSA_NAME_VAR (name
);
220 || (!SSA_NAME_IS_DEFAULT_DEF (name
)
221 && TREE_CODE (var
) == VAR_DECL
222 && !VAR_DECL_IS_VIRTUAL_OPERAND (var
)
223 && DECL_ARTIFICIAL (var
)
224 && DECL_IGNORED_P (var
)
225 && !DECL_NAME (var
)))
227 struct ptr_info_def
*pi
;
228 new_tree
= make_ssa_name (remap_type (TREE_TYPE (name
), id
), NULL
);
229 if (!var
&& SSA_NAME_IDENTIFIER (name
))
230 SET_SSA_NAME_VAR_OR_IDENTIFIER (new_tree
, SSA_NAME_IDENTIFIER (name
));
231 insert_decl_map (id
, name
, new_tree
);
232 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
233 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
234 /* At least IPA points-to info can be directly transferred. */
235 if (id
->src_cfun
->gimple_df
236 && id
->src_cfun
->gimple_df
->ipa_pta
237 && (pi
= SSA_NAME_PTR_INFO (name
))
240 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
246 /* Do not set DEF_STMT yet as statement is not copied yet. We do that
248 new_tree
= remap_decl (var
, id
);
250 /* We might've substituted constant or another SSA_NAME for
253 Replace the SSA name representing RESULT_DECL by variable during
254 inlining: this saves us from need to introduce PHI node in a case
255 return value is just partly initialized. */
256 if ((TREE_CODE (new_tree
) == VAR_DECL
|| TREE_CODE (new_tree
) == PARM_DECL
)
257 && (!SSA_NAME_VAR (name
)
258 || TREE_CODE (SSA_NAME_VAR (name
)) != RESULT_DECL
259 || !id
->transform_return_to_modify
))
261 struct ptr_info_def
*pi
;
262 new_tree
= make_ssa_name (new_tree
, NULL
);
263 insert_decl_map (id
, name
, new_tree
);
264 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
265 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
266 /* At least IPA points-to info can be directly transferred. */
267 if (id
->src_cfun
->gimple_df
268 && id
->src_cfun
->gimple_df
->ipa_pta
269 && (pi
= SSA_NAME_PTR_INFO (name
))
272 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
275 if (SSA_NAME_IS_DEFAULT_DEF (name
))
277 /* By inlining function having uninitialized variable, we might
278 extend the lifetime (variable might get reused). This cause
279 ICE in the case we end up extending lifetime of SSA name across
280 abnormal edge, but also increase register pressure.
282 We simply initialize all uninitialized vars by 0 except
283 for case we are inlining to very first BB. We can avoid
284 this for all BBs that are not inside strongly connected
285 regions of the CFG, but this is expensive to test. */
287 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
)
288 && (!SSA_NAME_VAR (name
)
289 || TREE_CODE (SSA_NAME_VAR (name
)) != PARM_DECL
)
290 && (id
->entry_bb
!= EDGE_SUCC (ENTRY_BLOCK_PTR
, 0)->dest
291 || EDGE_COUNT (id
->entry_bb
->preds
) != 1))
293 gimple_stmt_iterator gsi
= gsi_last_bb (id
->entry_bb
);
295 tree zero
= build_zero_cst (TREE_TYPE (new_tree
));
297 init_stmt
= gimple_build_assign (new_tree
, zero
);
298 gsi_insert_after (&gsi
, init_stmt
, GSI_NEW_STMT
);
299 SSA_NAME_IS_DEFAULT_DEF (new_tree
) = 0;
303 SSA_NAME_DEF_STMT (new_tree
) = gimple_build_nop ();
304 set_ssa_default_def (cfun
, SSA_NAME_VAR (new_tree
), new_tree
);
309 insert_decl_map (id
, name
, new_tree
);
313 /* Remap DECL during the copying of the BLOCK tree for the function. */
316 remap_decl (tree decl
, copy_body_data
*id
)
320 /* We only remap local variables in the current function. */
322 /* See if we have remapped this declaration. */
324 n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
326 if (!n
&& processing_debug_stmt
)
328 processing_debug_stmt
= -1;
332 /* If we didn't already have an equivalent for this declaration,
336 /* Make a copy of the variable or label. */
337 tree t
= id
->copy_decl (decl
, id
);
339 /* Remember it, so that if we encounter this local entity again
340 we can reuse this copy. Do this early because remap_type may
341 need this decl for TYPE_STUB_DECL. */
342 insert_decl_map (id
, decl
, t
);
347 /* Remap types, if necessary. */
348 TREE_TYPE (t
) = remap_type (TREE_TYPE (t
), id
);
349 if (TREE_CODE (t
) == TYPE_DECL
)
350 DECL_ORIGINAL_TYPE (t
) = remap_type (DECL_ORIGINAL_TYPE (t
), id
);
352 /* Remap sizes as necessary. */
353 walk_tree (&DECL_SIZE (t
), copy_tree_body_r
, id
, NULL
);
354 walk_tree (&DECL_SIZE_UNIT (t
), copy_tree_body_r
, id
, NULL
);
356 /* If fields, do likewise for offset and qualifier. */
357 if (TREE_CODE (t
) == FIELD_DECL
)
359 walk_tree (&DECL_FIELD_OFFSET (t
), copy_tree_body_r
, id
, NULL
);
360 if (TREE_CODE (DECL_CONTEXT (t
)) == QUAL_UNION_TYPE
)
361 walk_tree (&DECL_QUALIFIER (t
), copy_tree_body_r
, id
, NULL
);
367 if (id
->do_not_unshare
)
370 return unshare_expr (*n
);
374 remap_type_1 (tree type
, copy_body_data
*id
)
378 /* We do need a copy. build and register it now. If this is a pointer or
379 reference type, remap the designated type and make a new pointer or
381 if (TREE_CODE (type
) == POINTER_TYPE
)
383 new_tree
= build_pointer_type_for_mode (remap_type (TREE_TYPE (type
), id
),
385 TYPE_REF_CAN_ALIAS_ALL (type
));
386 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
387 new_tree
= build_type_attribute_qual_variant (new_tree
,
388 TYPE_ATTRIBUTES (type
),
390 insert_decl_map (id
, type
, new_tree
);
393 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
395 new_tree
= build_reference_type_for_mode (remap_type (TREE_TYPE (type
), id
),
397 TYPE_REF_CAN_ALIAS_ALL (type
));
398 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
399 new_tree
= build_type_attribute_qual_variant (new_tree
,
400 TYPE_ATTRIBUTES (type
),
402 insert_decl_map (id
, type
, new_tree
);
406 new_tree
= copy_node (type
);
408 insert_decl_map (id
, type
, new_tree
);
410 /* This is a new type, not a copy of an old type. Need to reassociate
411 variants. We can handle everything except the main variant lazily. */
412 t
= TYPE_MAIN_VARIANT (type
);
415 t
= remap_type (t
, id
);
416 TYPE_MAIN_VARIANT (new_tree
) = t
;
417 TYPE_NEXT_VARIANT (new_tree
) = TYPE_NEXT_VARIANT (t
);
418 TYPE_NEXT_VARIANT (t
) = new_tree
;
422 TYPE_MAIN_VARIANT (new_tree
) = new_tree
;
423 TYPE_NEXT_VARIANT (new_tree
) = NULL
;
426 if (TYPE_STUB_DECL (type
))
427 TYPE_STUB_DECL (new_tree
) = remap_decl (TYPE_STUB_DECL (type
), id
);
429 /* Lazily create pointer and reference types. */
430 TYPE_POINTER_TO (new_tree
) = NULL
;
431 TYPE_REFERENCE_TO (new_tree
) = NULL
;
433 switch (TREE_CODE (new_tree
))
437 case FIXED_POINT_TYPE
:
440 t
= TYPE_MIN_VALUE (new_tree
);
441 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
442 walk_tree (&TYPE_MIN_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
444 t
= TYPE_MAX_VALUE (new_tree
);
445 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
446 walk_tree (&TYPE_MAX_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
450 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
451 walk_tree (&TYPE_ARG_TYPES (new_tree
), copy_tree_body_r
, id
, NULL
);
455 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
456 TYPE_DOMAIN (new_tree
) = remap_type (TYPE_DOMAIN (new_tree
), id
);
461 case QUAL_UNION_TYPE
:
465 for (f
= TYPE_FIELDS (new_tree
); f
; f
= DECL_CHAIN (f
))
467 t
= remap_decl (f
, id
);
468 DECL_CONTEXT (t
) = new_tree
;
472 TYPE_FIELDS (new_tree
) = nreverse (nf
);
478 /* Shouldn't have been thought variable sized. */
482 walk_tree (&TYPE_SIZE (new_tree
), copy_tree_body_r
, id
, NULL
);
483 walk_tree (&TYPE_SIZE_UNIT (new_tree
), copy_tree_body_r
, id
, NULL
);
489 remap_type (tree type
, copy_body_data
*id
)
497 /* See if we have remapped this type. */
498 node
= (tree
*) pointer_map_contains (id
->decl_map
, type
);
502 /* The type only needs remapping if it's variably modified. */
503 if (! variably_modified_type_p (type
, id
->src_fn
))
505 insert_decl_map (id
, type
, type
);
509 id
->remapping_type_depth
++;
510 tmp
= remap_type_1 (type
, id
);
511 id
->remapping_type_depth
--;
516 /* Decide if DECL can be put into BLOCK_NONLOCAL_VARs. */
519 can_be_nonlocal (tree decl
, copy_body_data
*id
)
521 /* We can not duplicate function decls. */
522 if (TREE_CODE (decl
) == FUNCTION_DECL
)
525 /* Local static vars must be non-local or we get multiple declaration
527 if (TREE_CODE (decl
) == VAR_DECL
528 && !auto_var_in_fn_p (decl
, id
->src_fn
))
535 remap_decls (tree decls
, vec
<tree
, va_gc
> **nonlocalized_list
,
539 tree new_decls
= NULL_TREE
;
541 /* Remap its variables. */
542 for (old_var
= decls
; old_var
; old_var
= DECL_CHAIN (old_var
))
546 if (can_be_nonlocal (old_var
, id
))
548 /* We need to add this variable to the local decls as otherwise
549 nothing else will do so. */
550 if (TREE_CODE (old_var
) == VAR_DECL
551 && ! DECL_EXTERNAL (old_var
))
552 add_local_decl (cfun
, old_var
);
553 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
554 && !DECL_IGNORED_P (old_var
)
555 && nonlocalized_list
)
556 vec_safe_push (*nonlocalized_list
, old_var
);
560 /* Remap the variable. */
561 new_var
= remap_decl (old_var
, id
);
563 /* If we didn't remap this variable, we can't mess with its
564 TREE_CHAIN. If we remapped this variable to the return slot, it's
565 already declared somewhere else, so don't declare it here. */
567 if (new_var
== id
->retvar
)
571 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
572 && !DECL_IGNORED_P (old_var
)
573 && nonlocalized_list
)
574 vec_safe_push (*nonlocalized_list
, old_var
);
578 gcc_assert (DECL_P (new_var
));
579 DECL_CHAIN (new_var
) = new_decls
;
582 /* Also copy value-expressions. */
583 if (TREE_CODE (new_var
) == VAR_DECL
584 && DECL_HAS_VALUE_EXPR_P (new_var
))
586 tree tem
= DECL_VALUE_EXPR (new_var
);
587 bool old_regimplify
= id
->regimplify
;
588 id
->remapping_type_depth
++;
589 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
590 id
->remapping_type_depth
--;
591 id
->regimplify
= old_regimplify
;
592 SET_DECL_VALUE_EXPR (new_var
, tem
);
597 return nreverse (new_decls
);
600 /* Copy the BLOCK to contain remapped versions of the variables
601 therein. And hook the new block into the block-tree. */
604 remap_block (tree
*block
, copy_body_data
*id
)
609 /* Make the new block. */
611 new_block
= make_node (BLOCK
);
612 TREE_USED (new_block
) = TREE_USED (old_block
);
613 BLOCK_ABSTRACT_ORIGIN (new_block
) = old_block
;
614 BLOCK_SOURCE_LOCATION (new_block
) = BLOCK_SOURCE_LOCATION (old_block
);
615 BLOCK_NONLOCALIZED_VARS (new_block
)
616 = vec_safe_copy (BLOCK_NONLOCALIZED_VARS (old_block
));
619 /* Remap its variables. */
620 BLOCK_VARS (new_block
) = remap_decls (BLOCK_VARS (old_block
),
621 &BLOCK_NONLOCALIZED_VARS (new_block
),
624 if (id
->transform_lang_insert_block
)
625 id
->transform_lang_insert_block (new_block
);
627 /* Remember the remapped block. */
628 insert_decl_map (id
, old_block
, new_block
);
631 /* Copy the whole block tree and root it in id->block. */
633 remap_blocks (tree block
, copy_body_data
*id
)
636 tree new_tree
= block
;
641 remap_block (&new_tree
, id
);
642 gcc_assert (new_tree
!= block
);
643 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
644 prepend_lexical_block (new_tree
, remap_blocks (t
, id
));
645 /* Blocks are in arbitrary order, but make things slightly prettier and do
646 not swap order when producing a copy. */
647 BLOCK_SUBBLOCKS (new_tree
) = blocks_nreverse (BLOCK_SUBBLOCKS (new_tree
));
651 /* Remap the block tree rooted at BLOCK to nothing. */
653 remap_blocks_to_null (tree block
, copy_body_data
*id
)
656 insert_decl_map (id
, block
, NULL_TREE
);
657 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
658 remap_blocks_to_null (t
, id
);
662 copy_statement_list (tree
*tp
)
664 tree_stmt_iterator oi
, ni
;
667 new_tree
= alloc_stmt_list ();
668 ni
= tsi_start (new_tree
);
669 oi
= tsi_start (*tp
);
670 TREE_TYPE (new_tree
) = TREE_TYPE (*tp
);
673 for (; !tsi_end_p (oi
); tsi_next (&oi
))
675 tree stmt
= tsi_stmt (oi
);
676 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
677 /* This copy is not redundant; tsi_link_after will smash this
678 STATEMENT_LIST into the end of the one we're building, and we
679 don't want to do that with the original. */
680 copy_statement_list (&stmt
);
681 tsi_link_after (&ni
, stmt
, TSI_CONTINUE_LINKING
);
686 copy_bind_expr (tree
*tp
, int *walk_subtrees
, copy_body_data
*id
)
688 tree block
= BIND_EXPR_BLOCK (*tp
);
689 /* Copy (and replace) the statement. */
690 copy_tree_r (tp
, walk_subtrees
, NULL
);
693 remap_block (&block
, id
);
694 BIND_EXPR_BLOCK (*tp
) = block
;
697 if (BIND_EXPR_VARS (*tp
))
698 /* This will remap a lot of the same decls again, but this should be
700 BIND_EXPR_VARS (*tp
) = remap_decls (BIND_EXPR_VARS (*tp
), NULL
, id
);
704 /* Create a new gimple_seq by remapping all the statements in BODY
705 using the inlining information in ID. */
708 remap_gimple_seq (gimple_seq body
, copy_body_data
*id
)
710 gimple_stmt_iterator si
;
711 gimple_seq new_body
= NULL
;
713 for (si
= gsi_start (body
); !gsi_end_p (si
); gsi_next (&si
))
715 gimple new_stmt
= remap_gimple_stmt (gsi_stmt (si
), id
);
716 gimple_seq_add_stmt (&new_body
, new_stmt
);
723 /* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its
724 block using the mapping information in ID. */
727 copy_gimple_bind (gimple stmt
, copy_body_data
*id
)
730 tree new_block
, new_vars
;
731 gimple_seq body
, new_body
;
733 /* Copy the statement. Note that we purposely don't use copy_stmt
734 here because we need to remap statements as we copy. */
735 body
= gimple_bind_body (stmt
);
736 new_body
= remap_gimple_seq (body
, id
);
738 new_block
= gimple_bind_block (stmt
);
740 remap_block (&new_block
, id
);
742 /* This will remap a lot of the same decls again, but this should be
744 new_vars
= gimple_bind_vars (stmt
);
746 new_vars
= remap_decls (new_vars
, NULL
, id
);
748 new_bind
= gimple_build_bind (new_vars
, new_body
, new_block
);
754 /* Remap the GIMPLE operand pointed to by *TP. DATA is really a
755 'struct walk_stmt_info *'. DATA->INFO is a 'copy_body_data *'.
756 WALK_SUBTREES is used to indicate walk_gimple_op whether to keep
757 recursing into the children nodes of *TP. */
760 remap_gimple_op_r (tree
*tp
, int *walk_subtrees
, void *data
)
762 struct walk_stmt_info
*wi_p
= (struct walk_stmt_info
*) data
;
763 copy_body_data
*id
= (copy_body_data
*) wi_p
->info
;
764 tree fn
= id
->src_fn
;
766 if (TREE_CODE (*tp
) == SSA_NAME
)
768 *tp
= remap_ssa_name (*tp
, id
);
772 else if (auto_var_in_fn_p (*tp
, fn
))
774 /* Local variables and labels need to be replaced by equivalent
775 variables. We don't want to copy static variables; there's
776 only one of those, no matter how many times we inline the
777 containing function. Similarly for globals from an outer
781 /* Remap the declaration. */
782 new_decl
= remap_decl (*tp
, id
);
783 gcc_assert (new_decl
);
784 /* Replace this variable with the copy. */
785 STRIP_TYPE_NOPS (new_decl
);
786 /* ??? The C++ frontend uses void * pointer zero to initialize
787 any other type. This confuses the middle-end type verification.
788 As cloned bodies do not go through gimplification again the fixup
789 there doesn't trigger. */
790 if (TREE_CODE (new_decl
) == INTEGER_CST
791 && !useless_type_conversion_p (TREE_TYPE (*tp
), TREE_TYPE (new_decl
)))
792 new_decl
= fold_convert (TREE_TYPE (*tp
), new_decl
);
796 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
798 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
800 else if (TREE_CODE (*tp
) == LABEL_DECL
801 && (!DECL_CONTEXT (*tp
)
802 || decl_function_context (*tp
) == id
->src_fn
))
803 /* These may need to be remapped for EH handling. */
804 *tp
= remap_decl (*tp
, id
);
805 else if (TREE_CODE (*tp
) == FIELD_DECL
)
807 /* If the enclosing record type is variably_modified_type_p, the field
808 has already been remapped. Otherwise, it need not be. */
809 tree
*n
= (tree
*) pointer_map_contains (id
->decl_map
, *tp
);
814 else if (TYPE_P (*tp
))
815 /* Types may need remapping as well. */
816 *tp
= remap_type (*tp
, id
);
817 else if (CONSTANT_CLASS_P (*tp
))
819 /* If this is a constant, we have to copy the node iff the type
820 will be remapped. copy_tree_r will not copy a constant. */
821 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
823 if (new_type
== TREE_TYPE (*tp
))
826 else if (TREE_CODE (*tp
) == INTEGER_CST
)
827 *tp
= build_int_cst_wide (new_type
, TREE_INT_CST_LOW (*tp
),
828 TREE_INT_CST_HIGH (*tp
));
831 *tp
= copy_node (*tp
);
832 TREE_TYPE (*tp
) = new_type
;
837 /* Otherwise, just copy the node. Note that copy_tree_r already
838 knows not to copy VAR_DECLs, etc., so this is safe. */
840 if (TREE_CODE (*tp
) == MEM_REF
)
842 tree ptr
= TREE_OPERAND (*tp
, 0);
843 tree type
= remap_type (TREE_TYPE (*tp
), id
);
846 /* We need to re-canonicalize MEM_REFs from inline substitutions
847 that can happen when a pointer argument is an ADDR_EXPR.
848 Recurse here manually to allow that. */
849 walk_tree (&ptr
, remap_gimple_op_r
, data
, NULL
);
850 *tp
= fold_build2 (MEM_REF
, type
,
851 ptr
, TREE_OPERAND (*tp
, 1));
852 TREE_THIS_NOTRAP (*tp
) = TREE_THIS_NOTRAP (old
);
853 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
854 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
855 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
860 /* Here is the "usual case". Copy this tree node, and then
861 tweak some special cases. */
862 copy_tree_r (tp
, walk_subtrees
, NULL
);
864 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
865 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
867 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
869 /* The copied TARGET_EXPR has never been expanded, even if the
870 original node was expanded already. */
871 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
872 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
874 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
876 /* Variable substitution need not be simple. In particular,
877 the MEM_REF substitution above. Make sure that
878 TREE_CONSTANT and friends are up-to-date. */
879 int invariant
= is_gimple_min_invariant (*tp
);
880 walk_tree (&TREE_OPERAND (*tp
, 0), remap_gimple_op_r
, data
, NULL
);
881 recompute_tree_invariant_for_addr_expr (*tp
);
883 /* If this used to be invariant, but is not any longer,
884 then regimplification is probably needed. */
885 if (invariant
&& !is_gimple_min_invariant (*tp
))
886 id
->regimplify
= true;
892 /* Update the TREE_BLOCK for the cloned expr. */
895 tree new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
896 tree old_block
= TREE_BLOCK (*tp
);
900 n
= (tree
*) pointer_map_contains (id
->decl_map
,
905 TREE_SET_BLOCK (*tp
, new_block
);
908 /* Keep iterating. */
913 /* Called from copy_body_id via walk_tree. DATA is really a
914 `copy_body_data *'. */
917 copy_tree_body_r (tree
*tp
, int *walk_subtrees
, void *data
)
919 copy_body_data
*id
= (copy_body_data
*) data
;
920 tree fn
= id
->src_fn
;
923 /* Begin by recognizing trees that we'll completely rewrite for the
924 inlining context. Our output for these trees is completely
925 different from out input (e.g. RETURN_EXPR is deleted, and morphs
926 into an edge). Further down, we'll handle trees that get
927 duplicated and/or tweaked. */
929 /* When requested, RETURN_EXPRs should be transformed to just the
930 contained MODIFY_EXPR. The branch semantics of the return will
931 be handled elsewhere by manipulating the CFG rather than a statement. */
932 if (TREE_CODE (*tp
) == RETURN_EXPR
&& id
->transform_return_to_modify
)
934 tree assignment
= TREE_OPERAND (*tp
, 0);
936 /* If we're returning something, just turn that into an
937 assignment into the equivalent of the original RESULT_DECL.
938 If the "assignment" is just the result decl, the result
939 decl has already been set (e.g. a recent "foo (&result_decl,
940 ...)"); just toss the entire RETURN_EXPR. */
941 if (assignment
&& TREE_CODE (assignment
) == MODIFY_EXPR
)
943 /* Replace the RETURN_EXPR with (a copy of) the
944 MODIFY_EXPR hanging underneath. */
945 *tp
= copy_node (assignment
);
947 else /* Else the RETURN_EXPR returns no value. */
950 return (tree
) (void *)1;
953 else if (TREE_CODE (*tp
) == SSA_NAME
)
955 *tp
= remap_ssa_name (*tp
, id
);
960 /* Local variables and labels need to be replaced by equivalent
961 variables. We don't want to copy static variables; there's only
962 one of those, no matter how many times we inline the containing
963 function. Similarly for globals from an outer function. */
964 else if (auto_var_in_fn_p (*tp
, fn
))
968 /* Remap the declaration. */
969 new_decl
= remap_decl (*tp
, id
);
970 gcc_assert (new_decl
);
971 /* Replace this variable with the copy. */
972 STRIP_TYPE_NOPS (new_decl
);
976 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
977 copy_statement_list (tp
);
978 else if (TREE_CODE (*tp
) == SAVE_EXPR
979 || TREE_CODE (*tp
) == TARGET_EXPR
)
980 remap_save_expr (tp
, id
->decl_map
, walk_subtrees
);
981 else if (TREE_CODE (*tp
) == LABEL_DECL
982 && (! DECL_CONTEXT (*tp
)
983 || decl_function_context (*tp
) == id
->src_fn
))
984 /* These may need to be remapped for EH handling. */
985 *tp
= remap_decl (*tp
, id
);
986 else if (TREE_CODE (*tp
) == BIND_EXPR
)
987 copy_bind_expr (tp
, walk_subtrees
, id
);
988 /* Types may need remapping as well. */
989 else if (TYPE_P (*tp
))
990 *tp
= remap_type (*tp
, id
);
992 /* If this is a constant, we have to copy the node iff the type will be
993 remapped. copy_tree_r will not copy a constant. */
994 else if (CONSTANT_CLASS_P (*tp
))
996 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
998 if (new_type
== TREE_TYPE (*tp
))
1001 else if (TREE_CODE (*tp
) == INTEGER_CST
)
1002 *tp
= build_int_cst_wide (new_type
, TREE_INT_CST_LOW (*tp
),
1003 TREE_INT_CST_HIGH (*tp
));
1006 *tp
= copy_node (*tp
);
1007 TREE_TYPE (*tp
) = new_type
;
1011 /* Otherwise, just copy the node. Note that copy_tree_r already
1012 knows not to copy VAR_DECLs, etc., so this is safe. */
1015 /* Here we handle trees that are not completely rewritten.
1016 First we detect some inlining-induced bogosities for
1018 if (TREE_CODE (*tp
) == MODIFY_EXPR
1019 && TREE_OPERAND (*tp
, 0) == TREE_OPERAND (*tp
, 1)
1020 && (auto_var_in_fn_p (TREE_OPERAND (*tp
, 0), fn
)))
1022 /* Some assignments VAR = VAR; don't generate any rtl code
1023 and thus don't count as variable modification. Avoid
1024 keeping bogosities like 0 = 0. */
1025 tree decl
= TREE_OPERAND (*tp
, 0), value
;
1028 n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
1032 STRIP_TYPE_NOPS (value
);
1033 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1035 *tp
= build_empty_stmt (EXPR_LOCATION (*tp
));
1036 return copy_tree_body_r (tp
, walk_subtrees
, data
);
1040 else if (TREE_CODE (*tp
) == INDIRECT_REF
)
1042 /* Get rid of *& from inline substitutions that can happen when a
1043 pointer argument is an ADDR_EXPR. */
1044 tree decl
= TREE_OPERAND (*tp
, 0);
1047 n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
1052 /* If we happen to get an ADDR_EXPR in n->value, strip
1053 it manually here as we'll eventually get ADDR_EXPRs
1054 which lie about their types pointed to. In this case
1055 build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
1056 but we absolutely rely on that. As fold_indirect_ref
1057 does other useful transformations, try that first, though. */
1058 tree type
= TREE_TYPE (TREE_TYPE (*n
));
1059 if (id
->do_not_unshare
)
1062 new_tree
= unshare_expr (*n
);
1064 *tp
= gimple_fold_indirect_ref (new_tree
);
1067 if (TREE_CODE (new_tree
) == ADDR_EXPR
)
1069 *tp
= fold_indirect_ref_1 (EXPR_LOCATION (new_tree
),
1071 /* ??? We should either assert here or build
1072 a VIEW_CONVERT_EXPR instead of blindly leaking
1073 incompatible types to our IL. */
1075 *tp
= TREE_OPERAND (new_tree
, 0);
1079 *tp
= build1 (INDIRECT_REF
, type
, new_tree
);
1080 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1081 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1082 TREE_READONLY (*tp
) = TREE_READONLY (old
);
1083 TREE_THIS_NOTRAP (*tp
) = TREE_THIS_NOTRAP (old
);
1090 else if (TREE_CODE (*tp
) == MEM_REF
)
1092 tree ptr
= TREE_OPERAND (*tp
, 0);
1093 tree type
= remap_type (TREE_TYPE (*tp
), id
);
1096 /* We need to re-canonicalize MEM_REFs from inline substitutions
1097 that can happen when a pointer argument is an ADDR_EXPR.
1098 Recurse here manually to allow that. */
1099 walk_tree (&ptr
, copy_tree_body_r
, data
, NULL
);
1100 *tp
= fold_build2 (MEM_REF
, type
,
1101 ptr
, TREE_OPERAND (*tp
, 1));
1102 TREE_THIS_NOTRAP (*tp
) = TREE_THIS_NOTRAP (old
);
1103 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1104 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1105 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
1110 /* Here is the "usual case". Copy this tree node, and then
1111 tweak some special cases. */
1112 copy_tree_r (tp
, walk_subtrees
, NULL
);
1114 /* If EXPR has block defined, map it to newly constructed block.
1115 When inlining we want EXPRs without block appear in the block
1116 of function call if we are not remapping a type. */
1119 new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
1120 if (TREE_BLOCK (*tp
))
1123 n
= (tree
*) pointer_map_contains (id
->decl_map
,
1128 TREE_SET_BLOCK (*tp
, new_block
);
1131 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
1132 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
1134 /* The copied TARGET_EXPR has never been expanded, even if the
1135 original node was expanded already. */
1136 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
1138 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
1139 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
1142 /* Variable substitution need not be simple. In particular, the
1143 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
1144 and friends are up-to-date. */
1145 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
1147 int invariant
= is_gimple_min_invariant (*tp
);
1148 walk_tree (&TREE_OPERAND (*tp
, 0), copy_tree_body_r
, id
, NULL
);
1150 /* Handle the case where we substituted an INDIRECT_REF
1151 into the operand of the ADDR_EXPR. */
1152 if (TREE_CODE (TREE_OPERAND (*tp
, 0)) == INDIRECT_REF
)
1153 *tp
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0);
1155 recompute_tree_invariant_for_addr_expr (*tp
);
1157 /* If this used to be invariant, but is not any longer,
1158 then regimplification is probably needed. */
1159 if (invariant
&& !is_gimple_min_invariant (*tp
))
1160 id
->regimplify
= true;
1166 /* Keep iterating. */
1170 /* Helper for remap_gimple_stmt. Given an EH region number for the
1171 source function, map that to the duplicate EH region number in
1172 the destination function. */
1175 remap_eh_region_nr (int old_nr
, copy_body_data
*id
)
1177 eh_region old_r
, new_r
;
1180 old_r
= get_eh_region_from_number_fn (id
->src_cfun
, old_nr
);
1181 slot
= pointer_map_contains (id
->eh_map
, old_r
);
1182 new_r
= (eh_region
) *slot
;
1184 return new_r
->index
;
1187 /* Similar, but operate on INTEGER_CSTs. */
1190 remap_eh_region_tree_nr (tree old_t_nr
, copy_body_data
*id
)
1194 old_nr
= tree_low_cst (old_t_nr
, 0);
1195 new_nr
= remap_eh_region_nr (old_nr
, id
);
1197 return build_int_cst (integer_type_node
, new_nr
);
1200 /* Helper for copy_bb. Remap statement STMT using the inlining
1201 information in ID. Return the new statement copy. */
1204 remap_gimple_stmt (gimple stmt
, copy_body_data
*id
)
1207 struct walk_stmt_info wi
;
1208 bool skip_first
= false;
1210 /* Begin by recognizing trees that we'll completely rewrite for the
1211 inlining context. Our output for these trees is completely
1212 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1213 into an edge). Further down, we'll handle trees that get
1214 duplicated and/or tweaked. */
1216 /* When requested, GIMPLE_RETURNs should be transformed to just the
1217 contained GIMPLE_ASSIGN. The branch semantics of the return will
1218 be handled elsewhere by manipulating the CFG rather than the
1220 if (gimple_code (stmt
) == GIMPLE_RETURN
&& id
->transform_return_to_modify
)
1222 tree retval
= gimple_return_retval (stmt
);
1224 /* If we're returning something, just turn that into an
1225 assignment into the equivalent of the original RESULT_DECL.
1226 If RETVAL is just the result decl, the result decl has
1227 already been set (e.g. a recent "foo (&result_decl, ...)");
1228 just toss the entire GIMPLE_RETURN. */
1230 && (TREE_CODE (retval
) != RESULT_DECL
1231 && (TREE_CODE (retval
) != SSA_NAME
1232 || ! SSA_NAME_VAR (retval
)
1233 || TREE_CODE (SSA_NAME_VAR (retval
)) != RESULT_DECL
)))
1235 copy
= gimple_build_assign (id
->retvar
, retval
);
1236 /* id->retvar is already substituted. Skip it on later remapping. */
1240 return gimple_build_nop ();
1242 else if (gimple_has_substatements (stmt
))
1246 /* When cloning bodies from the C++ front end, we will be handed bodies
1247 in High GIMPLE form. Handle here all the High GIMPLE statements that
1248 have embedded statements. */
1249 switch (gimple_code (stmt
))
1252 copy
= copy_gimple_bind (stmt
, id
);
1256 s1
= remap_gimple_seq (gimple_catch_handler (stmt
), id
);
1257 copy
= gimple_build_catch (gimple_catch_types (stmt
), s1
);
1260 case GIMPLE_EH_FILTER
:
1261 s1
= remap_gimple_seq (gimple_eh_filter_failure (stmt
), id
);
1262 copy
= gimple_build_eh_filter (gimple_eh_filter_types (stmt
), s1
);
1266 s1
= remap_gimple_seq (gimple_try_eval (stmt
), id
);
1267 s2
= remap_gimple_seq (gimple_try_cleanup (stmt
), id
);
1268 copy
= gimple_build_try (s1
, s2
, gimple_try_kind (stmt
));
1271 case GIMPLE_WITH_CLEANUP_EXPR
:
1272 s1
= remap_gimple_seq (gimple_wce_cleanup (stmt
), id
);
1273 copy
= gimple_build_wce (s1
);
1276 case GIMPLE_OMP_PARALLEL
:
1277 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1278 copy
= gimple_build_omp_parallel
1280 gimple_omp_parallel_clauses (stmt
),
1281 gimple_omp_parallel_child_fn (stmt
),
1282 gimple_omp_parallel_data_arg (stmt
));
1285 case GIMPLE_OMP_TASK
:
1286 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1287 copy
= gimple_build_omp_task
1289 gimple_omp_task_clauses (stmt
),
1290 gimple_omp_task_child_fn (stmt
),
1291 gimple_omp_task_data_arg (stmt
),
1292 gimple_omp_task_copy_fn (stmt
),
1293 gimple_omp_task_arg_size (stmt
),
1294 gimple_omp_task_arg_align (stmt
));
1297 case GIMPLE_OMP_FOR
:
1298 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1299 s2
= remap_gimple_seq (gimple_omp_for_pre_body (stmt
), id
);
1300 copy
= gimple_build_omp_for (s1
, gimple_omp_for_clauses (stmt
),
1301 gimple_omp_for_collapse (stmt
), s2
);
1304 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1306 gimple_omp_for_set_index (copy
, i
,
1307 gimple_omp_for_index (stmt
, i
));
1308 gimple_omp_for_set_initial (copy
, i
,
1309 gimple_omp_for_initial (stmt
, i
));
1310 gimple_omp_for_set_final (copy
, i
,
1311 gimple_omp_for_final (stmt
, i
));
1312 gimple_omp_for_set_incr (copy
, i
,
1313 gimple_omp_for_incr (stmt
, i
));
1314 gimple_omp_for_set_cond (copy
, i
,
1315 gimple_omp_for_cond (stmt
, i
));
1320 case GIMPLE_OMP_MASTER
:
1321 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1322 copy
= gimple_build_omp_master (s1
);
1325 case GIMPLE_OMP_ORDERED
:
1326 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1327 copy
= gimple_build_omp_ordered (s1
);
1330 case GIMPLE_OMP_SECTION
:
1331 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1332 copy
= gimple_build_omp_section (s1
);
1335 case GIMPLE_OMP_SECTIONS
:
1336 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1337 copy
= gimple_build_omp_sections
1338 (s1
, gimple_omp_sections_clauses (stmt
));
1341 case GIMPLE_OMP_SINGLE
:
1342 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1343 copy
= gimple_build_omp_single
1344 (s1
, gimple_omp_single_clauses (stmt
));
1347 case GIMPLE_OMP_CRITICAL
:
1348 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1350 = gimple_build_omp_critical (s1
, gimple_omp_critical_name (stmt
));
1353 case GIMPLE_TRANSACTION
:
1354 s1
= remap_gimple_seq (gimple_transaction_body (stmt
), id
);
1355 copy
= gimple_build_transaction (s1
, gimple_transaction_label (stmt
));
1356 gimple_transaction_set_subcode (copy
, gimple_transaction_subcode (stmt
));
1365 if (gimple_assign_copy_p (stmt
)
1366 && gimple_assign_lhs (stmt
) == gimple_assign_rhs1 (stmt
)
1367 && auto_var_in_fn_p (gimple_assign_lhs (stmt
), id
->src_fn
))
1369 /* Here we handle statements that are not completely rewritten.
1370 First we detect some inlining-induced bogosities for
1373 /* Some assignments VAR = VAR; don't generate any rtl code
1374 and thus don't count as variable modification. Avoid
1375 keeping bogosities like 0 = 0. */
1376 tree decl
= gimple_assign_lhs (stmt
), value
;
1379 n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
1383 STRIP_TYPE_NOPS (value
);
1384 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1385 return gimple_build_nop ();
1389 if (gimple_debug_bind_p (stmt
))
1391 copy
= gimple_build_debug_bind (gimple_debug_bind_get_var (stmt
),
1392 gimple_debug_bind_get_value (stmt
),
1394 id
->debug_stmts
.safe_push (copy
);
1397 if (gimple_debug_source_bind_p (stmt
))
1399 copy
= gimple_build_debug_source_bind
1400 (gimple_debug_source_bind_get_var (stmt
),
1401 gimple_debug_source_bind_get_value (stmt
), stmt
);
1402 id
->debug_stmts
.safe_push (copy
);
1406 /* Create a new deep copy of the statement. */
1407 copy
= gimple_copy (stmt
);
1409 /* Remap the region numbers for __builtin_eh_{pointer,filter},
1410 RESX and EH_DISPATCH. */
1412 switch (gimple_code (copy
))
1416 tree r
, fndecl
= gimple_call_fndecl (copy
);
1417 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
1418 switch (DECL_FUNCTION_CODE (fndecl
))
1420 case BUILT_IN_EH_COPY_VALUES
:
1421 r
= gimple_call_arg (copy
, 1);
1422 r
= remap_eh_region_tree_nr (r
, id
);
1423 gimple_call_set_arg (copy
, 1, r
);
1426 case BUILT_IN_EH_POINTER
:
1427 case BUILT_IN_EH_FILTER
:
1428 r
= gimple_call_arg (copy
, 0);
1429 r
= remap_eh_region_tree_nr (r
, id
);
1430 gimple_call_set_arg (copy
, 0, r
);
1437 /* Reset alias info if we didn't apply measures to
1438 keep it valid over inlining by setting DECL_PT_UID. */
1439 if (!id
->src_cfun
->gimple_df
1440 || !id
->src_cfun
->gimple_df
->ipa_pta
)
1441 gimple_call_reset_alias_info (copy
);
1447 int r
= gimple_resx_region (copy
);
1448 r
= remap_eh_region_nr (r
, id
);
1449 gimple_resx_set_region (copy
, r
);
1453 case GIMPLE_EH_DISPATCH
:
1455 int r
= gimple_eh_dispatch_region (copy
);
1456 r
= remap_eh_region_nr (r
, id
);
1457 gimple_eh_dispatch_set_region (copy
, r
);
1466 /* If STMT has a block defined, map it to the newly constructed
1468 if (gimple_block (copy
))
1471 n
= (tree
*) pointer_map_contains (id
->decl_map
, gimple_block (copy
));
1473 gimple_set_block (copy
, *n
);
1476 if (gimple_debug_bind_p (copy
) || gimple_debug_source_bind_p (copy
))
1479 /* Remap all the operands in COPY. */
1480 memset (&wi
, 0, sizeof (wi
));
1483 walk_tree (gimple_op_ptr (copy
, 1), remap_gimple_op_r
, &wi
, NULL
);
1485 walk_gimple_op (copy
, remap_gimple_op_r
, &wi
);
1487 /* Clear the copied virtual operands. We are not remapping them here
1488 but are going to recreate them from scratch. */
1489 if (gimple_has_mem_ops (copy
))
1491 gimple_set_vdef (copy
, NULL_TREE
);
1492 gimple_set_vuse (copy
, NULL_TREE
);
1499 /* Copy basic block, scale profile accordingly. Edges will be taken care of
1503 copy_bb (copy_body_data
*id
, basic_block bb
, int frequency_scale
,
1504 gcov_type count_scale
)
1506 gimple_stmt_iterator gsi
, copy_gsi
, seq_gsi
;
1507 basic_block copy_basic_block
;
1512 /* Search for previous copied basic block. */
1515 prev
= prev
->prev_bb
;
1517 /* create_basic_block() will append every new block to
1518 basic_block_info automatically. */
1519 copy_basic_block
= create_basic_block (NULL
, (void *) 0,
1520 (basic_block
) prev
->aux
);
1521 /* Update to use apply_probability(). */
1522 copy_basic_block
->count
= bb
->count
* count_scale
/ REG_BR_PROB_BASE
;
1524 /* We are going to rebuild frequencies from scratch. These values
1525 have just small importance to drive canonicalize_loop_headers. */
1526 /* Update to use EDGE_FREQUENCY. */
1527 freq
= ((gcov_type
)bb
->frequency
* frequency_scale
/ REG_BR_PROB_BASE
);
1529 /* We recompute frequencies after inlining, so this is quite safe. */
1530 if (freq
> BB_FREQ_MAX
)
1532 copy_basic_block
->frequency
= freq
;
1534 copy_gsi
= gsi_start_bb (copy_basic_block
);
1536 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1538 gimple stmt
= gsi_stmt (gsi
);
1539 gimple orig_stmt
= stmt
;
1541 id
->regimplify
= false;
1542 stmt
= remap_gimple_stmt (stmt
, id
);
1543 if (gimple_nop_p (stmt
))
1546 gimple_duplicate_stmt_histograms (cfun
, stmt
, id
->src_cfun
, orig_stmt
);
1549 /* With return slot optimization we can end up with
1550 non-gimple (foo *)&this->m, fix that here. */
1551 if (is_gimple_assign (stmt
)
1552 && gimple_assign_rhs_code (stmt
) == NOP_EXPR
1553 && !is_gimple_val (gimple_assign_rhs1 (stmt
)))
1556 new_rhs
= force_gimple_operand_gsi (&seq_gsi
,
1557 gimple_assign_rhs1 (stmt
),
1559 GSI_CONTINUE_LINKING
);
1560 gimple_assign_set_rhs1 (stmt
, new_rhs
);
1561 id
->regimplify
= false;
1564 gsi_insert_after (&seq_gsi
, stmt
, GSI_NEW_STMT
);
1567 gimple_regimplify_operands (stmt
, &seq_gsi
);
1569 /* If copy_basic_block has been empty at the start of this iteration,
1570 call gsi_start_bb again to get at the newly added statements. */
1571 if (gsi_end_p (copy_gsi
))
1572 copy_gsi
= gsi_start_bb (copy_basic_block
);
1574 gsi_next (©_gsi
);
1576 /* Process the new statement. The call to gimple_regimplify_operands
1577 possibly turned the statement into multiple statements, we
1578 need to process all of them. */
1583 stmt
= gsi_stmt (copy_gsi
);
1584 if (is_gimple_call (stmt
)
1585 && gimple_call_va_arg_pack_p (stmt
)
1588 /* __builtin_va_arg_pack () should be replaced by
1589 all arguments corresponding to ... in the caller. */
1593 size_t nargs
= gimple_call_num_args (id
->gimple_call
);
1596 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1599 /* Create the new array of arguments. */
1600 n
= nargs
+ gimple_call_num_args (stmt
);
1601 argarray
.create (n
);
1602 argarray
.safe_grow_cleared (n
);
1604 /* Copy all the arguments before '...' */
1605 memcpy (argarray
.address (),
1606 gimple_call_arg_ptr (stmt
, 0),
1607 gimple_call_num_args (stmt
) * sizeof (tree
));
1609 /* Append the arguments passed in '...' */
1610 memcpy (argarray
.address () + gimple_call_num_args (stmt
),
1611 gimple_call_arg_ptr (id
->gimple_call
, 0)
1612 + (gimple_call_num_args (id
->gimple_call
) - nargs
),
1613 nargs
* sizeof (tree
));
1615 new_call
= gimple_build_call_vec (gimple_call_fn (stmt
),
1618 argarray
.release ();
1620 /* Copy all GIMPLE_CALL flags, location and block, except
1621 GF_CALL_VA_ARG_PACK. */
1622 gimple_call_copy_flags (new_call
, stmt
);
1623 gimple_call_set_va_arg_pack (new_call
, false);
1624 gimple_set_location (new_call
, gimple_location (stmt
));
1625 gimple_set_block (new_call
, gimple_block (stmt
));
1626 gimple_call_set_lhs (new_call
, gimple_call_lhs (stmt
));
1628 gsi_replace (©_gsi
, new_call
, false);
1631 else if (is_gimple_call (stmt
)
1633 && (decl
= gimple_call_fndecl (stmt
))
1634 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
1635 && DECL_FUNCTION_CODE (decl
) == BUILT_IN_VA_ARG_PACK_LEN
)
1637 /* __builtin_va_arg_pack_len () should be replaced by
1638 the number of anonymous arguments. */
1639 size_t nargs
= gimple_call_num_args (id
->gimple_call
);
1643 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1646 count
= build_int_cst (integer_type_node
, nargs
);
1647 new_stmt
= gimple_build_assign (gimple_call_lhs (stmt
), count
);
1648 gsi_replace (©_gsi
, new_stmt
, false);
1652 /* Statements produced by inlining can be unfolded, especially
1653 when we constant propagated some operands. We can't fold
1654 them right now for two reasons:
1655 1) folding require SSA_NAME_DEF_STMTs to be correct
1656 2) we can't change function calls to builtins.
1657 So we just mark statement for later folding. We mark
1658 all new statements, instead just statements that has changed
1659 by some nontrivial substitution so even statements made
1660 foldable indirectly are updated. If this turns out to be
1661 expensive, copy_body can be told to watch for nontrivial
1663 if (id
->statements_to_fold
)
1664 pointer_set_insert (id
->statements_to_fold
, stmt
);
1666 /* We're duplicating a CALL_EXPR. Find any corresponding
1667 callgraph edges and update or duplicate them. */
1668 if (is_gimple_call (stmt
))
1670 struct cgraph_edge
*edge
;
1673 switch (id
->transform_call_graph_edges
)
1675 case CB_CGE_DUPLICATE
:
1676 edge
= cgraph_edge (id
->src_node
, orig_stmt
);
1679 int edge_freq
= edge
->frequency
;
1680 edge
= cgraph_clone_edge (edge
, id
->dst_node
, stmt
,
1682 REG_BR_PROB_BASE
, CGRAPH_FREQ_BASE
,
1684 /* We could also just rescale the frequency, but
1685 doing so would introduce roundoff errors and make
1686 verifier unhappy. */
1688 = compute_call_stmt_bb_frequency (id
->dst_node
->symbol
.decl
,
1691 && profile_status_for_function (cfun
) != PROFILE_ABSENT
1692 && (edge_freq
> edge
->frequency
+ 10
1693 || edge_freq
< edge
->frequency
- 10))
1695 fprintf (dump_file
, "Edge frequency estimated by "
1696 "cgraph %i diverge from inliner's estimate %i\n",
1700 "Orig bb: %i, orig bb freq %i, new bb freq %i\n",
1703 copy_basic_block
->frequency
);
1705 stmt
= cgraph_redirect_edge_call_stmt_to_callee (edge
);
1709 case CB_CGE_MOVE_CLONES
:
1710 cgraph_set_call_stmt_including_clones (id
->dst_node
,
1712 edge
= cgraph_edge (id
->dst_node
, stmt
);
1716 edge
= cgraph_edge (id
->dst_node
, orig_stmt
);
1718 cgraph_set_call_stmt (edge
, stmt
);
1725 /* Constant propagation on argument done during inlining
1726 may create new direct call. Produce an edge for it. */
1728 || (edge
->indirect_inlining_edge
1729 && id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
))
1730 && id
->dst_node
->analyzed
1731 && (fn
= gimple_call_fndecl (stmt
)) != NULL
)
1733 struct cgraph_node
*dest
= cgraph_get_node (fn
);
1735 /* We have missing edge in the callgraph. This can happen
1736 when previous inlining turned an indirect call into a
1737 direct call by constant propagating arguments or we are
1738 producing dead clone (for further cloning). In all
1739 other cases we hit a bug (incorrect node sharing is the
1740 most common reason for missing edges). */
1741 gcc_assert (!dest
->analyzed
1742 || dest
->symbol
.address_taken
1743 || !id
->src_node
->analyzed
1744 || !id
->dst_node
->analyzed
);
1745 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
)
1746 cgraph_create_edge_including_clones
1747 (id
->dst_node
, dest
, orig_stmt
, stmt
, bb
->count
,
1748 compute_call_stmt_bb_frequency (id
->dst_node
->symbol
.decl
,
1750 CIF_ORIGINALLY_INDIRECT_CALL
);
1752 cgraph_create_edge (id
->dst_node
, dest
, stmt
,
1754 compute_call_stmt_bb_frequency
1755 (id
->dst_node
->symbol
.decl
,
1756 copy_basic_block
))->inline_failed
1757 = CIF_ORIGINALLY_INDIRECT_CALL
;
1760 fprintf (dump_file
, "Created new direct edge to %s\n",
1761 cgraph_node_name (dest
));
1765 flags
= gimple_call_flags (stmt
);
1766 if (flags
& ECF_MAY_BE_ALLOCA
)
1767 cfun
->calls_alloca
= true;
1768 if (flags
& ECF_RETURNS_TWICE
)
1769 cfun
->calls_setjmp
= true;
1772 maybe_duplicate_eh_stmt_fn (cfun
, stmt
, id
->src_cfun
, orig_stmt
,
1773 id
->eh_map
, id
->eh_lp_nr
);
1775 if (gimple_in_ssa_p (cfun
) && !is_gimple_debug (stmt
))
1780 FOR_EACH_SSA_TREE_OPERAND (def
, stmt
, i
, SSA_OP_DEF
)
1781 if (TREE_CODE (def
) == SSA_NAME
)
1782 SSA_NAME_DEF_STMT (def
) = stmt
;
1785 gsi_next (©_gsi
);
1787 while (!gsi_end_p (copy_gsi
));
1789 copy_gsi
= gsi_last_bb (copy_basic_block
);
1792 return copy_basic_block
;
1795 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
1796 form is quite easy, since dominator relationship for old basic blocks does
1799 There is however exception where inlining might change dominator relation
1800 across EH edges from basic block within inlined functions destinating
1801 to landing pads in function we inline into.
1803 The function fills in PHI_RESULTs of such PHI nodes if they refer
1804 to gimple regs. Otherwise, the function mark PHI_RESULT of such
1805 PHI nodes for renaming. For non-gimple regs, renaming is safe: the
1806 EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
1807 set, and this means that there will be no overlapping live ranges
1808 for the underlying symbol.
1810 This might change in future if we allow redirecting of EH edges and
1811 we might want to change way build CFG pre-inlining to include
1812 all the possible edges then. */
1814 update_ssa_across_abnormal_edges (basic_block bb
, basic_block ret_bb
,
1815 bool can_throw
, bool nonlocal_goto
)
1820 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1822 || ((basic_block
)e
->dest
->aux
)->index
== ENTRY_BLOCK
)
1825 gimple_stmt_iterator si
;
1828 gcc_assert (e
->flags
& EDGE_EH
);
1831 gcc_assert (!(e
->flags
& EDGE_EH
));
1833 for (si
= gsi_start_phis (e
->dest
); !gsi_end_p (si
); gsi_next (&si
))
1837 phi
= gsi_stmt (si
);
1839 /* There shouldn't be any PHI nodes in the ENTRY_BLOCK. */
1840 gcc_assert (!e
->dest
->aux
);
1842 gcc_assert ((e
->flags
& EDGE_EH
)
1843 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi
)));
1845 if (virtual_operand_p (PHI_RESULT (phi
)))
1847 mark_virtual_operands_for_renaming (cfun
);
1851 re
= find_edge (ret_bb
, e
->dest
);
1853 gcc_assert ((re
->flags
& (EDGE_EH
| EDGE_ABNORMAL
))
1854 == (e
->flags
& (EDGE_EH
| EDGE_ABNORMAL
)));
1856 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, e
),
1857 USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, re
)));
1863 /* Copy edges from BB into its copy constructed earlier, scale profile
1864 accordingly. Edges will be taken care of later. Assume aux
1865 pointers to point to the copies of each BB. Return true if any
1866 debug stmts are left after a statement that must end the basic block. */
1869 copy_edges_for_bb (basic_block bb
, gcov_type count_scale
, basic_block ret_bb
)
1871 basic_block new_bb
= (basic_block
) bb
->aux
;
1874 gimple_stmt_iterator si
;
1876 bool need_debug_cleanup
= false;
1878 /* Use the indices from the original blocks to create edges for the
1880 FOR_EACH_EDGE (old_edge
, ei
, bb
->succs
)
1881 if (!(old_edge
->flags
& EDGE_EH
))
1885 flags
= old_edge
->flags
;
1887 /* Return edges do get a FALLTHRU flag when the get inlined. */
1888 if (old_edge
->dest
->index
== EXIT_BLOCK
&& !old_edge
->flags
1889 && old_edge
->dest
->aux
!= EXIT_BLOCK_PTR
)
1890 flags
|= EDGE_FALLTHRU
;
1891 new_edge
= make_edge (new_bb
, (basic_block
) old_edge
->dest
->aux
, flags
);
1892 /* Update to use apply_probability(). */
1893 new_edge
->count
= old_edge
->count
* count_scale
/ REG_BR_PROB_BASE
;
1894 new_edge
->probability
= old_edge
->probability
;
1897 if (bb
->index
== ENTRY_BLOCK
|| bb
->index
== EXIT_BLOCK
)
1900 for (si
= gsi_start_bb (new_bb
); !gsi_end_p (si
);)
1903 bool can_throw
, nonlocal_goto
;
1905 copy_stmt
= gsi_stmt (si
);
1906 if (!is_gimple_debug (copy_stmt
))
1907 update_stmt (copy_stmt
);
1909 /* Do this before the possible split_block. */
1912 /* If this tree could throw an exception, there are two
1913 cases where we need to add abnormal edge(s): the
1914 tree wasn't in a region and there is a "current
1915 region" in the caller; or the original tree had
1916 EH edges. In both cases split the block after the tree,
1917 and add abnormal edge(s) as needed; we need both
1918 those from the callee and the caller.
1919 We check whether the copy can throw, because the const
1920 propagation can change an INDIRECT_REF which throws
1921 into a COMPONENT_REF which doesn't. If the copy
1922 can throw, the original could also throw. */
1923 can_throw
= stmt_can_throw_internal (copy_stmt
);
1924 nonlocal_goto
= stmt_can_make_abnormal_goto (copy_stmt
);
1926 if (can_throw
|| nonlocal_goto
)
1928 if (!gsi_end_p (si
))
1930 while (!gsi_end_p (si
) && is_gimple_debug (gsi_stmt (si
)))
1933 need_debug_cleanup
= true;
1935 if (!gsi_end_p (si
))
1936 /* Note that bb's predecessor edges aren't necessarily
1937 right at this point; split_block doesn't care. */
1939 edge e
= split_block (new_bb
, copy_stmt
);
1942 new_bb
->aux
= e
->src
->aux
;
1943 si
= gsi_start_bb (new_bb
);
1947 if (gimple_code (copy_stmt
) == GIMPLE_EH_DISPATCH
)
1948 make_eh_dispatch_edges (copy_stmt
);
1950 make_eh_edges (copy_stmt
);
1953 make_abnormal_goto_edges (gimple_bb (copy_stmt
), true);
1955 if ((can_throw
|| nonlocal_goto
)
1956 && gimple_in_ssa_p (cfun
))
1957 update_ssa_across_abnormal_edges (gimple_bb (copy_stmt
), ret_bb
,
1958 can_throw
, nonlocal_goto
);
1960 return need_debug_cleanup
;
1963 /* Copy the PHIs. All blocks and edges are copied, some blocks
1964 was possibly split and new outgoing EH edges inserted.
1965 BB points to the block of original function and AUX pointers links
1966 the original and newly copied blocks. */
1969 copy_phis_for_bb (basic_block bb
, copy_body_data
*id
)
1971 basic_block
const new_bb
= (basic_block
) bb
->aux
;
1974 gimple_stmt_iterator si
;
1976 bool inserted
= false;
1978 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
1983 phi
= gsi_stmt (si
);
1984 res
= PHI_RESULT (phi
);
1986 if (!virtual_operand_p (res
))
1988 walk_tree (&new_res
, copy_tree_body_r
, id
, NULL
);
1989 new_phi
= create_phi_node (new_res
, new_bb
);
1990 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
1992 edge old_edge
= find_edge ((basic_block
) new_edge
->src
->aux
, bb
);
1998 /* When doing partial cloning, we allow PHIs on the entry block
1999 as long as all the arguments are the same. Find any input
2000 edge to see argument to copy. */
2002 FOR_EACH_EDGE (old_edge
, ei2
, bb
->preds
)
2003 if (!old_edge
->src
->aux
)
2006 arg
= PHI_ARG_DEF_FROM_EDGE (phi
, old_edge
);
2008 walk_tree (&new_arg
, copy_tree_body_r
, id
, NULL
);
2009 gcc_assert (new_arg
);
2010 /* With return slot optimization we can end up with
2011 non-gimple (foo *)&this->m, fix that here. */
2012 if (TREE_CODE (new_arg
) != SSA_NAME
2013 && TREE_CODE (new_arg
) != FUNCTION_DECL
2014 && !is_gimple_val (new_arg
))
2016 gimple_seq stmts
= NULL
;
2017 new_arg
= force_gimple_operand (new_arg
, &stmts
, true, NULL
);
2018 gsi_insert_seq_on_edge (new_edge
, stmts
);
2021 locus
= gimple_phi_arg_location_from_edge (phi
, old_edge
);
2022 if (LOCATION_BLOCK (locus
))
2025 n
= (tree
*) pointer_map_contains (id
->decl_map
,
2026 LOCATION_BLOCK (locus
));
2028 locus
= COMBINE_LOCATION_DATA (line_table
, locus
, *n
);
2031 locus
= LOCATION_LOCUS (locus
);
2033 add_phi_arg (new_phi
, new_arg
, new_edge
, locus
);
2038 /* Commit the delayed edge insertions. */
2040 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2041 gsi_commit_one_edge_insert (new_edge
, NULL
);
2045 /* Wrapper for remap_decl so it can be used as a callback. */
2048 remap_decl_1 (tree decl
, void *data
)
2050 return remap_decl (decl
, (copy_body_data
*) data
);
2053 /* Build struct function and associated datastructures for the new clone
2054 NEW_FNDECL to be build. CALLEE_FNDECL is the original. Function changes
2055 the cfun to the function of new_fndecl (and current_function_decl too). */
2058 initialize_cfun (tree new_fndecl
, tree callee_fndecl
, gcov_type count
)
2060 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2061 gcov_type count_scale
;
2063 /* Update to use GCOV_COMPUTE_SCALE. */
2064 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
)
2065 count_scale
= (REG_BR_PROB_BASE
* count
2066 / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
);
2068 count_scale
= REG_BR_PROB_BASE
;
2070 /* Register specific tree functions. */
2071 gimple_register_cfg_hooks ();
2073 /* Get clean struct function. */
2074 push_struct_function (new_fndecl
);
2076 /* We will rebuild these, so just sanity check that they are empty. */
2077 gcc_assert (VALUE_HISTOGRAMS (cfun
) == NULL
);
2078 gcc_assert (cfun
->local_decls
== NULL
);
2079 gcc_assert (cfun
->cfg
== NULL
);
2080 gcc_assert (cfun
->decl
== new_fndecl
);
2082 /* Copy items we preserve during cloning. */
2083 cfun
->static_chain_decl
= src_cfun
->static_chain_decl
;
2084 cfun
->nonlocal_goto_save_area
= src_cfun
->nonlocal_goto_save_area
;
2085 cfun
->function_end_locus
= src_cfun
->function_end_locus
;
2086 cfun
->curr_properties
= src_cfun
->curr_properties
& ~PROP_loops
;
2087 cfun
->last_verified
= src_cfun
->last_verified
;
2088 cfun
->va_list_gpr_size
= src_cfun
->va_list_gpr_size
;
2089 cfun
->va_list_fpr_size
= src_cfun
->va_list_fpr_size
;
2090 cfun
->has_nonlocal_label
= src_cfun
->has_nonlocal_label
;
2091 cfun
->stdarg
= src_cfun
->stdarg
;
2092 cfun
->after_inlining
= src_cfun
->after_inlining
;
2093 cfun
->can_throw_non_call_exceptions
2094 = src_cfun
->can_throw_non_call_exceptions
;
2095 cfun
->can_delete_dead_exceptions
= src_cfun
->can_delete_dead_exceptions
;
2096 cfun
->returns_struct
= src_cfun
->returns_struct
;
2097 cfun
->returns_pcc_struct
= src_cfun
->returns_pcc_struct
;
2099 init_empty_tree_cfg ();
2101 profile_status_for_function (cfun
) = profile_status_for_function (src_cfun
);
2102 ENTRY_BLOCK_PTR
->count
=
2103 (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
* count_scale
/
2105 ENTRY_BLOCK_PTR
->frequency
2106 = ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->frequency
;
2107 EXIT_BLOCK_PTR
->count
=
2108 (EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
* count_scale
/
2110 EXIT_BLOCK_PTR
->frequency
=
2111 EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->frequency
;
2113 init_eh_for_function ();
2115 if (src_cfun
->gimple_df
)
2117 init_tree_ssa (cfun
);
2118 cfun
->gimple_df
->in_ssa_p
= true;
2119 init_ssa_operands (cfun
);
2123 /* Helper function for copy_cfg_body. Move debug stmts from the end
2124 of NEW_BB to the beginning of successor basic blocks when needed. If the
2125 successor has multiple predecessors, reset them, otherwise keep
2129 maybe_move_debug_stmts_to_successors (copy_body_data
*id
, basic_block new_bb
)
2133 gimple_stmt_iterator si
= gsi_last_nondebug_bb (new_bb
);
2136 || gsi_one_before_end_p (si
)
2137 || !(stmt_can_throw_internal (gsi_stmt (si
))
2138 || stmt_can_make_abnormal_goto (gsi_stmt (si
))))
2141 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
2143 gimple_stmt_iterator ssi
= gsi_last_bb (new_bb
);
2144 gimple_stmt_iterator dsi
= gsi_after_labels (e
->dest
);
2145 while (is_gimple_debug (gsi_stmt (ssi
)))
2147 gimple stmt
= gsi_stmt (ssi
), new_stmt
;
2151 /* For the last edge move the debug stmts instead of copying
2153 if (ei_one_before_end_p (ei
))
2157 if (!single_pred_p (e
->dest
) && gimple_debug_bind_p (stmt
))
2158 gimple_debug_bind_reset_value (stmt
);
2159 gsi_remove (&si
, false);
2160 gsi_insert_before (&dsi
, stmt
, GSI_SAME_STMT
);
2164 if (gimple_debug_bind_p (stmt
))
2166 var
= gimple_debug_bind_get_var (stmt
);
2167 if (single_pred_p (e
->dest
))
2169 value
= gimple_debug_bind_get_value (stmt
);
2170 value
= unshare_expr (value
);
2174 new_stmt
= gimple_build_debug_bind (var
, value
, stmt
);
2176 else if (gimple_debug_source_bind_p (stmt
))
2178 var
= gimple_debug_source_bind_get_var (stmt
);
2179 value
= gimple_debug_source_bind_get_value (stmt
);
2180 new_stmt
= gimple_build_debug_source_bind (var
, value
, stmt
);
2184 gsi_insert_before (&dsi
, new_stmt
, GSI_SAME_STMT
);
2185 id
->debug_stmts
.safe_push (new_stmt
);
2191 /* Make a copy of the body of FN so that it can be inserted inline in
2192 another function. Walks FN via CFG, returns new fndecl. */
2195 copy_cfg_body (copy_body_data
* id
, gcov_type count
, int frequency_scale
,
2196 basic_block entry_block_map
, basic_block exit_block_map
,
2197 bitmap blocks_to_copy
, basic_block new_entry
)
2199 tree callee_fndecl
= id
->src_fn
;
2200 /* Original cfun for the callee, doesn't change. */
2201 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2202 struct function
*cfun_to_copy
;
2204 tree new_fndecl
= NULL
;
2205 bool need_debug_cleanup
= false;
2206 gcov_type count_scale
;
2208 int incoming_frequency
= 0;
2209 gcov_type incoming_count
= 0;
2211 /* Update to use GCOV_COMPUTE_SCALE. */
2212 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
)
2213 count_scale
= (REG_BR_PROB_BASE
* count
2214 / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
);
2216 count_scale
= REG_BR_PROB_BASE
;
2218 /* Register specific tree functions. */
2219 gimple_register_cfg_hooks ();
2221 /* If we are inlining just region of the function, make sure to connect new entry
2222 to ENTRY_BLOCK_PTR. Since new entry can be part of loop, we must compute
2223 frequency and probability of ENTRY_BLOCK_PTR based on the frequencies and
2224 probabilities of edges incoming from nonduplicated region. */
2230 FOR_EACH_EDGE (e
, ei
, new_entry
->preds
)
2233 incoming_frequency
+= EDGE_FREQUENCY (e
);
2234 incoming_count
+= e
->count
;
2236 /* Update to use apply_probability(). */
2237 incoming_count
= incoming_count
* count_scale
/ REG_BR_PROB_BASE
;
2238 /* Update to use EDGE_FREQUENCY. */
2240 = incoming_frequency
* frequency_scale
/ REG_BR_PROB_BASE
;
2241 ENTRY_BLOCK_PTR
->count
= incoming_count
;
2242 ENTRY_BLOCK_PTR
->frequency
= incoming_frequency
;
2245 /* Must have a CFG here at this point. */
2246 gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION
2247 (DECL_STRUCT_FUNCTION (callee_fndecl
)));
2249 cfun_to_copy
= id
->src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2251 ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy
)->aux
= entry_block_map
;
2252 EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy
)->aux
= exit_block_map
;
2253 entry_block_map
->aux
= ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy
);
2254 exit_block_map
->aux
= EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy
);
2256 /* Duplicate any exception-handling regions. */
2258 id
->eh_map
= duplicate_eh_regions (cfun_to_copy
, NULL
, id
->eh_lp_nr
,
2261 /* Use aux pointers to map the original blocks to copy. */
2262 FOR_EACH_BB_FN (bb
, cfun_to_copy
)
2263 if (!blocks_to_copy
|| bitmap_bit_p (blocks_to_copy
, bb
->index
))
2265 basic_block new_bb
= copy_bb (id
, bb
, frequency_scale
, count_scale
);
2270 last
= last_basic_block
;
2272 /* Now that we've duplicated the blocks, duplicate their edges. */
2273 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2275 || (bb
->index
> 0 && bitmap_bit_p (blocks_to_copy
, bb
->index
)))
2276 need_debug_cleanup
|= copy_edges_for_bb (bb
, count_scale
, exit_block_map
);
2280 edge e
= make_edge (entry_block_map
, (basic_block
)new_entry
->aux
, EDGE_FALLTHRU
);
2281 e
->probability
= REG_BR_PROB_BASE
;
2282 e
->count
= incoming_count
;
2285 if (gimple_in_ssa_p (cfun
))
2286 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2288 || (bb
->index
> 0 && bitmap_bit_p (blocks_to_copy
, bb
->index
)))
2289 copy_phis_for_bb (bb
, id
);
2291 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2294 if (need_debug_cleanup
2295 && bb
->index
!= ENTRY_BLOCK
2296 && bb
->index
!= EXIT_BLOCK
)
2297 maybe_move_debug_stmts_to_successors (id
, (basic_block
) bb
->aux
);
2298 ((basic_block
)bb
->aux
)->aux
= NULL
;
2302 /* Zero out AUX fields of newly created block during EH edge
2304 for (; last
< last_basic_block
; last
++)
2306 if (need_debug_cleanup
)
2307 maybe_move_debug_stmts_to_successors (id
, BASIC_BLOCK (last
));
2308 BASIC_BLOCK (last
)->aux
= NULL
;
2310 entry_block_map
->aux
= NULL
;
2311 exit_block_map
->aux
= NULL
;
2315 pointer_map_destroy (id
->eh_map
);
2322 /* Copy the debug STMT using ID. We deal with these statements in a
2323 special way: if any variable in their VALUE expression wasn't
2324 remapped yet, we won't remap it, because that would get decl uids
2325 out of sync, causing codegen differences between -g and -g0. If
2326 this arises, we drop the VALUE expression altogether. */
2329 copy_debug_stmt (gimple stmt
, copy_body_data
*id
)
2332 struct walk_stmt_info wi
;
2334 if (gimple_block (stmt
))
2336 n
= (tree
*) pointer_map_contains (id
->decl_map
, gimple_block (stmt
));
2337 gimple_set_block (stmt
, n
? *n
: id
->block
);
2340 /* Remap all the operands in COPY. */
2341 memset (&wi
, 0, sizeof (wi
));
2344 processing_debug_stmt
= 1;
2346 if (gimple_debug_source_bind_p (stmt
))
2347 t
= gimple_debug_source_bind_get_var (stmt
);
2349 t
= gimple_debug_bind_get_var (stmt
);
2351 if (TREE_CODE (t
) == PARM_DECL
&& id
->debug_map
2352 && (n
= (tree
*) pointer_map_contains (id
->debug_map
, t
)))
2354 gcc_assert (TREE_CODE (*n
) == VAR_DECL
);
2357 else if (TREE_CODE (t
) == VAR_DECL
2358 && !is_global_var (t
)
2359 && !pointer_map_contains (id
->decl_map
, t
))
2360 /* T is a non-localized variable. */;
2362 walk_tree (&t
, remap_gimple_op_r
, &wi
, NULL
);
2364 if (gimple_debug_bind_p (stmt
))
2366 gimple_debug_bind_set_var (stmt
, t
);
2368 if (gimple_debug_bind_has_value_p (stmt
))
2369 walk_tree (gimple_debug_bind_get_value_ptr (stmt
),
2370 remap_gimple_op_r
, &wi
, NULL
);
2372 /* Punt if any decl couldn't be remapped. */
2373 if (processing_debug_stmt
< 0)
2374 gimple_debug_bind_reset_value (stmt
);
2376 else if (gimple_debug_source_bind_p (stmt
))
2378 gimple_debug_source_bind_set_var (stmt
, t
);
2379 walk_tree (gimple_debug_source_bind_get_value_ptr (stmt
),
2380 remap_gimple_op_r
, &wi
, NULL
);
2381 /* When inlining and source bind refers to one of the optimized
2382 away parameters, change the source bind into normal debug bind
2383 referring to the corresponding DEBUG_EXPR_DECL that should have
2384 been bound before the call stmt. */
2385 t
= gimple_debug_source_bind_get_value (stmt
);
2387 && TREE_CODE (t
) == PARM_DECL
2390 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (id
->src_fn
);
2392 if (debug_args
!= NULL
)
2394 for (i
= 0; i
< vec_safe_length (*debug_args
); i
+= 2)
2395 if ((**debug_args
)[i
] == DECL_ORIGIN (t
)
2396 && TREE_CODE ((**debug_args
)[i
+ 1]) == DEBUG_EXPR_DECL
)
2398 t
= (**debug_args
)[i
+ 1];
2399 stmt
->gsbase
.subcode
= GIMPLE_DEBUG_BIND
;
2400 gimple_debug_bind_set_value (stmt
, t
);
2407 processing_debug_stmt
= 0;
2412 /* Process deferred debug stmts. In order to give values better odds
2413 of being successfully remapped, we delay the processing of debug
2414 stmts until all other stmts that might require remapping are
2418 copy_debug_stmts (copy_body_data
*id
)
2423 if (!id
->debug_stmts
.exists ())
2426 FOR_EACH_VEC_ELT (id
->debug_stmts
, i
, stmt
)
2427 copy_debug_stmt (stmt
, id
);
2429 id
->debug_stmts
.release ();
2432 /* Make a copy of the body of SRC_FN so that it can be inserted inline in
2433 another function. */
2436 copy_tree_body (copy_body_data
*id
)
2438 tree fndecl
= id
->src_fn
;
2439 tree body
= DECL_SAVED_TREE (fndecl
);
2441 walk_tree (&body
, copy_tree_body_r
, id
, NULL
);
2446 /* Make a copy of the body of FN so that it can be inserted inline in
2447 another function. */
2450 copy_body (copy_body_data
*id
, gcov_type count
, int frequency_scale
,
2451 basic_block entry_block_map
, basic_block exit_block_map
,
2452 bitmap blocks_to_copy
, basic_block new_entry
)
2454 tree fndecl
= id
->src_fn
;
2457 /* If this body has a CFG, walk CFG and copy. */
2458 gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (fndecl
)));
2459 body
= copy_cfg_body (id
, count
, frequency_scale
, entry_block_map
, exit_block_map
,
2460 blocks_to_copy
, new_entry
);
2461 copy_debug_stmts (id
);
2466 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
2467 defined in function FN, or of a data member thereof. */
2470 self_inlining_addr_expr (tree value
, tree fn
)
2474 if (TREE_CODE (value
) != ADDR_EXPR
)
2477 var
= get_base_address (TREE_OPERAND (value
, 0));
2479 return var
&& auto_var_in_fn_p (var
, fn
);
2482 /* Append to BB a debug annotation that binds VAR to VALUE, inheriting
2483 lexical block and line number information from base_stmt, if given,
2484 or from the last stmt of the block otherwise. */
2487 insert_init_debug_bind (copy_body_data
*id
,
2488 basic_block bb
, tree var
, tree value
,
2492 gimple_stmt_iterator gsi
;
2495 if (!gimple_in_ssa_p (id
->src_cfun
))
2498 if (!MAY_HAVE_DEBUG_STMTS
)
2501 tracked_var
= target_for_debug_bind (var
);
2507 gsi
= gsi_last_bb (bb
);
2508 if (!base_stmt
&& !gsi_end_p (gsi
))
2509 base_stmt
= gsi_stmt (gsi
);
2512 note
= gimple_build_debug_bind (tracked_var
, value
, base_stmt
);
2516 if (!gsi_end_p (gsi
))
2517 gsi_insert_after (&gsi
, note
, GSI_SAME_STMT
);
2519 gsi_insert_before (&gsi
, note
, GSI_SAME_STMT
);
2526 insert_init_stmt (copy_body_data
*id
, basic_block bb
, gimple init_stmt
)
2528 /* If VAR represents a zero-sized variable, it's possible that the
2529 assignment statement may result in no gimple statements. */
2532 gimple_stmt_iterator si
= gsi_last_bb (bb
);
2534 /* We can end up with init statements that store to a non-register
2535 from a rhs with a conversion. Handle that here by forcing the
2536 rhs into a temporary. gimple_regimplify_operands is not
2537 prepared to do this for us. */
2538 if (!is_gimple_debug (init_stmt
)
2539 && !is_gimple_reg (gimple_assign_lhs (init_stmt
))
2540 && is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (init_stmt
)))
2541 && gimple_assign_rhs_class (init_stmt
) == GIMPLE_UNARY_RHS
)
2543 tree rhs
= build1 (gimple_assign_rhs_code (init_stmt
),
2544 gimple_expr_type (init_stmt
),
2545 gimple_assign_rhs1 (init_stmt
));
2546 rhs
= force_gimple_operand_gsi (&si
, rhs
, true, NULL_TREE
, false,
2548 gimple_assign_set_rhs_code (init_stmt
, TREE_CODE (rhs
));
2549 gimple_assign_set_rhs1 (init_stmt
, rhs
);
2551 gsi_insert_after (&si
, init_stmt
, GSI_NEW_STMT
);
2552 gimple_regimplify_operands (init_stmt
, &si
);
2554 if (!is_gimple_debug (init_stmt
) && MAY_HAVE_DEBUG_STMTS
)
2556 tree def
= gimple_assign_lhs (init_stmt
);
2557 insert_init_debug_bind (id
, bb
, def
, def
, init_stmt
);
2562 /* Initialize parameter P with VALUE. If needed, produce init statement
2563 at the end of BB. When BB is NULL, we return init statement to be
2566 setup_one_parameter (copy_body_data
*id
, tree p
, tree value
, tree fn
,
2567 basic_block bb
, tree
*vars
)
2569 gimple init_stmt
= NULL
;
2572 tree def
= (gimple_in_ssa_p (cfun
)
2573 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
2576 && value
!= error_mark_node
2577 && !useless_type_conversion_p (TREE_TYPE (p
), TREE_TYPE (value
)))
2579 /* If we can match up types by promotion/demotion do so. */
2580 if (fold_convertible_p (TREE_TYPE (p
), value
))
2581 rhs
= fold_convert (TREE_TYPE (p
), value
);
2584 /* ??? For valid programs we should not end up here.
2585 Still if we end up with truly mismatched types here, fall back
2586 to using a VIEW_CONVERT_EXPR or a literal zero to not leak invalid
2587 GIMPLE to the following passes. */
2588 if (!is_gimple_reg_type (TREE_TYPE (value
))
2589 || TYPE_SIZE (TREE_TYPE (p
)) == TYPE_SIZE (TREE_TYPE (value
)))
2590 rhs
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (p
), value
);
2592 rhs
= build_zero_cst (TREE_TYPE (p
));
2596 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
2597 here since the type of this decl must be visible to the calling
2599 var
= copy_decl_to_var (p
, id
);
2601 /* Declare this new variable. */
2602 DECL_CHAIN (var
) = *vars
;
2605 /* Make gimplifier happy about this variable. */
2606 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
2608 /* If the parameter is never assigned to, has no SSA_NAMEs created,
2609 we would not need to create a new variable here at all, if it
2610 weren't for debug info. Still, we can just use the argument
2612 if (TREE_READONLY (p
)
2613 && !TREE_ADDRESSABLE (p
)
2614 && value
&& !TREE_SIDE_EFFECTS (value
)
2617 /* We may produce non-gimple trees by adding NOPs or introduce
2618 invalid sharing when operand is not really constant.
2619 It is not big deal to prohibit constant propagation here as
2620 we will constant propagate in DOM1 pass anyway. */
2621 if (is_gimple_min_invariant (value
)
2622 && useless_type_conversion_p (TREE_TYPE (p
),
2624 /* We have to be very careful about ADDR_EXPR. Make sure
2625 the base variable isn't a local variable of the inlined
2626 function, e.g., when doing recursive inlining, direct or
2627 mutually-recursive or whatever, which is why we don't
2628 just test whether fn == current_function_decl. */
2629 && ! self_inlining_addr_expr (value
, fn
))
2631 insert_decl_map (id
, p
, value
);
2632 insert_debug_decl_map (id
, p
, var
);
2633 return insert_init_debug_bind (id
, bb
, var
, value
, NULL
);
2637 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
2638 that way, when the PARM_DECL is encountered, it will be
2639 automatically replaced by the VAR_DECL. */
2640 insert_decl_map (id
, p
, var
);
2642 /* Even if P was TREE_READONLY, the new VAR should not be.
2643 In the original code, we would have constructed a
2644 temporary, and then the function body would have never
2645 changed the value of P. However, now, we will be
2646 constructing VAR directly. The constructor body may
2647 change its value multiple times as it is being
2648 constructed. Therefore, it must not be TREE_READONLY;
2649 the back-end assumes that TREE_READONLY variable is
2650 assigned to only once. */
2651 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p
)))
2652 TREE_READONLY (var
) = 0;
2654 /* If there is no setup required and we are in SSA, take the easy route
2655 replacing all SSA names representing the function parameter by the
2656 SSA name passed to function.
2658 We need to construct map for the variable anyway as it might be used
2659 in different SSA names when parameter is set in function.
2661 Do replacement at -O0 for const arguments replaced by constant.
2662 This is important for builtin_constant_p and other construct requiring
2663 constant argument to be visible in inlined function body. */
2664 if (gimple_in_ssa_p (cfun
) && rhs
&& def
&& is_gimple_reg (p
)
2666 || (TREE_READONLY (p
)
2667 && is_gimple_min_invariant (rhs
)))
2668 && (TREE_CODE (rhs
) == SSA_NAME
2669 || is_gimple_min_invariant (rhs
))
2670 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
2672 insert_decl_map (id
, def
, rhs
);
2673 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
2676 /* If the value of argument is never used, don't care about initializing
2678 if (optimize
&& gimple_in_ssa_p (cfun
) && !def
&& is_gimple_reg (p
))
2680 gcc_assert (!value
|| !TREE_SIDE_EFFECTS (value
));
2681 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
2684 /* Initialize this VAR_DECL from the equivalent argument. Convert
2685 the argument to the proper type in case it was promoted. */
2688 if (rhs
== error_mark_node
)
2690 insert_decl_map (id
, p
, var
);
2691 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
2694 STRIP_USELESS_TYPE_CONVERSION (rhs
);
2696 /* If we are in SSA form properly remap the default definition
2697 or assign to a dummy SSA name if the parameter is unused and
2698 we are not optimizing. */
2699 if (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
))
2703 def
= remap_ssa_name (def
, id
);
2704 init_stmt
= gimple_build_assign (def
, rhs
);
2705 SSA_NAME_IS_DEFAULT_DEF (def
) = 0;
2706 set_ssa_default_def (cfun
, var
, NULL
);
2710 def
= make_ssa_name (var
, NULL
);
2711 init_stmt
= gimple_build_assign (def
, rhs
);
2715 init_stmt
= gimple_build_assign (var
, rhs
);
2717 if (bb
&& init_stmt
)
2718 insert_init_stmt (id
, bb
, init_stmt
);
2723 /* Generate code to initialize the parameters of the function at the
2724 top of the stack in ID from the GIMPLE_CALL STMT. */
2727 initialize_inlined_parameters (copy_body_data
*id
, gimple stmt
,
2728 tree fn
, basic_block bb
)
2733 tree vars
= NULL_TREE
;
2734 tree static_chain
= gimple_call_chain (stmt
);
2736 /* Figure out what the parameters are. */
2737 parms
= DECL_ARGUMENTS (fn
);
2739 /* Loop through the parameter declarations, replacing each with an
2740 equivalent VAR_DECL, appropriately initialized. */
2741 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
2744 val
= i
< gimple_call_num_args (stmt
) ? gimple_call_arg (stmt
, i
) : NULL
;
2745 setup_one_parameter (id
, p
, val
, fn
, bb
, &vars
);
2747 /* After remapping parameters remap their types. This has to be done
2748 in a second loop over all parameters to appropriately remap
2749 variable sized arrays when the size is specified in a
2750 parameter following the array. */
2751 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
2753 tree
*varp
= (tree
*) pointer_map_contains (id
->decl_map
, p
);
2755 && TREE_CODE (*varp
) == VAR_DECL
)
2757 tree def
= (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
)
2758 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
2760 TREE_TYPE (var
) = remap_type (TREE_TYPE (var
), id
);
2761 /* Also remap the default definition if it was remapped
2762 to the default definition of the parameter replacement
2763 by the parameter setup. */
2766 tree
*defp
= (tree
*) pointer_map_contains (id
->decl_map
, def
);
2768 && TREE_CODE (*defp
) == SSA_NAME
2769 && SSA_NAME_VAR (*defp
) == var
)
2770 TREE_TYPE (*defp
) = TREE_TYPE (var
);
2775 /* Initialize the static chain. */
2776 p
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
2777 gcc_assert (fn
!= current_function_decl
);
2780 /* No static chain? Seems like a bug in tree-nested.c. */
2781 gcc_assert (static_chain
);
2783 setup_one_parameter (id
, p
, static_chain
, fn
, bb
, &vars
);
2786 declare_inline_vars (id
->block
, vars
);
2790 /* Declare a return variable to replace the RESULT_DECL for the
2791 function we are calling. An appropriate DECL_STMT is returned.
2792 The USE_STMT is filled to contain a use of the declaration to
2793 indicate the return value of the function.
2795 RETURN_SLOT, if non-null is place where to store the result. It
2796 is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null,
2797 was the LHS of the MODIFY_EXPR to which this call is the RHS.
2799 The return value is a (possibly null) value that holds the result
2800 as seen by the caller. */
2803 declare_return_variable (copy_body_data
*id
, tree return_slot
, tree modify_dest
,
2804 basic_block entry_bb
)
2806 tree callee
= id
->src_fn
;
2807 tree result
= DECL_RESULT (callee
);
2808 tree callee_type
= TREE_TYPE (result
);
2812 /* Handle type-mismatches in the function declaration return type
2813 vs. the call expression. */
2815 caller_type
= TREE_TYPE (modify_dest
);
2817 caller_type
= TREE_TYPE (TREE_TYPE (callee
));
2819 /* We don't need to do anything for functions that don't return anything. */
2820 if (VOID_TYPE_P (callee_type
))
2823 /* If there was a return slot, then the return value is the
2824 dereferenced address of that object. */
2827 /* The front end shouldn't have used both return_slot and
2828 a modify expression. */
2829 gcc_assert (!modify_dest
);
2830 if (DECL_BY_REFERENCE (result
))
2832 tree return_slot_addr
= build_fold_addr_expr (return_slot
);
2833 STRIP_USELESS_TYPE_CONVERSION (return_slot_addr
);
2835 /* We are going to construct *&return_slot and we can't do that
2836 for variables believed to be not addressable.
2838 FIXME: This check possibly can match, because values returned
2839 via return slot optimization are not believed to have address
2840 taken by alias analysis. */
2841 gcc_assert (TREE_CODE (return_slot
) != SSA_NAME
);
2842 var
= return_slot_addr
;
2847 gcc_assert (TREE_CODE (var
) != SSA_NAME
);
2848 TREE_ADDRESSABLE (var
) |= TREE_ADDRESSABLE (result
);
2850 if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
2851 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
2852 && !DECL_GIMPLE_REG_P (result
)
2854 DECL_GIMPLE_REG_P (var
) = 0;
2859 /* All types requiring non-trivial constructors should have been handled. */
2860 gcc_assert (!TREE_ADDRESSABLE (callee_type
));
2862 /* Attempt to avoid creating a new temporary variable. */
2864 && TREE_CODE (modify_dest
) != SSA_NAME
)
2866 bool use_it
= false;
2868 /* We can't use MODIFY_DEST if there's type promotion involved. */
2869 if (!useless_type_conversion_p (callee_type
, caller_type
))
2872 /* ??? If we're assigning to a variable sized type, then we must
2873 reuse the destination variable, because we've no good way to
2874 create variable sized temporaries at this point. */
2875 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type
)) != INTEGER_CST
)
2878 /* If the callee cannot possibly modify MODIFY_DEST, then we can
2879 reuse it as the result of the call directly. Don't do this if
2880 it would promote MODIFY_DEST to addressable. */
2881 else if (TREE_ADDRESSABLE (result
))
2885 tree base_m
= get_base_address (modify_dest
);
2887 /* If the base isn't a decl, then it's a pointer, and we don't
2888 know where that's going to go. */
2889 if (!DECL_P (base_m
))
2891 else if (is_global_var (base_m
))
2893 else if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
2894 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
2895 && !DECL_GIMPLE_REG_P (result
)
2896 && DECL_GIMPLE_REG_P (base_m
))
2898 else if (!TREE_ADDRESSABLE (base_m
))
2910 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type
)) == INTEGER_CST
);
2912 var
= copy_result_decl_to_var (result
, id
);
2913 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
2915 /* Do not have the rest of GCC warn about this variable as it should
2916 not be visible to the user. */
2917 TREE_NO_WARNING (var
) = 1;
2919 declare_inline_vars (id
->block
, var
);
2921 /* Build the use expr. If the return type of the function was
2922 promoted, convert it back to the expected type. */
2924 if (!useless_type_conversion_p (caller_type
, TREE_TYPE (var
)))
2926 /* If we can match up types by promotion/demotion do so. */
2927 if (fold_convertible_p (caller_type
, var
))
2928 use
= fold_convert (caller_type
, var
);
2931 /* ??? For valid programs we should not end up here.
2932 Still if we end up with truly mismatched types here, fall back
2933 to using a MEM_REF to not leak invalid GIMPLE to the following
2935 /* Prevent var from being written into SSA form. */
2936 if (TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
2937 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
)
2938 DECL_GIMPLE_REG_P (var
) = false;
2939 else if (is_gimple_reg_type (TREE_TYPE (var
)))
2940 TREE_ADDRESSABLE (var
) = true;
2941 use
= fold_build2 (MEM_REF
, caller_type
,
2942 build_fold_addr_expr (var
),
2943 build_int_cst (ptr_type_node
, 0));
2947 STRIP_USELESS_TYPE_CONVERSION (use
);
2949 if (DECL_BY_REFERENCE (result
))
2951 TREE_ADDRESSABLE (var
) = 1;
2952 var
= build_fold_addr_expr (var
);
2956 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
2957 way, when the RESULT_DECL is encountered, it will be
2958 automatically replaced by the VAR_DECL.
2960 When returning by reference, ensure that RESULT_DECL remaps to
2962 if (DECL_BY_REFERENCE (result
)
2963 && !is_gimple_val (var
))
2965 tree temp
= create_tmp_var (TREE_TYPE (result
), "retvalptr");
2966 insert_decl_map (id
, result
, temp
);
2967 /* When RESULT_DECL is in SSA form, we need to remap and initialize
2968 it's default_def SSA_NAME. */
2969 if (gimple_in_ssa_p (id
->src_cfun
)
2970 && is_gimple_reg (result
))
2972 temp
= make_ssa_name (temp
, NULL
);
2973 insert_decl_map (id
, ssa_default_def (id
->src_cfun
, result
), temp
);
2975 insert_init_stmt (id
, entry_bb
, gimple_build_assign (temp
, var
));
2978 insert_decl_map (id
, result
, var
);
2980 /* Remember this so we can ignore it in remap_decls. */
2986 /* Callback through walk_tree. Determine if a DECL_INITIAL makes reference
2987 to a local label. */
2990 has_label_address_in_static_1 (tree
*nodep
, int *walk_subtrees
, void *fnp
)
2993 tree fn
= (tree
) fnp
;
2995 if (TREE_CODE (node
) == LABEL_DECL
&& DECL_CONTEXT (node
) == fn
)
3004 /* Determine if the function can be copied. If so return NULL. If
3005 not return a string describng the reason for failure. */
3008 copy_forbidden (struct function
*fun
, tree fndecl
)
3010 const char *reason
= fun
->cannot_be_copied_reason
;
3014 /* Only examine the function once. */
3015 if (fun
->cannot_be_copied_set
)
3018 /* We cannot copy a function that receives a non-local goto
3019 because we cannot remap the destination label used in the
3020 function that is performing the non-local goto. */
3021 /* ??? Actually, this should be possible, if we work at it.
3022 No doubt there's just a handful of places that simply
3023 assume it doesn't happen and don't substitute properly. */
3024 if (fun
->has_nonlocal_label
)
3026 reason
= G_("function %q+F can never be copied "
3027 "because it receives a non-local goto");
3031 FOR_EACH_LOCAL_DECL (fun
, ix
, decl
)
3032 if (TREE_CODE (decl
) == VAR_DECL
3033 && TREE_STATIC (decl
)
3034 && !DECL_EXTERNAL (decl
)
3035 && DECL_INITIAL (decl
)
3036 && walk_tree_without_duplicates (&DECL_INITIAL (decl
),
3037 has_label_address_in_static_1
,
3040 reason
= G_("function %q+F can never be copied because it saves "
3041 "address of local label in a static variable");
3046 fun
->cannot_be_copied_reason
= reason
;
3047 fun
->cannot_be_copied_set
= true;
3052 static const char *inline_forbidden_reason
;
3054 /* A callback for walk_gimple_seq to handle statements. Returns non-null
3055 iff a function can not be inlined. Also sets the reason why. */
3058 inline_forbidden_p_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
3059 struct walk_stmt_info
*wip
)
3061 tree fn
= (tree
) wip
->info
;
3063 gimple stmt
= gsi_stmt (*gsi
);
3065 switch (gimple_code (stmt
))
3068 /* Refuse to inline alloca call unless user explicitly forced so as
3069 this may change program's memory overhead drastically when the
3070 function using alloca is called in loop. In GCC present in
3071 SPEC2000 inlining into schedule_block cause it to require 2GB of
3072 RAM instead of 256MB. Don't do so for alloca calls emitted for
3073 VLA objects as those can't cause unbounded growth (they're always
3074 wrapped inside stack_save/stack_restore regions. */
3075 if (gimple_alloca_call_p (stmt
)
3076 && !gimple_call_alloca_for_var_p (stmt
)
3077 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
3079 inline_forbidden_reason
3080 = G_("function %q+F can never be inlined because it uses "
3081 "alloca (override using the always_inline attribute)");
3082 *handled_ops_p
= true;
3086 t
= gimple_call_fndecl (stmt
);
3090 /* We cannot inline functions that call setjmp. */
3091 if (setjmp_call_p (t
))
3093 inline_forbidden_reason
3094 = G_("function %q+F can never be inlined because it uses setjmp");
3095 *handled_ops_p
= true;
3099 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
3100 switch (DECL_FUNCTION_CODE (t
))
3102 /* We cannot inline functions that take a variable number of
3104 case BUILT_IN_VA_START
:
3105 case BUILT_IN_NEXT_ARG
:
3106 case BUILT_IN_VA_END
:
3107 inline_forbidden_reason
3108 = G_("function %q+F can never be inlined because it "
3109 "uses variable argument lists");
3110 *handled_ops_p
= true;
3113 case BUILT_IN_LONGJMP
:
3114 /* We can't inline functions that call __builtin_longjmp at
3115 all. The non-local goto machinery really requires the
3116 destination be in a different function. If we allow the
3117 function calling __builtin_longjmp to be inlined into the
3118 function calling __builtin_setjmp, Things will Go Awry. */
3119 inline_forbidden_reason
3120 = G_("function %q+F can never be inlined because "
3121 "it uses setjmp-longjmp exception handling");
3122 *handled_ops_p
= true;
3125 case BUILT_IN_NONLOCAL_GOTO
:
3127 inline_forbidden_reason
3128 = G_("function %q+F can never be inlined because "
3129 "it uses non-local goto");
3130 *handled_ops_p
= true;
3133 case BUILT_IN_RETURN
:
3134 case BUILT_IN_APPLY_ARGS
:
3135 /* If a __builtin_apply_args caller would be inlined,
3136 it would be saving arguments of the function it has
3137 been inlined into. Similarly __builtin_return would
3138 return from the function the inline has been inlined into. */
3139 inline_forbidden_reason
3140 = G_("function %q+F can never be inlined because "
3141 "it uses __builtin_return or __builtin_apply_args");
3142 *handled_ops_p
= true;
3151 t
= gimple_goto_dest (stmt
);
3153 /* We will not inline a function which uses computed goto. The
3154 addresses of its local labels, which may be tucked into
3155 global storage, are of course not constant across
3156 instantiations, which causes unexpected behavior. */
3157 if (TREE_CODE (t
) != LABEL_DECL
)
3159 inline_forbidden_reason
3160 = G_("function %q+F can never be inlined "
3161 "because it contains a computed goto");
3162 *handled_ops_p
= true;
3171 *handled_ops_p
= false;
3175 /* Return true if FNDECL is a function that cannot be inlined into
3179 inline_forbidden_p (tree fndecl
)
3181 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
3182 struct walk_stmt_info wi
;
3183 struct pointer_set_t
*visited_nodes
;
3185 bool forbidden_p
= false;
3187 /* First check for shared reasons not to copy the code. */
3188 inline_forbidden_reason
= copy_forbidden (fun
, fndecl
);
3189 if (inline_forbidden_reason
!= NULL
)
3192 /* Next, walk the statements of the function looking for
3193 constraucts we can't handle, or are non-optimal for inlining. */
3194 visited_nodes
= pointer_set_create ();
3195 memset (&wi
, 0, sizeof (wi
));
3196 wi
.info
= (void *) fndecl
;
3197 wi
.pset
= visited_nodes
;
3199 FOR_EACH_BB_FN (bb
, fun
)
3202 gimple_seq seq
= bb_seq (bb
);
3203 ret
= walk_gimple_seq (seq
, inline_forbidden_p_stmt
, NULL
, &wi
);
3204 forbidden_p
= (ret
!= NULL
);
3209 pointer_set_destroy (visited_nodes
);
3213 /* Return false if the function FNDECL cannot be inlined on account of its
3214 attributes, true otherwise. */
3216 function_attribute_inlinable_p (const_tree fndecl
)
3218 if (targetm
.attribute_table
)
3222 for (a
= DECL_ATTRIBUTES (fndecl
); a
; a
= TREE_CHAIN (a
))
3224 const_tree name
= TREE_PURPOSE (a
);
3227 for (i
= 0; targetm
.attribute_table
[i
].name
!= NULL
; i
++)
3228 if (is_attribute_p (targetm
.attribute_table
[i
].name
, name
))
3229 return targetm
.function_attribute_inlinable_p (fndecl
);
3236 /* Returns nonzero if FN is a function that does not have any
3237 fundamental inline blocking properties. */
3240 tree_inlinable_function_p (tree fn
)
3242 bool inlinable
= true;
3246 /* If we've already decided this function shouldn't be inlined,
3247 there's no need to check again. */
3248 if (DECL_UNINLINABLE (fn
))
3251 /* We only warn for functions declared `inline' by the user. */
3252 do_warning
= (warn_inline
3253 && DECL_DECLARED_INLINE_P (fn
)
3254 && !DECL_NO_INLINE_WARNING_P (fn
)
3255 && !DECL_IN_SYSTEM_HEADER (fn
));
3257 always_inline
= lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
));
3260 && always_inline
== NULL
)
3263 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3264 "is suppressed using -fno-inline", fn
);
3268 else if (!function_attribute_inlinable_p (fn
))
3271 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3272 "uses attributes conflicting with inlining", fn
);
3276 else if (inline_forbidden_p (fn
))
3278 /* See if we should warn about uninlinable functions. Previously,
3279 some of these warnings would be issued while trying to expand
3280 the function inline, but that would cause multiple warnings
3281 about functions that would for example call alloca. But since
3282 this a property of the function, just one warning is enough.
3283 As a bonus we can now give more details about the reason why a
3284 function is not inlinable. */
3286 error (inline_forbidden_reason
, fn
);
3287 else if (do_warning
)
3288 warning (OPT_Winline
, inline_forbidden_reason
, fn
);
3293 /* Squirrel away the result so that we don't have to check again. */
3294 DECL_UNINLINABLE (fn
) = !inlinable
;
3299 /* Estimate the cost of a memory move. Use machine dependent
3300 word size and take possible memcpy call into account. */
3303 estimate_move_cost (tree type
)
3307 gcc_assert (!VOID_TYPE_P (type
));
3309 if (TREE_CODE (type
) == VECTOR_TYPE
)
3311 enum machine_mode inner
= TYPE_MODE (TREE_TYPE (type
));
3312 enum machine_mode simd
3313 = targetm
.vectorize
.preferred_simd_mode (inner
);
3314 int simd_mode_size
= GET_MODE_SIZE (simd
);
3315 return ((GET_MODE_SIZE (TYPE_MODE (type
)) + simd_mode_size
- 1)
3319 size
= int_size_in_bytes (type
);
3321 if (size
< 0 || size
> MOVE_MAX_PIECES
* MOVE_RATIO (!optimize_size
))
3322 /* Cost of a memcpy call, 3 arguments and the call. */
3325 return ((size
+ MOVE_MAX_PIECES
- 1) / MOVE_MAX_PIECES
);
3328 /* Returns cost of operation CODE, according to WEIGHTS */
3331 estimate_operator_cost (enum tree_code code
, eni_weights
*weights
,
3332 tree op1 ATTRIBUTE_UNUSED
, tree op2
)
3336 /* These are "free" conversions, or their presumed cost
3337 is folded into other operations. */
3342 case VIEW_CONVERT_EXPR
:
3345 /* Assign cost of 1 to usual operations.
3346 ??? We may consider mapping RTL costs to this. */
3352 case POINTER_PLUS_EXPR
:
3355 case MULT_HIGHPART_EXPR
:
3358 case ADDR_SPACE_CONVERT_EXPR
:
3359 case FIXED_CONVERT_EXPR
:
3360 case FIX_TRUNC_EXPR
:
3372 case VEC_LSHIFT_EXPR
:
3373 case VEC_RSHIFT_EXPR
:
3380 case TRUTH_ANDIF_EXPR
:
3381 case TRUTH_ORIF_EXPR
:
3382 case TRUTH_AND_EXPR
:
3384 case TRUTH_XOR_EXPR
:
3385 case TRUTH_NOT_EXPR
:
3394 case UNORDERED_EXPR
:
3405 case PREDECREMENT_EXPR
:
3406 case PREINCREMENT_EXPR
:
3407 case POSTDECREMENT_EXPR
:
3408 case POSTINCREMENT_EXPR
:
3410 case REALIGN_LOAD_EXPR
:
3412 case REDUC_MAX_EXPR
:
3413 case REDUC_MIN_EXPR
:
3414 case REDUC_PLUS_EXPR
:
3415 case WIDEN_SUM_EXPR
:
3416 case WIDEN_MULT_EXPR
:
3418 case WIDEN_MULT_PLUS_EXPR
:
3419 case WIDEN_MULT_MINUS_EXPR
:
3420 case WIDEN_LSHIFT_EXPR
:
3422 case VEC_WIDEN_MULT_HI_EXPR
:
3423 case VEC_WIDEN_MULT_LO_EXPR
:
3424 case VEC_WIDEN_MULT_EVEN_EXPR
:
3425 case VEC_WIDEN_MULT_ODD_EXPR
:
3426 case VEC_UNPACK_HI_EXPR
:
3427 case VEC_UNPACK_LO_EXPR
:
3428 case VEC_UNPACK_FLOAT_HI_EXPR
:
3429 case VEC_UNPACK_FLOAT_LO_EXPR
:
3430 case VEC_PACK_TRUNC_EXPR
:
3431 case VEC_PACK_SAT_EXPR
:
3432 case VEC_PACK_FIX_TRUNC_EXPR
:
3433 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3434 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3438 /* Few special cases of expensive operations. This is useful
3439 to avoid inlining on functions having too many of these. */
3440 case TRUNC_DIV_EXPR
:
3442 case FLOOR_DIV_EXPR
:
3443 case ROUND_DIV_EXPR
:
3444 case EXACT_DIV_EXPR
:
3445 case TRUNC_MOD_EXPR
:
3447 case FLOOR_MOD_EXPR
:
3448 case ROUND_MOD_EXPR
:
3450 if (TREE_CODE (op2
) != INTEGER_CST
)
3451 return weights
->div_mod_cost
;
3455 /* We expect a copy assignment with no operator. */
3456 gcc_assert (get_gimple_rhs_class (code
) == GIMPLE_SINGLE_RHS
);
3462 /* Estimate number of instructions that will be created by expanding
3463 the statements in the statement sequence STMTS.
3464 WEIGHTS contains weights attributed to various constructs. */
3467 int estimate_num_insns_seq (gimple_seq stmts
, eni_weights
*weights
)
3470 gimple_stmt_iterator gsi
;
3473 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3474 cost
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
3480 /* Estimate number of instructions that will be created by expanding STMT.
3481 WEIGHTS contains weights attributed to various constructs. */
3484 estimate_num_insns (gimple stmt
, eni_weights
*weights
)
3487 enum gimple_code code
= gimple_code (stmt
);
3494 /* Try to estimate the cost of assignments. We have three cases to
3496 1) Simple assignments to registers;
3497 2) Stores to things that must live in memory. This includes
3498 "normal" stores to scalars, but also assignments of large
3499 structures, or constructors of big arrays;
3501 Let us look at the first two cases, assuming we have "a = b + C":
3502 <GIMPLE_ASSIGN <var_decl "a">
3503 <plus_expr <var_decl "b"> <constant C>>
3504 If "a" is a GIMPLE register, the assignment to it is free on almost
3505 any target, because "a" usually ends up in a real register. Hence
3506 the only cost of this expression comes from the PLUS_EXPR, and we
3507 can ignore the GIMPLE_ASSIGN.
3508 If "a" is not a GIMPLE register, the assignment to "a" will most
3509 likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost
3510 of moving something into "a", which we compute using the function
3511 estimate_move_cost. */
3512 if (gimple_clobber_p (stmt
))
3513 return 0; /* ={v} {CLOBBER} stmt expands to nothing. */
3515 lhs
= gimple_assign_lhs (stmt
);
3516 rhs
= gimple_assign_rhs1 (stmt
);
3520 /* Account for the cost of moving to / from memory. */
3521 if (gimple_store_p (stmt
))
3522 cost
+= estimate_move_cost (TREE_TYPE (lhs
));
3523 if (gimple_assign_load_p (stmt
))
3524 cost
+= estimate_move_cost (TREE_TYPE (rhs
));
3526 cost
+= estimate_operator_cost (gimple_assign_rhs_code (stmt
), weights
,
3527 gimple_assign_rhs1 (stmt
),
3528 get_gimple_rhs_class (gimple_assign_rhs_code (stmt
))
3529 == GIMPLE_BINARY_RHS
3530 ? gimple_assign_rhs2 (stmt
) : NULL
);
3534 cost
= 1 + estimate_operator_cost (gimple_cond_code (stmt
), weights
,
3535 gimple_op (stmt
, 0),
3536 gimple_op (stmt
, 1));
3540 /* Take into account cost of the switch + guess 2 conditional jumps for
3543 TODO: once the switch expansion logic is sufficiently separated, we can
3544 do better job on estimating cost of the switch. */
3545 if (weights
->time_based
)
3546 cost
= floor_log2 (gimple_switch_num_labels (stmt
)) * 2;
3548 cost
= gimple_switch_num_labels (stmt
) * 2;
3553 tree decl
= gimple_call_fndecl (stmt
);
3554 struct cgraph_node
*node
= NULL
;
3556 /* Do not special case builtins where we see the body.
3557 This just confuse inliner. */
3558 if (!decl
|| !(node
= cgraph_get_node (decl
)) || node
->analyzed
)
3560 /* For buitins that are likely expanded to nothing or
3561 inlined do not account operand costs. */
3562 else if (is_simple_builtin (decl
))
3564 else if (is_inexpensive_builtin (decl
))
3565 return weights
->target_builtin_call_cost
;
3566 else if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
3568 /* We canonicalize x * x to pow (x, 2.0) with -ffast-math, so
3569 specialize the cheap expansion we do here.
3570 ??? This asks for a more general solution. */
3571 switch (DECL_FUNCTION_CODE (decl
))
3576 if (TREE_CODE (gimple_call_arg (stmt
, 1)) == REAL_CST
3577 && REAL_VALUES_EQUAL
3578 (TREE_REAL_CST (gimple_call_arg (stmt
, 1)), dconst2
))
3579 return estimate_operator_cost (MULT_EXPR
, weights
,
3580 gimple_call_arg (stmt
, 0),
3581 gimple_call_arg (stmt
, 0));
3589 cost
= node
? weights
->call_cost
: weights
->indirect_call_cost
;
3590 if (gimple_call_lhs (stmt
))
3591 cost
+= estimate_move_cost (TREE_TYPE (gimple_call_lhs (stmt
)));
3592 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
3594 tree arg
= gimple_call_arg (stmt
, i
);
3595 cost
+= estimate_move_cost (TREE_TYPE (arg
));
3601 return weights
->return_cost
;
3607 case GIMPLE_PREDICT
:
3612 return asm_str_count (gimple_asm_string (stmt
));
3615 /* This is either going to be an external function call with one
3616 argument, or two register copy statements plus a goto. */
3619 case GIMPLE_EH_DISPATCH
:
3620 /* ??? This is going to turn into a switch statement. Ideally
3621 we'd have a look at the eh region and estimate the number of
3626 return estimate_num_insns_seq (gimple_bind_body (stmt
), weights
);
3628 case GIMPLE_EH_FILTER
:
3629 return estimate_num_insns_seq (gimple_eh_filter_failure (stmt
), weights
);
3632 return estimate_num_insns_seq (gimple_catch_handler (stmt
), weights
);
3635 return (estimate_num_insns_seq (gimple_try_eval (stmt
), weights
)
3636 + estimate_num_insns_seq (gimple_try_cleanup (stmt
), weights
));
3638 /* OpenMP directives are generally very expensive. */
3640 case GIMPLE_OMP_RETURN
:
3641 case GIMPLE_OMP_SECTIONS_SWITCH
:
3642 case GIMPLE_OMP_ATOMIC_STORE
:
3643 case GIMPLE_OMP_CONTINUE
:
3644 /* ...except these, which are cheap. */
3647 case GIMPLE_OMP_ATOMIC_LOAD
:
3648 return weights
->omp_cost
;
3650 case GIMPLE_OMP_FOR
:
3651 return (weights
->omp_cost
3652 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
)
3653 + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt
), weights
));
3655 case GIMPLE_OMP_PARALLEL
:
3656 case GIMPLE_OMP_TASK
:
3657 case GIMPLE_OMP_CRITICAL
:
3658 case GIMPLE_OMP_MASTER
:
3659 case GIMPLE_OMP_ORDERED
:
3660 case GIMPLE_OMP_SECTION
:
3661 case GIMPLE_OMP_SECTIONS
:
3662 case GIMPLE_OMP_SINGLE
:
3663 return (weights
->omp_cost
3664 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
));
3666 case GIMPLE_TRANSACTION
:
3667 return (weights
->tm_cost
3668 + estimate_num_insns_seq (gimple_transaction_body (stmt
),
3678 /* Estimate number of instructions that will be created by expanding
3679 function FNDECL. WEIGHTS contains weights attributed to various
3683 estimate_num_insns_fn (tree fndecl
, eni_weights
*weights
)
3685 struct function
*my_function
= DECL_STRUCT_FUNCTION (fndecl
);
3686 gimple_stmt_iterator bsi
;
3690 gcc_assert (my_function
&& my_function
->cfg
);
3691 FOR_EACH_BB_FN (bb
, my_function
)
3693 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
3694 n
+= estimate_num_insns (gsi_stmt (bsi
), weights
);
3701 /* Initializes weights used by estimate_num_insns. */
3704 init_inline_once (void)
3706 eni_size_weights
.call_cost
= 1;
3707 eni_size_weights
.indirect_call_cost
= 3;
3708 eni_size_weights
.target_builtin_call_cost
= 1;
3709 eni_size_weights
.div_mod_cost
= 1;
3710 eni_size_weights
.omp_cost
= 40;
3711 eni_size_weights
.tm_cost
= 10;
3712 eni_size_weights
.time_based
= false;
3713 eni_size_weights
.return_cost
= 1;
3715 /* Estimating time for call is difficult, since we have no idea what the
3716 called function does. In the current uses of eni_time_weights,
3717 underestimating the cost does less harm than overestimating it, so
3718 we choose a rather small value here. */
3719 eni_time_weights
.call_cost
= 10;
3720 eni_time_weights
.indirect_call_cost
= 15;
3721 eni_time_weights
.target_builtin_call_cost
= 1;
3722 eni_time_weights
.div_mod_cost
= 10;
3723 eni_time_weights
.omp_cost
= 40;
3724 eni_time_weights
.tm_cost
= 40;
3725 eni_time_weights
.time_based
= true;
3726 eni_time_weights
.return_cost
= 2;
3729 /* Estimate the number of instructions in a gimple_seq. */
3732 count_insns_seq (gimple_seq seq
, eni_weights
*weights
)
3734 gimple_stmt_iterator gsi
;
3736 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3737 n
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
3743 /* Install new lexical TREE_BLOCK underneath 'current_block'. */
3746 prepend_lexical_block (tree current_block
, tree new_block
)
3748 BLOCK_CHAIN (new_block
) = BLOCK_SUBBLOCKS (current_block
);
3749 BLOCK_SUBBLOCKS (current_block
) = new_block
;
3750 BLOCK_SUPERCONTEXT (new_block
) = current_block
;
3753 /* Add local variables from CALLEE to CALLER. */
3756 add_local_variables (struct function
*callee
, struct function
*caller
,
3762 FOR_EACH_LOCAL_DECL (callee
, ix
, var
)
3763 if (!can_be_nonlocal (var
, id
))
3765 tree new_var
= remap_decl (var
, id
);
3767 /* Remap debug-expressions. */
3768 if (TREE_CODE (new_var
) == VAR_DECL
3769 && DECL_HAS_DEBUG_EXPR_P (var
)
3772 tree tem
= DECL_DEBUG_EXPR (var
);
3773 bool old_regimplify
= id
->regimplify
;
3774 id
->remapping_type_depth
++;
3775 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
3776 id
->remapping_type_depth
--;
3777 id
->regimplify
= old_regimplify
;
3778 SET_DECL_DEBUG_EXPR (new_var
, tem
);
3779 DECL_HAS_DEBUG_EXPR_P (new_var
) = 1;
3781 add_local_decl (caller
, new_var
);
3785 /* If STMT is a GIMPLE_CALL, replace it with its inline expansion. */
3788 expand_call_inline (basic_block bb
, gimple stmt
, copy_body_data
*id
)
3792 struct pointer_map_t
*st
, *dst
;
3795 location_t saved_location
;
3796 struct cgraph_edge
*cg_edge
;
3797 cgraph_inline_failed_t reason
;
3798 basic_block return_block
;
3800 gimple_stmt_iterator gsi
, stmt_gsi
;
3801 bool successfully_inlined
= FALSE
;
3802 bool purge_dead_abnormal_edges
;
3804 /* Set input_location here so we get the right instantiation context
3805 if we call instantiate_decl from inlinable_function_p. */
3806 /* FIXME: instantiate_decl isn't called by inlinable_function_p. */
3807 saved_location
= input_location
;
3808 input_location
= gimple_location (stmt
);
3810 /* From here on, we're only interested in CALL_EXPRs. */
3811 if (gimple_code (stmt
) != GIMPLE_CALL
)
3814 cg_edge
= cgraph_edge (id
->dst_node
, stmt
);
3815 gcc_checking_assert (cg_edge
);
3816 /* First, see if we can figure out what function is being called.
3817 If we cannot, then there is no hope of inlining the function. */
3818 if (cg_edge
->indirect_unknown_callee
)
3820 fn
= cg_edge
->callee
->symbol
.decl
;
3821 gcc_checking_assert (fn
);
3823 /* If FN is a declaration of a function in a nested scope that was
3824 globally declared inline, we don't set its DECL_INITIAL.
3825 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
3826 C++ front-end uses it for cdtors to refer to their internal
3827 declarations, that are not real functions. Fortunately those
3828 don't have trees to be saved, so we can tell by checking their
3830 if (!DECL_INITIAL (fn
)
3831 && DECL_ABSTRACT_ORIGIN (fn
)
3832 && gimple_has_body_p (DECL_ABSTRACT_ORIGIN (fn
)))
3833 fn
= DECL_ABSTRACT_ORIGIN (fn
);
3835 /* Don't try to inline functions that are not well-suited to inlining. */
3836 if (cg_edge
->inline_failed
)
3838 reason
= cg_edge
->inline_failed
;
3839 /* If this call was originally indirect, we do not want to emit any
3840 inlining related warnings or sorry messages because there are no
3841 guarantees regarding those. */
3842 if (cg_edge
->indirect_inlining_edge
)
3845 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
))
3846 /* For extern inline functions that get redefined we always
3847 silently ignored always_inline flag. Better behaviour would
3848 be to be able to keep both bodies and use extern inline body
3849 for inlining, but we can't do that because frontends overwrite
3851 && !cg_edge
->callee
->local
.redefined_extern_inline
3852 /* Avoid warnings during early inline pass. */
3853 && cgraph_global_info_ready
3854 /* PR 20090218-1_0.c. Body can be provided by another module. */
3855 && (reason
!= CIF_BODY_NOT_AVAILABLE
|| !flag_generate_lto
))
3857 error ("inlining failed in call to always_inline %q+F: %s", fn
,
3858 cgraph_inline_failed_string (reason
));
3859 error ("called from here");
3861 else if (warn_inline
3862 && DECL_DECLARED_INLINE_P (fn
)
3863 && !DECL_NO_INLINE_WARNING_P (fn
)
3864 && !DECL_IN_SYSTEM_HEADER (fn
)
3865 && reason
!= CIF_UNSPECIFIED
3866 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn
))
3867 /* Do not warn about not inlined recursive calls. */
3868 && !cgraph_edge_recursive_p (cg_edge
)
3869 /* Avoid warnings during early inline pass. */
3870 && cgraph_global_info_ready
)
3872 warning (OPT_Winline
, "inlining failed in call to %q+F: %s",
3873 fn
, _(cgraph_inline_failed_string (reason
)));
3874 warning (OPT_Winline
, "called from here");
3878 fn
= cg_edge
->callee
->symbol
.decl
;
3880 #ifdef ENABLE_CHECKING
3881 if (cg_edge
->callee
->symbol
.decl
!= id
->dst_node
->symbol
.decl
)
3882 verify_cgraph_node (cg_edge
->callee
);
3885 /* We will be inlining this callee. */
3886 id
->eh_lp_nr
= lookup_stmt_eh_lp (stmt
);
3888 /* Update the callers EH personality. */
3889 if (DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->symbol
.decl
))
3890 DECL_FUNCTION_PERSONALITY (cg_edge
->caller
->symbol
.decl
)
3891 = DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->symbol
.decl
);
3893 /* Split the block holding the GIMPLE_CALL. */
3894 e
= split_block (bb
, stmt
);
3896 return_block
= e
->dest
;
3899 /* split_block splits after the statement; work around this by
3900 moving the call into the second block manually. Not pretty,
3901 but seems easier than doing the CFG manipulation by hand
3902 when the GIMPLE_CALL is in the last statement of BB. */
3903 stmt_gsi
= gsi_last_bb (bb
);
3904 gsi_remove (&stmt_gsi
, false);
3906 /* If the GIMPLE_CALL was in the last statement of BB, it may have
3907 been the source of abnormal edges. In this case, schedule
3908 the removal of dead abnormal edges. */
3909 gsi
= gsi_start_bb (return_block
);
3910 if (gsi_end_p (gsi
))
3912 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
3913 purge_dead_abnormal_edges
= true;
3917 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
3918 purge_dead_abnormal_edges
= false;
3921 stmt_gsi
= gsi_start_bb (return_block
);
3923 /* Build a block containing code to initialize the arguments, the
3924 actual inline expansion of the body, and a label for the return
3925 statements within the function to jump to. The type of the
3926 statement expression is the return type of the function call.
3927 ??? If the call does not have an associated block then we will
3928 remap all callee blocks to NULL, effectively dropping most of
3929 its debug information. This should only happen for calls to
3930 artificial decls inserted by the compiler itself. We need to
3931 either link the inlined blocks into the caller block tree or
3932 not refer to them in any way to not break GC for locations. */
3933 if (gimple_block (stmt
))
3935 id
->block
= make_node (BLOCK
);
3936 BLOCK_ABSTRACT_ORIGIN (id
->block
) = fn
;
3937 BLOCK_SOURCE_LOCATION (id
->block
) = LOCATION_LOCUS (input_location
);
3938 prepend_lexical_block (gimple_block (stmt
), id
->block
);
3941 /* Local declarations will be replaced by their equivalents in this
3944 id
->decl_map
= pointer_map_create ();
3945 dst
= id
->debug_map
;
3946 id
->debug_map
= NULL
;
3948 /* Record the function we are about to inline. */
3950 id
->src_node
= cg_edge
->callee
;
3951 id
->src_cfun
= DECL_STRUCT_FUNCTION (fn
);
3952 id
->gimple_call
= stmt
;
3954 gcc_assert (!id
->src_cfun
->after_inlining
);
3957 if (lookup_attribute ("cold", DECL_ATTRIBUTES (fn
)))
3959 gimple_stmt_iterator si
= gsi_last_bb (bb
);
3960 gsi_insert_after (&si
, gimple_build_predict (PRED_COLD_FUNCTION
,
3964 initialize_inlined_parameters (id
, stmt
, fn
, bb
);
3966 if (DECL_INITIAL (fn
))
3968 if (gimple_block (stmt
))
3972 prepend_lexical_block (id
->block
,
3973 remap_blocks (DECL_INITIAL (fn
), id
));
3974 gcc_checking_assert (BLOCK_SUBBLOCKS (id
->block
)
3975 && (BLOCK_CHAIN (BLOCK_SUBBLOCKS (id
->block
))
3977 /* Move vars for PARM_DECLs from DECL_INITIAL block to id->block,
3978 otherwise for DWARF DW_TAG_formal_parameter will not be children of
3979 DW_TAG_inlined_subroutine, but of a DW_TAG_lexical_block
3980 under it. The parameters can be then evaluated in the debugger,
3981 but don't show in backtraces. */
3982 for (var
= &BLOCK_VARS (BLOCK_SUBBLOCKS (id
->block
)); *var
; )
3983 if (TREE_CODE (DECL_ORIGIN (*var
)) == PARM_DECL
)
3986 *var
= TREE_CHAIN (v
);
3987 TREE_CHAIN (v
) = BLOCK_VARS (id
->block
);
3988 BLOCK_VARS (id
->block
) = v
;
3991 var
= &TREE_CHAIN (*var
);
3994 remap_blocks_to_null (DECL_INITIAL (fn
), id
);
3997 /* Return statements in the function body will be replaced by jumps
3998 to the RET_LABEL. */
3999 gcc_assert (DECL_INITIAL (fn
));
4000 gcc_assert (TREE_CODE (DECL_INITIAL (fn
)) == BLOCK
);
4002 /* Find the LHS to which the result of this call is assigned. */
4004 if (gimple_call_lhs (stmt
))
4006 modify_dest
= gimple_call_lhs (stmt
);
4008 /* The function which we are inlining might not return a value,
4009 in which case we should issue a warning that the function
4010 does not return a value. In that case the optimizers will
4011 see that the variable to which the value is assigned was not
4012 initialized. We do not want to issue a warning about that
4013 uninitialized variable. */
4014 if (DECL_P (modify_dest
))
4015 TREE_NO_WARNING (modify_dest
) = 1;
4017 if (gimple_call_return_slot_opt_p (stmt
))
4019 return_slot
= modify_dest
;
4026 /* If we are inlining a call to the C++ operator new, we don't want
4027 to use type based alias analysis on the return value. Otherwise
4028 we may get confused if the compiler sees that the inlined new
4029 function returns a pointer which was just deleted. See bug
4031 if (DECL_IS_OPERATOR_NEW (fn
))
4037 /* Declare the return variable for the function. */
4038 use_retvar
= declare_return_variable (id
, return_slot
, modify_dest
, bb
);
4040 /* Add local vars in this inlined callee to caller. */
4041 add_local_variables (id
->src_cfun
, cfun
, id
);
4043 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4045 fprintf (dump_file
, "Inlining ");
4046 print_generic_expr (dump_file
, id
->src_fn
, 0);
4047 fprintf (dump_file
, " to ");
4048 print_generic_expr (dump_file
, id
->dst_fn
, 0);
4049 fprintf (dump_file
, " with frequency %i\n", cg_edge
->frequency
);
4052 /* This is it. Duplicate the callee body. Assume callee is
4053 pre-gimplified. Note that we must not alter the caller
4054 function in any way before this point, as this CALL_EXPR may be
4055 a self-referential call; if we're calling ourselves, we need to
4056 duplicate our body before altering anything. */
4057 copy_body (id
, bb
->count
,
4058 /* Update to use GCOV_COMPUTE_SCALE. */
4059 cg_edge
->frequency
* REG_BR_PROB_BASE
/ CGRAPH_FREQ_BASE
,
4060 bb
, return_block
, NULL
, NULL
);
4062 /* Reset the escaped solution. */
4063 if (cfun
->gimple_df
)
4064 pt_solution_reset (&cfun
->gimple_df
->escaped
);
4069 pointer_map_destroy (id
->debug_map
);
4070 id
->debug_map
= dst
;
4072 pointer_map_destroy (id
->decl_map
);
4075 /* Unlink the calls virtual operands before replacing it. */
4076 unlink_stmt_vdef (stmt
);
4078 /* If the inlined function returns a result that we care about,
4079 substitute the GIMPLE_CALL with an assignment of the return
4080 variable to the LHS of the call. That is, if STMT was
4081 'a = foo (...)', substitute the call with 'a = USE_RETVAR'. */
4082 if (use_retvar
&& gimple_call_lhs (stmt
))
4084 gimple old_stmt
= stmt
;
4085 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), use_retvar
);
4086 gsi_replace (&stmt_gsi
, stmt
, false);
4087 maybe_clean_or_replace_eh_stmt (old_stmt
, stmt
);
4091 /* Handle the case of inlining a function with no return
4092 statement, which causes the return value to become undefined. */
4093 if (gimple_call_lhs (stmt
)
4094 && TREE_CODE (gimple_call_lhs (stmt
)) == SSA_NAME
)
4096 tree name
= gimple_call_lhs (stmt
);
4097 tree var
= SSA_NAME_VAR (name
);
4098 tree def
= ssa_default_def (cfun
, var
);
4102 /* If the variable is used undefined, make this name
4103 undefined via a move. */
4104 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), def
);
4105 gsi_replace (&stmt_gsi
, stmt
, true);
4109 /* Otherwise make this variable undefined. */
4110 gsi_remove (&stmt_gsi
, true);
4111 set_ssa_default_def (cfun
, var
, name
);
4112 SSA_NAME_DEF_STMT (name
) = gimple_build_nop ();
4116 gsi_remove (&stmt_gsi
, true);
4119 if (purge_dead_abnormal_edges
)
4121 gimple_purge_dead_eh_edges (return_block
);
4122 gimple_purge_dead_abnormal_call_edges (return_block
);
4125 /* If the value of the new expression is ignored, that's OK. We
4126 don't warn about this for CALL_EXPRs, so we shouldn't warn about
4127 the equivalent inlined version either. */
4128 if (is_gimple_assign (stmt
))
4130 gcc_assert (gimple_assign_single_p (stmt
)
4131 || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
)));
4132 TREE_USED (gimple_assign_rhs1 (stmt
)) = 1;
4135 /* Output the inlining info for this abstract function, since it has been
4136 inlined. If we don't do this now, we can lose the information about the
4137 variables in the function when the blocks get blown away as soon as we
4138 remove the cgraph node. */
4139 if (gimple_block (stmt
))
4140 (*debug_hooks
->outlining_inline_function
) (cg_edge
->callee
->symbol
.decl
);
4142 /* Update callgraph if needed. */
4143 cgraph_remove_node (cg_edge
->callee
);
4145 id
->block
= NULL_TREE
;
4146 successfully_inlined
= TRUE
;
4149 input_location
= saved_location
;
4150 return successfully_inlined
;
4153 /* Expand call statements reachable from STMT_P.
4154 We can only have CALL_EXPRs as the "toplevel" tree code or nested
4155 in a MODIFY_EXPR. */
4158 gimple_expand_calls_inline (basic_block bb
, copy_body_data
*id
)
4160 gimple_stmt_iterator gsi
;
4162 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4164 gimple stmt
= gsi_stmt (gsi
);
4166 if (is_gimple_call (stmt
)
4167 && expand_call_inline (bb
, stmt
, id
))
4175 /* Walk all basic blocks created after FIRST and try to fold every statement
4176 in the STATEMENTS pointer set. */
4179 fold_marked_statements (int first
, struct pointer_set_t
*statements
)
4181 for (; first
< n_basic_blocks
; first
++)
4182 if (BASIC_BLOCK (first
))
4184 gimple_stmt_iterator gsi
;
4186 for (gsi
= gsi_start_bb (BASIC_BLOCK (first
));
4189 if (pointer_set_contains (statements
, gsi_stmt (gsi
)))
4191 gimple old_stmt
= gsi_stmt (gsi
);
4192 tree old_decl
= is_gimple_call (old_stmt
) ? gimple_call_fndecl (old_stmt
) : 0;
4194 if (old_decl
&& DECL_BUILT_IN (old_decl
))
4196 /* Folding builtins can create multiple instructions,
4197 we need to look at all of them. */
4198 gimple_stmt_iterator i2
= gsi
;
4200 if (fold_stmt (&gsi
))
4203 /* If a builtin at the end of a bb folded into nothing,
4204 the following loop won't work. */
4205 if (gsi_end_p (gsi
))
4207 cgraph_update_edges_for_call_stmt (old_stmt
,
4212 i2
= gsi_start_bb (BASIC_BLOCK (first
));
4217 new_stmt
= gsi_stmt (i2
);
4218 update_stmt (new_stmt
);
4219 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4222 if (new_stmt
== gsi_stmt (gsi
))
4224 /* It is okay to check only for the very last
4225 of these statements. If it is a throwing
4226 statement nothing will change. If it isn't
4227 this can remove EH edges. If that weren't
4228 correct then because some intermediate stmts
4229 throw, but not the last one. That would mean
4230 we'd have to split the block, which we can't
4231 here and we'd loose anyway. And as builtins
4232 probably never throw, this all
4234 if (maybe_clean_or_replace_eh_stmt (old_stmt
,
4236 gimple_purge_dead_eh_edges (BASIC_BLOCK (first
));
4243 else if (fold_stmt (&gsi
))
4245 /* Re-read the statement from GSI as fold_stmt() may
4247 gimple new_stmt
= gsi_stmt (gsi
);
4248 update_stmt (new_stmt
);
4250 if (is_gimple_call (old_stmt
)
4251 || is_gimple_call (new_stmt
))
4252 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4255 if (maybe_clean_or_replace_eh_stmt (old_stmt
, new_stmt
))
4256 gimple_purge_dead_eh_edges (BASIC_BLOCK (first
));
4262 /* Return true if BB has at least one abnormal outgoing edge. */
4265 has_abnormal_outgoing_edge_p (basic_block bb
)
4270 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
4271 if (e
->flags
& EDGE_ABNORMAL
)
4277 /* Expand calls to inline functions in the body of FN. */
4280 optimize_inline_calls (tree fn
)
4284 int last
= n_basic_blocks
;
4285 struct gimplify_ctx gctx
;
4286 bool inlined_p
= false;
4289 memset (&id
, 0, sizeof (id
));
4291 id
.src_node
= id
.dst_node
= cgraph_get_node (fn
);
4292 gcc_assert (id
.dst_node
->analyzed
);
4294 /* Or any functions that aren't finished yet. */
4295 if (current_function_decl
)
4296 id
.dst_fn
= current_function_decl
;
4298 id
.copy_decl
= copy_decl_maybe_to_var
;
4299 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
4300 id
.transform_new_cfg
= false;
4301 id
.transform_return_to_modify
= true;
4302 id
.transform_lang_insert_block
= NULL
;
4303 id
.statements_to_fold
= pointer_set_create ();
4305 push_gimplify_context (&gctx
);
4307 /* We make no attempts to keep dominance info up-to-date. */
4308 free_dominance_info (CDI_DOMINATORS
);
4309 free_dominance_info (CDI_POST_DOMINATORS
);
4311 /* Register specific gimple functions. */
4312 gimple_register_cfg_hooks ();
4314 /* Reach the trees by walking over the CFG, and note the
4315 enclosing basic-blocks in the call edges. */
4316 /* We walk the blocks going forward, because inlined function bodies
4317 will split id->current_basic_block, and the new blocks will
4318 follow it; we'll trudge through them, processing their CALL_EXPRs
4321 inlined_p
|= gimple_expand_calls_inline (bb
, &id
);
4323 pop_gimplify_context (NULL
);
4325 #ifdef ENABLE_CHECKING
4327 struct cgraph_edge
*e
;
4329 verify_cgraph_node (id
.dst_node
);
4331 /* Double check that we inlined everything we are supposed to inline. */
4332 for (e
= id
.dst_node
->callees
; e
; e
= e
->next_callee
)
4333 gcc_assert (e
->inline_failed
);
4337 /* Fold queued statements. */
4338 fold_marked_statements (last
, id
.statements_to_fold
);
4339 pointer_set_destroy (id
.statements_to_fold
);
4341 gcc_assert (!id
.debug_stmts
.exists ());
4343 /* If we didn't inline into the function there is nothing to do. */
4347 /* Renumber the lexical scoping (non-code) blocks consecutively. */
4350 delete_unreachable_blocks_update_callgraph (&id
);
4351 #ifdef ENABLE_CHECKING
4352 verify_cgraph_node (id
.dst_node
);
4355 /* It would be nice to check SSA/CFG/statement consistency here, but it is
4356 not possible yet - the IPA passes might make various functions to not
4357 throw and they don't care to proactively update local EH info. This is
4358 done later in fixup_cfg pass that also execute the verification. */
4359 return (TODO_update_ssa
4361 | (gimple_in_ssa_p (cfun
) ? TODO_remove_unused_locals
: 0)
4362 | (gimple_in_ssa_p (cfun
) ? TODO_update_address_taken
: 0)
4363 | (profile_status
!= PROFILE_ABSENT
? TODO_rebuild_frequencies
: 0));
4366 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
4369 copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
4371 enum tree_code code
= TREE_CODE (*tp
);
4372 enum tree_code_class cl
= TREE_CODE_CLASS (code
);
4374 /* We make copies of most nodes. */
4375 if (IS_EXPR_CODE_CLASS (cl
)
4376 || code
== TREE_LIST
4378 || code
== TYPE_DECL
4379 || code
== OMP_CLAUSE
)
4381 /* Because the chain gets clobbered when we make a copy, we save it
4383 tree chain
= NULL_TREE
, new_tree
;
4385 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
4386 chain
= TREE_CHAIN (*tp
);
4388 /* Copy the node. */
4389 new_tree
= copy_node (*tp
);
4391 /* Propagate mudflap marked-ness. */
4392 if (flag_mudflap
&& mf_marked_p (*tp
))
4397 /* Now, restore the chain, if appropriate. That will cause
4398 walk_tree to walk into the chain as well. */
4399 if (code
== PARM_DECL
4400 || code
== TREE_LIST
4401 || code
== OMP_CLAUSE
)
4402 TREE_CHAIN (*tp
) = chain
;
4404 /* For now, we don't update BLOCKs when we make copies. So, we
4405 have to nullify all BIND_EXPRs. */
4406 if (TREE_CODE (*tp
) == BIND_EXPR
)
4407 BIND_EXPR_BLOCK (*tp
) = NULL_TREE
;
4409 else if (code
== CONSTRUCTOR
)
4411 /* CONSTRUCTOR nodes need special handling because
4412 we need to duplicate the vector of elements. */
4415 new_tree
= copy_node (*tp
);
4417 /* Propagate mudflap marked-ness. */
4418 if (flag_mudflap
&& mf_marked_p (*tp
))
4421 CONSTRUCTOR_ELTS (new_tree
) = vec_safe_copy (CONSTRUCTOR_ELTS (*tp
));
4424 else if (code
== STATEMENT_LIST
)
4425 /* We used to just abort on STATEMENT_LIST, but we can run into them
4426 with statement-expressions (c++/40975). */
4427 copy_statement_list (tp
);
4428 else if (TREE_CODE_CLASS (code
) == tcc_type
)
4430 else if (TREE_CODE_CLASS (code
) == tcc_declaration
)
4432 else if (TREE_CODE_CLASS (code
) == tcc_constant
)
4437 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
4438 information indicating to what new SAVE_EXPR this one should be mapped,
4439 use that one. Otherwise, create a new node and enter it in ST. FN is
4440 the function into which the copy will be placed. */
4443 remap_save_expr (tree
*tp
, void *st_
, int *walk_subtrees
)
4445 struct pointer_map_t
*st
= (struct pointer_map_t
*) st_
;
4449 /* See if we already encountered this SAVE_EXPR. */
4450 n
= (tree
*) pointer_map_contains (st
, *tp
);
4452 /* If we didn't already remap this SAVE_EXPR, do so now. */
4455 t
= copy_node (*tp
);
4457 /* Remember this SAVE_EXPR. */
4458 *pointer_map_insert (st
, *tp
) = t
;
4459 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
4460 *pointer_map_insert (st
, t
) = t
;
4464 /* We've already walked into this SAVE_EXPR; don't do it again. */
4469 /* Replace this SAVE_EXPR with the copy. */
4473 /* Called via walk_gimple_seq. If *GSIP points to a GIMPLE_LABEL for a local
4474 label, copies the declaration and enters it in the splay_tree in DATA (which
4475 is really a 'copy_body_data *'. */
4478 mark_local_labels_stmt (gimple_stmt_iterator
*gsip
,
4479 bool *handled_ops_p ATTRIBUTE_UNUSED
,
4480 struct walk_stmt_info
*wi
)
4482 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4483 gimple stmt
= gsi_stmt (*gsip
);
4485 if (gimple_code (stmt
) == GIMPLE_LABEL
)
4487 tree decl
= gimple_label_label (stmt
);
4489 /* Copy the decl and remember the copy. */
4490 insert_decl_map (id
, decl
, id
->copy_decl (decl
, id
));
4497 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
4498 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
4499 remaps all local declarations to appropriate replacements in gimple
4503 replace_locals_op (tree
*tp
, int *walk_subtrees
, void *data
)
4505 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
4506 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4507 struct pointer_map_t
*st
= id
->decl_map
;
4511 /* Only a local declaration (variable or label). */
4512 if ((TREE_CODE (expr
) == VAR_DECL
4513 && !TREE_STATIC (expr
))
4514 || TREE_CODE (expr
) == LABEL_DECL
)
4516 /* Lookup the declaration. */
4517 n
= (tree
*) pointer_map_contains (st
, expr
);
4519 /* If it's there, remap it. */
4524 else if (TREE_CODE (expr
) == STATEMENT_LIST
4525 || TREE_CODE (expr
) == BIND_EXPR
4526 || TREE_CODE (expr
) == SAVE_EXPR
)
4528 else if (TREE_CODE (expr
) == TARGET_EXPR
)
4530 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
4531 It's OK for this to happen if it was part of a subtree that
4532 isn't immediately expanded, such as operand 2 of another
4534 if (!TREE_OPERAND (expr
, 1))
4536 TREE_OPERAND (expr
, 1) = TREE_OPERAND (expr
, 3);
4537 TREE_OPERAND (expr
, 3) = NULL_TREE
;
4541 /* Keep iterating. */
4546 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
4547 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
4548 remaps all local declarations to appropriate replacements in gimple
4552 replace_locals_stmt (gimple_stmt_iterator
*gsip
,
4553 bool *handled_ops_p ATTRIBUTE_UNUSED
,
4554 struct walk_stmt_info
*wi
)
4556 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4557 gimple stmt
= gsi_stmt (*gsip
);
4559 if (gimple_code (stmt
) == GIMPLE_BIND
)
4561 tree block
= gimple_bind_block (stmt
);
4565 remap_block (&block
, id
);
4566 gimple_bind_set_block (stmt
, block
);
4569 /* This will remap a lot of the same decls again, but this should be
4571 if (gimple_bind_vars (stmt
))
4572 gimple_bind_set_vars (stmt
, remap_decls (gimple_bind_vars (stmt
),
4576 /* Keep iterating. */
4581 /* Copies everything in SEQ and replaces variables and labels local to
4582 current_function_decl. */
4585 copy_gimple_seq_and_replace_locals (gimple_seq seq
)
4588 struct walk_stmt_info wi
;
4589 struct pointer_set_t
*visited
;
4592 /* There's nothing to do for NULL_TREE. */
4597 memset (&id
, 0, sizeof (id
));
4598 id
.src_fn
= current_function_decl
;
4599 id
.dst_fn
= current_function_decl
;
4600 id
.decl_map
= pointer_map_create ();
4601 id
.debug_map
= NULL
;
4603 id
.copy_decl
= copy_decl_no_change
;
4604 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
4605 id
.transform_new_cfg
= false;
4606 id
.transform_return_to_modify
= false;
4607 id
.transform_lang_insert_block
= NULL
;
4609 /* Walk the tree once to find local labels. */
4610 memset (&wi
, 0, sizeof (wi
));
4611 visited
= pointer_set_create ();
4614 walk_gimple_seq (seq
, mark_local_labels_stmt
, NULL
, &wi
);
4615 pointer_set_destroy (visited
);
4617 copy
= gimple_seq_copy (seq
);
4619 /* Walk the copy, remapping decls. */
4620 memset (&wi
, 0, sizeof (wi
));
4622 walk_gimple_seq (copy
, replace_locals_stmt
, replace_locals_op
, &wi
);
4625 pointer_map_destroy (id
.decl_map
);
4627 pointer_map_destroy (id
.debug_map
);
4633 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
4636 debug_find_tree_1 (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
, void *data
)
4645 debug_find_tree (tree top
, tree search
)
4647 return walk_tree_without_duplicates (&top
, debug_find_tree_1
, search
) != 0;
4651 /* Declare the variables created by the inliner. Add all the variables in
4652 VARS to BIND_EXPR. */
4655 declare_inline_vars (tree block
, tree vars
)
4658 for (t
= vars
; t
; t
= DECL_CHAIN (t
))
4660 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
4661 gcc_assert (!TREE_STATIC (t
) && !TREE_ASM_WRITTEN (t
));
4662 add_local_decl (cfun
, t
);
4666 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), vars
);
4669 /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN,
4670 but now it will be in the TO_FN. PARM_TO_VAR means enable PARM_DECL to
4671 VAR_DECL translation. */
4674 copy_decl_for_dup_finish (copy_body_data
*id
, tree decl
, tree copy
)
4676 /* Don't generate debug information for the copy if we wouldn't have
4677 generated it for the copy either. */
4678 DECL_ARTIFICIAL (copy
) = DECL_ARTIFICIAL (decl
);
4679 DECL_IGNORED_P (copy
) = DECL_IGNORED_P (decl
);
4681 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
4682 declaration inspired this copy. */
4683 DECL_ABSTRACT_ORIGIN (copy
) = DECL_ORIGIN (decl
);
4685 /* The new variable/label has no RTL, yet. */
4686 if (CODE_CONTAINS_STRUCT (TREE_CODE (copy
), TS_DECL_WRTL
)
4687 && !TREE_STATIC (copy
) && !DECL_EXTERNAL (copy
))
4688 SET_DECL_RTL (copy
, 0);
4690 /* These args would always appear unused, if not for this. */
4691 TREE_USED (copy
) = 1;
4693 /* Set the context for the new declaration. */
4694 if (!DECL_CONTEXT (decl
))
4695 /* Globals stay global. */
4697 else if (DECL_CONTEXT (decl
) != id
->src_fn
)
4698 /* Things that weren't in the scope of the function we're inlining
4699 from aren't in the scope we're inlining to, either. */
4701 else if (TREE_STATIC (decl
))
4702 /* Function-scoped static variables should stay in the original
4706 /* Ordinary automatic local variables are now in the scope of the
4708 DECL_CONTEXT (copy
) = id
->dst_fn
;
4714 copy_decl_to_var (tree decl
, copy_body_data
*id
)
4718 gcc_assert (TREE_CODE (decl
) == PARM_DECL
4719 || TREE_CODE (decl
) == RESULT_DECL
);
4721 type
= TREE_TYPE (decl
);
4723 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
4724 VAR_DECL
, DECL_NAME (decl
), type
);
4725 if (DECL_PT_UID_SET_P (decl
))
4726 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
4727 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
4728 TREE_READONLY (copy
) = TREE_READONLY (decl
);
4729 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
4730 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
4732 return copy_decl_for_dup_finish (id
, decl
, copy
);
4735 /* Like copy_decl_to_var, but create a return slot object instead of a
4736 pointer variable for return by invisible reference. */
4739 copy_result_decl_to_var (tree decl
, copy_body_data
*id
)
4743 gcc_assert (TREE_CODE (decl
) == PARM_DECL
4744 || TREE_CODE (decl
) == RESULT_DECL
);
4746 type
= TREE_TYPE (decl
);
4747 if (DECL_BY_REFERENCE (decl
))
4748 type
= TREE_TYPE (type
);
4750 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
4751 VAR_DECL
, DECL_NAME (decl
), type
);
4752 if (DECL_PT_UID_SET_P (decl
))
4753 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
4754 TREE_READONLY (copy
) = TREE_READONLY (decl
);
4755 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
4756 if (!DECL_BY_REFERENCE (decl
))
4758 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
4759 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
4762 return copy_decl_for_dup_finish (id
, decl
, copy
);
4766 copy_decl_no_change (tree decl
, copy_body_data
*id
)
4770 copy
= copy_node (decl
);
4772 /* The COPY is not abstract; it will be generated in DST_FN. */
4773 DECL_ABSTRACT (copy
) = 0;
4774 lang_hooks
.dup_lang_specific_decl (copy
);
4776 /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
4777 been taken; it's for internal bookkeeping in expand_goto_internal. */
4778 if (TREE_CODE (copy
) == LABEL_DECL
)
4780 TREE_ADDRESSABLE (copy
) = 0;
4781 LABEL_DECL_UID (copy
) = -1;
4784 return copy_decl_for_dup_finish (id
, decl
, copy
);
4788 copy_decl_maybe_to_var (tree decl
, copy_body_data
*id
)
4790 if (TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
)
4791 return copy_decl_to_var (decl
, id
);
4793 return copy_decl_no_change (decl
, id
);
4796 /* Return a copy of the function's argument tree. */
4798 copy_arguments_for_versioning (tree orig_parm
, copy_body_data
* id
,
4799 bitmap args_to_skip
, tree
*vars
)
4802 tree new_parm
= NULL
;
4807 for (arg
= orig_parm
; arg
; arg
= DECL_CHAIN (arg
), i
++)
4808 if (!args_to_skip
|| !bitmap_bit_p (args_to_skip
, i
))
4810 tree new_tree
= remap_decl (arg
, id
);
4811 if (TREE_CODE (new_tree
) != PARM_DECL
)
4812 new_tree
= id
->copy_decl (arg
, id
);
4813 lang_hooks
.dup_lang_specific_decl (new_tree
);
4815 parg
= &DECL_CHAIN (new_tree
);
4817 else if (!pointer_map_contains (id
->decl_map
, arg
))
4819 /* Make an equivalent VAR_DECL. If the argument was used
4820 as temporary variable later in function, the uses will be
4821 replaced by local variable. */
4822 tree var
= copy_decl_to_var (arg
, id
);
4823 insert_decl_map (id
, arg
, var
);
4824 /* Declare this new variable. */
4825 DECL_CHAIN (var
) = *vars
;
4831 /* Return a copy of the function's static chain. */
4833 copy_static_chain (tree static_chain
, copy_body_data
* id
)
4835 tree
*chain_copy
, *pvar
;
4837 chain_copy
= &static_chain
;
4838 for (pvar
= chain_copy
; *pvar
; pvar
= &DECL_CHAIN (*pvar
))
4840 tree new_tree
= remap_decl (*pvar
, id
);
4841 lang_hooks
.dup_lang_specific_decl (new_tree
);
4842 DECL_CHAIN (new_tree
) = DECL_CHAIN (*pvar
);
4845 return static_chain
;
4848 /* Return true if the function is allowed to be versioned.
4849 This is a guard for the versioning functionality. */
4852 tree_versionable_function_p (tree fndecl
)
4854 return (!lookup_attribute ("noclone", DECL_ATTRIBUTES (fndecl
))
4855 && copy_forbidden (DECL_STRUCT_FUNCTION (fndecl
), fndecl
) == NULL
);
4858 /* Delete all unreachable basic blocks and update callgraph.
4859 Doing so is somewhat nontrivial because we need to update all clones and
4860 remove inline function that become unreachable. */
4863 delete_unreachable_blocks_update_callgraph (copy_body_data
*id
)
4865 bool changed
= false;
4866 basic_block b
, next_bb
;
4868 find_unreachable_blocks ();
4870 /* Delete all unreachable basic blocks. */
4872 for (b
= ENTRY_BLOCK_PTR
->next_bb
; b
!= EXIT_BLOCK_PTR
; b
= next_bb
)
4874 next_bb
= b
->next_bb
;
4876 if (!(b
->flags
& BB_REACHABLE
))
4878 gimple_stmt_iterator bsi
;
4880 for (bsi
= gsi_start_bb (b
); !gsi_end_p (bsi
); gsi_next (&bsi
))
4881 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
)
4883 struct cgraph_edge
*e
;
4884 struct cgraph_node
*node
;
4886 if ((e
= cgraph_edge (id
->dst_node
, gsi_stmt (bsi
))) != NULL
)
4888 if (!e
->inline_failed
)
4889 cgraph_remove_node_and_inline_clones (e
->callee
, id
->dst_node
);
4891 cgraph_remove_edge (e
);
4893 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
4894 && id
->dst_node
->clones
)
4895 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
4897 if ((e
= cgraph_edge (node
, gsi_stmt (bsi
))) != NULL
)
4899 if (!e
->inline_failed
)
4900 cgraph_remove_node_and_inline_clones (e
->callee
, id
->dst_node
);
4902 cgraph_remove_edge (e
);
4906 node
= node
->clones
;
4907 else if (node
->next_sibling_clone
)
4908 node
= node
->next_sibling_clone
;
4911 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
4912 node
= node
->clone_of
;
4913 if (node
!= id
->dst_node
)
4914 node
= node
->next_sibling_clone
;
4918 delete_basic_block (b
);
4926 /* Update clone info after duplication. */
4929 update_clone_info (copy_body_data
* id
)
4931 struct cgraph_node
*node
;
4932 if (!id
->dst_node
->clones
)
4934 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
4936 /* First update replace maps to match the new body. */
4937 if (node
->clone
.tree_map
)
4940 for (i
= 0; i
< vec_safe_length (node
->clone
.tree_map
); i
++)
4942 struct ipa_replace_map
*replace_info
;
4943 replace_info
= (*node
->clone
.tree_map
)[i
];
4944 walk_tree (&replace_info
->old_tree
, copy_tree_body_r
, id
, NULL
);
4945 walk_tree (&replace_info
->new_tree
, copy_tree_body_r
, id
, NULL
);
4949 node
= node
->clones
;
4950 else if (node
->next_sibling_clone
)
4951 node
= node
->next_sibling_clone
;
4954 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
4955 node
= node
->clone_of
;
4956 if (node
!= id
->dst_node
)
4957 node
= node
->next_sibling_clone
;
4962 /* Create a copy of a function's tree.
4963 OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
4964 of the original function and the new copied function
4965 respectively. In case we want to replace a DECL
4966 tree with another tree while duplicating the function's
4967 body, TREE_MAP represents the mapping between these
4968 trees. If UPDATE_CLONES is set, the call_stmt fields
4969 of edges of clones of the function will be updated.
4971 If non-NULL ARGS_TO_SKIP determine function parameters to remove
4973 If SKIP_RETURN is true, the new version will return void.
4974 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
4975 If non_NULL NEW_ENTRY determine new entry BB of the clone.
4978 tree_function_versioning (tree old_decl
, tree new_decl
,
4979 vec
<ipa_replace_map_p
, va_gc
> *tree_map
,
4980 bool update_clones
, bitmap args_to_skip
,
4981 bool skip_return
, bitmap blocks_to_copy
,
4982 basic_block new_entry
)
4984 struct cgraph_node
*old_version_node
;
4985 struct cgraph_node
*new_version_node
;
4989 struct ipa_replace_map
*replace_info
;
4990 basic_block old_entry_block
, bb
;
4991 vec
<gimple
> init_stmts
;
4992 init_stmts
.create (10);
4993 tree vars
= NULL_TREE
;
4995 gcc_assert (TREE_CODE (old_decl
) == FUNCTION_DECL
4996 && TREE_CODE (new_decl
) == FUNCTION_DECL
);
4997 DECL_POSSIBLY_INLINED (old_decl
) = 1;
4999 old_version_node
= cgraph_get_node (old_decl
);
5000 gcc_checking_assert (old_version_node
);
5001 new_version_node
= cgraph_get_node (new_decl
);
5002 gcc_checking_assert (new_version_node
);
5004 /* Copy over debug args. */
5005 if (DECL_HAS_DEBUG_ARGS_P (old_decl
))
5007 vec
<tree
, va_gc
> **new_debug_args
, **old_debug_args
;
5008 gcc_checking_assert (decl_debug_args_lookup (new_decl
) == NULL
);
5009 DECL_HAS_DEBUG_ARGS_P (new_decl
) = 0;
5010 old_debug_args
= decl_debug_args_lookup (old_decl
);
5013 new_debug_args
= decl_debug_args_insert (new_decl
);
5014 *new_debug_args
= vec_safe_copy (*old_debug_args
);
5018 /* Output the inlining info for this abstract function, since it has been
5019 inlined. If we don't do this now, we can lose the information about the
5020 variables in the function when the blocks get blown away as soon as we
5021 remove the cgraph node. */
5022 (*debug_hooks
->outlining_inline_function
) (old_decl
);
5024 DECL_ARTIFICIAL (new_decl
) = 1;
5025 DECL_ABSTRACT_ORIGIN (new_decl
) = DECL_ORIGIN (old_decl
);
5026 DECL_FUNCTION_PERSONALITY (new_decl
) = DECL_FUNCTION_PERSONALITY (old_decl
);
5028 /* Prepare the data structures for the tree copy. */
5029 memset (&id
, 0, sizeof (id
));
5031 /* Generate a new name for the new version. */
5032 id
.statements_to_fold
= pointer_set_create ();
5034 id
.decl_map
= pointer_map_create ();
5035 id
.debug_map
= NULL
;
5036 id
.src_fn
= old_decl
;
5037 id
.dst_fn
= new_decl
;
5038 id
.src_node
= old_version_node
;
5039 id
.dst_node
= new_version_node
;
5040 id
.src_cfun
= DECL_STRUCT_FUNCTION (old_decl
);
5041 if (id
.src_node
->ipa_transforms_to_apply
.exists ())
5043 vec
<ipa_opt_pass
> old_transforms_to_apply
5044 = id
.dst_node
->ipa_transforms_to_apply
;
5047 id
.dst_node
->ipa_transforms_to_apply
5048 = id
.src_node
->ipa_transforms_to_apply
.copy ();
5049 for (i
= 0; i
< old_transforms_to_apply
.length (); i
++)
5050 id
.dst_node
->ipa_transforms_to_apply
.safe_push (old_transforms_to_apply
[i
]);
5051 old_transforms_to_apply
.release ();
5054 id
.copy_decl
= copy_decl_no_change
;
5055 id
.transform_call_graph_edges
5056 = update_clones
? CB_CGE_MOVE_CLONES
: CB_CGE_MOVE
;
5057 id
.transform_new_cfg
= true;
5058 id
.transform_return_to_modify
= false;
5059 id
.transform_lang_insert_block
= NULL
;
5061 old_entry_block
= ENTRY_BLOCK_PTR_FOR_FUNCTION
5062 (DECL_STRUCT_FUNCTION (old_decl
));
5063 initialize_cfun (new_decl
, old_decl
,
5064 old_entry_block
->count
);
5065 DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
->ipa_pta
5066 = id
.src_cfun
->gimple_df
->ipa_pta
;
5068 /* Copy the function's static chain. */
5069 p
= DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
;
5071 DECL_STRUCT_FUNCTION (new_decl
)->static_chain_decl
=
5072 copy_static_chain (DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
,
5075 /* If there's a tree_map, prepare for substitution. */
5077 for (i
= 0; i
< tree_map
->length (); i
++)
5080 replace_info
= (*tree_map
)[i
];
5081 if (replace_info
->replace_p
)
5083 if (!replace_info
->old_tree
)
5085 int i
= replace_info
->parm_num
;
5087 for (parm
= DECL_ARGUMENTS (old_decl
); i
; parm
= DECL_CHAIN (parm
))
5089 replace_info
->old_tree
= parm
;
5091 gcc_assert (TREE_CODE (replace_info
->old_tree
) == PARM_DECL
);
5092 init
= setup_one_parameter (&id
, replace_info
->old_tree
,
5093 replace_info
->new_tree
, id
.src_fn
,
5097 init_stmts
.safe_push (init
);
5100 /* Copy the function's arguments. */
5101 if (DECL_ARGUMENTS (old_decl
) != NULL_TREE
)
5102 DECL_ARGUMENTS (new_decl
) =
5103 copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl
), &id
,
5104 args_to_skip
, &vars
);
5106 DECL_INITIAL (new_decl
) = remap_blocks (DECL_INITIAL (id
.src_fn
), &id
);
5107 BLOCK_SUPERCONTEXT (DECL_INITIAL (new_decl
)) = new_decl
;
5109 declare_inline_vars (DECL_INITIAL (new_decl
), vars
);
5111 if (!vec_safe_is_empty (DECL_STRUCT_FUNCTION (old_decl
)->local_decls
))
5112 /* Add local vars. */
5113 add_local_variables (DECL_STRUCT_FUNCTION (old_decl
), cfun
, &id
);
5115 if (DECL_RESULT (old_decl
) == NULL_TREE
)
5117 else if (skip_return
&& !VOID_TYPE_P (TREE_TYPE (DECL_RESULT (old_decl
))))
5119 DECL_RESULT (new_decl
)
5120 = build_decl (DECL_SOURCE_LOCATION (DECL_RESULT (old_decl
)),
5121 RESULT_DECL
, NULL_TREE
, void_type_node
);
5122 DECL_CONTEXT (DECL_RESULT (new_decl
)) = new_decl
;
5123 cfun
->returns_struct
= 0;
5124 cfun
->returns_pcc_struct
= 0;
5129 DECL_RESULT (new_decl
) = remap_decl (DECL_RESULT (old_decl
), &id
);
5130 lang_hooks
.dup_lang_specific_decl (DECL_RESULT (new_decl
));
5131 if (gimple_in_ssa_p (id
.src_cfun
)
5132 && DECL_BY_REFERENCE (DECL_RESULT (old_decl
))
5133 && (old_name
= ssa_default_def (id
.src_cfun
, DECL_RESULT (old_decl
))))
5135 tree new_name
= make_ssa_name (DECL_RESULT (new_decl
), NULL
);
5136 insert_decl_map (&id
, old_name
, new_name
);
5137 SSA_NAME_DEF_STMT (new_name
) = gimple_build_nop ();
5138 set_ssa_default_def (cfun
, DECL_RESULT (new_decl
), new_name
);
5142 /* Copy the Function's body. */
5143 copy_body (&id
, old_entry_block
->count
, REG_BR_PROB_BASE
,
5144 ENTRY_BLOCK_PTR
, EXIT_BLOCK_PTR
, blocks_to_copy
, new_entry
);
5146 /* Renumber the lexical scoping (non-code) blocks consecutively. */
5147 number_blocks (new_decl
);
5149 /* We want to create the BB unconditionally, so that the addition of
5150 debug stmts doesn't affect BB count, which may in the end cause
5151 codegen differences. */
5152 bb
= split_edge (single_succ_edge (ENTRY_BLOCK_PTR
));
5153 while (init_stmts
.length ())
5154 insert_init_stmt (&id
, bb
, init_stmts
.pop ());
5155 update_clone_info (&id
);
5157 /* Remap the nonlocal_goto_save_area, if any. */
5158 if (cfun
->nonlocal_goto_save_area
)
5160 struct walk_stmt_info wi
;
5162 memset (&wi
, 0, sizeof (wi
));
5164 walk_tree (&cfun
->nonlocal_goto_save_area
, remap_gimple_op_r
, &wi
, NULL
);
5168 pointer_map_destroy (id
.decl_map
);
5170 pointer_map_destroy (id
.debug_map
);
5171 free_dominance_info (CDI_DOMINATORS
);
5172 free_dominance_info (CDI_POST_DOMINATORS
);
5174 fold_marked_statements (0, id
.statements_to_fold
);
5175 pointer_set_destroy (id
.statements_to_fold
);
5176 fold_cond_expr_cond ();
5177 delete_unreachable_blocks_update_callgraph (&id
);
5178 if (id
.dst_node
->analyzed
)
5179 cgraph_rebuild_references ();
5180 update_ssa (TODO_update_ssa
);
5182 /* After partial cloning we need to rescale frequencies, so they are
5183 within proper range in the cloned function. */
5186 struct cgraph_edge
*e
;
5187 rebuild_frequencies ();
5189 new_version_node
->count
= ENTRY_BLOCK_PTR
->count
;
5190 for (e
= new_version_node
->callees
; e
; e
= e
->next_callee
)
5192 basic_block bb
= gimple_bb (e
->call_stmt
);
5193 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
5195 e
->count
= bb
->count
;
5197 for (e
= new_version_node
->indirect_calls
; e
; e
= e
->next_callee
)
5199 basic_block bb
= gimple_bb (e
->call_stmt
);
5200 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
5202 e
->count
= bb
->count
;
5206 free_dominance_info (CDI_DOMINATORS
);
5207 free_dominance_info (CDI_POST_DOMINATORS
);
5209 gcc_assert (!id
.debug_stmts
.exists ());
5210 init_stmts
.release ();
5215 /* EXP is CALL_EXPR present in a GENERIC expression tree. Try to integrate
5216 the callee and return the inlined body on success. */
5219 maybe_inline_call_in_expr (tree exp
)
5221 tree fn
= get_callee_fndecl (exp
);
5223 /* We can only try to inline "const" functions. */
5224 if (fn
&& TREE_READONLY (fn
) && DECL_SAVED_TREE (fn
))
5226 struct pointer_map_t
*decl_map
= pointer_map_create ();
5227 call_expr_arg_iterator iter
;
5231 /* Remap the parameters. */
5232 for (param
= DECL_ARGUMENTS (fn
), arg
= first_call_expr_arg (exp
, &iter
);
5234 param
= DECL_CHAIN (param
), arg
= next_call_expr_arg (&iter
))
5235 *pointer_map_insert (decl_map
, param
) = arg
;
5237 memset (&id
, 0, sizeof (id
));
5239 id
.dst_fn
= current_function_decl
;
5240 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
5241 id
.decl_map
= decl_map
;
5243 id
.copy_decl
= copy_decl_no_change
;
5244 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5245 id
.transform_new_cfg
= false;
5246 id
.transform_return_to_modify
= true;
5247 id
.transform_lang_insert_block
= NULL
;
5249 /* Make sure not to unshare trees behind the front-end's back
5250 since front-end specific mechanisms may rely on sharing. */
5251 id
.regimplify
= false;
5252 id
.do_not_unshare
= true;
5254 /* We're not inside any EH region. */
5257 t
= copy_tree_body (&id
);
5258 pointer_map_destroy (decl_map
);
5260 /* We can only return something suitable for use in a GENERIC
5262 if (TREE_CODE (t
) == MODIFY_EXPR
)
5263 return TREE_OPERAND (t
, 1);
5269 /* Duplicate a type, fields and all. */
5272 build_duplicate_type (tree type
)
5274 struct copy_body_data id
;
5276 memset (&id
, 0, sizeof (id
));
5277 id
.src_fn
= current_function_decl
;
5278 id
.dst_fn
= current_function_decl
;
5280 id
.decl_map
= pointer_map_create ();
5281 id
.debug_map
= NULL
;
5282 id
.copy_decl
= copy_decl_no_change
;
5284 type
= remap_type_1 (type
, &id
);
5286 pointer_map_destroy (id
.decl_map
);
5288 pointer_map_destroy (id
.debug_map
);
5290 TYPE_CANONICAL (type
) = type
;