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"
52 #include "rtl.h" /* FIXME: For asm_str_count. */
54 /* I'm not real happy about this, but we need to handle gimple and
58 /* Inlining, Cloning, Versioning, Parallelization
60 Inlining: a function body is duplicated, but the PARM_DECLs are
61 remapped into VAR_DECLs, and non-void RETURN_EXPRs become
62 MODIFY_EXPRs that store to a dedicated returned-value variable.
63 The duplicated eh_region info of the copy will later be appended
64 to the info for the caller; the eh_region info in copied throwing
65 statements and RESX statements are adjusted accordingly.
67 Cloning: (only in C++) We have one body for a con/de/structor, and
68 multiple function decls, each with a unique parameter list.
69 Duplicate the body, using the given splay tree; some parameters
70 will become constants (like 0 or 1).
72 Versioning: a function body is duplicated and the result is a new
73 function rather than into blocks of an existing function as with
74 inlining. Some parameters will become constants.
76 Parallelization: a region of a function is duplicated resulting in
77 a new function. Variables may be replaced with complex expressions
78 to enable shared variable semantics.
80 All of these will simultaneously lookup any callgraph edges. If
81 we're going to inline the duplicated function body, and the given
82 function has some cloned callgraph nodes (one for each place this
83 function will be inlined) those callgraph edges will be duplicated.
84 If we're cloning the body, those callgraph edges will be
85 updated to point into the new body. (Note that the original
86 callgraph node and edge list will not be altered.)
88 See the CALL_EXPR handling case in copy_tree_body_r (). */
92 o In order to make inlining-on-trees work, we pessimized
93 function-local static constants. In particular, they are now
94 always output, even when not addressed. Fix this by treating
95 function-local static constants just like global static
96 constants; the back-end already knows not to output them if they
99 o Provide heuristics to clamp inlining of recursive template
103 /* Weights that estimate_num_insns uses to estimate the size of the
106 eni_weights eni_size_weights
;
108 /* Weights that estimate_num_insns uses to estimate the time necessary
109 to execute the produced code. */
111 eni_weights eni_time_weights
;
115 static tree
declare_return_variable (copy_body_data
*, tree
, tree
, basic_block
);
116 static void remap_block (tree
*, copy_body_data
*);
117 static void copy_bind_expr (tree
*, int *, copy_body_data
*);
118 static void declare_inline_vars (tree
, tree
);
119 static void remap_save_expr (tree
*, void *, int *);
120 static void prepend_lexical_block (tree current_block
, tree new_block
);
121 static tree
copy_decl_to_var (tree
, copy_body_data
*);
122 static tree
copy_result_decl_to_var (tree
, copy_body_data
*);
123 static tree
copy_decl_maybe_to_var (tree
, copy_body_data
*);
124 static gimple
remap_gimple_stmt (gimple
, copy_body_data
*);
125 static bool delete_unreachable_blocks_update_callgraph (copy_body_data
*id
);
127 /* Insert a tree->tree mapping for ID. Despite the name suggests
128 that the trees should be variables, it is used for more than that. */
131 insert_decl_map (copy_body_data
*id
, tree key
, tree value
)
133 *pointer_map_insert (id
->decl_map
, key
) = value
;
135 /* Always insert an identity map as well. If we see this same new
136 node again, we won't want to duplicate it a second time. */
138 *pointer_map_insert (id
->decl_map
, value
) = value
;
141 /* Insert a tree->tree mapping for ID. This is only used for
145 insert_debug_decl_map (copy_body_data
*id
, tree key
, tree value
)
147 if (!gimple_in_ssa_p (id
->src_cfun
))
150 if (!MAY_HAVE_DEBUG_STMTS
)
153 if (!target_for_debug_bind (key
))
156 gcc_assert (TREE_CODE (key
) == PARM_DECL
);
157 gcc_assert (TREE_CODE (value
) == VAR_DECL
);
160 id
->debug_map
= pointer_map_create ();
162 *pointer_map_insert (id
->debug_map
, key
) = value
;
165 /* If nonzero, we're remapping the contents of inlined debug
166 statements. If negative, an error has occurred, such as a
167 reference to a variable that isn't available in the inlined
169 static int processing_debug_stmt
= 0;
171 /* Construct new SSA name for old NAME. ID is the inline context. */
174 remap_ssa_name (tree name
, copy_body_data
*id
)
179 gcc_assert (TREE_CODE (name
) == SSA_NAME
);
181 n
= (tree
*) pointer_map_contains (id
->decl_map
, name
);
183 return unshare_expr (*n
);
185 if (processing_debug_stmt
)
187 if (SSA_NAME_IS_DEFAULT_DEF (name
)
188 && TREE_CODE (SSA_NAME_VAR (name
)) == PARM_DECL
189 && id
->entry_bb
== NULL
190 && single_succ_p (ENTRY_BLOCK_PTR
))
192 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
194 gimple_stmt_iterator gsi
;
195 tree val
= SSA_NAME_VAR (name
);
197 n
= (tree
*) pointer_map_contains (id
->decl_map
, val
);
200 if (TREE_CODE (val
) != PARM_DECL
)
202 processing_debug_stmt
= -1;
205 def_temp
= gimple_build_debug_source_bind (vexpr
, val
, NULL
);
206 DECL_ARTIFICIAL (vexpr
) = 1;
207 TREE_TYPE (vexpr
) = TREE_TYPE (name
);
208 DECL_MODE (vexpr
) = DECL_MODE (SSA_NAME_VAR (name
));
209 gsi
= gsi_after_labels (single_succ (ENTRY_BLOCK_PTR
));
210 gsi_insert_before (&gsi
, def_temp
, GSI_SAME_STMT
);
214 processing_debug_stmt
= -1;
218 /* Remap anonymous SSA names or SSA names of anonymous decls. */
219 var
= SSA_NAME_VAR (name
);
221 || (!SSA_NAME_IS_DEFAULT_DEF (name
)
222 && TREE_CODE (var
) == VAR_DECL
223 && !VAR_DECL_IS_VIRTUAL_OPERAND (var
)
224 && DECL_ARTIFICIAL (var
)
225 && DECL_IGNORED_P (var
)
226 && !DECL_NAME (var
)))
228 struct ptr_info_def
*pi
;
229 new_tree
= make_ssa_name (remap_type (TREE_TYPE (name
), id
), NULL
);
230 if (!var
&& SSA_NAME_IDENTIFIER (name
))
231 SET_SSA_NAME_VAR_OR_IDENTIFIER (new_tree
, SSA_NAME_IDENTIFIER (name
));
232 insert_decl_map (id
, name
, new_tree
);
233 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
234 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
235 /* At least IPA points-to info can be directly transferred. */
236 if (id
->src_cfun
->gimple_df
237 && id
->src_cfun
->gimple_df
->ipa_pta
238 && (pi
= SSA_NAME_PTR_INFO (name
))
241 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
247 /* Do not set DEF_STMT yet as statement is not copied yet. We do that
249 new_tree
= remap_decl (var
, id
);
251 /* We might've substituted constant or another SSA_NAME for
254 Replace the SSA name representing RESULT_DECL by variable during
255 inlining: this saves us from need to introduce PHI node in a case
256 return value is just partly initialized. */
257 if ((TREE_CODE (new_tree
) == VAR_DECL
|| TREE_CODE (new_tree
) == PARM_DECL
)
258 && (!SSA_NAME_VAR (name
)
259 || TREE_CODE (SSA_NAME_VAR (name
)) != RESULT_DECL
260 || !id
->transform_return_to_modify
))
262 struct ptr_info_def
*pi
;
263 new_tree
= make_ssa_name (new_tree
, NULL
);
264 insert_decl_map (id
, name
, new_tree
);
265 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
266 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
267 /* At least IPA points-to info can be directly transferred. */
268 if (id
->src_cfun
->gimple_df
269 && id
->src_cfun
->gimple_df
->ipa_pta
270 && (pi
= SSA_NAME_PTR_INFO (name
))
273 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
276 if (SSA_NAME_IS_DEFAULT_DEF (name
))
278 /* By inlining function having uninitialized variable, we might
279 extend the lifetime (variable might get reused). This cause
280 ICE in the case we end up extending lifetime of SSA name across
281 abnormal edge, but also increase register pressure.
283 We simply initialize all uninitialized vars by 0 except
284 for case we are inlining to very first BB. We can avoid
285 this for all BBs that are not inside strongly connected
286 regions of the CFG, but this is expensive to test. */
288 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
)
289 && (!SSA_NAME_VAR (name
)
290 || TREE_CODE (SSA_NAME_VAR (name
)) != PARM_DECL
)
291 && (id
->entry_bb
!= EDGE_SUCC (ENTRY_BLOCK_PTR
, 0)->dest
292 || EDGE_COUNT (id
->entry_bb
->preds
) != 1))
294 gimple_stmt_iterator gsi
= gsi_last_bb (id
->entry_bb
);
296 tree zero
= build_zero_cst (TREE_TYPE (new_tree
));
298 init_stmt
= gimple_build_assign (new_tree
, zero
);
299 gsi_insert_after (&gsi
, init_stmt
, GSI_NEW_STMT
);
300 SSA_NAME_IS_DEFAULT_DEF (new_tree
) = 0;
304 SSA_NAME_DEF_STMT (new_tree
) = gimple_build_nop ();
305 set_ssa_default_def (cfun
, SSA_NAME_VAR (new_tree
), new_tree
);
310 insert_decl_map (id
, name
, new_tree
);
314 /* Remap DECL during the copying of the BLOCK tree for the function. */
317 remap_decl (tree decl
, copy_body_data
*id
)
321 /* We only remap local variables in the current function. */
323 /* See if we have remapped this declaration. */
325 n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
327 if (!n
&& processing_debug_stmt
)
329 processing_debug_stmt
= -1;
333 /* If we didn't already have an equivalent for this declaration,
337 /* Make a copy of the variable or label. */
338 tree t
= id
->copy_decl (decl
, id
);
340 /* Remember it, so that if we encounter this local entity again
341 we can reuse this copy. Do this early because remap_type may
342 need this decl for TYPE_STUB_DECL. */
343 insert_decl_map (id
, decl
, t
);
348 /* Remap types, if necessary. */
349 TREE_TYPE (t
) = remap_type (TREE_TYPE (t
), id
);
350 if (TREE_CODE (t
) == TYPE_DECL
)
351 DECL_ORIGINAL_TYPE (t
) = remap_type (DECL_ORIGINAL_TYPE (t
), id
);
353 /* Remap sizes as necessary. */
354 walk_tree (&DECL_SIZE (t
), copy_tree_body_r
, id
, NULL
);
355 walk_tree (&DECL_SIZE_UNIT (t
), copy_tree_body_r
, id
, NULL
);
357 /* If fields, do likewise for offset and qualifier. */
358 if (TREE_CODE (t
) == FIELD_DECL
)
360 walk_tree (&DECL_FIELD_OFFSET (t
), copy_tree_body_r
, id
, NULL
);
361 if (TREE_CODE (DECL_CONTEXT (t
)) == QUAL_UNION_TYPE
)
362 walk_tree (&DECL_QUALIFIER (t
), copy_tree_body_r
, id
, NULL
);
368 if (id
->do_not_unshare
)
371 return unshare_expr (*n
);
375 remap_type_1 (tree type
, copy_body_data
*id
)
379 /* We do need a copy. build and register it now. If this is a pointer or
380 reference type, remap the designated type and make a new pointer or
382 if (TREE_CODE (type
) == POINTER_TYPE
)
384 new_tree
= build_pointer_type_for_mode (remap_type (TREE_TYPE (type
), id
),
386 TYPE_REF_CAN_ALIAS_ALL (type
));
387 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
388 new_tree
= build_type_attribute_qual_variant (new_tree
,
389 TYPE_ATTRIBUTES (type
),
391 insert_decl_map (id
, type
, new_tree
);
394 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
396 new_tree
= build_reference_type_for_mode (remap_type (TREE_TYPE (type
), id
),
398 TYPE_REF_CAN_ALIAS_ALL (type
));
399 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
400 new_tree
= build_type_attribute_qual_variant (new_tree
,
401 TYPE_ATTRIBUTES (type
),
403 insert_decl_map (id
, type
, new_tree
);
407 new_tree
= copy_node (type
);
409 insert_decl_map (id
, type
, new_tree
);
411 /* This is a new type, not a copy of an old type. Need to reassociate
412 variants. We can handle everything except the main variant lazily. */
413 t
= TYPE_MAIN_VARIANT (type
);
416 t
= remap_type (t
, id
);
417 TYPE_MAIN_VARIANT (new_tree
) = t
;
418 TYPE_NEXT_VARIANT (new_tree
) = TYPE_NEXT_VARIANT (t
);
419 TYPE_NEXT_VARIANT (t
) = new_tree
;
423 TYPE_MAIN_VARIANT (new_tree
) = new_tree
;
424 TYPE_NEXT_VARIANT (new_tree
) = NULL
;
427 if (TYPE_STUB_DECL (type
))
428 TYPE_STUB_DECL (new_tree
) = remap_decl (TYPE_STUB_DECL (type
), id
);
430 /* Lazily create pointer and reference types. */
431 TYPE_POINTER_TO (new_tree
) = NULL
;
432 TYPE_REFERENCE_TO (new_tree
) = NULL
;
434 switch (TREE_CODE (new_tree
))
438 case FIXED_POINT_TYPE
:
441 t
= TYPE_MIN_VALUE (new_tree
);
442 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
443 walk_tree (&TYPE_MIN_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
445 t
= TYPE_MAX_VALUE (new_tree
);
446 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
447 walk_tree (&TYPE_MAX_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
451 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
452 walk_tree (&TYPE_ARG_TYPES (new_tree
), copy_tree_body_r
, id
, NULL
);
456 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
457 TYPE_DOMAIN (new_tree
) = remap_type (TYPE_DOMAIN (new_tree
), id
);
462 case QUAL_UNION_TYPE
:
466 for (f
= TYPE_FIELDS (new_tree
); f
; f
= DECL_CHAIN (f
))
468 t
= remap_decl (f
, id
);
469 DECL_CONTEXT (t
) = new_tree
;
473 TYPE_FIELDS (new_tree
) = nreverse (nf
);
479 /* Shouldn't have been thought variable sized. */
483 walk_tree (&TYPE_SIZE (new_tree
), copy_tree_body_r
, id
, NULL
);
484 walk_tree (&TYPE_SIZE_UNIT (new_tree
), copy_tree_body_r
, id
, NULL
);
490 remap_type (tree type
, copy_body_data
*id
)
498 /* See if we have remapped this type. */
499 node
= (tree
*) pointer_map_contains (id
->decl_map
, type
);
503 /* The type only needs remapping if it's variably modified. */
504 if (! variably_modified_type_p (type
, id
->src_fn
))
506 insert_decl_map (id
, type
, type
);
510 id
->remapping_type_depth
++;
511 tmp
= remap_type_1 (type
, id
);
512 id
->remapping_type_depth
--;
517 /* Decide if DECL can be put into BLOCK_NONLOCAL_VARs. */
520 can_be_nonlocal (tree decl
, copy_body_data
*id
)
522 /* We can not duplicate function decls. */
523 if (TREE_CODE (decl
) == FUNCTION_DECL
)
526 /* Local static vars must be non-local or we get multiple declaration
528 if (TREE_CODE (decl
) == VAR_DECL
529 && !auto_var_in_fn_p (decl
, id
->src_fn
))
536 remap_decls (tree decls
, vec
<tree
, va_gc
> **nonlocalized_list
,
540 tree new_decls
= NULL_TREE
;
542 /* Remap its variables. */
543 for (old_var
= decls
; old_var
; old_var
= DECL_CHAIN (old_var
))
547 if (can_be_nonlocal (old_var
, id
))
549 /* We need to add this variable to the local decls as otherwise
550 nothing else will do so. */
551 if (TREE_CODE (old_var
) == VAR_DECL
552 && ! DECL_EXTERNAL (old_var
))
553 add_local_decl (cfun
, old_var
);
554 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
555 && !DECL_IGNORED_P (old_var
)
556 && nonlocalized_list
)
557 vec_safe_push (*nonlocalized_list
, old_var
);
561 /* Remap the variable. */
562 new_var
= remap_decl (old_var
, id
);
564 /* If we didn't remap this variable, we can't mess with its
565 TREE_CHAIN. If we remapped this variable to the return slot, it's
566 already declared somewhere else, so don't declare it here. */
568 if (new_var
== id
->retvar
)
572 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
573 && !DECL_IGNORED_P (old_var
)
574 && nonlocalized_list
)
575 vec_safe_push (*nonlocalized_list
, old_var
);
579 gcc_assert (DECL_P (new_var
));
580 DECL_CHAIN (new_var
) = new_decls
;
583 /* Also copy value-expressions. */
584 if (TREE_CODE (new_var
) == VAR_DECL
585 && DECL_HAS_VALUE_EXPR_P (new_var
))
587 tree tem
= DECL_VALUE_EXPR (new_var
);
588 bool old_regimplify
= id
->regimplify
;
589 id
->remapping_type_depth
++;
590 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
591 id
->remapping_type_depth
--;
592 id
->regimplify
= old_regimplify
;
593 SET_DECL_VALUE_EXPR (new_var
, tem
);
598 return nreverse (new_decls
);
601 /* Copy the BLOCK to contain remapped versions of the variables
602 therein. And hook the new block into the block-tree. */
605 remap_block (tree
*block
, copy_body_data
*id
)
610 /* Make the new block. */
612 new_block
= make_node (BLOCK
);
613 TREE_USED (new_block
) = TREE_USED (old_block
);
614 BLOCK_ABSTRACT_ORIGIN (new_block
) = old_block
;
615 BLOCK_SOURCE_LOCATION (new_block
) = BLOCK_SOURCE_LOCATION (old_block
);
616 BLOCK_NONLOCALIZED_VARS (new_block
)
617 = vec_safe_copy (BLOCK_NONLOCALIZED_VARS (old_block
));
620 /* Remap its variables. */
621 BLOCK_VARS (new_block
) = remap_decls (BLOCK_VARS (old_block
),
622 &BLOCK_NONLOCALIZED_VARS (new_block
),
625 if (id
->transform_lang_insert_block
)
626 id
->transform_lang_insert_block (new_block
);
628 /* Remember the remapped block. */
629 insert_decl_map (id
, old_block
, new_block
);
632 /* Copy the whole block tree and root it in id->block. */
634 remap_blocks (tree block
, copy_body_data
*id
)
637 tree new_tree
= block
;
642 remap_block (&new_tree
, id
);
643 gcc_assert (new_tree
!= block
);
644 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
645 prepend_lexical_block (new_tree
, remap_blocks (t
, id
));
646 /* Blocks are in arbitrary order, but make things slightly prettier and do
647 not swap order when producing a copy. */
648 BLOCK_SUBBLOCKS (new_tree
) = blocks_nreverse (BLOCK_SUBBLOCKS (new_tree
));
652 /* Remap the block tree rooted at BLOCK to nothing. */
654 remap_blocks_to_null (tree block
, copy_body_data
*id
)
657 insert_decl_map (id
, block
, NULL_TREE
);
658 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
659 remap_blocks_to_null (t
, id
);
663 copy_statement_list (tree
*tp
)
665 tree_stmt_iterator oi
, ni
;
668 new_tree
= alloc_stmt_list ();
669 ni
= tsi_start (new_tree
);
670 oi
= tsi_start (*tp
);
671 TREE_TYPE (new_tree
) = TREE_TYPE (*tp
);
674 for (; !tsi_end_p (oi
); tsi_next (&oi
))
676 tree stmt
= tsi_stmt (oi
);
677 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
678 /* This copy is not redundant; tsi_link_after will smash this
679 STATEMENT_LIST into the end of the one we're building, and we
680 don't want to do that with the original. */
681 copy_statement_list (&stmt
);
682 tsi_link_after (&ni
, stmt
, TSI_CONTINUE_LINKING
);
687 copy_bind_expr (tree
*tp
, int *walk_subtrees
, copy_body_data
*id
)
689 tree block
= BIND_EXPR_BLOCK (*tp
);
690 /* Copy (and replace) the statement. */
691 copy_tree_r (tp
, walk_subtrees
, NULL
);
694 remap_block (&block
, id
);
695 BIND_EXPR_BLOCK (*tp
) = block
;
698 if (BIND_EXPR_VARS (*tp
))
699 /* This will remap a lot of the same decls again, but this should be
701 BIND_EXPR_VARS (*tp
) = remap_decls (BIND_EXPR_VARS (*tp
), NULL
, id
);
705 /* Create a new gimple_seq by remapping all the statements in BODY
706 using the inlining information in ID. */
709 remap_gimple_seq (gimple_seq body
, copy_body_data
*id
)
711 gimple_stmt_iterator si
;
712 gimple_seq new_body
= NULL
;
714 for (si
= gsi_start (body
); !gsi_end_p (si
); gsi_next (&si
))
716 gimple new_stmt
= remap_gimple_stmt (gsi_stmt (si
), id
);
717 gimple_seq_add_stmt (&new_body
, new_stmt
);
724 /* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its
725 block using the mapping information in ID. */
728 copy_gimple_bind (gimple stmt
, copy_body_data
*id
)
731 tree new_block
, new_vars
;
732 gimple_seq body
, new_body
;
734 /* Copy the statement. Note that we purposely don't use copy_stmt
735 here because we need to remap statements as we copy. */
736 body
= gimple_bind_body (stmt
);
737 new_body
= remap_gimple_seq (body
, id
);
739 new_block
= gimple_bind_block (stmt
);
741 remap_block (&new_block
, id
);
743 /* This will remap a lot of the same decls again, but this should be
745 new_vars
= gimple_bind_vars (stmt
);
747 new_vars
= remap_decls (new_vars
, NULL
, id
);
749 new_bind
= gimple_build_bind (new_vars
, new_body
, new_block
);
755 /* Remap the GIMPLE operand pointed to by *TP. DATA is really a
756 'struct walk_stmt_info *'. DATA->INFO is a 'copy_body_data *'.
757 WALK_SUBTREES is used to indicate walk_gimple_op whether to keep
758 recursing into the children nodes of *TP. */
761 remap_gimple_op_r (tree
*tp
, int *walk_subtrees
, void *data
)
763 struct walk_stmt_info
*wi_p
= (struct walk_stmt_info
*) data
;
764 copy_body_data
*id
= (copy_body_data
*) wi_p
->info
;
765 tree fn
= id
->src_fn
;
767 if (TREE_CODE (*tp
) == SSA_NAME
)
769 *tp
= remap_ssa_name (*tp
, id
);
773 else if (auto_var_in_fn_p (*tp
, fn
))
775 /* Local variables and labels need to be replaced by equivalent
776 variables. We don't want to copy static variables; there's
777 only one of those, no matter how many times we inline the
778 containing function. Similarly for globals from an outer
782 /* Remap the declaration. */
783 new_decl
= remap_decl (*tp
, id
);
784 gcc_assert (new_decl
);
785 /* Replace this variable with the copy. */
786 STRIP_TYPE_NOPS (new_decl
);
787 /* ??? The C++ frontend uses void * pointer zero to initialize
788 any other type. This confuses the middle-end type verification.
789 As cloned bodies do not go through gimplification again the fixup
790 there doesn't trigger. */
791 if (TREE_CODE (new_decl
) == INTEGER_CST
792 && !useless_type_conversion_p (TREE_TYPE (*tp
), TREE_TYPE (new_decl
)))
793 new_decl
= fold_convert (TREE_TYPE (*tp
), new_decl
);
797 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
799 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
801 else if (TREE_CODE (*tp
) == LABEL_DECL
802 && (!DECL_CONTEXT (*tp
)
803 || decl_function_context (*tp
) == id
->src_fn
))
804 /* These may need to be remapped for EH handling. */
805 *tp
= remap_decl (*tp
, id
);
806 else if (TREE_CODE (*tp
) == FIELD_DECL
)
808 /* If the enclosing record type is variably_modified_type_p, the field
809 has already been remapped. Otherwise, it need not be. */
810 tree
*n
= (tree
*) pointer_map_contains (id
->decl_map
, *tp
);
815 else if (TYPE_P (*tp
))
816 /* Types may need remapping as well. */
817 *tp
= remap_type (*tp
, id
);
818 else if (CONSTANT_CLASS_P (*tp
))
820 /* If this is a constant, we have to copy the node iff the type
821 will be remapped. copy_tree_r will not copy a constant. */
822 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
824 if (new_type
== TREE_TYPE (*tp
))
827 else if (TREE_CODE (*tp
) == INTEGER_CST
)
828 *tp
= build_int_cst_wide (new_type
, TREE_INT_CST_LOW (*tp
),
829 TREE_INT_CST_HIGH (*tp
));
832 *tp
= copy_node (*tp
);
833 TREE_TYPE (*tp
) = new_type
;
838 /* Otherwise, just copy the node. Note that copy_tree_r already
839 knows not to copy VAR_DECLs, etc., so this is safe. */
841 if (TREE_CODE (*tp
) == MEM_REF
)
843 tree ptr
= TREE_OPERAND (*tp
, 0);
844 tree type
= remap_type (TREE_TYPE (*tp
), id
);
847 /* We need to re-canonicalize MEM_REFs from inline substitutions
848 that can happen when a pointer argument is an ADDR_EXPR.
849 Recurse here manually to allow that. */
850 walk_tree (&ptr
, remap_gimple_op_r
, data
, NULL
);
851 *tp
= fold_build2 (MEM_REF
, type
,
852 ptr
, TREE_OPERAND (*tp
, 1));
853 TREE_THIS_NOTRAP (*tp
) = TREE_THIS_NOTRAP (old
);
854 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
855 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
856 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
861 /* Here is the "usual case". Copy this tree node, and then
862 tweak some special cases. */
863 copy_tree_r (tp
, walk_subtrees
, NULL
);
865 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
866 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
868 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
870 /* The copied TARGET_EXPR has never been expanded, even if the
871 original node was expanded already. */
872 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
873 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
875 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
877 /* Variable substitution need not be simple. In particular,
878 the MEM_REF substitution above. Make sure that
879 TREE_CONSTANT and friends are up-to-date. */
880 int invariant
= is_gimple_min_invariant (*tp
);
881 walk_tree (&TREE_OPERAND (*tp
, 0), remap_gimple_op_r
, data
, NULL
);
882 recompute_tree_invariant_for_addr_expr (*tp
);
884 /* If this used to be invariant, but is not any longer,
885 then regimplification is probably needed. */
886 if (invariant
&& !is_gimple_min_invariant (*tp
))
887 id
->regimplify
= true;
893 /* Update the TREE_BLOCK for the cloned expr. */
896 tree new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
897 tree old_block
= TREE_BLOCK (*tp
);
901 n
= (tree
*) pointer_map_contains (id
->decl_map
,
906 TREE_SET_BLOCK (*tp
, new_block
);
909 /* Keep iterating. */
914 /* Called from copy_body_id via walk_tree. DATA is really a
915 `copy_body_data *'. */
918 copy_tree_body_r (tree
*tp
, int *walk_subtrees
, void *data
)
920 copy_body_data
*id
= (copy_body_data
*) data
;
921 tree fn
= id
->src_fn
;
924 /* Begin by recognizing trees that we'll completely rewrite for the
925 inlining context. Our output for these trees is completely
926 different from out input (e.g. RETURN_EXPR is deleted, and morphs
927 into an edge). Further down, we'll handle trees that get
928 duplicated and/or tweaked. */
930 /* When requested, RETURN_EXPRs should be transformed to just the
931 contained MODIFY_EXPR. The branch semantics of the return will
932 be handled elsewhere by manipulating the CFG rather than a statement. */
933 if (TREE_CODE (*tp
) == RETURN_EXPR
&& id
->transform_return_to_modify
)
935 tree assignment
= TREE_OPERAND (*tp
, 0);
937 /* If we're returning something, just turn that into an
938 assignment into the equivalent of the original RESULT_DECL.
939 If the "assignment" is just the result decl, the result
940 decl has already been set (e.g. a recent "foo (&result_decl,
941 ...)"); just toss the entire RETURN_EXPR. */
942 if (assignment
&& TREE_CODE (assignment
) == MODIFY_EXPR
)
944 /* Replace the RETURN_EXPR with (a copy of) the
945 MODIFY_EXPR hanging underneath. */
946 *tp
= copy_node (assignment
);
948 else /* Else the RETURN_EXPR returns no value. */
951 return (tree
) (void *)1;
954 else if (TREE_CODE (*tp
) == SSA_NAME
)
956 *tp
= remap_ssa_name (*tp
, id
);
961 /* Local variables and labels need to be replaced by equivalent
962 variables. We don't want to copy static variables; there's only
963 one of those, no matter how many times we inline the containing
964 function. Similarly for globals from an outer function. */
965 else if (auto_var_in_fn_p (*tp
, fn
))
969 /* Remap the declaration. */
970 new_decl
= remap_decl (*tp
, id
);
971 gcc_assert (new_decl
);
972 /* Replace this variable with the copy. */
973 STRIP_TYPE_NOPS (new_decl
);
977 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
978 copy_statement_list (tp
);
979 else if (TREE_CODE (*tp
) == SAVE_EXPR
980 || TREE_CODE (*tp
) == TARGET_EXPR
)
981 remap_save_expr (tp
, id
->decl_map
, walk_subtrees
);
982 else if (TREE_CODE (*tp
) == LABEL_DECL
983 && (! DECL_CONTEXT (*tp
)
984 || decl_function_context (*tp
) == id
->src_fn
))
985 /* These may need to be remapped for EH handling. */
986 *tp
= remap_decl (*tp
, id
);
987 else if (TREE_CODE (*tp
) == BIND_EXPR
)
988 copy_bind_expr (tp
, walk_subtrees
, id
);
989 /* Types may need remapping as well. */
990 else if (TYPE_P (*tp
))
991 *tp
= remap_type (*tp
, id
);
993 /* If this is a constant, we have to copy the node iff the type will be
994 remapped. copy_tree_r will not copy a constant. */
995 else if (CONSTANT_CLASS_P (*tp
))
997 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
999 if (new_type
== TREE_TYPE (*tp
))
1002 else if (TREE_CODE (*tp
) == INTEGER_CST
)
1003 *tp
= build_int_cst_wide (new_type
, TREE_INT_CST_LOW (*tp
),
1004 TREE_INT_CST_HIGH (*tp
));
1007 *tp
= copy_node (*tp
);
1008 TREE_TYPE (*tp
) = new_type
;
1012 /* Otherwise, just copy the node. Note that copy_tree_r already
1013 knows not to copy VAR_DECLs, etc., so this is safe. */
1016 /* Here we handle trees that are not completely rewritten.
1017 First we detect some inlining-induced bogosities for
1019 if (TREE_CODE (*tp
) == MODIFY_EXPR
1020 && TREE_OPERAND (*tp
, 0) == TREE_OPERAND (*tp
, 1)
1021 && (auto_var_in_fn_p (TREE_OPERAND (*tp
, 0), fn
)))
1023 /* Some assignments VAR = VAR; don't generate any rtl code
1024 and thus don't count as variable modification. Avoid
1025 keeping bogosities like 0 = 0. */
1026 tree decl
= TREE_OPERAND (*tp
, 0), value
;
1029 n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
1033 STRIP_TYPE_NOPS (value
);
1034 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1036 *tp
= build_empty_stmt (EXPR_LOCATION (*tp
));
1037 return copy_tree_body_r (tp
, walk_subtrees
, data
);
1041 else if (TREE_CODE (*tp
) == INDIRECT_REF
)
1043 /* Get rid of *& from inline substitutions that can happen when a
1044 pointer argument is an ADDR_EXPR. */
1045 tree decl
= TREE_OPERAND (*tp
, 0);
1048 n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
1053 /* If we happen to get an ADDR_EXPR in n->value, strip
1054 it manually here as we'll eventually get ADDR_EXPRs
1055 which lie about their types pointed to. In this case
1056 build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
1057 but we absolutely rely on that. As fold_indirect_ref
1058 does other useful transformations, try that first, though. */
1059 tree type
= TREE_TYPE (TREE_TYPE (*n
));
1060 if (id
->do_not_unshare
)
1063 new_tree
= unshare_expr (*n
);
1065 *tp
= gimple_fold_indirect_ref (new_tree
);
1068 if (TREE_CODE (new_tree
) == ADDR_EXPR
)
1070 *tp
= fold_indirect_ref_1 (EXPR_LOCATION (new_tree
),
1072 /* ??? We should either assert here or build
1073 a VIEW_CONVERT_EXPR instead of blindly leaking
1074 incompatible types to our IL. */
1076 *tp
= TREE_OPERAND (new_tree
, 0);
1080 *tp
= build1 (INDIRECT_REF
, type
, new_tree
);
1081 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1082 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1083 TREE_READONLY (*tp
) = TREE_READONLY (old
);
1084 TREE_THIS_NOTRAP (*tp
) = TREE_THIS_NOTRAP (old
);
1091 else if (TREE_CODE (*tp
) == MEM_REF
)
1093 tree ptr
= TREE_OPERAND (*tp
, 0);
1094 tree type
= remap_type (TREE_TYPE (*tp
), id
);
1097 /* We need to re-canonicalize MEM_REFs from inline substitutions
1098 that can happen when a pointer argument is an ADDR_EXPR.
1099 Recurse here manually to allow that. */
1100 walk_tree (&ptr
, copy_tree_body_r
, data
, NULL
);
1101 *tp
= fold_build2 (MEM_REF
, type
,
1102 ptr
, TREE_OPERAND (*tp
, 1));
1103 TREE_THIS_NOTRAP (*tp
) = TREE_THIS_NOTRAP (old
);
1104 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1105 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1106 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
1111 /* Here is the "usual case". Copy this tree node, and then
1112 tweak some special cases. */
1113 copy_tree_r (tp
, walk_subtrees
, NULL
);
1115 /* If EXPR has block defined, map it to newly constructed block.
1116 When inlining we want EXPRs without block appear in the block
1117 of function call if we are not remapping a type. */
1120 new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
1121 if (TREE_BLOCK (*tp
))
1124 n
= (tree
*) pointer_map_contains (id
->decl_map
,
1129 TREE_SET_BLOCK (*tp
, new_block
);
1132 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
1133 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
1135 /* The copied TARGET_EXPR has never been expanded, even if the
1136 original node was expanded already. */
1137 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
1139 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
1140 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
1143 /* Variable substitution need not be simple. In particular, the
1144 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
1145 and friends are up-to-date. */
1146 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
1148 int invariant
= is_gimple_min_invariant (*tp
);
1149 walk_tree (&TREE_OPERAND (*tp
, 0), copy_tree_body_r
, id
, NULL
);
1151 /* Handle the case where we substituted an INDIRECT_REF
1152 into the operand of the ADDR_EXPR. */
1153 if (TREE_CODE (TREE_OPERAND (*tp
, 0)) == INDIRECT_REF
)
1154 *tp
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0);
1156 recompute_tree_invariant_for_addr_expr (*tp
);
1158 /* If this used to be invariant, but is not any longer,
1159 then regimplification is probably needed. */
1160 if (invariant
&& !is_gimple_min_invariant (*tp
))
1161 id
->regimplify
= true;
1167 /* Keep iterating. */
1171 /* Helper for remap_gimple_stmt. Given an EH region number for the
1172 source function, map that to the duplicate EH region number in
1173 the destination function. */
1176 remap_eh_region_nr (int old_nr
, copy_body_data
*id
)
1178 eh_region old_r
, new_r
;
1181 old_r
= get_eh_region_from_number_fn (id
->src_cfun
, old_nr
);
1182 slot
= pointer_map_contains (id
->eh_map
, old_r
);
1183 new_r
= (eh_region
) *slot
;
1185 return new_r
->index
;
1188 /* Similar, but operate on INTEGER_CSTs. */
1191 remap_eh_region_tree_nr (tree old_t_nr
, copy_body_data
*id
)
1195 old_nr
= tree_low_cst (old_t_nr
, 0);
1196 new_nr
= remap_eh_region_nr (old_nr
, id
);
1198 return build_int_cst (integer_type_node
, new_nr
);
1201 /* Helper for copy_bb. Remap statement STMT using the inlining
1202 information in ID. Return the new statement copy. */
1205 remap_gimple_stmt (gimple stmt
, copy_body_data
*id
)
1208 struct walk_stmt_info wi
;
1209 bool skip_first
= false;
1211 /* Begin by recognizing trees that we'll completely rewrite for the
1212 inlining context. Our output for these trees is completely
1213 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1214 into an edge). Further down, we'll handle trees that get
1215 duplicated and/or tweaked. */
1217 /* When requested, GIMPLE_RETURNs should be transformed to just the
1218 contained GIMPLE_ASSIGN. The branch semantics of the return will
1219 be handled elsewhere by manipulating the CFG rather than the
1221 if (gimple_code (stmt
) == GIMPLE_RETURN
&& id
->transform_return_to_modify
)
1223 tree retval
= gimple_return_retval (stmt
);
1225 /* If we're returning something, just turn that into an
1226 assignment into the equivalent of the original RESULT_DECL.
1227 If RETVAL is just the result decl, the result decl has
1228 already been set (e.g. a recent "foo (&result_decl, ...)");
1229 just toss the entire GIMPLE_RETURN. */
1231 && (TREE_CODE (retval
) != RESULT_DECL
1232 && (TREE_CODE (retval
) != SSA_NAME
1233 || ! SSA_NAME_VAR (retval
)
1234 || TREE_CODE (SSA_NAME_VAR (retval
)) != RESULT_DECL
)))
1236 copy
= gimple_build_assign (id
->retvar
, retval
);
1237 /* id->retvar is already substituted. Skip it on later remapping. */
1241 return gimple_build_nop ();
1243 else if (gimple_has_substatements (stmt
))
1247 /* When cloning bodies from the C++ front end, we will be handed bodies
1248 in High GIMPLE form. Handle here all the High GIMPLE statements that
1249 have embedded statements. */
1250 switch (gimple_code (stmt
))
1253 copy
= copy_gimple_bind (stmt
, id
);
1257 s1
= remap_gimple_seq (gimple_catch_handler (stmt
), id
);
1258 copy
= gimple_build_catch (gimple_catch_types (stmt
), s1
);
1261 case GIMPLE_EH_FILTER
:
1262 s1
= remap_gimple_seq (gimple_eh_filter_failure (stmt
), id
);
1263 copy
= gimple_build_eh_filter (gimple_eh_filter_types (stmt
), s1
);
1267 s1
= remap_gimple_seq (gimple_try_eval (stmt
), id
);
1268 s2
= remap_gimple_seq (gimple_try_cleanup (stmt
), id
);
1269 copy
= gimple_build_try (s1
, s2
, gimple_try_kind (stmt
));
1272 case GIMPLE_WITH_CLEANUP_EXPR
:
1273 s1
= remap_gimple_seq (gimple_wce_cleanup (stmt
), id
);
1274 copy
= gimple_build_wce (s1
);
1277 case GIMPLE_OMP_PARALLEL
:
1278 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1279 copy
= gimple_build_omp_parallel
1281 gimple_omp_parallel_clauses (stmt
),
1282 gimple_omp_parallel_child_fn (stmt
),
1283 gimple_omp_parallel_data_arg (stmt
));
1286 case GIMPLE_OMP_TASK
:
1287 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1288 copy
= gimple_build_omp_task
1290 gimple_omp_task_clauses (stmt
),
1291 gimple_omp_task_child_fn (stmt
),
1292 gimple_omp_task_data_arg (stmt
),
1293 gimple_omp_task_copy_fn (stmt
),
1294 gimple_omp_task_arg_size (stmt
),
1295 gimple_omp_task_arg_align (stmt
));
1298 case GIMPLE_OMP_FOR
:
1299 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1300 s2
= remap_gimple_seq (gimple_omp_for_pre_body (stmt
), id
);
1301 copy
= gimple_build_omp_for (s1
, gimple_omp_for_clauses (stmt
),
1302 gimple_omp_for_collapse (stmt
), s2
);
1305 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1307 gimple_omp_for_set_index (copy
, i
,
1308 gimple_omp_for_index (stmt
, i
));
1309 gimple_omp_for_set_initial (copy
, i
,
1310 gimple_omp_for_initial (stmt
, i
));
1311 gimple_omp_for_set_final (copy
, i
,
1312 gimple_omp_for_final (stmt
, i
));
1313 gimple_omp_for_set_incr (copy
, i
,
1314 gimple_omp_for_incr (stmt
, i
));
1315 gimple_omp_for_set_cond (copy
, i
,
1316 gimple_omp_for_cond (stmt
, i
));
1321 case GIMPLE_OMP_MASTER
:
1322 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1323 copy
= gimple_build_omp_master (s1
);
1326 case GIMPLE_OMP_ORDERED
:
1327 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1328 copy
= gimple_build_omp_ordered (s1
);
1331 case GIMPLE_OMP_SECTION
:
1332 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1333 copy
= gimple_build_omp_section (s1
);
1336 case GIMPLE_OMP_SECTIONS
:
1337 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1338 copy
= gimple_build_omp_sections
1339 (s1
, gimple_omp_sections_clauses (stmt
));
1342 case GIMPLE_OMP_SINGLE
:
1343 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1344 copy
= gimple_build_omp_single
1345 (s1
, gimple_omp_single_clauses (stmt
));
1348 case GIMPLE_OMP_CRITICAL
:
1349 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1351 = gimple_build_omp_critical (s1
, gimple_omp_critical_name (stmt
));
1354 case GIMPLE_TRANSACTION
:
1355 s1
= remap_gimple_seq (gimple_transaction_body (stmt
), id
);
1356 copy
= gimple_build_transaction (s1
, gimple_transaction_label (stmt
));
1357 gimple_transaction_set_subcode (copy
, gimple_transaction_subcode (stmt
));
1366 if (gimple_assign_copy_p (stmt
)
1367 && gimple_assign_lhs (stmt
) == gimple_assign_rhs1 (stmt
)
1368 && auto_var_in_fn_p (gimple_assign_lhs (stmt
), id
->src_fn
))
1370 /* Here we handle statements that are not completely rewritten.
1371 First we detect some inlining-induced bogosities for
1374 /* Some assignments VAR = VAR; don't generate any rtl code
1375 and thus don't count as variable modification. Avoid
1376 keeping bogosities like 0 = 0. */
1377 tree decl
= gimple_assign_lhs (stmt
), value
;
1380 n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
1384 STRIP_TYPE_NOPS (value
);
1385 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1386 return gimple_build_nop ();
1390 if (gimple_debug_bind_p (stmt
))
1392 copy
= gimple_build_debug_bind (gimple_debug_bind_get_var (stmt
),
1393 gimple_debug_bind_get_value (stmt
),
1395 id
->debug_stmts
.safe_push (copy
);
1398 if (gimple_debug_source_bind_p (stmt
))
1400 copy
= gimple_build_debug_source_bind
1401 (gimple_debug_source_bind_get_var (stmt
),
1402 gimple_debug_source_bind_get_value (stmt
), stmt
);
1403 id
->debug_stmts
.safe_push (copy
);
1407 /* Create a new deep copy of the statement. */
1408 copy
= gimple_copy (stmt
);
1410 /* Remap the region numbers for __builtin_eh_{pointer,filter},
1411 RESX and EH_DISPATCH. */
1413 switch (gimple_code (copy
))
1417 tree r
, fndecl
= gimple_call_fndecl (copy
);
1418 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
1419 switch (DECL_FUNCTION_CODE (fndecl
))
1421 case BUILT_IN_EH_COPY_VALUES
:
1422 r
= gimple_call_arg (copy
, 1);
1423 r
= remap_eh_region_tree_nr (r
, id
);
1424 gimple_call_set_arg (copy
, 1, r
);
1427 case BUILT_IN_EH_POINTER
:
1428 case BUILT_IN_EH_FILTER
:
1429 r
= gimple_call_arg (copy
, 0);
1430 r
= remap_eh_region_tree_nr (r
, id
);
1431 gimple_call_set_arg (copy
, 0, r
);
1438 /* Reset alias info if we didn't apply measures to
1439 keep it valid over inlining by setting DECL_PT_UID. */
1440 if (!id
->src_cfun
->gimple_df
1441 || !id
->src_cfun
->gimple_df
->ipa_pta
)
1442 gimple_call_reset_alias_info (copy
);
1448 int r
= gimple_resx_region (copy
);
1449 r
= remap_eh_region_nr (r
, id
);
1450 gimple_resx_set_region (copy
, r
);
1454 case GIMPLE_EH_DISPATCH
:
1456 int r
= gimple_eh_dispatch_region (copy
);
1457 r
= remap_eh_region_nr (r
, id
);
1458 gimple_eh_dispatch_set_region (copy
, r
);
1467 /* If STMT has a block defined, map it to the newly constructed
1469 if (gimple_block (copy
))
1472 n
= (tree
*) pointer_map_contains (id
->decl_map
, gimple_block (copy
));
1474 gimple_set_block (copy
, *n
);
1477 if (gimple_debug_bind_p (copy
) || gimple_debug_source_bind_p (copy
))
1480 /* Remap all the operands in COPY. */
1481 memset (&wi
, 0, sizeof (wi
));
1484 walk_tree (gimple_op_ptr (copy
, 1), remap_gimple_op_r
, &wi
, NULL
);
1486 walk_gimple_op (copy
, remap_gimple_op_r
, &wi
);
1488 /* Clear the copied virtual operands. We are not remapping them here
1489 but are going to recreate them from scratch. */
1490 if (gimple_has_mem_ops (copy
))
1492 gimple_set_vdef (copy
, NULL_TREE
);
1493 gimple_set_vuse (copy
, NULL_TREE
);
1500 /* Copy basic block, scale profile accordingly. Edges will be taken care of
1504 copy_bb (copy_body_data
*id
, basic_block bb
, int frequency_scale
,
1505 gcov_type count_scale
)
1507 gimple_stmt_iterator gsi
, copy_gsi
, seq_gsi
;
1508 basic_block copy_basic_block
;
1513 /* Search for previous copied basic block. */
1516 prev
= prev
->prev_bb
;
1518 /* create_basic_block() will append every new block to
1519 basic_block_info automatically. */
1520 copy_basic_block
= create_basic_block (NULL
, (void *) 0,
1521 (basic_block
) prev
->aux
);
1522 copy_basic_block
->count
= apply_scale (bb
->count
, count_scale
);
1524 /* We are going to rebuild frequencies from scratch. These values
1525 have just small importance to drive canonicalize_loop_headers. */
1526 freq
= apply_scale ((gcov_type
)bb
->frequency
, frequency_scale
);
1528 /* We recompute frequencies after inlining, so this is quite safe. */
1529 if (freq
> BB_FREQ_MAX
)
1531 copy_basic_block
->frequency
= freq
;
1533 copy_gsi
= gsi_start_bb (copy_basic_block
);
1535 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1537 gimple stmt
= gsi_stmt (gsi
);
1538 gimple orig_stmt
= stmt
;
1540 id
->regimplify
= false;
1541 stmt
= remap_gimple_stmt (stmt
, id
);
1542 if (gimple_nop_p (stmt
))
1545 gimple_duplicate_stmt_histograms (cfun
, stmt
, id
->src_cfun
, orig_stmt
);
1548 /* With return slot optimization we can end up with
1549 non-gimple (foo *)&this->m, fix that here. */
1550 if (is_gimple_assign (stmt
)
1551 && gimple_assign_rhs_code (stmt
) == NOP_EXPR
1552 && !is_gimple_val (gimple_assign_rhs1 (stmt
)))
1555 new_rhs
= force_gimple_operand_gsi (&seq_gsi
,
1556 gimple_assign_rhs1 (stmt
),
1558 GSI_CONTINUE_LINKING
);
1559 gimple_assign_set_rhs1 (stmt
, new_rhs
);
1560 id
->regimplify
= false;
1563 gsi_insert_after (&seq_gsi
, stmt
, GSI_NEW_STMT
);
1566 gimple_regimplify_operands (stmt
, &seq_gsi
);
1568 /* If copy_basic_block has been empty at the start of this iteration,
1569 call gsi_start_bb again to get at the newly added statements. */
1570 if (gsi_end_p (copy_gsi
))
1571 copy_gsi
= gsi_start_bb (copy_basic_block
);
1573 gsi_next (©_gsi
);
1575 /* Process the new statement. The call to gimple_regimplify_operands
1576 possibly turned the statement into multiple statements, we
1577 need to process all of them. */
1582 stmt
= gsi_stmt (copy_gsi
);
1583 if (is_gimple_call (stmt
)
1584 && gimple_call_va_arg_pack_p (stmt
)
1587 /* __builtin_va_arg_pack () should be replaced by
1588 all arguments corresponding to ... in the caller. */
1592 size_t nargs
= gimple_call_num_args (id
->gimple_call
);
1595 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1598 /* Create the new array of arguments. */
1599 n
= nargs
+ gimple_call_num_args (stmt
);
1600 argarray
.create (n
);
1601 argarray
.safe_grow_cleared (n
);
1603 /* Copy all the arguments before '...' */
1604 memcpy (argarray
.address (),
1605 gimple_call_arg_ptr (stmt
, 0),
1606 gimple_call_num_args (stmt
) * sizeof (tree
));
1608 /* Append the arguments passed in '...' */
1609 memcpy (argarray
.address () + gimple_call_num_args (stmt
),
1610 gimple_call_arg_ptr (id
->gimple_call
, 0)
1611 + (gimple_call_num_args (id
->gimple_call
) - nargs
),
1612 nargs
* sizeof (tree
));
1614 new_call
= gimple_build_call_vec (gimple_call_fn (stmt
),
1617 argarray
.release ();
1619 /* Copy all GIMPLE_CALL flags, location and block, except
1620 GF_CALL_VA_ARG_PACK. */
1621 gimple_call_copy_flags (new_call
, stmt
);
1622 gimple_call_set_va_arg_pack (new_call
, false);
1623 gimple_set_location (new_call
, gimple_location (stmt
));
1624 gimple_set_block (new_call
, gimple_block (stmt
));
1625 gimple_call_set_lhs (new_call
, gimple_call_lhs (stmt
));
1627 gsi_replace (©_gsi
, new_call
, false);
1630 else if (is_gimple_call (stmt
)
1632 && (decl
= gimple_call_fndecl (stmt
))
1633 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
1634 && DECL_FUNCTION_CODE (decl
) == BUILT_IN_VA_ARG_PACK_LEN
)
1636 /* __builtin_va_arg_pack_len () should be replaced by
1637 the number of anonymous arguments. */
1638 size_t nargs
= gimple_call_num_args (id
->gimple_call
);
1642 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1645 count
= build_int_cst (integer_type_node
, nargs
);
1646 new_stmt
= gimple_build_assign (gimple_call_lhs (stmt
), count
);
1647 gsi_replace (©_gsi
, new_stmt
, false);
1651 /* Statements produced by inlining can be unfolded, especially
1652 when we constant propagated some operands. We can't fold
1653 them right now for two reasons:
1654 1) folding require SSA_NAME_DEF_STMTs to be correct
1655 2) we can't change function calls to builtins.
1656 So we just mark statement for later folding. We mark
1657 all new statements, instead just statements that has changed
1658 by some nontrivial substitution so even statements made
1659 foldable indirectly are updated. If this turns out to be
1660 expensive, copy_body can be told to watch for nontrivial
1662 if (id
->statements_to_fold
)
1663 pointer_set_insert (id
->statements_to_fold
, stmt
);
1665 /* We're duplicating a CALL_EXPR. Find any corresponding
1666 callgraph edges and update or duplicate them. */
1667 if (is_gimple_call (stmt
))
1669 struct cgraph_edge
*edge
;
1672 switch (id
->transform_call_graph_edges
)
1674 case CB_CGE_DUPLICATE
:
1675 edge
= cgraph_edge (id
->src_node
, orig_stmt
);
1678 int edge_freq
= edge
->frequency
;
1679 edge
= cgraph_clone_edge (edge
, id
->dst_node
, stmt
,
1681 REG_BR_PROB_BASE
, CGRAPH_FREQ_BASE
,
1683 /* We could also just rescale the frequency, but
1684 doing so would introduce roundoff errors and make
1685 verifier unhappy. */
1687 = compute_call_stmt_bb_frequency (id
->dst_node
->symbol
.decl
,
1690 && profile_status_for_function (cfun
) != PROFILE_ABSENT
1691 && (edge_freq
> edge
->frequency
+ 10
1692 || edge_freq
< edge
->frequency
- 10))
1694 fprintf (dump_file
, "Edge frequency estimated by "
1695 "cgraph %i diverge from inliner's estimate %i\n",
1699 "Orig bb: %i, orig bb freq %i, new bb freq %i\n",
1702 copy_basic_block
->frequency
);
1704 stmt
= cgraph_redirect_edge_call_stmt_to_callee (edge
);
1708 case CB_CGE_MOVE_CLONES
:
1709 cgraph_set_call_stmt_including_clones (id
->dst_node
,
1711 edge
= cgraph_edge (id
->dst_node
, stmt
);
1715 edge
= cgraph_edge (id
->dst_node
, orig_stmt
);
1717 cgraph_set_call_stmt (edge
, stmt
);
1724 /* Constant propagation on argument done during inlining
1725 may create new direct call. Produce an edge for it. */
1727 || (edge
->indirect_inlining_edge
1728 && id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
))
1729 && id
->dst_node
->analyzed
1730 && (fn
= gimple_call_fndecl (stmt
)) != NULL
)
1732 struct cgraph_node
*dest
= cgraph_get_node (fn
);
1734 /* We have missing edge in the callgraph. This can happen
1735 when previous inlining turned an indirect call into a
1736 direct call by constant propagating arguments or we are
1737 producing dead clone (for further cloning). In all
1738 other cases we hit a bug (incorrect node sharing is the
1739 most common reason for missing edges). */
1740 gcc_assert (!dest
->analyzed
1741 || dest
->symbol
.address_taken
1742 || !id
->src_node
->analyzed
1743 || !id
->dst_node
->analyzed
);
1744 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
)
1745 cgraph_create_edge_including_clones
1746 (id
->dst_node
, dest
, orig_stmt
, stmt
, bb
->count
,
1747 compute_call_stmt_bb_frequency (id
->dst_node
->symbol
.decl
,
1749 CIF_ORIGINALLY_INDIRECT_CALL
);
1751 cgraph_create_edge (id
->dst_node
, dest
, stmt
,
1753 compute_call_stmt_bb_frequency
1754 (id
->dst_node
->symbol
.decl
,
1755 copy_basic_block
))->inline_failed
1756 = CIF_ORIGINALLY_INDIRECT_CALL
;
1759 fprintf (dump_file
, "Created new direct edge to %s\n",
1760 cgraph_node_name (dest
));
1764 flags
= gimple_call_flags (stmt
);
1765 if (flags
& ECF_MAY_BE_ALLOCA
)
1766 cfun
->calls_alloca
= true;
1767 if (flags
& ECF_RETURNS_TWICE
)
1768 cfun
->calls_setjmp
= true;
1771 maybe_duplicate_eh_stmt_fn (cfun
, stmt
, id
->src_cfun
, orig_stmt
,
1772 id
->eh_map
, id
->eh_lp_nr
);
1774 if (gimple_in_ssa_p (cfun
) && !is_gimple_debug (stmt
))
1779 FOR_EACH_SSA_TREE_OPERAND (def
, stmt
, i
, SSA_OP_DEF
)
1780 if (TREE_CODE (def
) == SSA_NAME
)
1781 SSA_NAME_DEF_STMT (def
) = stmt
;
1784 gsi_next (©_gsi
);
1786 while (!gsi_end_p (copy_gsi
));
1788 copy_gsi
= gsi_last_bb (copy_basic_block
);
1791 return copy_basic_block
;
1794 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
1795 form is quite easy, since dominator relationship for old basic blocks does
1798 There is however exception where inlining might change dominator relation
1799 across EH edges from basic block within inlined functions destinating
1800 to landing pads in function we inline into.
1802 The function fills in PHI_RESULTs of such PHI nodes if they refer
1803 to gimple regs. Otherwise, the function mark PHI_RESULT of such
1804 PHI nodes for renaming. For non-gimple regs, renaming is safe: the
1805 EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
1806 set, and this means that there will be no overlapping live ranges
1807 for the underlying symbol.
1809 This might change in future if we allow redirecting of EH edges and
1810 we might want to change way build CFG pre-inlining to include
1811 all the possible edges then. */
1813 update_ssa_across_abnormal_edges (basic_block bb
, basic_block ret_bb
,
1814 bool can_throw
, bool nonlocal_goto
)
1819 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1821 || ((basic_block
)e
->dest
->aux
)->index
== ENTRY_BLOCK
)
1824 gimple_stmt_iterator si
;
1827 gcc_assert (e
->flags
& EDGE_EH
);
1830 gcc_assert (!(e
->flags
& EDGE_EH
));
1832 for (si
= gsi_start_phis (e
->dest
); !gsi_end_p (si
); gsi_next (&si
))
1836 phi
= gsi_stmt (si
);
1838 /* There shouldn't be any PHI nodes in the ENTRY_BLOCK. */
1839 gcc_assert (!e
->dest
->aux
);
1841 gcc_assert ((e
->flags
& EDGE_EH
)
1842 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi
)));
1844 if (virtual_operand_p (PHI_RESULT (phi
)))
1846 mark_virtual_operands_for_renaming (cfun
);
1850 re
= find_edge (ret_bb
, e
->dest
);
1852 gcc_assert ((re
->flags
& (EDGE_EH
| EDGE_ABNORMAL
))
1853 == (e
->flags
& (EDGE_EH
| EDGE_ABNORMAL
)));
1855 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, e
),
1856 USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, re
)));
1862 /* Copy edges from BB into its copy constructed earlier, scale profile
1863 accordingly. Edges will be taken care of later. Assume aux
1864 pointers to point to the copies of each BB. Return true if any
1865 debug stmts are left after a statement that must end the basic block. */
1868 copy_edges_for_bb (basic_block bb
, gcov_type count_scale
, basic_block ret_bb
,
1869 bool can_make_abnormal_goto
)
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 new_edge
->count
= apply_scale (old_edge
->count
, count_scale
);
1893 new_edge
->probability
= old_edge
->probability
;
1896 if (bb
->index
== ENTRY_BLOCK
|| bb
->index
== EXIT_BLOCK
)
1899 for (si
= gsi_start_bb (new_bb
); !gsi_end_p (si
);)
1902 bool can_throw
, nonlocal_goto
;
1904 copy_stmt
= gsi_stmt (si
);
1905 if (!is_gimple_debug (copy_stmt
))
1906 update_stmt (copy_stmt
);
1908 /* Do this before the possible split_block. */
1911 /* If this tree could throw an exception, there are two
1912 cases where we need to add abnormal edge(s): the
1913 tree wasn't in a region and there is a "current
1914 region" in the caller; or the original tree had
1915 EH edges. In both cases split the block after the tree,
1916 and add abnormal edge(s) as needed; we need both
1917 those from the callee and the caller.
1918 We check whether the copy can throw, because the const
1919 propagation can change an INDIRECT_REF which throws
1920 into a COMPONENT_REF which doesn't. If the copy
1921 can throw, the original could also throw. */
1922 can_throw
= stmt_can_throw_internal (copy_stmt
);
1923 nonlocal_goto
= stmt_can_make_abnormal_goto (copy_stmt
);
1925 if (can_throw
|| nonlocal_goto
)
1927 if (!gsi_end_p (si
))
1929 while (!gsi_end_p (si
) && is_gimple_debug (gsi_stmt (si
)))
1932 need_debug_cleanup
= true;
1934 if (!gsi_end_p (si
))
1935 /* Note that bb's predecessor edges aren't necessarily
1936 right at this point; split_block doesn't care. */
1938 edge e
= split_block (new_bb
, copy_stmt
);
1941 new_bb
->aux
= e
->src
->aux
;
1942 si
= gsi_start_bb (new_bb
);
1946 if (gimple_code (copy_stmt
) == GIMPLE_EH_DISPATCH
)
1947 make_eh_dispatch_edges (copy_stmt
);
1949 make_eh_edges (copy_stmt
);
1951 /* If the call we inline cannot make abnormal goto do not add
1952 additional abnormal edges but only retain those already present
1953 in the original function body. */
1954 nonlocal_goto
&= can_make_abnormal_goto
;
1956 make_abnormal_goto_edges (gimple_bb (copy_stmt
), true);
1958 if ((can_throw
|| nonlocal_goto
)
1959 && gimple_in_ssa_p (cfun
))
1960 update_ssa_across_abnormal_edges (gimple_bb (copy_stmt
), ret_bb
,
1961 can_throw
, nonlocal_goto
);
1963 return need_debug_cleanup
;
1966 /* Copy the PHIs. All blocks and edges are copied, some blocks
1967 was possibly split and new outgoing EH edges inserted.
1968 BB points to the block of original function and AUX pointers links
1969 the original and newly copied blocks. */
1972 copy_phis_for_bb (basic_block bb
, copy_body_data
*id
)
1974 basic_block
const new_bb
= (basic_block
) bb
->aux
;
1977 gimple_stmt_iterator si
;
1979 bool inserted
= false;
1981 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
1986 phi
= gsi_stmt (si
);
1987 res
= PHI_RESULT (phi
);
1989 if (!virtual_operand_p (res
))
1991 walk_tree (&new_res
, copy_tree_body_r
, id
, NULL
);
1992 new_phi
= create_phi_node (new_res
, new_bb
);
1993 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
1995 edge old_edge
= find_edge ((basic_block
) new_edge
->src
->aux
, bb
);
2001 /* When doing partial cloning, we allow PHIs on the entry block
2002 as long as all the arguments are the same. Find any input
2003 edge to see argument to copy. */
2005 FOR_EACH_EDGE (old_edge
, ei2
, bb
->preds
)
2006 if (!old_edge
->src
->aux
)
2009 arg
= PHI_ARG_DEF_FROM_EDGE (phi
, old_edge
);
2011 walk_tree (&new_arg
, copy_tree_body_r
, id
, NULL
);
2012 gcc_assert (new_arg
);
2013 /* With return slot optimization we can end up with
2014 non-gimple (foo *)&this->m, fix that here. */
2015 if (TREE_CODE (new_arg
) != SSA_NAME
2016 && TREE_CODE (new_arg
) != FUNCTION_DECL
2017 && !is_gimple_val (new_arg
))
2019 gimple_seq stmts
= NULL
;
2020 new_arg
= force_gimple_operand (new_arg
, &stmts
, true, NULL
);
2021 gsi_insert_seq_on_edge (new_edge
, stmts
);
2024 locus
= gimple_phi_arg_location_from_edge (phi
, old_edge
);
2025 if (LOCATION_BLOCK (locus
))
2028 n
= (tree
*) pointer_map_contains (id
->decl_map
,
2029 LOCATION_BLOCK (locus
));
2031 locus
= COMBINE_LOCATION_DATA (line_table
, locus
, *n
);
2034 locus
= LOCATION_LOCUS (locus
);
2036 add_phi_arg (new_phi
, new_arg
, new_edge
, locus
);
2041 /* Commit the delayed edge insertions. */
2043 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2044 gsi_commit_one_edge_insert (new_edge
, NULL
);
2048 /* Wrapper for remap_decl so it can be used as a callback. */
2051 remap_decl_1 (tree decl
, void *data
)
2053 return remap_decl (decl
, (copy_body_data
*) data
);
2056 /* Build struct function and associated datastructures for the new clone
2057 NEW_FNDECL to be build. CALLEE_FNDECL is the original. Function changes
2058 the cfun to the function of new_fndecl (and current_function_decl too). */
2061 initialize_cfun (tree new_fndecl
, tree callee_fndecl
, gcov_type count
)
2063 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2064 gcov_type count_scale
;
2066 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
)
2068 = GCOV_COMPUTE_SCALE (count
,
2069 ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
);
2071 count_scale
= REG_BR_PROB_BASE
;
2073 /* Register specific tree functions. */
2074 gimple_register_cfg_hooks ();
2076 /* Get clean struct function. */
2077 push_struct_function (new_fndecl
);
2079 /* We will rebuild these, so just sanity check that they are empty. */
2080 gcc_assert (VALUE_HISTOGRAMS (cfun
) == NULL
);
2081 gcc_assert (cfun
->local_decls
== NULL
);
2082 gcc_assert (cfun
->cfg
== NULL
);
2083 gcc_assert (cfun
->decl
== new_fndecl
);
2085 /* Copy items we preserve during cloning. */
2086 cfun
->static_chain_decl
= src_cfun
->static_chain_decl
;
2087 cfun
->nonlocal_goto_save_area
= src_cfun
->nonlocal_goto_save_area
;
2088 cfun
->function_end_locus
= src_cfun
->function_end_locus
;
2089 cfun
->curr_properties
= src_cfun
->curr_properties
;
2090 cfun
->last_verified
= src_cfun
->last_verified
;
2091 cfun
->va_list_gpr_size
= src_cfun
->va_list_gpr_size
;
2092 cfun
->va_list_fpr_size
= src_cfun
->va_list_fpr_size
;
2093 cfun
->has_nonlocal_label
= src_cfun
->has_nonlocal_label
;
2094 cfun
->stdarg
= src_cfun
->stdarg
;
2095 cfun
->after_inlining
= src_cfun
->after_inlining
;
2096 cfun
->can_throw_non_call_exceptions
2097 = src_cfun
->can_throw_non_call_exceptions
;
2098 cfun
->can_delete_dead_exceptions
= src_cfun
->can_delete_dead_exceptions
;
2099 cfun
->returns_struct
= src_cfun
->returns_struct
;
2100 cfun
->returns_pcc_struct
= src_cfun
->returns_pcc_struct
;
2102 init_empty_tree_cfg ();
2104 profile_status_for_function (cfun
) = profile_status_for_function (src_cfun
);
2105 ENTRY_BLOCK_PTR
->count
=
2106 (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
* count_scale
/
2108 ENTRY_BLOCK_PTR
->frequency
2109 = ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->frequency
;
2110 EXIT_BLOCK_PTR
->count
=
2111 (EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
* count_scale
/
2113 EXIT_BLOCK_PTR
->frequency
=
2114 EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->frequency
;
2116 init_eh_for_function ();
2118 if (src_cfun
->gimple_df
)
2120 init_tree_ssa (cfun
);
2121 cfun
->gimple_df
->in_ssa_p
= true;
2122 init_ssa_operands (cfun
);
2126 /* Helper function for copy_cfg_body. Move debug stmts from the end
2127 of NEW_BB to the beginning of successor basic blocks when needed. If the
2128 successor has multiple predecessors, reset them, otherwise keep
2132 maybe_move_debug_stmts_to_successors (copy_body_data
*id
, basic_block new_bb
)
2136 gimple_stmt_iterator si
= gsi_last_nondebug_bb (new_bb
);
2139 || gsi_one_before_end_p (si
)
2140 || !(stmt_can_throw_internal (gsi_stmt (si
))
2141 || stmt_can_make_abnormal_goto (gsi_stmt (si
))))
2144 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
2146 gimple_stmt_iterator ssi
= gsi_last_bb (new_bb
);
2147 gimple_stmt_iterator dsi
= gsi_after_labels (e
->dest
);
2148 while (is_gimple_debug (gsi_stmt (ssi
)))
2150 gimple stmt
= gsi_stmt (ssi
), new_stmt
;
2154 /* For the last edge move the debug stmts instead of copying
2156 if (ei_one_before_end_p (ei
))
2160 if (!single_pred_p (e
->dest
) && gimple_debug_bind_p (stmt
))
2161 gimple_debug_bind_reset_value (stmt
);
2162 gsi_remove (&si
, false);
2163 gsi_insert_before (&dsi
, stmt
, GSI_SAME_STMT
);
2167 if (gimple_debug_bind_p (stmt
))
2169 var
= gimple_debug_bind_get_var (stmt
);
2170 if (single_pred_p (e
->dest
))
2172 value
= gimple_debug_bind_get_value (stmt
);
2173 value
= unshare_expr (value
);
2177 new_stmt
= gimple_build_debug_bind (var
, value
, stmt
);
2179 else if (gimple_debug_source_bind_p (stmt
))
2181 var
= gimple_debug_source_bind_get_var (stmt
);
2182 value
= gimple_debug_source_bind_get_value (stmt
);
2183 new_stmt
= gimple_build_debug_source_bind (var
, value
, stmt
);
2187 gsi_insert_before (&dsi
, new_stmt
, GSI_SAME_STMT
);
2188 id
->debug_stmts
.safe_push (new_stmt
);
2194 /* Make a copy of the sub-loops of SRC_PARENT and place them
2195 as siblings of DEST_PARENT. */
2198 copy_loops (bitmap blocks_to_copy
,
2199 struct loop
*dest_parent
, struct loop
*src_parent
)
2201 struct loop
*src_loop
= src_parent
->inner
;
2205 || bitmap_bit_p (blocks_to_copy
, src_loop
->header
->index
))
2207 struct loop
*dest_loop
= alloc_loop ();
2209 /* Assign the new loop its header and latch and associate
2210 those with the new loop. */
2211 if (src_loop
->header
!= NULL
)
2213 dest_loop
->header
= (basic_block
)src_loop
->header
->aux
;
2214 dest_loop
->header
->loop_father
= dest_loop
;
2216 if (src_loop
->latch
!= NULL
)
2218 dest_loop
->latch
= (basic_block
)src_loop
->latch
->aux
;
2219 dest_loop
->latch
->loop_father
= dest_loop
;
2222 /* Copy loop meta-data. */
2223 copy_loop_info (src_loop
, dest_loop
);
2225 /* Finally place it into the loop array and the loop tree. */
2226 place_new_loop (cfun
, dest_loop
);
2227 flow_loop_tree_node_add (dest_parent
, dest_loop
);
2230 copy_loops (blocks_to_copy
, dest_loop
, src_loop
);
2232 src_loop
= src_loop
->next
;
2236 /* Make a copy of the body of FN so that it can be inserted inline in
2237 another function. Walks FN via CFG, returns new fndecl. */
2240 copy_cfg_body (copy_body_data
* id
, gcov_type count
, int frequency_scale
,
2241 basic_block entry_block_map
, basic_block exit_block_map
,
2242 bitmap blocks_to_copy
, basic_block new_entry
)
2244 tree callee_fndecl
= id
->src_fn
;
2245 /* Original cfun for the callee, doesn't change. */
2246 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2247 struct function
*cfun_to_copy
;
2249 tree new_fndecl
= NULL
;
2250 bool need_debug_cleanup
= false;
2251 gcov_type count_scale
;
2253 int incoming_frequency
= 0;
2254 gcov_type incoming_count
= 0;
2256 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
)
2258 = GCOV_COMPUTE_SCALE (count
,
2259 ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
);
2261 count_scale
= REG_BR_PROB_BASE
;
2263 /* Register specific tree functions. */
2264 gimple_register_cfg_hooks ();
2266 /* If we are inlining just region of the function, make sure to connect new entry
2267 to ENTRY_BLOCK_PTR. Since new entry can be part of loop, we must compute
2268 frequency and probability of ENTRY_BLOCK_PTR based on the frequencies and
2269 probabilities of edges incoming from nonduplicated region. */
2275 FOR_EACH_EDGE (e
, ei
, new_entry
->preds
)
2278 incoming_frequency
+= EDGE_FREQUENCY (e
);
2279 incoming_count
+= e
->count
;
2281 incoming_count
= apply_scale (incoming_count
, count_scale
);
2283 = apply_scale ((gcov_type
)incoming_frequency
, frequency_scale
);
2284 ENTRY_BLOCK_PTR
->count
= incoming_count
;
2285 ENTRY_BLOCK_PTR
->frequency
= incoming_frequency
;
2288 /* Must have a CFG here at this point. */
2289 gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION
2290 (DECL_STRUCT_FUNCTION (callee_fndecl
)));
2292 cfun_to_copy
= id
->src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2294 ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy
)->aux
= entry_block_map
;
2295 EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy
)->aux
= exit_block_map
;
2296 entry_block_map
->aux
= ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy
);
2297 exit_block_map
->aux
= EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy
);
2299 /* Duplicate any exception-handling regions. */
2301 id
->eh_map
= duplicate_eh_regions (cfun_to_copy
, NULL
, id
->eh_lp_nr
,
2304 /* Use aux pointers to map the original blocks to copy. */
2305 FOR_EACH_BB_FN (bb
, cfun_to_copy
)
2306 if (!blocks_to_copy
|| bitmap_bit_p (blocks_to_copy
, bb
->index
))
2308 basic_block new_bb
= copy_bb (id
, bb
, frequency_scale
, count_scale
);
2311 new_bb
->loop_father
= entry_block_map
->loop_father
;
2314 last
= last_basic_block
;
2316 /* Now that we've duplicated the blocks, duplicate their edges. */
2317 bool can_make_abormal_goto
2318 = id
->gimple_call
&& stmt_can_make_abnormal_goto (id
->gimple_call
);
2319 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2321 || (bb
->index
> 0 && bitmap_bit_p (blocks_to_copy
, bb
->index
)))
2322 need_debug_cleanup
|= copy_edges_for_bb (bb
, count_scale
, exit_block_map
,
2323 can_make_abormal_goto
);
2327 edge e
= make_edge (entry_block_map
, (basic_block
)new_entry
->aux
, EDGE_FALLTHRU
);
2328 e
->probability
= REG_BR_PROB_BASE
;
2329 e
->count
= incoming_count
;
2332 /* Duplicate the loop tree, if available and wanted. */
2333 if (loops_for_fn (src_cfun
) != NULL
2334 && current_loops
!= NULL
)
2336 copy_loops (blocks_to_copy
, entry_block_map
->loop_father
,
2337 get_loop (src_cfun
, 0));
2338 /* Defer to cfgcleanup to update loop-father fields of basic-blocks. */
2339 loops_state_set (LOOPS_NEED_FIXUP
);
2342 /* If the loop tree in the source function needed fixup, mark the
2343 destination loop tree for fixup, too. */
2344 if (loops_for_fn (src_cfun
)->state
& LOOPS_NEED_FIXUP
)
2345 loops_state_set (LOOPS_NEED_FIXUP
);
2347 if (gimple_in_ssa_p (cfun
))
2348 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2350 || (bb
->index
> 0 && bitmap_bit_p (blocks_to_copy
, bb
->index
)))
2351 copy_phis_for_bb (bb
, id
);
2353 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2356 if (need_debug_cleanup
2357 && bb
->index
!= ENTRY_BLOCK
2358 && bb
->index
!= EXIT_BLOCK
)
2359 maybe_move_debug_stmts_to_successors (id
, (basic_block
) bb
->aux
);
2360 ((basic_block
)bb
->aux
)->aux
= NULL
;
2364 /* Zero out AUX fields of newly created block during EH edge
2366 for (; last
< last_basic_block
; last
++)
2368 if (need_debug_cleanup
)
2369 maybe_move_debug_stmts_to_successors (id
, BASIC_BLOCK (last
));
2370 BASIC_BLOCK (last
)->aux
= NULL
;
2372 entry_block_map
->aux
= NULL
;
2373 exit_block_map
->aux
= NULL
;
2377 pointer_map_destroy (id
->eh_map
);
2384 /* Copy the debug STMT using ID. We deal with these statements in a
2385 special way: if any variable in their VALUE expression wasn't
2386 remapped yet, we won't remap it, because that would get decl uids
2387 out of sync, causing codegen differences between -g and -g0. If
2388 this arises, we drop the VALUE expression altogether. */
2391 copy_debug_stmt (gimple stmt
, copy_body_data
*id
)
2394 struct walk_stmt_info wi
;
2396 if (gimple_block (stmt
))
2398 n
= (tree
*) pointer_map_contains (id
->decl_map
, gimple_block (stmt
));
2399 gimple_set_block (stmt
, n
? *n
: id
->block
);
2402 /* Remap all the operands in COPY. */
2403 memset (&wi
, 0, sizeof (wi
));
2406 processing_debug_stmt
= 1;
2408 if (gimple_debug_source_bind_p (stmt
))
2409 t
= gimple_debug_source_bind_get_var (stmt
);
2411 t
= gimple_debug_bind_get_var (stmt
);
2413 if (TREE_CODE (t
) == PARM_DECL
&& id
->debug_map
2414 && (n
= (tree
*) pointer_map_contains (id
->debug_map
, t
)))
2416 gcc_assert (TREE_CODE (*n
) == VAR_DECL
);
2419 else if (TREE_CODE (t
) == VAR_DECL
2420 && !is_global_var (t
)
2421 && !pointer_map_contains (id
->decl_map
, t
))
2422 /* T is a non-localized variable. */;
2424 walk_tree (&t
, remap_gimple_op_r
, &wi
, NULL
);
2426 if (gimple_debug_bind_p (stmt
))
2428 gimple_debug_bind_set_var (stmt
, t
);
2430 if (gimple_debug_bind_has_value_p (stmt
))
2431 walk_tree (gimple_debug_bind_get_value_ptr (stmt
),
2432 remap_gimple_op_r
, &wi
, NULL
);
2434 /* Punt if any decl couldn't be remapped. */
2435 if (processing_debug_stmt
< 0)
2436 gimple_debug_bind_reset_value (stmt
);
2438 else if (gimple_debug_source_bind_p (stmt
))
2440 gimple_debug_source_bind_set_var (stmt
, t
);
2441 walk_tree (gimple_debug_source_bind_get_value_ptr (stmt
),
2442 remap_gimple_op_r
, &wi
, NULL
);
2443 /* When inlining and source bind refers to one of the optimized
2444 away parameters, change the source bind into normal debug bind
2445 referring to the corresponding DEBUG_EXPR_DECL that should have
2446 been bound before the call stmt. */
2447 t
= gimple_debug_source_bind_get_value (stmt
);
2449 && TREE_CODE (t
) == PARM_DECL
2452 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (id
->src_fn
);
2454 if (debug_args
!= NULL
)
2456 for (i
= 0; i
< vec_safe_length (*debug_args
); i
+= 2)
2457 if ((**debug_args
)[i
] == DECL_ORIGIN (t
)
2458 && TREE_CODE ((**debug_args
)[i
+ 1]) == DEBUG_EXPR_DECL
)
2460 t
= (**debug_args
)[i
+ 1];
2461 stmt
->gsbase
.subcode
= GIMPLE_DEBUG_BIND
;
2462 gimple_debug_bind_set_value (stmt
, t
);
2469 processing_debug_stmt
= 0;
2474 /* Process deferred debug stmts. In order to give values better odds
2475 of being successfully remapped, we delay the processing of debug
2476 stmts until all other stmts that might require remapping are
2480 copy_debug_stmts (copy_body_data
*id
)
2485 if (!id
->debug_stmts
.exists ())
2488 FOR_EACH_VEC_ELT (id
->debug_stmts
, i
, stmt
)
2489 copy_debug_stmt (stmt
, id
);
2491 id
->debug_stmts
.release ();
2494 /* Make a copy of the body of SRC_FN so that it can be inserted inline in
2495 another function. */
2498 copy_tree_body (copy_body_data
*id
)
2500 tree fndecl
= id
->src_fn
;
2501 tree body
= DECL_SAVED_TREE (fndecl
);
2503 walk_tree (&body
, copy_tree_body_r
, id
, NULL
);
2508 /* Make a copy of the body of FN so that it can be inserted inline in
2509 another function. */
2512 copy_body (copy_body_data
*id
, gcov_type count
, int frequency_scale
,
2513 basic_block entry_block_map
, basic_block exit_block_map
,
2514 bitmap blocks_to_copy
, basic_block new_entry
)
2516 tree fndecl
= id
->src_fn
;
2519 /* If this body has a CFG, walk CFG and copy. */
2520 gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (fndecl
)));
2521 body
= copy_cfg_body (id
, count
, frequency_scale
, entry_block_map
, exit_block_map
,
2522 blocks_to_copy
, new_entry
);
2523 copy_debug_stmts (id
);
2528 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
2529 defined in function FN, or of a data member thereof. */
2532 self_inlining_addr_expr (tree value
, tree fn
)
2536 if (TREE_CODE (value
) != ADDR_EXPR
)
2539 var
= get_base_address (TREE_OPERAND (value
, 0));
2541 return var
&& auto_var_in_fn_p (var
, fn
);
2544 /* Append to BB a debug annotation that binds VAR to VALUE, inheriting
2545 lexical block and line number information from base_stmt, if given,
2546 or from the last stmt of the block otherwise. */
2549 insert_init_debug_bind (copy_body_data
*id
,
2550 basic_block bb
, tree var
, tree value
,
2554 gimple_stmt_iterator gsi
;
2557 if (!gimple_in_ssa_p (id
->src_cfun
))
2560 if (!MAY_HAVE_DEBUG_STMTS
)
2563 tracked_var
= target_for_debug_bind (var
);
2569 gsi
= gsi_last_bb (bb
);
2570 if (!base_stmt
&& !gsi_end_p (gsi
))
2571 base_stmt
= gsi_stmt (gsi
);
2574 note
= gimple_build_debug_bind (tracked_var
, value
, base_stmt
);
2578 if (!gsi_end_p (gsi
))
2579 gsi_insert_after (&gsi
, note
, GSI_SAME_STMT
);
2581 gsi_insert_before (&gsi
, note
, GSI_SAME_STMT
);
2588 insert_init_stmt (copy_body_data
*id
, basic_block bb
, gimple init_stmt
)
2590 /* If VAR represents a zero-sized variable, it's possible that the
2591 assignment statement may result in no gimple statements. */
2594 gimple_stmt_iterator si
= gsi_last_bb (bb
);
2596 /* We can end up with init statements that store to a non-register
2597 from a rhs with a conversion. Handle that here by forcing the
2598 rhs into a temporary. gimple_regimplify_operands is not
2599 prepared to do this for us. */
2600 if (!is_gimple_debug (init_stmt
)
2601 && !is_gimple_reg (gimple_assign_lhs (init_stmt
))
2602 && is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (init_stmt
)))
2603 && gimple_assign_rhs_class (init_stmt
) == GIMPLE_UNARY_RHS
)
2605 tree rhs
= build1 (gimple_assign_rhs_code (init_stmt
),
2606 gimple_expr_type (init_stmt
),
2607 gimple_assign_rhs1 (init_stmt
));
2608 rhs
= force_gimple_operand_gsi (&si
, rhs
, true, NULL_TREE
, false,
2610 gimple_assign_set_rhs_code (init_stmt
, TREE_CODE (rhs
));
2611 gimple_assign_set_rhs1 (init_stmt
, rhs
);
2613 gsi_insert_after (&si
, init_stmt
, GSI_NEW_STMT
);
2614 gimple_regimplify_operands (init_stmt
, &si
);
2616 if (!is_gimple_debug (init_stmt
) && MAY_HAVE_DEBUG_STMTS
)
2618 tree def
= gimple_assign_lhs (init_stmt
);
2619 insert_init_debug_bind (id
, bb
, def
, def
, init_stmt
);
2624 /* Initialize parameter P with VALUE. If needed, produce init statement
2625 at the end of BB. When BB is NULL, we return init statement to be
2628 setup_one_parameter (copy_body_data
*id
, tree p
, tree value
, tree fn
,
2629 basic_block bb
, tree
*vars
)
2631 gimple init_stmt
= NULL
;
2634 tree def
= (gimple_in_ssa_p (cfun
)
2635 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
2638 && value
!= error_mark_node
2639 && !useless_type_conversion_p (TREE_TYPE (p
), TREE_TYPE (value
)))
2641 /* If we can match up types by promotion/demotion do so. */
2642 if (fold_convertible_p (TREE_TYPE (p
), value
))
2643 rhs
= fold_convert (TREE_TYPE (p
), value
);
2646 /* ??? For valid programs we should not end up here.
2647 Still if we end up with truly mismatched types here, fall back
2648 to using a VIEW_CONVERT_EXPR or a literal zero to not leak invalid
2649 GIMPLE to the following passes. */
2650 if (!is_gimple_reg_type (TREE_TYPE (value
))
2651 || TYPE_SIZE (TREE_TYPE (p
)) == TYPE_SIZE (TREE_TYPE (value
)))
2652 rhs
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (p
), value
);
2654 rhs
= build_zero_cst (TREE_TYPE (p
));
2658 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
2659 here since the type of this decl must be visible to the calling
2661 var
= copy_decl_to_var (p
, id
);
2663 /* Declare this new variable. */
2664 DECL_CHAIN (var
) = *vars
;
2667 /* Make gimplifier happy about this variable. */
2668 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
2670 /* If the parameter is never assigned to, has no SSA_NAMEs created,
2671 we would not need to create a new variable here at all, if it
2672 weren't for debug info. Still, we can just use the argument
2674 if (TREE_READONLY (p
)
2675 && !TREE_ADDRESSABLE (p
)
2676 && value
&& !TREE_SIDE_EFFECTS (value
)
2679 /* We may produce non-gimple trees by adding NOPs or introduce
2680 invalid sharing when operand is not really constant.
2681 It is not big deal to prohibit constant propagation here as
2682 we will constant propagate in DOM1 pass anyway. */
2683 if (is_gimple_min_invariant (value
)
2684 && useless_type_conversion_p (TREE_TYPE (p
),
2686 /* We have to be very careful about ADDR_EXPR. Make sure
2687 the base variable isn't a local variable of the inlined
2688 function, e.g., when doing recursive inlining, direct or
2689 mutually-recursive or whatever, which is why we don't
2690 just test whether fn == current_function_decl. */
2691 && ! self_inlining_addr_expr (value
, fn
))
2693 insert_decl_map (id
, p
, value
);
2694 insert_debug_decl_map (id
, p
, var
);
2695 return insert_init_debug_bind (id
, bb
, var
, value
, NULL
);
2699 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
2700 that way, when the PARM_DECL is encountered, it will be
2701 automatically replaced by the VAR_DECL. */
2702 insert_decl_map (id
, p
, var
);
2704 /* Even if P was TREE_READONLY, the new VAR should not be.
2705 In the original code, we would have constructed a
2706 temporary, and then the function body would have never
2707 changed the value of P. However, now, we will be
2708 constructing VAR directly. The constructor body may
2709 change its value multiple times as it is being
2710 constructed. Therefore, it must not be TREE_READONLY;
2711 the back-end assumes that TREE_READONLY variable is
2712 assigned to only once. */
2713 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p
)))
2714 TREE_READONLY (var
) = 0;
2716 /* If there is no setup required and we are in SSA, take the easy route
2717 replacing all SSA names representing the function parameter by the
2718 SSA name passed to function.
2720 We need to construct map for the variable anyway as it might be used
2721 in different SSA names when parameter is set in function.
2723 Do replacement at -O0 for const arguments replaced by constant.
2724 This is important for builtin_constant_p and other construct requiring
2725 constant argument to be visible in inlined function body. */
2726 if (gimple_in_ssa_p (cfun
) && rhs
&& def
&& is_gimple_reg (p
)
2728 || (TREE_READONLY (p
)
2729 && is_gimple_min_invariant (rhs
)))
2730 && (TREE_CODE (rhs
) == SSA_NAME
2731 || is_gimple_min_invariant (rhs
))
2732 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
2734 insert_decl_map (id
, def
, rhs
);
2735 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
2738 /* If the value of argument is never used, don't care about initializing
2740 if (optimize
&& gimple_in_ssa_p (cfun
) && !def
&& is_gimple_reg (p
))
2742 gcc_assert (!value
|| !TREE_SIDE_EFFECTS (value
));
2743 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
2746 /* Initialize this VAR_DECL from the equivalent argument. Convert
2747 the argument to the proper type in case it was promoted. */
2750 if (rhs
== error_mark_node
)
2752 insert_decl_map (id
, p
, var
);
2753 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
2756 STRIP_USELESS_TYPE_CONVERSION (rhs
);
2758 /* If we are in SSA form properly remap the default definition
2759 or assign to a dummy SSA name if the parameter is unused and
2760 we are not optimizing. */
2761 if (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
))
2765 def
= remap_ssa_name (def
, id
);
2766 init_stmt
= gimple_build_assign (def
, rhs
);
2767 SSA_NAME_IS_DEFAULT_DEF (def
) = 0;
2768 set_ssa_default_def (cfun
, var
, NULL
);
2772 def
= make_ssa_name (var
, NULL
);
2773 init_stmt
= gimple_build_assign (def
, rhs
);
2777 init_stmt
= gimple_build_assign (var
, rhs
);
2779 if (bb
&& init_stmt
)
2780 insert_init_stmt (id
, bb
, init_stmt
);
2785 /* Generate code to initialize the parameters of the function at the
2786 top of the stack in ID from the GIMPLE_CALL STMT. */
2789 initialize_inlined_parameters (copy_body_data
*id
, gimple stmt
,
2790 tree fn
, basic_block bb
)
2795 tree vars
= NULL_TREE
;
2796 tree static_chain
= gimple_call_chain (stmt
);
2798 /* Figure out what the parameters are. */
2799 parms
= DECL_ARGUMENTS (fn
);
2801 /* Loop through the parameter declarations, replacing each with an
2802 equivalent VAR_DECL, appropriately initialized. */
2803 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
2806 val
= i
< gimple_call_num_args (stmt
) ? gimple_call_arg (stmt
, i
) : NULL
;
2807 setup_one_parameter (id
, p
, val
, fn
, bb
, &vars
);
2809 /* After remapping parameters remap their types. This has to be done
2810 in a second loop over all parameters to appropriately remap
2811 variable sized arrays when the size is specified in a
2812 parameter following the array. */
2813 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
2815 tree
*varp
= (tree
*) pointer_map_contains (id
->decl_map
, p
);
2817 && TREE_CODE (*varp
) == VAR_DECL
)
2819 tree def
= (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
)
2820 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
2822 TREE_TYPE (var
) = remap_type (TREE_TYPE (var
), id
);
2823 /* Also remap the default definition if it was remapped
2824 to the default definition of the parameter replacement
2825 by the parameter setup. */
2828 tree
*defp
= (tree
*) pointer_map_contains (id
->decl_map
, def
);
2830 && TREE_CODE (*defp
) == SSA_NAME
2831 && SSA_NAME_VAR (*defp
) == var
)
2832 TREE_TYPE (*defp
) = TREE_TYPE (var
);
2837 /* Initialize the static chain. */
2838 p
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
2839 gcc_assert (fn
!= current_function_decl
);
2842 /* No static chain? Seems like a bug in tree-nested.c. */
2843 gcc_assert (static_chain
);
2845 setup_one_parameter (id
, p
, static_chain
, fn
, bb
, &vars
);
2848 declare_inline_vars (id
->block
, vars
);
2852 /* Declare a return variable to replace the RESULT_DECL for the
2853 function we are calling. An appropriate DECL_STMT is returned.
2854 The USE_STMT is filled to contain a use of the declaration to
2855 indicate the return value of the function.
2857 RETURN_SLOT, if non-null is place where to store the result. It
2858 is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null,
2859 was the LHS of the MODIFY_EXPR to which this call is the RHS.
2861 The return value is a (possibly null) value that holds the result
2862 as seen by the caller. */
2865 declare_return_variable (copy_body_data
*id
, tree return_slot
, tree modify_dest
,
2866 basic_block entry_bb
)
2868 tree callee
= id
->src_fn
;
2869 tree result
= DECL_RESULT (callee
);
2870 tree callee_type
= TREE_TYPE (result
);
2874 /* Handle type-mismatches in the function declaration return type
2875 vs. the call expression. */
2877 caller_type
= TREE_TYPE (modify_dest
);
2879 caller_type
= TREE_TYPE (TREE_TYPE (callee
));
2881 /* We don't need to do anything for functions that don't return anything. */
2882 if (VOID_TYPE_P (callee_type
))
2885 /* If there was a return slot, then the return value is the
2886 dereferenced address of that object. */
2889 /* The front end shouldn't have used both return_slot and
2890 a modify expression. */
2891 gcc_assert (!modify_dest
);
2892 if (DECL_BY_REFERENCE (result
))
2894 tree return_slot_addr
= build_fold_addr_expr (return_slot
);
2895 STRIP_USELESS_TYPE_CONVERSION (return_slot_addr
);
2897 /* We are going to construct *&return_slot and we can't do that
2898 for variables believed to be not addressable.
2900 FIXME: This check possibly can match, because values returned
2901 via return slot optimization are not believed to have address
2902 taken by alias analysis. */
2903 gcc_assert (TREE_CODE (return_slot
) != SSA_NAME
);
2904 var
= return_slot_addr
;
2909 gcc_assert (TREE_CODE (var
) != SSA_NAME
);
2910 TREE_ADDRESSABLE (var
) |= TREE_ADDRESSABLE (result
);
2912 if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
2913 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
2914 && !DECL_GIMPLE_REG_P (result
)
2916 DECL_GIMPLE_REG_P (var
) = 0;
2921 /* All types requiring non-trivial constructors should have been handled. */
2922 gcc_assert (!TREE_ADDRESSABLE (callee_type
));
2924 /* Attempt to avoid creating a new temporary variable. */
2926 && TREE_CODE (modify_dest
) != SSA_NAME
)
2928 bool use_it
= false;
2930 /* We can't use MODIFY_DEST if there's type promotion involved. */
2931 if (!useless_type_conversion_p (callee_type
, caller_type
))
2934 /* ??? If we're assigning to a variable sized type, then we must
2935 reuse the destination variable, because we've no good way to
2936 create variable sized temporaries at this point. */
2937 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type
)) != INTEGER_CST
)
2940 /* If the callee cannot possibly modify MODIFY_DEST, then we can
2941 reuse it as the result of the call directly. Don't do this if
2942 it would promote MODIFY_DEST to addressable. */
2943 else if (TREE_ADDRESSABLE (result
))
2947 tree base_m
= get_base_address (modify_dest
);
2949 /* If the base isn't a decl, then it's a pointer, and we don't
2950 know where that's going to go. */
2951 if (!DECL_P (base_m
))
2953 else if (is_global_var (base_m
))
2955 else if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
2956 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
2957 && !DECL_GIMPLE_REG_P (result
)
2958 && DECL_GIMPLE_REG_P (base_m
))
2960 else if (!TREE_ADDRESSABLE (base_m
))
2972 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type
)) == INTEGER_CST
);
2974 var
= copy_result_decl_to_var (result
, id
);
2975 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
2977 /* Do not have the rest of GCC warn about this variable as it should
2978 not be visible to the user. */
2979 TREE_NO_WARNING (var
) = 1;
2981 declare_inline_vars (id
->block
, var
);
2983 /* Build the use expr. If the return type of the function was
2984 promoted, convert it back to the expected type. */
2986 if (!useless_type_conversion_p (caller_type
, TREE_TYPE (var
)))
2988 /* If we can match up types by promotion/demotion do so. */
2989 if (fold_convertible_p (caller_type
, var
))
2990 use
= fold_convert (caller_type
, var
);
2993 /* ??? For valid programs we should not end up here.
2994 Still if we end up with truly mismatched types here, fall back
2995 to using a MEM_REF to not leak invalid GIMPLE to the following
2997 /* Prevent var from being written into SSA form. */
2998 if (TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
2999 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
)
3000 DECL_GIMPLE_REG_P (var
) = false;
3001 else if (is_gimple_reg_type (TREE_TYPE (var
)))
3002 TREE_ADDRESSABLE (var
) = true;
3003 use
= fold_build2 (MEM_REF
, caller_type
,
3004 build_fold_addr_expr (var
),
3005 build_int_cst (ptr_type_node
, 0));
3009 STRIP_USELESS_TYPE_CONVERSION (use
);
3011 if (DECL_BY_REFERENCE (result
))
3013 TREE_ADDRESSABLE (var
) = 1;
3014 var
= build_fold_addr_expr (var
);
3018 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
3019 way, when the RESULT_DECL is encountered, it will be
3020 automatically replaced by the VAR_DECL.
3022 When returning by reference, ensure that RESULT_DECL remaps to
3024 if (DECL_BY_REFERENCE (result
)
3025 && !is_gimple_val (var
))
3027 tree temp
= create_tmp_var (TREE_TYPE (result
), "retvalptr");
3028 insert_decl_map (id
, result
, temp
);
3029 /* When RESULT_DECL is in SSA form, we need to remap and initialize
3030 it's default_def SSA_NAME. */
3031 if (gimple_in_ssa_p (id
->src_cfun
)
3032 && is_gimple_reg (result
))
3034 temp
= make_ssa_name (temp
, NULL
);
3035 insert_decl_map (id
, ssa_default_def (id
->src_cfun
, result
), temp
);
3037 insert_init_stmt (id
, entry_bb
, gimple_build_assign (temp
, var
));
3040 insert_decl_map (id
, result
, var
);
3042 /* Remember this so we can ignore it in remap_decls. */
3048 /* Callback through walk_tree. Determine if a DECL_INITIAL makes reference
3049 to a local label. */
3052 has_label_address_in_static_1 (tree
*nodep
, int *walk_subtrees
, void *fnp
)
3055 tree fn
= (tree
) fnp
;
3057 if (TREE_CODE (node
) == LABEL_DECL
&& DECL_CONTEXT (node
) == fn
)
3066 /* Determine if the function can be copied. If so return NULL. If
3067 not return a string describng the reason for failure. */
3070 copy_forbidden (struct function
*fun
, tree fndecl
)
3072 const char *reason
= fun
->cannot_be_copied_reason
;
3076 /* Only examine the function once. */
3077 if (fun
->cannot_be_copied_set
)
3080 /* We cannot copy a function that receives a non-local goto
3081 because we cannot remap the destination label used in the
3082 function that is performing the non-local goto. */
3083 /* ??? Actually, this should be possible, if we work at it.
3084 No doubt there's just a handful of places that simply
3085 assume it doesn't happen and don't substitute properly. */
3086 if (fun
->has_nonlocal_label
)
3088 reason
= G_("function %q+F can never be copied "
3089 "because it receives a non-local goto");
3093 FOR_EACH_LOCAL_DECL (fun
, ix
, decl
)
3094 if (TREE_CODE (decl
) == VAR_DECL
3095 && TREE_STATIC (decl
)
3096 && !DECL_EXTERNAL (decl
)
3097 && DECL_INITIAL (decl
)
3098 && walk_tree_without_duplicates (&DECL_INITIAL (decl
),
3099 has_label_address_in_static_1
,
3102 reason
= G_("function %q+F can never be copied because it saves "
3103 "address of local label in a static variable");
3108 fun
->cannot_be_copied_reason
= reason
;
3109 fun
->cannot_be_copied_set
= true;
3114 static const char *inline_forbidden_reason
;
3116 /* A callback for walk_gimple_seq to handle statements. Returns non-null
3117 iff a function can not be inlined. Also sets the reason why. */
3120 inline_forbidden_p_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
3121 struct walk_stmt_info
*wip
)
3123 tree fn
= (tree
) wip
->info
;
3125 gimple stmt
= gsi_stmt (*gsi
);
3127 switch (gimple_code (stmt
))
3130 /* Refuse to inline alloca call unless user explicitly forced so as
3131 this may change program's memory overhead drastically when the
3132 function using alloca is called in loop. In GCC present in
3133 SPEC2000 inlining into schedule_block cause it to require 2GB of
3134 RAM instead of 256MB. Don't do so for alloca calls emitted for
3135 VLA objects as those can't cause unbounded growth (they're always
3136 wrapped inside stack_save/stack_restore regions. */
3137 if (gimple_alloca_call_p (stmt
)
3138 && !gimple_call_alloca_for_var_p (stmt
)
3139 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
3141 inline_forbidden_reason
3142 = G_("function %q+F can never be inlined because it uses "
3143 "alloca (override using the always_inline attribute)");
3144 *handled_ops_p
= true;
3148 t
= gimple_call_fndecl (stmt
);
3152 /* We cannot inline functions that call setjmp. */
3153 if (setjmp_call_p (t
))
3155 inline_forbidden_reason
3156 = G_("function %q+F can never be inlined because it uses setjmp");
3157 *handled_ops_p
= true;
3161 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
3162 switch (DECL_FUNCTION_CODE (t
))
3164 /* We cannot inline functions that take a variable number of
3166 case BUILT_IN_VA_START
:
3167 case BUILT_IN_NEXT_ARG
:
3168 case BUILT_IN_VA_END
:
3169 inline_forbidden_reason
3170 = G_("function %q+F can never be inlined because it "
3171 "uses variable argument lists");
3172 *handled_ops_p
= true;
3175 case BUILT_IN_LONGJMP
:
3176 /* We can't inline functions that call __builtin_longjmp at
3177 all. The non-local goto machinery really requires the
3178 destination be in a different function. If we allow the
3179 function calling __builtin_longjmp to be inlined into the
3180 function calling __builtin_setjmp, Things will Go Awry. */
3181 inline_forbidden_reason
3182 = G_("function %q+F can never be inlined because "
3183 "it uses setjmp-longjmp exception handling");
3184 *handled_ops_p
= true;
3187 case BUILT_IN_NONLOCAL_GOTO
:
3189 inline_forbidden_reason
3190 = G_("function %q+F can never be inlined because "
3191 "it uses non-local goto");
3192 *handled_ops_p
= true;
3195 case BUILT_IN_RETURN
:
3196 case BUILT_IN_APPLY_ARGS
:
3197 /* If a __builtin_apply_args caller would be inlined,
3198 it would be saving arguments of the function it has
3199 been inlined into. Similarly __builtin_return would
3200 return from the function the inline has been inlined into. */
3201 inline_forbidden_reason
3202 = G_("function %q+F can never be inlined because "
3203 "it uses __builtin_return or __builtin_apply_args");
3204 *handled_ops_p
= true;
3213 t
= gimple_goto_dest (stmt
);
3215 /* We will not inline a function which uses computed goto. The
3216 addresses of its local labels, which may be tucked into
3217 global storage, are of course not constant across
3218 instantiations, which causes unexpected behavior. */
3219 if (TREE_CODE (t
) != LABEL_DECL
)
3221 inline_forbidden_reason
3222 = G_("function %q+F can never be inlined "
3223 "because it contains a computed goto");
3224 *handled_ops_p
= true;
3233 *handled_ops_p
= false;
3237 /* Return true if FNDECL is a function that cannot be inlined into
3241 inline_forbidden_p (tree fndecl
)
3243 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
3244 struct walk_stmt_info wi
;
3245 struct pointer_set_t
*visited_nodes
;
3247 bool forbidden_p
= false;
3249 /* First check for shared reasons not to copy the code. */
3250 inline_forbidden_reason
= copy_forbidden (fun
, fndecl
);
3251 if (inline_forbidden_reason
!= NULL
)
3254 /* Next, walk the statements of the function looking for
3255 constraucts we can't handle, or are non-optimal for inlining. */
3256 visited_nodes
= pointer_set_create ();
3257 memset (&wi
, 0, sizeof (wi
));
3258 wi
.info
= (void *) fndecl
;
3259 wi
.pset
= visited_nodes
;
3261 FOR_EACH_BB_FN (bb
, fun
)
3264 gimple_seq seq
= bb_seq (bb
);
3265 ret
= walk_gimple_seq (seq
, inline_forbidden_p_stmt
, NULL
, &wi
);
3266 forbidden_p
= (ret
!= NULL
);
3271 pointer_set_destroy (visited_nodes
);
3275 /* Return false if the function FNDECL cannot be inlined on account of its
3276 attributes, true otherwise. */
3278 function_attribute_inlinable_p (const_tree fndecl
)
3280 if (targetm
.attribute_table
)
3284 for (a
= DECL_ATTRIBUTES (fndecl
); a
; a
= TREE_CHAIN (a
))
3286 const_tree name
= TREE_PURPOSE (a
);
3289 for (i
= 0; targetm
.attribute_table
[i
].name
!= NULL
; i
++)
3290 if (is_attribute_p (targetm
.attribute_table
[i
].name
, name
))
3291 return targetm
.function_attribute_inlinable_p (fndecl
);
3298 /* Returns nonzero if FN is a function that does not have any
3299 fundamental inline blocking properties. */
3302 tree_inlinable_function_p (tree fn
)
3304 bool inlinable
= true;
3308 /* If we've already decided this function shouldn't be inlined,
3309 there's no need to check again. */
3310 if (DECL_UNINLINABLE (fn
))
3313 /* We only warn for functions declared `inline' by the user. */
3314 do_warning
= (warn_inline
3315 && DECL_DECLARED_INLINE_P (fn
)
3316 && !DECL_NO_INLINE_WARNING_P (fn
)
3317 && !DECL_IN_SYSTEM_HEADER (fn
));
3319 always_inline
= lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
));
3322 && always_inline
== NULL
)
3325 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3326 "is suppressed using -fno-inline", fn
);
3330 else if (!function_attribute_inlinable_p (fn
))
3333 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3334 "uses attributes conflicting with inlining", fn
);
3338 else if (inline_forbidden_p (fn
))
3340 /* See if we should warn about uninlinable functions. Previously,
3341 some of these warnings would be issued while trying to expand
3342 the function inline, but that would cause multiple warnings
3343 about functions that would for example call alloca. But since
3344 this a property of the function, just one warning is enough.
3345 As a bonus we can now give more details about the reason why a
3346 function is not inlinable. */
3348 error (inline_forbidden_reason
, fn
);
3349 else if (do_warning
)
3350 warning (OPT_Winline
, inline_forbidden_reason
, fn
);
3355 /* Squirrel away the result so that we don't have to check again. */
3356 DECL_UNINLINABLE (fn
) = !inlinable
;
3361 /* Estimate the cost of a memory move. Use machine dependent
3362 word size and take possible memcpy call into account. */
3365 estimate_move_cost (tree type
)
3369 gcc_assert (!VOID_TYPE_P (type
));
3371 if (TREE_CODE (type
) == VECTOR_TYPE
)
3373 enum machine_mode inner
= TYPE_MODE (TREE_TYPE (type
));
3374 enum machine_mode simd
3375 = targetm
.vectorize
.preferred_simd_mode (inner
);
3376 int simd_mode_size
= GET_MODE_SIZE (simd
);
3377 return ((GET_MODE_SIZE (TYPE_MODE (type
)) + simd_mode_size
- 1)
3381 size
= int_size_in_bytes (type
);
3383 if (size
< 0 || size
> MOVE_MAX_PIECES
* MOVE_RATIO (!optimize_size
))
3384 /* Cost of a memcpy call, 3 arguments and the call. */
3387 return ((size
+ MOVE_MAX_PIECES
- 1) / MOVE_MAX_PIECES
);
3390 /* Returns cost of operation CODE, according to WEIGHTS */
3393 estimate_operator_cost (enum tree_code code
, eni_weights
*weights
,
3394 tree op1 ATTRIBUTE_UNUSED
, tree op2
)
3398 /* These are "free" conversions, or their presumed cost
3399 is folded into other operations. */
3404 case VIEW_CONVERT_EXPR
:
3407 /* Assign cost of 1 to usual operations.
3408 ??? We may consider mapping RTL costs to this. */
3414 case POINTER_PLUS_EXPR
:
3417 case MULT_HIGHPART_EXPR
:
3420 case ADDR_SPACE_CONVERT_EXPR
:
3421 case FIXED_CONVERT_EXPR
:
3422 case FIX_TRUNC_EXPR
:
3434 case VEC_LSHIFT_EXPR
:
3435 case VEC_RSHIFT_EXPR
:
3442 case TRUTH_ANDIF_EXPR
:
3443 case TRUTH_ORIF_EXPR
:
3444 case TRUTH_AND_EXPR
:
3446 case TRUTH_XOR_EXPR
:
3447 case TRUTH_NOT_EXPR
:
3456 case UNORDERED_EXPR
:
3467 case PREDECREMENT_EXPR
:
3468 case PREINCREMENT_EXPR
:
3469 case POSTDECREMENT_EXPR
:
3470 case POSTINCREMENT_EXPR
:
3472 case REALIGN_LOAD_EXPR
:
3474 case REDUC_MAX_EXPR
:
3475 case REDUC_MIN_EXPR
:
3476 case REDUC_PLUS_EXPR
:
3477 case WIDEN_SUM_EXPR
:
3478 case WIDEN_MULT_EXPR
:
3480 case WIDEN_MULT_PLUS_EXPR
:
3481 case WIDEN_MULT_MINUS_EXPR
:
3482 case WIDEN_LSHIFT_EXPR
:
3484 case VEC_WIDEN_MULT_HI_EXPR
:
3485 case VEC_WIDEN_MULT_LO_EXPR
:
3486 case VEC_WIDEN_MULT_EVEN_EXPR
:
3487 case VEC_WIDEN_MULT_ODD_EXPR
:
3488 case VEC_UNPACK_HI_EXPR
:
3489 case VEC_UNPACK_LO_EXPR
:
3490 case VEC_UNPACK_FLOAT_HI_EXPR
:
3491 case VEC_UNPACK_FLOAT_LO_EXPR
:
3492 case VEC_PACK_TRUNC_EXPR
:
3493 case VEC_PACK_SAT_EXPR
:
3494 case VEC_PACK_FIX_TRUNC_EXPR
:
3495 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3496 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3500 /* Few special cases of expensive operations. This is useful
3501 to avoid inlining on functions having too many of these. */
3502 case TRUNC_DIV_EXPR
:
3504 case FLOOR_DIV_EXPR
:
3505 case ROUND_DIV_EXPR
:
3506 case EXACT_DIV_EXPR
:
3507 case TRUNC_MOD_EXPR
:
3509 case FLOOR_MOD_EXPR
:
3510 case ROUND_MOD_EXPR
:
3512 if (TREE_CODE (op2
) != INTEGER_CST
)
3513 return weights
->div_mod_cost
;
3517 /* We expect a copy assignment with no operator. */
3518 gcc_assert (get_gimple_rhs_class (code
) == GIMPLE_SINGLE_RHS
);
3524 /* Estimate number of instructions that will be created by expanding
3525 the statements in the statement sequence STMTS.
3526 WEIGHTS contains weights attributed to various constructs. */
3529 int estimate_num_insns_seq (gimple_seq stmts
, eni_weights
*weights
)
3532 gimple_stmt_iterator gsi
;
3535 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3536 cost
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
3542 /* Estimate number of instructions that will be created by expanding STMT.
3543 WEIGHTS contains weights attributed to various constructs. */
3546 estimate_num_insns (gimple stmt
, eni_weights
*weights
)
3549 enum gimple_code code
= gimple_code (stmt
);
3556 /* Try to estimate the cost of assignments. We have three cases to
3558 1) Simple assignments to registers;
3559 2) Stores to things that must live in memory. This includes
3560 "normal" stores to scalars, but also assignments of large
3561 structures, or constructors of big arrays;
3563 Let us look at the first two cases, assuming we have "a = b + C":
3564 <GIMPLE_ASSIGN <var_decl "a">
3565 <plus_expr <var_decl "b"> <constant C>>
3566 If "a" is a GIMPLE register, the assignment to it is free on almost
3567 any target, because "a" usually ends up in a real register. Hence
3568 the only cost of this expression comes from the PLUS_EXPR, and we
3569 can ignore the GIMPLE_ASSIGN.
3570 If "a" is not a GIMPLE register, the assignment to "a" will most
3571 likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost
3572 of moving something into "a", which we compute using the function
3573 estimate_move_cost. */
3574 if (gimple_clobber_p (stmt
))
3575 return 0; /* ={v} {CLOBBER} stmt expands to nothing. */
3577 lhs
= gimple_assign_lhs (stmt
);
3578 rhs
= gimple_assign_rhs1 (stmt
);
3582 /* Account for the cost of moving to / from memory. */
3583 if (gimple_store_p (stmt
))
3584 cost
+= estimate_move_cost (TREE_TYPE (lhs
));
3585 if (gimple_assign_load_p (stmt
))
3586 cost
+= estimate_move_cost (TREE_TYPE (rhs
));
3588 cost
+= estimate_operator_cost (gimple_assign_rhs_code (stmt
), weights
,
3589 gimple_assign_rhs1 (stmt
),
3590 get_gimple_rhs_class (gimple_assign_rhs_code (stmt
))
3591 == GIMPLE_BINARY_RHS
3592 ? gimple_assign_rhs2 (stmt
) : NULL
);
3596 cost
= 1 + estimate_operator_cost (gimple_cond_code (stmt
), weights
,
3597 gimple_op (stmt
, 0),
3598 gimple_op (stmt
, 1));
3602 /* Take into account cost of the switch + guess 2 conditional jumps for
3605 TODO: once the switch expansion logic is sufficiently separated, we can
3606 do better job on estimating cost of the switch. */
3607 if (weights
->time_based
)
3608 cost
= floor_log2 (gimple_switch_num_labels (stmt
)) * 2;
3610 cost
= gimple_switch_num_labels (stmt
) * 2;
3615 tree decl
= gimple_call_fndecl (stmt
);
3616 struct cgraph_node
*node
= NULL
;
3618 /* Do not special case builtins where we see the body.
3619 This just confuse inliner. */
3620 if (!decl
|| !(node
= cgraph_get_node (decl
)) || node
->analyzed
)
3622 /* For buitins that are likely expanded to nothing or
3623 inlined do not account operand costs. */
3624 else if (is_simple_builtin (decl
))
3626 else if (is_inexpensive_builtin (decl
))
3627 return weights
->target_builtin_call_cost
;
3628 else if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
3630 /* We canonicalize x * x to pow (x, 2.0) with -ffast-math, so
3631 specialize the cheap expansion we do here.
3632 ??? This asks for a more general solution. */
3633 switch (DECL_FUNCTION_CODE (decl
))
3638 if (TREE_CODE (gimple_call_arg (stmt
, 1)) == REAL_CST
3639 && REAL_VALUES_EQUAL
3640 (TREE_REAL_CST (gimple_call_arg (stmt
, 1)), dconst2
))
3641 return estimate_operator_cost (MULT_EXPR
, weights
,
3642 gimple_call_arg (stmt
, 0),
3643 gimple_call_arg (stmt
, 0));
3651 cost
= node
? weights
->call_cost
: weights
->indirect_call_cost
;
3652 if (gimple_call_lhs (stmt
))
3653 cost
+= estimate_move_cost (TREE_TYPE (gimple_call_lhs (stmt
)));
3654 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
3656 tree arg
= gimple_call_arg (stmt
, i
);
3657 cost
+= estimate_move_cost (TREE_TYPE (arg
));
3663 return weights
->return_cost
;
3669 case GIMPLE_PREDICT
:
3674 return asm_str_count (gimple_asm_string (stmt
));
3677 /* This is either going to be an external function call with one
3678 argument, or two register copy statements plus a goto. */
3681 case GIMPLE_EH_DISPATCH
:
3682 /* ??? This is going to turn into a switch statement. Ideally
3683 we'd have a look at the eh region and estimate the number of
3688 return estimate_num_insns_seq (gimple_bind_body (stmt
), weights
);
3690 case GIMPLE_EH_FILTER
:
3691 return estimate_num_insns_seq (gimple_eh_filter_failure (stmt
), weights
);
3694 return estimate_num_insns_seq (gimple_catch_handler (stmt
), weights
);
3697 return (estimate_num_insns_seq (gimple_try_eval (stmt
), weights
)
3698 + estimate_num_insns_seq (gimple_try_cleanup (stmt
), weights
));
3700 /* OpenMP directives are generally very expensive. */
3702 case GIMPLE_OMP_RETURN
:
3703 case GIMPLE_OMP_SECTIONS_SWITCH
:
3704 case GIMPLE_OMP_ATOMIC_STORE
:
3705 case GIMPLE_OMP_CONTINUE
:
3706 /* ...except these, which are cheap. */
3709 case GIMPLE_OMP_ATOMIC_LOAD
:
3710 return weights
->omp_cost
;
3712 case GIMPLE_OMP_FOR
:
3713 return (weights
->omp_cost
3714 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
)
3715 + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt
), weights
));
3717 case GIMPLE_OMP_PARALLEL
:
3718 case GIMPLE_OMP_TASK
:
3719 case GIMPLE_OMP_CRITICAL
:
3720 case GIMPLE_OMP_MASTER
:
3721 case GIMPLE_OMP_ORDERED
:
3722 case GIMPLE_OMP_SECTION
:
3723 case GIMPLE_OMP_SECTIONS
:
3724 case GIMPLE_OMP_SINGLE
:
3725 return (weights
->omp_cost
3726 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
));
3728 case GIMPLE_TRANSACTION
:
3729 return (weights
->tm_cost
3730 + estimate_num_insns_seq (gimple_transaction_body (stmt
),
3740 /* Estimate number of instructions that will be created by expanding
3741 function FNDECL. WEIGHTS contains weights attributed to various
3745 estimate_num_insns_fn (tree fndecl
, eni_weights
*weights
)
3747 struct function
*my_function
= DECL_STRUCT_FUNCTION (fndecl
);
3748 gimple_stmt_iterator bsi
;
3752 gcc_assert (my_function
&& my_function
->cfg
);
3753 FOR_EACH_BB_FN (bb
, my_function
)
3755 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
3756 n
+= estimate_num_insns (gsi_stmt (bsi
), weights
);
3763 /* Initializes weights used by estimate_num_insns. */
3766 init_inline_once (void)
3768 eni_size_weights
.call_cost
= 1;
3769 eni_size_weights
.indirect_call_cost
= 3;
3770 eni_size_weights
.target_builtin_call_cost
= 1;
3771 eni_size_weights
.div_mod_cost
= 1;
3772 eni_size_weights
.omp_cost
= 40;
3773 eni_size_weights
.tm_cost
= 10;
3774 eni_size_weights
.time_based
= false;
3775 eni_size_weights
.return_cost
= 1;
3777 /* Estimating time for call is difficult, since we have no idea what the
3778 called function does. In the current uses of eni_time_weights,
3779 underestimating the cost does less harm than overestimating it, so
3780 we choose a rather small value here. */
3781 eni_time_weights
.call_cost
= 10;
3782 eni_time_weights
.indirect_call_cost
= 15;
3783 eni_time_weights
.target_builtin_call_cost
= 1;
3784 eni_time_weights
.div_mod_cost
= 10;
3785 eni_time_weights
.omp_cost
= 40;
3786 eni_time_weights
.tm_cost
= 40;
3787 eni_time_weights
.time_based
= true;
3788 eni_time_weights
.return_cost
= 2;
3791 /* Estimate the number of instructions in a gimple_seq. */
3794 count_insns_seq (gimple_seq seq
, eni_weights
*weights
)
3796 gimple_stmt_iterator gsi
;
3798 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3799 n
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
3805 /* Install new lexical TREE_BLOCK underneath 'current_block'. */
3808 prepend_lexical_block (tree current_block
, tree new_block
)
3810 BLOCK_CHAIN (new_block
) = BLOCK_SUBBLOCKS (current_block
);
3811 BLOCK_SUBBLOCKS (current_block
) = new_block
;
3812 BLOCK_SUPERCONTEXT (new_block
) = current_block
;
3815 /* Add local variables from CALLEE to CALLER. */
3818 add_local_variables (struct function
*callee
, struct function
*caller
,
3824 FOR_EACH_LOCAL_DECL (callee
, ix
, var
)
3825 if (!can_be_nonlocal (var
, id
))
3827 tree new_var
= remap_decl (var
, id
);
3829 /* Remap debug-expressions. */
3830 if (TREE_CODE (new_var
) == VAR_DECL
3831 && DECL_HAS_DEBUG_EXPR_P (var
)
3834 tree tem
= DECL_DEBUG_EXPR (var
);
3835 bool old_regimplify
= id
->regimplify
;
3836 id
->remapping_type_depth
++;
3837 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
3838 id
->remapping_type_depth
--;
3839 id
->regimplify
= old_regimplify
;
3840 SET_DECL_DEBUG_EXPR (new_var
, tem
);
3841 DECL_HAS_DEBUG_EXPR_P (new_var
) = 1;
3843 add_local_decl (caller
, new_var
);
3847 /* If STMT is a GIMPLE_CALL, replace it with its inline expansion. */
3850 expand_call_inline (basic_block bb
, gimple stmt
, copy_body_data
*id
)
3854 struct pointer_map_t
*st
, *dst
;
3857 location_t saved_location
;
3858 struct cgraph_edge
*cg_edge
;
3859 cgraph_inline_failed_t reason
;
3860 basic_block return_block
;
3862 gimple_stmt_iterator gsi
, stmt_gsi
;
3863 bool successfully_inlined
= FALSE
;
3864 bool purge_dead_abnormal_edges
;
3866 /* Set input_location here so we get the right instantiation context
3867 if we call instantiate_decl from inlinable_function_p. */
3868 /* FIXME: instantiate_decl isn't called by inlinable_function_p. */
3869 saved_location
= input_location
;
3870 input_location
= gimple_location (stmt
);
3872 /* From here on, we're only interested in CALL_EXPRs. */
3873 if (gimple_code (stmt
) != GIMPLE_CALL
)
3876 cg_edge
= cgraph_edge (id
->dst_node
, stmt
);
3877 gcc_checking_assert (cg_edge
);
3878 /* First, see if we can figure out what function is being called.
3879 If we cannot, then there is no hope of inlining the function. */
3880 if (cg_edge
->indirect_unknown_callee
)
3882 fn
= cg_edge
->callee
->symbol
.decl
;
3883 gcc_checking_assert (fn
);
3885 /* If FN is a declaration of a function in a nested scope that was
3886 globally declared inline, we don't set its DECL_INITIAL.
3887 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
3888 C++ front-end uses it for cdtors to refer to their internal
3889 declarations, that are not real functions. Fortunately those
3890 don't have trees to be saved, so we can tell by checking their
3892 if (!DECL_INITIAL (fn
)
3893 && DECL_ABSTRACT_ORIGIN (fn
)
3894 && gimple_has_body_p (DECL_ABSTRACT_ORIGIN (fn
)))
3895 fn
= DECL_ABSTRACT_ORIGIN (fn
);
3897 /* Don't try to inline functions that are not well-suited to inlining. */
3898 if (cg_edge
->inline_failed
)
3900 reason
= cg_edge
->inline_failed
;
3901 /* If this call was originally indirect, we do not want to emit any
3902 inlining related warnings or sorry messages because there are no
3903 guarantees regarding those. */
3904 if (cg_edge
->indirect_inlining_edge
)
3907 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
))
3908 /* For extern inline functions that get redefined we always
3909 silently ignored always_inline flag. Better behaviour would
3910 be to be able to keep both bodies and use extern inline body
3911 for inlining, but we can't do that because frontends overwrite
3913 && !cg_edge
->callee
->local
.redefined_extern_inline
3914 /* Avoid warnings during early inline pass. */
3915 && cgraph_global_info_ready
3916 /* PR 20090218-1_0.c. Body can be provided by another module. */
3917 && (reason
!= CIF_BODY_NOT_AVAILABLE
|| !flag_generate_lto
))
3919 error ("inlining failed in call to always_inline %q+F: %s", fn
,
3920 cgraph_inline_failed_string (reason
));
3921 error ("called from here");
3923 else if (warn_inline
3924 && DECL_DECLARED_INLINE_P (fn
)
3925 && !DECL_NO_INLINE_WARNING_P (fn
)
3926 && !DECL_IN_SYSTEM_HEADER (fn
)
3927 && reason
!= CIF_UNSPECIFIED
3928 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn
))
3929 /* Do not warn about not inlined recursive calls. */
3930 && !cgraph_edge_recursive_p (cg_edge
)
3931 /* Avoid warnings during early inline pass. */
3932 && cgraph_global_info_ready
)
3934 warning (OPT_Winline
, "inlining failed in call to %q+F: %s",
3935 fn
, _(cgraph_inline_failed_string (reason
)));
3936 warning (OPT_Winline
, "called from here");
3940 fn
= cg_edge
->callee
->symbol
.decl
;
3942 #ifdef ENABLE_CHECKING
3943 if (cg_edge
->callee
->symbol
.decl
!= id
->dst_node
->symbol
.decl
)
3944 verify_cgraph_node (cg_edge
->callee
);
3947 /* We will be inlining this callee. */
3948 id
->eh_lp_nr
= lookup_stmt_eh_lp (stmt
);
3950 /* Update the callers EH personality. */
3951 if (DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->symbol
.decl
))
3952 DECL_FUNCTION_PERSONALITY (cg_edge
->caller
->symbol
.decl
)
3953 = DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->symbol
.decl
);
3955 /* Split the block holding the GIMPLE_CALL. */
3956 e
= split_block (bb
, stmt
);
3958 return_block
= e
->dest
;
3961 /* split_block splits after the statement; work around this by
3962 moving the call into the second block manually. Not pretty,
3963 but seems easier than doing the CFG manipulation by hand
3964 when the GIMPLE_CALL is in the last statement of BB. */
3965 stmt_gsi
= gsi_last_bb (bb
);
3966 gsi_remove (&stmt_gsi
, false);
3968 /* If the GIMPLE_CALL was in the last statement of BB, it may have
3969 been the source of abnormal edges. In this case, schedule
3970 the removal of dead abnormal edges. */
3971 gsi
= gsi_start_bb (return_block
);
3972 if (gsi_end_p (gsi
))
3974 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
3975 purge_dead_abnormal_edges
= true;
3979 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
3980 purge_dead_abnormal_edges
= false;
3983 stmt_gsi
= gsi_start_bb (return_block
);
3985 /* Build a block containing code to initialize the arguments, the
3986 actual inline expansion of the body, and a label for the return
3987 statements within the function to jump to. The type of the
3988 statement expression is the return type of the function call.
3989 ??? If the call does not have an associated block then we will
3990 remap all callee blocks to NULL, effectively dropping most of
3991 its debug information. This should only happen for calls to
3992 artificial decls inserted by the compiler itself. We need to
3993 either link the inlined blocks into the caller block tree or
3994 not refer to them in any way to not break GC for locations. */
3995 if (gimple_block (stmt
))
3997 id
->block
= make_node (BLOCK
);
3998 BLOCK_ABSTRACT_ORIGIN (id
->block
) = fn
;
3999 BLOCK_SOURCE_LOCATION (id
->block
) = LOCATION_LOCUS (input_location
);
4000 prepend_lexical_block (gimple_block (stmt
), id
->block
);
4003 /* Local declarations will be replaced by their equivalents in this
4006 id
->decl_map
= pointer_map_create ();
4007 dst
= id
->debug_map
;
4008 id
->debug_map
= NULL
;
4010 /* Record the function we are about to inline. */
4012 id
->src_node
= cg_edge
->callee
;
4013 id
->src_cfun
= DECL_STRUCT_FUNCTION (fn
);
4014 id
->gimple_call
= stmt
;
4016 gcc_assert (!id
->src_cfun
->after_inlining
);
4019 if (lookup_attribute ("cold", DECL_ATTRIBUTES (fn
)))
4021 gimple_stmt_iterator si
= gsi_last_bb (bb
);
4022 gsi_insert_after (&si
, gimple_build_predict (PRED_COLD_FUNCTION
,
4026 initialize_inlined_parameters (id
, stmt
, fn
, bb
);
4028 if (DECL_INITIAL (fn
))
4030 if (gimple_block (stmt
))
4034 prepend_lexical_block (id
->block
,
4035 remap_blocks (DECL_INITIAL (fn
), id
));
4036 gcc_checking_assert (BLOCK_SUBBLOCKS (id
->block
)
4037 && (BLOCK_CHAIN (BLOCK_SUBBLOCKS (id
->block
))
4039 /* Move vars for PARM_DECLs from DECL_INITIAL block to id->block,
4040 otherwise for DWARF DW_TAG_formal_parameter will not be children of
4041 DW_TAG_inlined_subroutine, but of a DW_TAG_lexical_block
4042 under it. The parameters can be then evaluated in the debugger,
4043 but don't show in backtraces. */
4044 for (var
= &BLOCK_VARS (BLOCK_SUBBLOCKS (id
->block
)); *var
; )
4045 if (TREE_CODE (DECL_ORIGIN (*var
)) == PARM_DECL
)
4048 *var
= TREE_CHAIN (v
);
4049 TREE_CHAIN (v
) = BLOCK_VARS (id
->block
);
4050 BLOCK_VARS (id
->block
) = v
;
4053 var
= &TREE_CHAIN (*var
);
4056 remap_blocks_to_null (DECL_INITIAL (fn
), id
);
4059 /* Return statements in the function body will be replaced by jumps
4060 to the RET_LABEL. */
4061 gcc_assert (DECL_INITIAL (fn
));
4062 gcc_assert (TREE_CODE (DECL_INITIAL (fn
)) == BLOCK
);
4064 /* Find the LHS to which the result of this call is assigned. */
4066 if (gimple_call_lhs (stmt
))
4068 modify_dest
= gimple_call_lhs (stmt
);
4070 /* The function which we are inlining might not return a value,
4071 in which case we should issue a warning that the function
4072 does not return a value. In that case the optimizers will
4073 see that the variable to which the value is assigned was not
4074 initialized. We do not want to issue a warning about that
4075 uninitialized variable. */
4076 if (DECL_P (modify_dest
))
4077 TREE_NO_WARNING (modify_dest
) = 1;
4079 if (gimple_call_return_slot_opt_p (stmt
))
4081 return_slot
= modify_dest
;
4088 /* If we are inlining a call to the C++ operator new, we don't want
4089 to use type based alias analysis on the return value. Otherwise
4090 we may get confused if the compiler sees that the inlined new
4091 function returns a pointer which was just deleted. See bug
4093 if (DECL_IS_OPERATOR_NEW (fn
))
4099 /* Declare the return variable for the function. */
4100 use_retvar
= declare_return_variable (id
, return_slot
, modify_dest
, bb
);
4102 /* Add local vars in this inlined callee to caller. */
4103 add_local_variables (id
->src_cfun
, cfun
, id
);
4105 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4107 fprintf (dump_file
, "Inlining ");
4108 print_generic_expr (dump_file
, id
->src_fn
, 0);
4109 fprintf (dump_file
, " to ");
4110 print_generic_expr (dump_file
, id
->dst_fn
, 0);
4111 fprintf (dump_file
, " with frequency %i\n", cg_edge
->frequency
);
4114 /* This is it. Duplicate the callee body. Assume callee is
4115 pre-gimplified. Note that we must not alter the caller
4116 function in any way before this point, as this CALL_EXPR may be
4117 a self-referential call; if we're calling ourselves, we need to
4118 duplicate our body before altering anything. */
4119 copy_body (id
, bb
->count
,
4120 GCOV_COMPUTE_SCALE (cg_edge
->frequency
, CGRAPH_FREQ_BASE
),
4121 bb
, return_block
, NULL
, NULL
);
4123 /* Reset the escaped solution. */
4124 if (cfun
->gimple_df
)
4125 pt_solution_reset (&cfun
->gimple_df
->escaped
);
4130 pointer_map_destroy (id
->debug_map
);
4131 id
->debug_map
= dst
;
4133 pointer_map_destroy (id
->decl_map
);
4136 /* Unlink the calls virtual operands before replacing it. */
4137 unlink_stmt_vdef (stmt
);
4139 /* If the inlined function returns a result that we care about,
4140 substitute the GIMPLE_CALL with an assignment of the return
4141 variable to the LHS of the call. That is, if STMT was
4142 'a = foo (...)', substitute the call with 'a = USE_RETVAR'. */
4143 if (use_retvar
&& gimple_call_lhs (stmt
))
4145 gimple old_stmt
= stmt
;
4146 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), use_retvar
);
4147 gsi_replace (&stmt_gsi
, stmt
, false);
4148 maybe_clean_or_replace_eh_stmt (old_stmt
, stmt
);
4152 /* Handle the case of inlining a function with no return
4153 statement, which causes the return value to become undefined. */
4154 if (gimple_call_lhs (stmt
)
4155 && TREE_CODE (gimple_call_lhs (stmt
)) == SSA_NAME
)
4157 tree name
= gimple_call_lhs (stmt
);
4158 tree var
= SSA_NAME_VAR (name
);
4159 tree def
= ssa_default_def (cfun
, var
);
4163 /* If the variable is used undefined, make this name
4164 undefined via a move. */
4165 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), def
);
4166 gsi_replace (&stmt_gsi
, stmt
, true);
4170 /* Otherwise make this variable undefined. */
4171 gsi_remove (&stmt_gsi
, true);
4172 set_ssa_default_def (cfun
, var
, name
);
4173 SSA_NAME_DEF_STMT (name
) = gimple_build_nop ();
4177 gsi_remove (&stmt_gsi
, true);
4180 if (purge_dead_abnormal_edges
)
4182 gimple_purge_dead_eh_edges (return_block
);
4183 gimple_purge_dead_abnormal_call_edges (return_block
);
4186 /* If the value of the new expression is ignored, that's OK. We
4187 don't warn about this for CALL_EXPRs, so we shouldn't warn about
4188 the equivalent inlined version either. */
4189 if (is_gimple_assign (stmt
))
4191 gcc_assert (gimple_assign_single_p (stmt
)
4192 || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
)));
4193 TREE_USED (gimple_assign_rhs1 (stmt
)) = 1;
4196 /* Output the inlining info for this abstract function, since it has been
4197 inlined. If we don't do this now, we can lose the information about the
4198 variables in the function when the blocks get blown away as soon as we
4199 remove the cgraph node. */
4200 if (gimple_block (stmt
))
4201 (*debug_hooks
->outlining_inline_function
) (cg_edge
->callee
->symbol
.decl
);
4203 /* Update callgraph if needed. */
4204 cgraph_remove_node (cg_edge
->callee
);
4206 id
->block
= NULL_TREE
;
4207 successfully_inlined
= TRUE
;
4210 input_location
= saved_location
;
4211 return successfully_inlined
;
4214 /* Expand call statements reachable from STMT_P.
4215 We can only have CALL_EXPRs as the "toplevel" tree code or nested
4216 in a MODIFY_EXPR. */
4219 gimple_expand_calls_inline (basic_block bb
, copy_body_data
*id
)
4221 gimple_stmt_iterator gsi
;
4223 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4225 gimple stmt
= gsi_stmt (gsi
);
4227 if (is_gimple_call (stmt
)
4228 && expand_call_inline (bb
, stmt
, id
))
4236 /* Walk all basic blocks created after FIRST and try to fold every statement
4237 in the STATEMENTS pointer set. */
4240 fold_marked_statements (int first
, struct pointer_set_t
*statements
)
4242 for (; first
< n_basic_blocks
; first
++)
4243 if (BASIC_BLOCK (first
))
4245 gimple_stmt_iterator gsi
;
4247 for (gsi
= gsi_start_bb (BASIC_BLOCK (first
));
4250 if (pointer_set_contains (statements
, gsi_stmt (gsi
)))
4252 gimple old_stmt
= gsi_stmt (gsi
);
4253 tree old_decl
= is_gimple_call (old_stmt
) ? gimple_call_fndecl (old_stmt
) : 0;
4255 if (old_decl
&& DECL_BUILT_IN (old_decl
))
4257 /* Folding builtins can create multiple instructions,
4258 we need to look at all of them. */
4259 gimple_stmt_iterator i2
= gsi
;
4261 if (fold_stmt (&gsi
))
4264 /* If a builtin at the end of a bb folded into nothing,
4265 the following loop won't work. */
4266 if (gsi_end_p (gsi
))
4268 cgraph_update_edges_for_call_stmt (old_stmt
,
4273 i2
= gsi_start_bb (BASIC_BLOCK (first
));
4278 new_stmt
= gsi_stmt (i2
);
4279 update_stmt (new_stmt
);
4280 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4283 if (new_stmt
== gsi_stmt (gsi
))
4285 /* It is okay to check only for the very last
4286 of these statements. If it is a throwing
4287 statement nothing will change. If it isn't
4288 this can remove EH edges. If that weren't
4289 correct then because some intermediate stmts
4290 throw, but not the last one. That would mean
4291 we'd have to split the block, which we can't
4292 here and we'd loose anyway. And as builtins
4293 probably never throw, this all
4295 if (maybe_clean_or_replace_eh_stmt (old_stmt
,
4297 gimple_purge_dead_eh_edges (BASIC_BLOCK (first
));
4304 else if (fold_stmt (&gsi
))
4306 /* Re-read the statement from GSI as fold_stmt() may
4308 gimple new_stmt
= gsi_stmt (gsi
);
4309 update_stmt (new_stmt
);
4311 if (is_gimple_call (old_stmt
)
4312 || is_gimple_call (new_stmt
))
4313 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4316 if (maybe_clean_or_replace_eh_stmt (old_stmt
, new_stmt
))
4317 gimple_purge_dead_eh_edges (BASIC_BLOCK (first
));
4323 /* Return true if BB has at least one abnormal outgoing edge. */
4326 has_abnormal_outgoing_edge_p (basic_block bb
)
4331 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
4332 if (e
->flags
& EDGE_ABNORMAL
)
4338 /* Expand calls to inline functions in the body of FN. */
4341 optimize_inline_calls (tree fn
)
4345 int last
= n_basic_blocks
;
4346 struct gimplify_ctx gctx
;
4347 bool inlined_p
= false;
4350 memset (&id
, 0, sizeof (id
));
4352 id
.src_node
= id
.dst_node
= cgraph_get_node (fn
);
4353 gcc_assert (id
.dst_node
->analyzed
);
4355 /* Or any functions that aren't finished yet. */
4356 if (current_function_decl
)
4357 id
.dst_fn
= current_function_decl
;
4359 id
.copy_decl
= copy_decl_maybe_to_var
;
4360 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
4361 id
.transform_new_cfg
= false;
4362 id
.transform_return_to_modify
= true;
4363 id
.transform_lang_insert_block
= NULL
;
4364 id
.statements_to_fold
= pointer_set_create ();
4366 push_gimplify_context (&gctx
);
4368 /* We make no attempts to keep dominance info up-to-date. */
4369 free_dominance_info (CDI_DOMINATORS
);
4370 free_dominance_info (CDI_POST_DOMINATORS
);
4372 /* Register specific gimple functions. */
4373 gimple_register_cfg_hooks ();
4375 /* Reach the trees by walking over the CFG, and note the
4376 enclosing basic-blocks in the call edges. */
4377 /* We walk the blocks going forward, because inlined function bodies
4378 will split id->current_basic_block, and the new blocks will
4379 follow it; we'll trudge through them, processing their CALL_EXPRs
4382 inlined_p
|= gimple_expand_calls_inline (bb
, &id
);
4384 pop_gimplify_context (NULL
);
4386 #ifdef ENABLE_CHECKING
4388 struct cgraph_edge
*e
;
4390 verify_cgraph_node (id
.dst_node
);
4392 /* Double check that we inlined everything we are supposed to inline. */
4393 for (e
= id
.dst_node
->callees
; e
; e
= e
->next_callee
)
4394 gcc_assert (e
->inline_failed
);
4398 /* Fold queued statements. */
4399 fold_marked_statements (last
, id
.statements_to_fold
);
4400 pointer_set_destroy (id
.statements_to_fold
);
4402 gcc_assert (!id
.debug_stmts
.exists ());
4404 /* If we didn't inline into the function there is nothing to do. */
4408 /* Renumber the lexical scoping (non-code) blocks consecutively. */
4411 delete_unreachable_blocks_update_callgraph (&id
);
4412 #ifdef ENABLE_CHECKING
4413 verify_cgraph_node (id
.dst_node
);
4416 /* It would be nice to check SSA/CFG/statement consistency here, but it is
4417 not possible yet - the IPA passes might make various functions to not
4418 throw and they don't care to proactively update local EH info. This is
4419 done later in fixup_cfg pass that also execute the verification. */
4420 return (TODO_update_ssa
4422 | (gimple_in_ssa_p (cfun
) ? TODO_remove_unused_locals
: 0)
4423 | (gimple_in_ssa_p (cfun
) ? TODO_update_address_taken
: 0)
4424 | (profile_status
!= PROFILE_ABSENT
? TODO_rebuild_frequencies
: 0));
4427 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
4430 copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
4432 enum tree_code code
= TREE_CODE (*tp
);
4433 enum tree_code_class cl
= TREE_CODE_CLASS (code
);
4435 /* We make copies of most nodes. */
4436 if (IS_EXPR_CODE_CLASS (cl
)
4437 || code
== TREE_LIST
4439 || code
== TYPE_DECL
4440 || code
== OMP_CLAUSE
)
4442 /* Because the chain gets clobbered when we make a copy, we save it
4444 tree chain
= NULL_TREE
, new_tree
;
4446 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
4447 chain
= TREE_CHAIN (*tp
);
4449 /* Copy the node. */
4450 new_tree
= copy_node (*tp
);
4452 /* Propagate mudflap marked-ness. */
4453 if (flag_mudflap
&& mf_marked_p (*tp
))
4458 /* Now, restore the chain, if appropriate. That will cause
4459 walk_tree to walk into the chain as well. */
4460 if (code
== PARM_DECL
4461 || code
== TREE_LIST
4462 || code
== OMP_CLAUSE
)
4463 TREE_CHAIN (*tp
) = chain
;
4465 /* For now, we don't update BLOCKs when we make copies. So, we
4466 have to nullify all BIND_EXPRs. */
4467 if (TREE_CODE (*tp
) == BIND_EXPR
)
4468 BIND_EXPR_BLOCK (*tp
) = NULL_TREE
;
4470 else if (code
== CONSTRUCTOR
)
4472 /* CONSTRUCTOR nodes need special handling because
4473 we need to duplicate the vector of elements. */
4476 new_tree
= copy_node (*tp
);
4478 /* Propagate mudflap marked-ness. */
4479 if (flag_mudflap
&& mf_marked_p (*tp
))
4482 CONSTRUCTOR_ELTS (new_tree
) = vec_safe_copy (CONSTRUCTOR_ELTS (*tp
));
4485 else if (code
== STATEMENT_LIST
)
4486 /* We used to just abort on STATEMENT_LIST, but we can run into them
4487 with statement-expressions (c++/40975). */
4488 copy_statement_list (tp
);
4489 else if (TREE_CODE_CLASS (code
) == tcc_type
)
4491 else if (TREE_CODE_CLASS (code
) == tcc_declaration
)
4493 else if (TREE_CODE_CLASS (code
) == tcc_constant
)
4498 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
4499 information indicating to what new SAVE_EXPR this one should be mapped,
4500 use that one. Otherwise, create a new node and enter it in ST. FN is
4501 the function into which the copy will be placed. */
4504 remap_save_expr (tree
*tp
, void *st_
, int *walk_subtrees
)
4506 struct pointer_map_t
*st
= (struct pointer_map_t
*) st_
;
4510 /* See if we already encountered this SAVE_EXPR. */
4511 n
= (tree
*) pointer_map_contains (st
, *tp
);
4513 /* If we didn't already remap this SAVE_EXPR, do so now. */
4516 t
= copy_node (*tp
);
4518 /* Remember this SAVE_EXPR. */
4519 *pointer_map_insert (st
, *tp
) = t
;
4520 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
4521 *pointer_map_insert (st
, t
) = t
;
4525 /* We've already walked into this SAVE_EXPR; don't do it again. */
4530 /* Replace this SAVE_EXPR with the copy. */
4534 /* Called via walk_gimple_seq. If *GSIP points to a GIMPLE_LABEL for a local
4535 label, copies the declaration and enters it in the splay_tree in DATA (which
4536 is really a 'copy_body_data *'. */
4539 mark_local_labels_stmt (gimple_stmt_iterator
*gsip
,
4540 bool *handled_ops_p ATTRIBUTE_UNUSED
,
4541 struct walk_stmt_info
*wi
)
4543 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4544 gimple stmt
= gsi_stmt (*gsip
);
4546 if (gimple_code (stmt
) == GIMPLE_LABEL
)
4548 tree decl
= gimple_label_label (stmt
);
4550 /* Copy the decl and remember the copy. */
4551 insert_decl_map (id
, decl
, id
->copy_decl (decl
, id
));
4558 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
4559 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
4560 remaps all local declarations to appropriate replacements in gimple
4564 replace_locals_op (tree
*tp
, int *walk_subtrees
, void *data
)
4566 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
4567 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4568 struct pointer_map_t
*st
= id
->decl_map
;
4572 /* Only a local declaration (variable or label). */
4573 if ((TREE_CODE (expr
) == VAR_DECL
4574 && !TREE_STATIC (expr
))
4575 || TREE_CODE (expr
) == LABEL_DECL
)
4577 /* Lookup the declaration. */
4578 n
= (tree
*) pointer_map_contains (st
, expr
);
4580 /* If it's there, remap it. */
4585 else if (TREE_CODE (expr
) == STATEMENT_LIST
4586 || TREE_CODE (expr
) == BIND_EXPR
4587 || TREE_CODE (expr
) == SAVE_EXPR
)
4589 else if (TREE_CODE (expr
) == TARGET_EXPR
)
4591 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
4592 It's OK for this to happen if it was part of a subtree that
4593 isn't immediately expanded, such as operand 2 of another
4595 if (!TREE_OPERAND (expr
, 1))
4597 TREE_OPERAND (expr
, 1) = TREE_OPERAND (expr
, 3);
4598 TREE_OPERAND (expr
, 3) = NULL_TREE
;
4602 /* Keep iterating. */
4607 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
4608 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
4609 remaps all local declarations to appropriate replacements in gimple
4613 replace_locals_stmt (gimple_stmt_iterator
*gsip
,
4614 bool *handled_ops_p ATTRIBUTE_UNUSED
,
4615 struct walk_stmt_info
*wi
)
4617 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4618 gimple stmt
= gsi_stmt (*gsip
);
4620 if (gimple_code (stmt
) == GIMPLE_BIND
)
4622 tree block
= gimple_bind_block (stmt
);
4626 remap_block (&block
, id
);
4627 gimple_bind_set_block (stmt
, block
);
4630 /* This will remap a lot of the same decls again, but this should be
4632 if (gimple_bind_vars (stmt
))
4633 gimple_bind_set_vars (stmt
, remap_decls (gimple_bind_vars (stmt
),
4637 /* Keep iterating. */
4642 /* Copies everything in SEQ and replaces variables and labels local to
4643 current_function_decl. */
4646 copy_gimple_seq_and_replace_locals (gimple_seq seq
)
4649 struct walk_stmt_info wi
;
4650 struct pointer_set_t
*visited
;
4653 /* There's nothing to do for NULL_TREE. */
4658 memset (&id
, 0, sizeof (id
));
4659 id
.src_fn
= current_function_decl
;
4660 id
.dst_fn
= current_function_decl
;
4661 id
.decl_map
= pointer_map_create ();
4662 id
.debug_map
= NULL
;
4664 id
.copy_decl
= copy_decl_no_change
;
4665 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
4666 id
.transform_new_cfg
= false;
4667 id
.transform_return_to_modify
= false;
4668 id
.transform_lang_insert_block
= NULL
;
4670 /* Walk the tree once to find local labels. */
4671 memset (&wi
, 0, sizeof (wi
));
4672 visited
= pointer_set_create ();
4675 walk_gimple_seq (seq
, mark_local_labels_stmt
, NULL
, &wi
);
4676 pointer_set_destroy (visited
);
4678 copy
= gimple_seq_copy (seq
);
4680 /* Walk the copy, remapping decls. */
4681 memset (&wi
, 0, sizeof (wi
));
4683 walk_gimple_seq (copy
, replace_locals_stmt
, replace_locals_op
, &wi
);
4686 pointer_map_destroy (id
.decl_map
);
4688 pointer_map_destroy (id
.debug_map
);
4694 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
4697 debug_find_tree_1 (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
, void *data
)
4706 debug_find_tree (tree top
, tree search
)
4708 return walk_tree_without_duplicates (&top
, debug_find_tree_1
, search
) != 0;
4712 /* Declare the variables created by the inliner. Add all the variables in
4713 VARS to BIND_EXPR. */
4716 declare_inline_vars (tree block
, tree vars
)
4719 for (t
= vars
; t
; t
= DECL_CHAIN (t
))
4721 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
4722 gcc_assert (!TREE_STATIC (t
) && !TREE_ASM_WRITTEN (t
));
4723 add_local_decl (cfun
, t
);
4727 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), vars
);
4730 /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN,
4731 but now it will be in the TO_FN. PARM_TO_VAR means enable PARM_DECL to
4732 VAR_DECL translation. */
4735 copy_decl_for_dup_finish (copy_body_data
*id
, tree decl
, tree copy
)
4737 /* Don't generate debug information for the copy if we wouldn't have
4738 generated it for the copy either. */
4739 DECL_ARTIFICIAL (copy
) = DECL_ARTIFICIAL (decl
);
4740 DECL_IGNORED_P (copy
) = DECL_IGNORED_P (decl
);
4742 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
4743 declaration inspired this copy. */
4744 DECL_ABSTRACT_ORIGIN (copy
) = DECL_ORIGIN (decl
);
4746 /* The new variable/label has no RTL, yet. */
4747 if (CODE_CONTAINS_STRUCT (TREE_CODE (copy
), TS_DECL_WRTL
)
4748 && !TREE_STATIC (copy
) && !DECL_EXTERNAL (copy
))
4749 SET_DECL_RTL (copy
, 0);
4751 /* These args would always appear unused, if not for this. */
4752 TREE_USED (copy
) = 1;
4754 /* Set the context for the new declaration. */
4755 if (!DECL_CONTEXT (decl
))
4756 /* Globals stay global. */
4758 else if (DECL_CONTEXT (decl
) != id
->src_fn
)
4759 /* Things that weren't in the scope of the function we're inlining
4760 from aren't in the scope we're inlining to, either. */
4762 else if (TREE_STATIC (decl
))
4763 /* Function-scoped static variables should stay in the original
4767 /* Ordinary automatic local variables are now in the scope of the
4769 DECL_CONTEXT (copy
) = id
->dst_fn
;
4775 copy_decl_to_var (tree decl
, copy_body_data
*id
)
4779 gcc_assert (TREE_CODE (decl
) == PARM_DECL
4780 || TREE_CODE (decl
) == RESULT_DECL
);
4782 type
= TREE_TYPE (decl
);
4784 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
4785 VAR_DECL
, DECL_NAME (decl
), type
);
4786 if (DECL_PT_UID_SET_P (decl
))
4787 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
4788 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
4789 TREE_READONLY (copy
) = TREE_READONLY (decl
);
4790 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
4791 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
4793 return copy_decl_for_dup_finish (id
, decl
, copy
);
4796 /* Like copy_decl_to_var, but create a return slot object instead of a
4797 pointer variable for return by invisible reference. */
4800 copy_result_decl_to_var (tree decl
, copy_body_data
*id
)
4804 gcc_assert (TREE_CODE (decl
) == PARM_DECL
4805 || TREE_CODE (decl
) == RESULT_DECL
);
4807 type
= TREE_TYPE (decl
);
4808 if (DECL_BY_REFERENCE (decl
))
4809 type
= TREE_TYPE (type
);
4811 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
4812 VAR_DECL
, DECL_NAME (decl
), type
);
4813 if (DECL_PT_UID_SET_P (decl
))
4814 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
4815 TREE_READONLY (copy
) = TREE_READONLY (decl
);
4816 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
4817 if (!DECL_BY_REFERENCE (decl
))
4819 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
4820 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
4823 return copy_decl_for_dup_finish (id
, decl
, copy
);
4827 copy_decl_no_change (tree decl
, copy_body_data
*id
)
4831 copy
= copy_node (decl
);
4833 /* The COPY is not abstract; it will be generated in DST_FN. */
4834 DECL_ABSTRACT (copy
) = 0;
4835 lang_hooks
.dup_lang_specific_decl (copy
);
4837 /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
4838 been taken; it's for internal bookkeeping in expand_goto_internal. */
4839 if (TREE_CODE (copy
) == LABEL_DECL
)
4841 TREE_ADDRESSABLE (copy
) = 0;
4842 LABEL_DECL_UID (copy
) = -1;
4845 return copy_decl_for_dup_finish (id
, decl
, copy
);
4849 copy_decl_maybe_to_var (tree decl
, copy_body_data
*id
)
4851 if (TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
)
4852 return copy_decl_to_var (decl
, id
);
4854 return copy_decl_no_change (decl
, id
);
4857 /* Return a copy of the function's argument tree. */
4859 copy_arguments_for_versioning (tree orig_parm
, copy_body_data
* id
,
4860 bitmap args_to_skip
, tree
*vars
)
4863 tree new_parm
= NULL
;
4868 for (arg
= orig_parm
; arg
; arg
= DECL_CHAIN (arg
), i
++)
4869 if (!args_to_skip
|| !bitmap_bit_p (args_to_skip
, i
))
4871 tree new_tree
= remap_decl (arg
, id
);
4872 if (TREE_CODE (new_tree
) != PARM_DECL
)
4873 new_tree
= id
->copy_decl (arg
, id
);
4874 lang_hooks
.dup_lang_specific_decl (new_tree
);
4876 parg
= &DECL_CHAIN (new_tree
);
4878 else if (!pointer_map_contains (id
->decl_map
, arg
))
4880 /* Make an equivalent VAR_DECL. If the argument was used
4881 as temporary variable later in function, the uses will be
4882 replaced by local variable. */
4883 tree var
= copy_decl_to_var (arg
, id
);
4884 insert_decl_map (id
, arg
, var
);
4885 /* Declare this new variable. */
4886 DECL_CHAIN (var
) = *vars
;
4892 /* Return a copy of the function's static chain. */
4894 copy_static_chain (tree static_chain
, copy_body_data
* id
)
4896 tree
*chain_copy
, *pvar
;
4898 chain_copy
= &static_chain
;
4899 for (pvar
= chain_copy
; *pvar
; pvar
= &DECL_CHAIN (*pvar
))
4901 tree new_tree
= remap_decl (*pvar
, id
);
4902 lang_hooks
.dup_lang_specific_decl (new_tree
);
4903 DECL_CHAIN (new_tree
) = DECL_CHAIN (*pvar
);
4906 return static_chain
;
4909 /* Return true if the function is allowed to be versioned.
4910 This is a guard for the versioning functionality. */
4913 tree_versionable_function_p (tree fndecl
)
4915 return (!lookup_attribute ("noclone", DECL_ATTRIBUTES (fndecl
))
4916 && copy_forbidden (DECL_STRUCT_FUNCTION (fndecl
), fndecl
) == NULL
);
4919 /* Delete all unreachable basic blocks and update callgraph.
4920 Doing so is somewhat nontrivial because we need to update all clones and
4921 remove inline function that become unreachable. */
4924 delete_unreachable_blocks_update_callgraph (copy_body_data
*id
)
4926 bool changed
= false;
4927 basic_block b
, next_bb
;
4929 find_unreachable_blocks ();
4931 /* Delete all unreachable basic blocks. */
4933 for (b
= ENTRY_BLOCK_PTR
->next_bb
; b
!= EXIT_BLOCK_PTR
; b
= next_bb
)
4935 next_bb
= b
->next_bb
;
4937 if (!(b
->flags
& BB_REACHABLE
))
4939 gimple_stmt_iterator bsi
;
4941 for (bsi
= gsi_start_bb (b
); !gsi_end_p (bsi
); gsi_next (&bsi
))
4942 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
)
4944 struct cgraph_edge
*e
;
4945 struct cgraph_node
*node
;
4947 if ((e
= cgraph_edge (id
->dst_node
, gsi_stmt (bsi
))) != NULL
)
4949 if (!e
->inline_failed
)
4950 cgraph_remove_node_and_inline_clones (e
->callee
, id
->dst_node
);
4952 cgraph_remove_edge (e
);
4954 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
4955 && id
->dst_node
->clones
)
4956 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
4958 if ((e
= cgraph_edge (node
, gsi_stmt (bsi
))) != NULL
)
4960 if (!e
->inline_failed
)
4961 cgraph_remove_node_and_inline_clones (e
->callee
, id
->dst_node
);
4963 cgraph_remove_edge (e
);
4967 node
= node
->clones
;
4968 else if (node
->next_sibling_clone
)
4969 node
= node
->next_sibling_clone
;
4972 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
4973 node
= node
->clone_of
;
4974 if (node
!= id
->dst_node
)
4975 node
= node
->next_sibling_clone
;
4979 delete_basic_block (b
);
4987 /* Update clone info after duplication. */
4990 update_clone_info (copy_body_data
* id
)
4992 struct cgraph_node
*node
;
4993 if (!id
->dst_node
->clones
)
4995 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
4997 /* First update replace maps to match the new body. */
4998 if (node
->clone
.tree_map
)
5001 for (i
= 0; i
< vec_safe_length (node
->clone
.tree_map
); i
++)
5003 struct ipa_replace_map
*replace_info
;
5004 replace_info
= (*node
->clone
.tree_map
)[i
];
5005 walk_tree (&replace_info
->old_tree
, copy_tree_body_r
, id
, NULL
);
5006 walk_tree (&replace_info
->new_tree
, copy_tree_body_r
, id
, NULL
);
5010 node
= node
->clones
;
5011 else if (node
->next_sibling_clone
)
5012 node
= node
->next_sibling_clone
;
5015 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5016 node
= node
->clone_of
;
5017 if (node
!= id
->dst_node
)
5018 node
= node
->next_sibling_clone
;
5023 /* Create a copy of a function's tree.
5024 OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
5025 of the original function and the new copied function
5026 respectively. In case we want to replace a DECL
5027 tree with another tree while duplicating the function's
5028 body, TREE_MAP represents the mapping between these
5029 trees. If UPDATE_CLONES is set, the call_stmt fields
5030 of edges of clones of the function will be updated.
5032 If non-NULL ARGS_TO_SKIP determine function parameters to remove
5034 If SKIP_RETURN is true, the new version will return void.
5035 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
5036 If non_NULL NEW_ENTRY determine new entry BB of the clone.
5039 tree_function_versioning (tree old_decl
, tree new_decl
,
5040 vec
<ipa_replace_map_p
, va_gc
> *tree_map
,
5041 bool update_clones
, bitmap args_to_skip
,
5042 bool skip_return
, bitmap blocks_to_copy
,
5043 basic_block new_entry
)
5045 struct cgraph_node
*old_version_node
;
5046 struct cgraph_node
*new_version_node
;
5050 struct ipa_replace_map
*replace_info
;
5051 basic_block old_entry_block
, bb
;
5052 vec
<gimple
> init_stmts
;
5053 init_stmts
.create (10);
5054 tree vars
= NULL_TREE
;
5056 gcc_assert (TREE_CODE (old_decl
) == FUNCTION_DECL
5057 && TREE_CODE (new_decl
) == FUNCTION_DECL
);
5058 DECL_POSSIBLY_INLINED (old_decl
) = 1;
5060 old_version_node
= cgraph_get_node (old_decl
);
5061 gcc_checking_assert (old_version_node
);
5062 new_version_node
= cgraph_get_node (new_decl
);
5063 gcc_checking_assert (new_version_node
);
5065 /* Copy over debug args. */
5066 if (DECL_HAS_DEBUG_ARGS_P (old_decl
))
5068 vec
<tree
, va_gc
> **new_debug_args
, **old_debug_args
;
5069 gcc_checking_assert (decl_debug_args_lookup (new_decl
) == NULL
);
5070 DECL_HAS_DEBUG_ARGS_P (new_decl
) = 0;
5071 old_debug_args
= decl_debug_args_lookup (old_decl
);
5074 new_debug_args
= decl_debug_args_insert (new_decl
);
5075 *new_debug_args
= vec_safe_copy (*old_debug_args
);
5079 /* Output the inlining info for this abstract function, since it has been
5080 inlined. If we don't do this now, we can lose the information about the
5081 variables in the function when the blocks get blown away as soon as we
5082 remove the cgraph node. */
5083 (*debug_hooks
->outlining_inline_function
) (old_decl
);
5085 DECL_ARTIFICIAL (new_decl
) = 1;
5086 DECL_ABSTRACT_ORIGIN (new_decl
) = DECL_ORIGIN (old_decl
);
5087 DECL_FUNCTION_PERSONALITY (new_decl
) = DECL_FUNCTION_PERSONALITY (old_decl
);
5089 /* Prepare the data structures for the tree copy. */
5090 memset (&id
, 0, sizeof (id
));
5092 /* Generate a new name for the new version. */
5093 id
.statements_to_fold
= pointer_set_create ();
5095 id
.decl_map
= pointer_map_create ();
5096 id
.debug_map
= NULL
;
5097 id
.src_fn
= old_decl
;
5098 id
.dst_fn
= new_decl
;
5099 id
.src_node
= old_version_node
;
5100 id
.dst_node
= new_version_node
;
5101 id
.src_cfun
= DECL_STRUCT_FUNCTION (old_decl
);
5102 if (id
.src_node
->ipa_transforms_to_apply
.exists ())
5104 vec
<ipa_opt_pass
> old_transforms_to_apply
5105 = id
.dst_node
->ipa_transforms_to_apply
;
5108 id
.dst_node
->ipa_transforms_to_apply
5109 = id
.src_node
->ipa_transforms_to_apply
.copy ();
5110 for (i
= 0; i
< old_transforms_to_apply
.length (); i
++)
5111 id
.dst_node
->ipa_transforms_to_apply
.safe_push (old_transforms_to_apply
[i
]);
5112 old_transforms_to_apply
.release ();
5115 id
.copy_decl
= copy_decl_no_change
;
5116 id
.transform_call_graph_edges
5117 = update_clones
? CB_CGE_MOVE_CLONES
: CB_CGE_MOVE
;
5118 id
.transform_new_cfg
= true;
5119 id
.transform_return_to_modify
= false;
5120 id
.transform_lang_insert_block
= NULL
;
5122 old_entry_block
= ENTRY_BLOCK_PTR_FOR_FUNCTION
5123 (DECL_STRUCT_FUNCTION (old_decl
));
5124 initialize_cfun (new_decl
, old_decl
,
5125 old_entry_block
->count
);
5126 DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
->ipa_pta
5127 = id
.src_cfun
->gimple_df
->ipa_pta
;
5129 /* Copy the function's static chain. */
5130 p
= DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
;
5132 DECL_STRUCT_FUNCTION (new_decl
)->static_chain_decl
=
5133 copy_static_chain (DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
,
5136 /* If there's a tree_map, prepare for substitution. */
5138 for (i
= 0; i
< tree_map
->length (); i
++)
5141 replace_info
= (*tree_map
)[i
];
5142 if (replace_info
->replace_p
)
5144 if (!replace_info
->old_tree
)
5146 int i
= replace_info
->parm_num
;
5148 for (parm
= DECL_ARGUMENTS (old_decl
); i
; parm
= DECL_CHAIN (parm
))
5150 replace_info
->old_tree
= parm
;
5152 gcc_assert (TREE_CODE (replace_info
->old_tree
) == PARM_DECL
);
5153 init
= setup_one_parameter (&id
, replace_info
->old_tree
,
5154 replace_info
->new_tree
, id
.src_fn
,
5158 init_stmts
.safe_push (init
);
5161 /* Copy the function's arguments. */
5162 if (DECL_ARGUMENTS (old_decl
) != NULL_TREE
)
5163 DECL_ARGUMENTS (new_decl
) =
5164 copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl
), &id
,
5165 args_to_skip
, &vars
);
5167 DECL_INITIAL (new_decl
) = remap_blocks (DECL_INITIAL (id
.src_fn
), &id
);
5168 BLOCK_SUPERCONTEXT (DECL_INITIAL (new_decl
)) = new_decl
;
5170 declare_inline_vars (DECL_INITIAL (new_decl
), vars
);
5172 if (!vec_safe_is_empty (DECL_STRUCT_FUNCTION (old_decl
)->local_decls
))
5173 /* Add local vars. */
5174 add_local_variables (DECL_STRUCT_FUNCTION (old_decl
), cfun
, &id
);
5176 if (DECL_RESULT (old_decl
) == NULL_TREE
)
5178 else if (skip_return
&& !VOID_TYPE_P (TREE_TYPE (DECL_RESULT (old_decl
))))
5180 DECL_RESULT (new_decl
)
5181 = build_decl (DECL_SOURCE_LOCATION (DECL_RESULT (old_decl
)),
5182 RESULT_DECL
, NULL_TREE
, void_type_node
);
5183 DECL_CONTEXT (DECL_RESULT (new_decl
)) = new_decl
;
5184 cfun
->returns_struct
= 0;
5185 cfun
->returns_pcc_struct
= 0;
5190 DECL_RESULT (new_decl
) = remap_decl (DECL_RESULT (old_decl
), &id
);
5191 lang_hooks
.dup_lang_specific_decl (DECL_RESULT (new_decl
));
5192 if (gimple_in_ssa_p (id
.src_cfun
)
5193 && DECL_BY_REFERENCE (DECL_RESULT (old_decl
))
5194 && (old_name
= ssa_default_def (id
.src_cfun
, DECL_RESULT (old_decl
))))
5196 tree new_name
= make_ssa_name (DECL_RESULT (new_decl
), NULL
);
5197 insert_decl_map (&id
, old_name
, new_name
);
5198 SSA_NAME_DEF_STMT (new_name
) = gimple_build_nop ();
5199 set_ssa_default_def (cfun
, DECL_RESULT (new_decl
), new_name
);
5203 /* Set up the destination functions loop tree. */
5204 if (loops_for_fn (DECL_STRUCT_FUNCTION (old_decl
)) != NULL
)
5206 cfun
->curr_properties
&= ~PROP_loops
;
5207 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
5208 cfun
->curr_properties
|= PROP_loops
;
5211 /* Copy the Function's body. */
5212 copy_body (&id
, old_entry_block
->count
, REG_BR_PROB_BASE
,
5213 ENTRY_BLOCK_PTR
, EXIT_BLOCK_PTR
, blocks_to_copy
, new_entry
);
5215 /* Renumber the lexical scoping (non-code) blocks consecutively. */
5216 number_blocks (new_decl
);
5218 /* We want to create the BB unconditionally, so that the addition of
5219 debug stmts doesn't affect BB count, which may in the end cause
5220 codegen differences. */
5221 bb
= split_edge (single_succ_edge (ENTRY_BLOCK_PTR
));
5222 while (init_stmts
.length ())
5223 insert_init_stmt (&id
, bb
, init_stmts
.pop ());
5224 update_clone_info (&id
);
5226 /* Remap the nonlocal_goto_save_area, if any. */
5227 if (cfun
->nonlocal_goto_save_area
)
5229 struct walk_stmt_info wi
;
5231 memset (&wi
, 0, sizeof (wi
));
5233 walk_tree (&cfun
->nonlocal_goto_save_area
, remap_gimple_op_r
, &wi
, NULL
);
5237 pointer_map_destroy (id
.decl_map
);
5239 pointer_map_destroy (id
.debug_map
);
5240 free_dominance_info (CDI_DOMINATORS
);
5241 free_dominance_info (CDI_POST_DOMINATORS
);
5243 fold_marked_statements (0, id
.statements_to_fold
);
5244 pointer_set_destroy (id
.statements_to_fold
);
5245 fold_cond_expr_cond ();
5246 delete_unreachable_blocks_update_callgraph (&id
);
5247 if (id
.dst_node
->analyzed
)
5248 cgraph_rebuild_references ();
5249 update_ssa (TODO_update_ssa
);
5251 /* After partial cloning we need to rescale frequencies, so they are
5252 within proper range in the cloned function. */
5255 struct cgraph_edge
*e
;
5256 rebuild_frequencies ();
5258 new_version_node
->count
= ENTRY_BLOCK_PTR
->count
;
5259 for (e
= new_version_node
->callees
; e
; e
= e
->next_callee
)
5261 basic_block bb
= gimple_bb (e
->call_stmt
);
5262 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
5264 e
->count
= bb
->count
;
5266 for (e
= new_version_node
->indirect_calls
; e
; e
= e
->next_callee
)
5268 basic_block bb
= gimple_bb (e
->call_stmt
);
5269 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
5271 e
->count
= bb
->count
;
5275 free_dominance_info (CDI_DOMINATORS
);
5276 free_dominance_info (CDI_POST_DOMINATORS
);
5278 gcc_assert (!id
.debug_stmts
.exists ());
5279 init_stmts
.release ();
5284 /* EXP is CALL_EXPR present in a GENERIC expression tree. Try to integrate
5285 the callee and return the inlined body on success. */
5288 maybe_inline_call_in_expr (tree exp
)
5290 tree fn
= get_callee_fndecl (exp
);
5292 /* We can only try to inline "const" functions. */
5293 if (fn
&& TREE_READONLY (fn
) && DECL_SAVED_TREE (fn
))
5295 struct pointer_map_t
*decl_map
= pointer_map_create ();
5296 call_expr_arg_iterator iter
;
5300 /* Remap the parameters. */
5301 for (param
= DECL_ARGUMENTS (fn
), arg
= first_call_expr_arg (exp
, &iter
);
5303 param
= DECL_CHAIN (param
), arg
= next_call_expr_arg (&iter
))
5304 *pointer_map_insert (decl_map
, param
) = arg
;
5306 memset (&id
, 0, sizeof (id
));
5308 id
.dst_fn
= current_function_decl
;
5309 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
5310 id
.decl_map
= decl_map
;
5312 id
.copy_decl
= copy_decl_no_change
;
5313 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5314 id
.transform_new_cfg
= false;
5315 id
.transform_return_to_modify
= true;
5316 id
.transform_lang_insert_block
= NULL
;
5318 /* Make sure not to unshare trees behind the front-end's back
5319 since front-end specific mechanisms may rely on sharing. */
5320 id
.regimplify
= false;
5321 id
.do_not_unshare
= true;
5323 /* We're not inside any EH region. */
5326 t
= copy_tree_body (&id
);
5327 pointer_map_destroy (decl_map
);
5329 /* We can only return something suitable for use in a GENERIC
5331 if (TREE_CODE (t
) == MODIFY_EXPR
)
5332 return TREE_OPERAND (t
, 1);
5338 /* Duplicate a type, fields and all. */
5341 build_duplicate_type (tree type
)
5343 struct copy_body_data id
;
5345 memset (&id
, 0, sizeof (id
));
5346 id
.src_fn
= current_function_decl
;
5347 id
.dst_fn
= current_function_decl
;
5349 id
.decl_map
= pointer_map_create ();
5350 id
.debug_map
= NULL
;
5351 id
.copy_decl
= copy_decl_no_change
;
5353 type
= remap_type_1 (type
, &id
);
5355 pointer_map_destroy (id
.decl_map
);
5357 pointer_map_destroy (id
.debug_map
);
5359 TYPE_CANONICAL (type
) = type
;