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"
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_kind (stmt
),
1302 gimple_omp_for_clauses (stmt
),
1303 gimple_omp_for_collapse (stmt
), s2
);
1306 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1308 gimple_omp_for_set_index (copy
, i
,
1309 gimple_omp_for_index (stmt
, i
));
1310 gimple_omp_for_set_initial (copy
, i
,
1311 gimple_omp_for_initial (stmt
, i
));
1312 gimple_omp_for_set_final (copy
, i
,
1313 gimple_omp_for_final (stmt
, i
));
1314 gimple_omp_for_set_incr (copy
, i
,
1315 gimple_omp_for_incr (stmt
, i
));
1316 gimple_omp_for_set_cond (copy
, i
,
1317 gimple_omp_for_cond (stmt
, i
));
1322 case GIMPLE_OMP_MASTER
:
1323 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1324 copy
= gimple_build_omp_master (s1
);
1327 case GIMPLE_OMP_ORDERED
:
1328 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1329 copy
= gimple_build_omp_ordered (s1
);
1332 case GIMPLE_OMP_SECTION
:
1333 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1334 copy
= gimple_build_omp_section (s1
);
1337 case GIMPLE_OMP_SECTIONS
:
1338 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1339 copy
= gimple_build_omp_sections
1340 (s1
, gimple_omp_sections_clauses (stmt
));
1343 case GIMPLE_OMP_SINGLE
:
1344 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1345 copy
= gimple_build_omp_single
1346 (s1
, gimple_omp_single_clauses (stmt
));
1349 case GIMPLE_OMP_CRITICAL
:
1350 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1352 = gimple_build_omp_critical (s1
, gimple_omp_critical_name (stmt
));
1355 case GIMPLE_TRANSACTION
:
1356 s1
= remap_gimple_seq (gimple_transaction_body (stmt
), id
);
1357 copy
= gimple_build_transaction (s1
, gimple_transaction_label (stmt
));
1358 gimple_transaction_set_subcode (copy
, gimple_transaction_subcode (stmt
));
1367 if (gimple_assign_copy_p (stmt
)
1368 && gimple_assign_lhs (stmt
) == gimple_assign_rhs1 (stmt
)
1369 && auto_var_in_fn_p (gimple_assign_lhs (stmt
), id
->src_fn
))
1371 /* Here we handle statements that are not completely rewritten.
1372 First we detect some inlining-induced bogosities for
1375 /* Some assignments VAR = VAR; don't generate any rtl code
1376 and thus don't count as variable modification. Avoid
1377 keeping bogosities like 0 = 0. */
1378 tree decl
= gimple_assign_lhs (stmt
), value
;
1381 n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
1385 STRIP_TYPE_NOPS (value
);
1386 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1387 return gimple_build_nop ();
1391 /* For *ptr_N ={v} {CLOBBER}, if ptr_N is SSA_NAME defined
1392 in a block that we aren't copying during tree_function_versioning,
1393 just drop the clobber stmt. */
1394 if (id
->blocks_to_copy
&& gimple_clobber_p (stmt
))
1396 tree lhs
= gimple_assign_lhs (stmt
);
1397 if (TREE_CODE (lhs
) == MEM_REF
1398 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == SSA_NAME
)
1400 gimple def_stmt
= SSA_NAME_DEF_STMT (TREE_OPERAND (lhs
, 0));
1401 if (gimple_bb (def_stmt
)
1402 && !bitmap_bit_p (id
->blocks_to_copy
,
1403 gimple_bb (def_stmt
)->index
))
1404 return gimple_build_nop ();
1408 if (gimple_debug_bind_p (stmt
))
1410 copy
= gimple_build_debug_bind (gimple_debug_bind_get_var (stmt
),
1411 gimple_debug_bind_get_value (stmt
),
1413 id
->debug_stmts
.safe_push (copy
);
1416 if (gimple_debug_source_bind_p (stmt
))
1418 copy
= gimple_build_debug_source_bind
1419 (gimple_debug_source_bind_get_var (stmt
),
1420 gimple_debug_source_bind_get_value (stmt
), stmt
);
1421 id
->debug_stmts
.safe_push (copy
);
1425 /* Create a new deep copy of the statement. */
1426 copy
= gimple_copy (stmt
);
1428 /* Remap the region numbers for __builtin_eh_{pointer,filter},
1429 RESX and EH_DISPATCH. */
1431 switch (gimple_code (copy
))
1435 tree r
, fndecl
= gimple_call_fndecl (copy
);
1436 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
1437 switch (DECL_FUNCTION_CODE (fndecl
))
1439 case BUILT_IN_EH_COPY_VALUES
:
1440 r
= gimple_call_arg (copy
, 1);
1441 r
= remap_eh_region_tree_nr (r
, id
);
1442 gimple_call_set_arg (copy
, 1, r
);
1445 case BUILT_IN_EH_POINTER
:
1446 case BUILT_IN_EH_FILTER
:
1447 r
= gimple_call_arg (copy
, 0);
1448 r
= remap_eh_region_tree_nr (r
, id
);
1449 gimple_call_set_arg (copy
, 0, r
);
1456 /* Reset alias info if we didn't apply measures to
1457 keep it valid over inlining by setting DECL_PT_UID. */
1458 if (!id
->src_cfun
->gimple_df
1459 || !id
->src_cfun
->gimple_df
->ipa_pta
)
1460 gimple_call_reset_alias_info (copy
);
1466 int r
= gimple_resx_region (copy
);
1467 r
= remap_eh_region_nr (r
, id
);
1468 gimple_resx_set_region (copy
, r
);
1472 case GIMPLE_EH_DISPATCH
:
1474 int r
= gimple_eh_dispatch_region (copy
);
1475 r
= remap_eh_region_nr (r
, id
);
1476 gimple_eh_dispatch_set_region (copy
, r
);
1485 /* If STMT has a block defined, map it to the newly constructed
1487 if (gimple_block (copy
))
1490 n
= (tree
*) pointer_map_contains (id
->decl_map
, gimple_block (copy
));
1492 gimple_set_block (copy
, *n
);
1495 if (gimple_debug_bind_p (copy
) || gimple_debug_source_bind_p (copy
))
1498 /* Remap all the operands in COPY. */
1499 memset (&wi
, 0, sizeof (wi
));
1502 walk_tree (gimple_op_ptr (copy
, 1), remap_gimple_op_r
, &wi
, NULL
);
1504 walk_gimple_op (copy
, remap_gimple_op_r
, &wi
);
1506 /* Clear the copied virtual operands. We are not remapping them here
1507 but are going to recreate them from scratch. */
1508 if (gimple_has_mem_ops (copy
))
1510 gimple_set_vdef (copy
, NULL_TREE
);
1511 gimple_set_vuse (copy
, NULL_TREE
);
1518 /* Copy basic block, scale profile accordingly. Edges will be taken care of
1522 copy_bb (copy_body_data
*id
, basic_block bb
, int frequency_scale
,
1523 gcov_type count_scale
)
1525 gimple_stmt_iterator gsi
, copy_gsi
, seq_gsi
;
1526 basic_block copy_basic_block
;
1531 /* Search for previous copied basic block. */
1534 prev
= prev
->prev_bb
;
1536 /* create_basic_block() will append every new block to
1537 basic_block_info automatically. */
1538 copy_basic_block
= create_basic_block (NULL
, (void *) 0,
1539 (basic_block
) prev
->aux
);
1540 copy_basic_block
->count
= apply_scale (bb
->count
, count_scale
);
1542 /* We are going to rebuild frequencies from scratch. These values
1543 have just small importance to drive canonicalize_loop_headers. */
1544 freq
= apply_scale ((gcov_type
)bb
->frequency
, frequency_scale
);
1546 /* We recompute frequencies after inlining, so this is quite safe. */
1547 if (freq
> BB_FREQ_MAX
)
1549 copy_basic_block
->frequency
= freq
;
1551 copy_gsi
= gsi_start_bb (copy_basic_block
);
1553 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1555 gimple stmt
= gsi_stmt (gsi
);
1556 gimple orig_stmt
= stmt
;
1558 id
->regimplify
= false;
1559 stmt
= remap_gimple_stmt (stmt
, id
);
1560 if (gimple_nop_p (stmt
))
1563 gimple_duplicate_stmt_histograms (cfun
, stmt
, id
->src_cfun
, orig_stmt
);
1566 /* With return slot optimization we can end up with
1567 non-gimple (foo *)&this->m, fix that here. */
1568 if (is_gimple_assign (stmt
)
1569 && gimple_assign_rhs_code (stmt
) == NOP_EXPR
1570 && !is_gimple_val (gimple_assign_rhs1 (stmt
)))
1573 new_rhs
= force_gimple_operand_gsi (&seq_gsi
,
1574 gimple_assign_rhs1 (stmt
),
1576 GSI_CONTINUE_LINKING
);
1577 gimple_assign_set_rhs1 (stmt
, new_rhs
);
1578 id
->regimplify
= false;
1581 gsi_insert_after (&seq_gsi
, stmt
, GSI_NEW_STMT
);
1584 gimple_regimplify_operands (stmt
, &seq_gsi
);
1586 /* If copy_basic_block has been empty at the start of this iteration,
1587 call gsi_start_bb again to get at the newly added statements. */
1588 if (gsi_end_p (copy_gsi
))
1589 copy_gsi
= gsi_start_bb (copy_basic_block
);
1591 gsi_next (©_gsi
);
1593 /* Process the new statement. The call to gimple_regimplify_operands
1594 possibly turned the statement into multiple statements, we
1595 need to process all of them. */
1600 stmt
= gsi_stmt (copy_gsi
);
1601 if (is_gimple_call (stmt
)
1602 && gimple_call_va_arg_pack_p (stmt
)
1605 /* __builtin_va_arg_pack () should be replaced by
1606 all arguments corresponding to ... in the caller. */
1610 size_t nargs
= gimple_call_num_args (id
->gimple_call
);
1613 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1616 /* Create the new array of arguments. */
1617 n
= nargs
+ gimple_call_num_args (stmt
);
1618 argarray
.create (n
);
1619 argarray
.safe_grow_cleared (n
);
1621 /* Copy all the arguments before '...' */
1622 memcpy (argarray
.address (),
1623 gimple_call_arg_ptr (stmt
, 0),
1624 gimple_call_num_args (stmt
) * sizeof (tree
));
1626 /* Append the arguments passed in '...' */
1627 memcpy (argarray
.address () + gimple_call_num_args (stmt
),
1628 gimple_call_arg_ptr (id
->gimple_call
, 0)
1629 + (gimple_call_num_args (id
->gimple_call
) - nargs
),
1630 nargs
* sizeof (tree
));
1632 new_call
= gimple_build_call_vec (gimple_call_fn (stmt
),
1635 argarray
.release ();
1637 /* Copy all GIMPLE_CALL flags, location and block, except
1638 GF_CALL_VA_ARG_PACK. */
1639 gimple_call_copy_flags (new_call
, stmt
);
1640 gimple_call_set_va_arg_pack (new_call
, false);
1641 gimple_set_location (new_call
, gimple_location (stmt
));
1642 gimple_set_block (new_call
, gimple_block (stmt
));
1643 gimple_call_set_lhs (new_call
, gimple_call_lhs (stmt
));
1645 gsi_replace (©_gsi
, new_call
, false);
1648 else if (is_gimple_call (stmt
)
1650 && (decl
= gimple_call_fndecl (stmt
))
1651 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
1652 && DECL_FUNCTION_CODE (decl
) == BUILT_IN_VA_ARG_PACK_LEN
)
1654 /* __builtin_va_arg_pack_len () should be replaced by
1655 the number of anonymous arguments. */
1656 size_t nargs
= gimple_call_num_args (id
->gimple_call
);
1660 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1663 count
= build_int_cst (integer_type_node
, nargs
);
1664 new_stmt
= gimple_build_assign (gimple_call_lhs (stmt
), count
);
1665 gsi_replace (©_gsi
, new_stmt
, false);
1669 /* Statements produced by inlining can be unfolded, especially
1670 when we constant propagated some operands. We can't fold
1671 them right now for two reasons:
1672 1) folding require SSA_NAME_DEF_STMTs to be correct
1673 2) we can't change function calls to builtins.
1674 So we just mark statement for later folding. We mark
1675 all new statements, instead just statements that has changed
1676 by some nontrivial substitution so even statements made
1677 foldable indirectly are updated. If this turns out to be
1678 expensive, copy_body can be told to watch for nontrivial
1680 if (id
->statements_to_fold
)
1681 pointer_set_insert (id
->statements_to_fold
, stmt
);
1683 /* We're duplicating a CALL_EXPR. Find any corresponding
1684 callgraph edges and update or duplicate them. */
1685 if (is_gimple_call (stmt
))
1687 struct cgraph_edge
*edge
;
1690 switch (id
->transform_call_graph_edges
)
1692 case CB_CGE_DUPLICATE
:
1693 edge
= cgraph_edge (id
->src_node
, orig_stmt
);
1696 int edge_freq
= edge
->frequency
;
1698 struct cgraph_edge
*old_edge
= edge
;
1699 edge
= cgraph_clone_edge (edge
, id
->dst_node
, stmt
,
1701 REG_BR_PROB_BASE
, CGRAPH_FREQ_BASE
,
1703 /* We could also just rescale the frequency, but
1704 doing so would introduce roundoff errors and make
1705 verifier unhappy. */
1706 new_freq
= compute_call_stmt_bb_frequency (id
->dst_node
->symbol
.decl
,
1709 /* Speculative calls consist of two edges - direct and indirect.
1710 Duplicate the whole thing and distribute frequencies accordingly. */
1711 if (edge
->speculative
)
1713 struct cgraph_edge
*direct
, *indirect
;
1714 struct ipa_ref
*ref
;
1716 gcc_assert (!edge
->indirect_unknown_callee
);
1717 cgraph_speculative_call_info (old_edge
, direct
, indirect
, ref
);
1718 indirect
= cgraph_clone_edge (indirect
, id
->dst_node
, stmt
,
1720 REG_BR_PROB_BASE
, CGRAPH_FREQ_BASE
,
1722 if (old_edge
->frequency
+ indirect
->frequency
)
1724 edge
->frequency
= MIN (RDIV ((gcov_type
)new_freq
* old_edge
->frequency
,
1725 (old_edge
->frequency
+ indirect
->frequency
)),
1727 indirect
->frequency
= MIN (RDIV ((gcov_type
)new_freq
* indirect
->frequency
,
1728 (old_edge
->frequency
+ indirect
->frequency
)),
1731 ipa_clone_ref (ref
, (symtab_node
)id
->dst_node
, stmt
);
1735 edge
->frequency
= new_freq
;
1737 && profile_status_for_function (cfun
) != PROFILE_ABSENT
1738 && (edge_freq
> edge
->frequency
+ 10
1739 || edge_freq
< edge
->frequency
- 10))
1741 fprintf (dump_file
, "Edge frequency estimated by "
1742 "cgraph %i diverge from inliner's estimate %i\n",
1746 "Orig bb: %i, orig bb freq %i, new bb freq %i\n",
1749 copy_basic_block
->frequency
);
1755 case CB_CGE_MOVE_CLONES
:
1756 cgraph_set_call_stmt_including_clones (id
->dst_node
,
1758 edge
= cgraph_edge (id
->dst_node
, stmt
);
1762 edge
= cgraph_edge (id
->dst_node
, orig_stmt
);
1764 cgraph_set_call_stmt (edge
, stmt
);
1771 /* Constant propagation on argument done during inlining
1772 may create new direct call. Produce an edge for it. */
1774 || (edge
->indirect_inlining_edge
1775 && id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
))
1776 && id
->dst_node
->symbol
.definition
1777 && (fn
= gimple_call_fndecl (stmt
)) != NULL
)
1779 struct cgraph_node
*dest
= cgraph_get_node (fn
);
1781 /* We have missing edge in the callgraph. This can happen
1782 when previous inlining turned an indirect call into a
1783 direct call by constant propagating arguments or we are
1784 producing dead clone (for further cloning). In all
1785 other cases we hit a bug (incorrect node sharing is the
1786 most common reason for missing edges). */
1787 gcc_assert (!dest
->symbol
.definition
1788 || dest
->symbol
.address_taken
1789 || !id
->src_node
->symbol
.definition
1790 || !id
->dst_node
->symbol
.definition
);
1791 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
)
1792 cgraph_create_edge_including_clones
1793 (id
->dst_node
, dest
, orig_stmt
, stmt
, bb
->count
,
1794 compute_call_stmt_bb_frequency (id
->dst_node
->symbol
.decl
,
1796 CIF_ORIGINALLY_INDIRECT_CALL
);
1798 cgraph_create_edge (id
->dst_node
, dest
, stmt
,
1800 compute_call_stmt_bb_frequency
1801 (id
->dst_node
->symbol
.decl
,
1802 copy_basic_block
))->inline_failed
1803 = CIF_ORIGINALLY_INDIRECT_CALL
;
1806 fprintf (dump_file
, "Created new direct edge to %s\n",
1807 cgraph_node_name (dest
));
1811 flags
= gimple_call_flags (stmt
);
1812 if (flags
& ECF_MAY_BE_ALLOCA
)
1813 cfun
->calls_alloca
= true;
1814 if (flags
& ECF_RETURNS_TWICE
)
1815 cfun
->calls_setjmp
= true;
1818 maybe_duplicate_eh_stmt_fn (cfun
, stmt
, id
->src_cfun
, orig_stmt
,
1819 id
->eh_map
, id
->eh_lp_nr
);
1821 if (gimple_in_ssa_p (cfun
) && !is_gimple_debug (stmt
))
1826 FOR_EACH_SSA_TREE_OPERAND (def
, stmt
, i
, SSA_OP_DEF
)
1827 if (TREE_CODE (def
) == SSA_NAME
)
1828 SSA_NAME_DEF_STMT (def
) = stmt
;
1831 gsi_next (©_gsi
);
1833 while (!gsi_end_p (copy_gsi
));
1835 copy_gsi
= gsi_last_bb (copy_basic_block
);
1838 return copy_basic_block
;
1841 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
1842 form is quite easy, since dominator relationship for old basic blocks does
1845 There is however exception where inlining might change dominator relation
1846 across EH edges from basic block within inlined functions destinating
1847 to landing pads in function we inline into.
1849 The function fills in PHI_RESULTs of such PHI nodes if they refer
1850 to gimple regs. Otherwise, the function mark PHI_RESULT of such
1851 PHI nodes for renaming. For non-gimple regs, renaming is safe: the
1852 EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
1853 set, and this means that there will be no overlapping live ranges
1854 for the underlying symbol.
1856 This might change in future if we allow redirecting of EH edges and
1857 we might want to change way build CFG pre-inlining to include
1858 all the possible edges then. */
1860 update_ssa_across_abnormal_edges (basic_block bb
, basic_block ret_bb
,
1861 bool can_throw
, bool nonlocal_goto
)
1866 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1868 || ((basic_block
)e
->dest
->aux
)->index
== ENTRY_BLOCK
)
1871 gimple_stmt_iterator si
;
1874 gcc_assert (e
->flags
& EDGE_EH
);
1877 gcc_assert (!(e
->flags
& EDGE_EH
));
1879 for (si
= gsi_start_phis (e
->dest
); !gsi_end_p (si
); gsi_next (&si
))
1883 phi
= gsi_stmt (si
);
1885 /* For abnormal goto/call edges the receiver can be the
1886 ENTRY_BLOCK. Do not assert this cannot happen. */
1888 gcc_assert ((e
->flags
& EDGE_EH
)
1889 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi
)));
1891 re
= find_edge (ret_bb
, e
->dest
);
1892 gcc_checking_assert (re
);
1893 gcc_assert ((re
->flags
& (EDGE_EH
| EDGE_ABNORMAL
))
1894 == (e
->flags
& (EDGE_EH
| EDGE_ABNORMAL
)));
1896 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, e
),
1897 USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, re
)));
1903 /* Copy edges from BB into its copy constructed earlier, scale profile
1904 accordingly. Edges will be taken care of later. Assume aux
1905 pointers to point to the copies of each BB. Return true if any
1906 debug stmts are left after a statement that must end the basic block. */
1909 copy_edges_for_bb (basic_block bb
, gcov_type count_scale
, basic_block ret_bb
,
1910 bool can_make_abnormal_goto
)
1912 basic_block new_bb
= (basic_block
) bb
->aux
;
1915 gimple_stmt_iterator si
;
1917 bool need_debug_cleanup
= false;
1919 /* Use the indices from the original blocks to create edges for the
1921 FOR_EACH_EDGE (old_edge
, ei
, bb
->succs
)
1922 if (!(old_edge
->flags
& EDGE_EH
))
1926 flags
= old_edge
->flags
;
1928 /* Return edges do get a FALLTHRU flag when the get inlined. */
1929 if (old_edge
->dest
->index
== EXIT_BLOCK
&& !old_edge
->flags
1930 && old_edge
->dest
->aux
!= EXIT_BLOCK_PTR
)
1931 flags
|= EDGE_FALLTHRU
;
1932 new_edge
= make_edge (new_bb
, (basic_block
) old_edge
->dest
->aux
, flags
);
1933 new_edge
->count
= apply_scale (old_edge
->count
, count_scale
);
1934 new_edge
->probability
= old_edge
->probability
;
1937 if (bb
->index
== ENTRY_BLOCK
|| bb
->index
== EXIT_BLOCK
)
1940 for (si
= gsi_start_bb (new_bb
); !gsi_end_p (si
);)
1943 bool can_throw
, nonlocal_goto
;
1945 copy_stmt
= gsi_stmt (si
);
1946 if (!is_gimple_debug (copy_stmt
))
1947 update_stmt (copy_stmt
);
1949 /* Do this before the possible split_block. */
1952 /* If this tree could throw an exception, there are two
1953 cases where we need to add abnormal edge(s): the
1954 tree wasn't in a region and there is a "current
1955 region" in the caller; or the original tree had
1956 EH edges. In both cases split the block after the tree,
1957 and add abnormal edge(s) as needed; we need both
1958 those from the callee and the caller.
1959 We check whether the copy can throw, because the const
1960 propagation can change an INDIRECT_REF which throws
1961 into a COMPONENT_REF which doesn't. If the copy
1962 can throw, the original could also throw. */
1963 can_throw
= stmt_can_throw_internal (copy_stmt
);
1964 nonlocal_goto
= stmt_can_make_abnormal_goto (copy_stmt
);
1966 if (can_throw
|| nonlocal_goto
)
1968 if (!gsi_end_p (si
))
1970 while (!gsi_end_p (si
) && is_gimple_debug (gsi_stmt (si
)))
1973 need_debug_cleanup
= true;
1975 if (!gsi_end_p (si
))
1976 /* Note that bb's predecessor edges aren't necessarily
1977 right at this point; split_block doesn't care. */
1979 edge e
= split_block (new_bb
, copy_stmt
);
1982 new_bb
->aux
= e
->src
->aux
;
1983 si
= gsi_start_bb (new_bb
);
1987 if (gimple_code (copy_stmt
) == GIMPLE_EH_DISPATCH
)
1988 make_eh_dispatch_edges (copy_stmt
);
1990 make_eh_edges (copy_stmt
);
1992 /* If the call we inline cannot make abnormal goto do not add
1993 additional abnormal edges but only retain those already present
1994 in the original function body. */
1995 nonlocal_goto
&= can_make_abnormal_goto
;
1997 make_abnormal_goto_edges (gimple_bb (copy_stmt
), true);
1999 if ((can_throw
|| nonlocal_goto
)
2000 && gimple_in_ssa_p (cfun
))
2001 update_ssa_across_abnormal_edges (gimple_bb (copy_stmt
), ret_bb
,
2002 can_throw
, nonlocal_goto
);
2004 return need_debug_cleanup
;
2007 /* Copy the PHIs. All blocks and edges are copied, some blocks
2008 was possibly split and new outgoing EH edges inserted.
2009 BB points to the block of original function and AUX pointers links
2010 the original and newly copied blocks. */
2013 copy_phis_for_bb (basic_block bb
, copy_body_data
*id
)
2015 basic_block
const new_bb
= (basic_block
) bb
->aux
;
2018 gimple_stmt_iterator si
;
2020 bool inserted
= false;
2022 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
2027 phi
= gsi_stmt (si
);
2028 res
= PHI_RESULT (phi
);
2030 if (!virtual_operand_p (res
))
2032 walk_tree (&new_res
, copy_tree_body_r
, id
, NULL
);
2033 new_phi
= create_phi_node (new_res
, new_bb
);
2034 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2036 edge old_edge
= find_edge ((basic_block
) new_edge
->src
->aux
, bb
);
2042 /* When doing partial cloning, we allow PHIs on the entry block
2043 as long as all the arguments are the same. Find any input
2044 edge to see argument to copy. */
2046 FOR_EACH_EDGE (old_edge
, ei2
, bb
->preds
)
2047 if (!old_edge
->src
->aux
)
2050 arg
= PHI_ARG_DEF_FROM_EDGE (phi
, old_edge
);
2052 walk_tree (&new_arg
, copy_tree_body_r
, id
, NULL
);
2053 gcc_assert (new_arg
);
2054 /* With return slot optimization we can end up with
2055 non-gimple (foo *)&this->m, fix that here. */
2056 if (TREE_CODE (new_arg
) != SSA_NAME
2057 && TREE_CODE (new_arg
) != FUNCTION_DECL
2058 && !is_gimple_val (new_arg
))
2060 gimple_seq stmts
= NULL
;
2061 new_arg
= force_gimple_operand (new_arg
, &stmts
, true, NULL
);
2062 gsi_insert_seq_on_edge (new_edge
, stmts
);
2065 locus
= gimple_phi_arg_location_from_edge (phi
, old_edge
);
2066 if (LOCATION_BLOCK (locus
))
2069 n
= (tree
*) pointer_map_contains (id
->decl_map
,
2070 LOCATION_BLOCK (locus
));
2072 locus
= COMBINE_LOCATION_DATA (line_table
, locus
, *n
);
2075 locus
= LOCATION_LOCUS (locus
);
2077 add_phi_arg (new_phi
, new_arg
, new_edge
, locus
);
2082 /* Commit the delayed edge insertions. */
2084 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2085 gsi_commit_one_edge_insert (new_edge
, NULL
);
2089 /* Wrapper for remap_decl so it can be used as a callback. */
2092 remap_decl_1 (tree decl
, void *data
)
2094 return remap_decl (decl
, (copy_body_data
*) data
);
2097 /* Build struct function and associated datastructures for the new clone
2098 NEW_FNDECL to be build. CALLEE_FNDECL is the original. Function changes
2099 the cfun to the function of new_fndecl (and current_function_decl too). */
2102 initialize_cfun (tree new_fndecl
, tree callee_fndecl
, gcov_type count
)
2104 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2105 gcov_type count_scale
;
2107 if (!DECL_ARGUMENTS (new_fndecl
))
2108 DECL_ARGUMENTS (new_fndecl
) = DECL_ARGUMENTS (callee_fndecl
);
2109 if (!DECL_RESULT (new_fndecl
))
2110 DECL_RESULT (new_fndecl
) = DECL_RESULT (callee_fndecl
);
2112 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
)
2114 = GCOV_COMPUTE_SCALE (count
,
2115 ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
);
2117 count_scale
= REG_BR_PROB_BASE
;
2119 /* Register specific tree functions. */
2120 gimple_register_cfg_hooks ();
2122 /* Get clean struct function. */
2123 push_struct_function (new_fndecl
);
2125 /* We will rebuild these, so just sanity check that they are empty. */
2126 gcc_assert (VALUE_HISTOGRAMS (cfun
) == NULL
);
2127 gcc_assert (cfun
->local_decls
== NULL
);
2128 gcc_assert (cfun
->cfg
== NULL
);
2129 gcc_assert (cfun
->decl
== new_fndecl
);
2131 /* Copy items we preserve during cloning. */
2132 cfun
->static_chain_decl
= src_cfun
->static_chain_decl
;
2133 cfun
->nonlocal_goto_save_area
= src_cfun
->nonlocal_goto_save_area
;
2134 cfun
->function_end_locus
= src_cfun
->function_end_locus
;
2135 cfun
->curr_properties
= src_cfun
->curr_properties
;
2136 cfun
->last_verified
= src_cfun
->last_verified
;
2137 cfun
->va_list_gpr_size
= src_cfun
->va_list_gpr_size
;
2138 cfun
->va_list_fpr_size
= src_cfun
->va_list_fpr_size
;
2139 cfun
->has_nonlocal_label
= src_cfun
->has_nonlocal_label
;
2140 cfun
->stdarg
= src_cfun
->stdarg
;
2141 cfun
->after_inlining
= src_cfun
->after_inlining
;
2142 cfun
->can_throw_non_call_exceptions
2143 = src_cfun
->can_throw_non_call_exceptions
;
2144 cfun
->can_delete_dead_exceptions
= src_cfun
->can_delete_dead_exceptions
;
2145 cfun
->returns_struct
= src_cfun
->returns_struct
;
2146 cfun
->returns_pcc_struct
= src_cfun
->returns_pcc_struct
;
2148 init_empty_tree_cfg ();
2150 profile_status_for_function (cfun
) = profile_status_for_function (src_cfun
);
2151 ENTRY_BLOCK_PTR
->count
=
2152 (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
* count_scale
/
2154 ENTRY_BLOCK_PTR
->frequency
2155 = ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->frequency
;
2156 EXIT_BLOCK_PTR
->count
=
2157 (EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
* count_scale
/
2159 EXIT_BLOCK_PTR
->frequency
=
2160 EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->frequency
;
2162 init_eh_for_function ();
2164 if (src_cfun
->gimple_df
)
2166 init_tree_ssa (cfun
);
2167 cfun
->gimple_df
->in_ssa_p
= true;
2168 init_ssa_operands (cfun
);
2172 /* Helper function for copy_cfg_body. Move debug stmts from the end
2173 of NEW_BB to the beginning of successor basic blocks when needed. If the
2174 successor has multiple predecessors, reset them, otherwise keep
2178 maybe_move_debug_stmts_to_successors (copy_body_data
*id
, basic_block new_bb
)
2182 gimple_stmt_iterator si
= gsi_last_nondebug_bb (new_bb
);
2185 || gsi_one_before_end_p (si
)
2186 || !(stmt_can_throw_internal (gsi_stmt (si
))
2187 || stmt_can_make_abnormal_goto (gsi_stmt (si
))))
2190 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
2192 gimple_stmt_iterator ssi
= gsi_last_bb (new_bb
);
2193 gimple_stmt_iterator dsi
= gsi_after_labels (e
->dest
);
2194 while (is_gimple_debug (gsi_stmt (ssi
)))
2196 gimple stmt
= gsi_stmt (ssi
), new_stmt
;
2200 /* For the last edge move the debug stmts instead of copying
2202 if (ei_one_before_end_p (ei
))
2206 if (!single_pred_p (e
->dest
) && gimple_debug_bind_p (stmt
))
2207 gimple_debug_bind_reset_value (stmt
);
2208 gsi_remove (&si
, false);
2209 gsi_insert_before (&dsi
, stmt
, GSI_SAME_STMT
);
2213 if (gimple_debug_bind_p (stmt
))
2215 var
= gimple_debug_bind_get_var (stmt
);
2216 if (single_pred_p (e
->dest
))
2218 value
= gimple_debug_bind_get_value (stmt
);
2219 value
= unshare_expr (value
);
2223 new_stmt
= gimple_build_debug_bind (var
, value
, stmt
);
2225 else if (gimple_debug_source_bind_p (stmt
))
2227 var
= gimple_debug_source_bind_get_var (stmt
);
2228 value
= gimple_debug_source_bind_get_value (stmt
);
2229 new_stmt
= gimple_build_debug_source_bind (var
, value
, stmt
);
2233 gsi_insert_before (&dsi
, new_stmt
, GSI_SAME_STMT
);
2234 id
->debug_stmts
.safe_push (new_stmt
);
2240 /* Make a copy of the sub-loops of SRC_PARENT and place them
2241 as siblings of DEST_PARENT. */
2244 copy_loops (bitmap blocks_to_copy
,
2245 struct loop
*dest_parent
, struct loop
*src_parent
)
2247 struct loop
*src_loop
= src_parent
->inner
;
2251 || bitmap_bit_p (blocks_to_copy
, src_loop
->header
->index
))
2253 struct loop
*dest_loop
= alloc_loop ();
2255 /* Assign the new loop its header and latch and associate
2256 those with the new loop. */
2257 if (src_loop
->header
!= NULL
)
2259 dest_loop
->header
= (basic_block
)src_loop
->header
->aux
;
2260 dest_loop
->header
->loop_father
= dest_loop
;
2262 if (src_loop
->latch
!= NULL
)
2264 dest_loop
->latch
= (basic_block
)src_loop
->latch
->aux
;
2265 dest_loop
->latch
->loop_father
= dest_loop
;
2268 /* Copy loop meta-data. */
2269 copy_loop_info (src_loop
, dest_loop
);
2271 /* Finally place it into the loop array and the loop tree. */
2272 place_new_loop (cfun
, dest_loop
);
2273 flow_loop_tree_node_add (dest_parent
, dest_loop
);
2276 copy_loops (blocks_to_copy
, dest_loop
, src_loop
);
2278 src_loop
= src_loop
->next
;
2282 /* Call cgraph_redirect_edge_call_stmt_to_callee on all calls in BB */
2285 redirect_all_calls (copy_body_data
* id
, basic_block bb
)
2287 gimple_stmt_iterator si
;
2288 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
2290 if (is_gimple_call (gsi_stmt (si
)))
2292 struct cgraph_edge
*edge
= cgraph_edge (id
->dst_node
, gsi_stmt (si
));
2294 cgraph_redirect_edge_call_stmt_to_callee (edge
);
2299 /* Make a copy of the body of FN so that it can be inserted inline in
2300 another function. Walks FN via CFG, returns new fndecl. */
2303 copy_cfg_body (copy_body_data
* id
, gcov_type count
, int frequency_scale
,
2304 basic_block entry_block_map
, basic_block exit_block_map
,
2305 bitmap blocks_to_copy
, basic_block new_entry
)
2307 tree callee_fndecl
= id
->src_fn
;
2308 /* Original cfun for the callee, doesn't change. */
2309 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2310 struct function
*cfun_to_copy
;
2312 tree new_fndecl
= NULL
;
2313 bool need_debug_cleanup
= false;
2314 gcov_type count_scale
;
2316 int incoming_frequency
= 0;
2317 gcov_type incoming_count
= 0;
2319 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
)
2321 = GCOV_COMPUTE_SCALE (count
,
2322 ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
);
2324 count_scale
= REG_BR_PROB_BASE
;
2326 /* Register specific tree functions. */
2327 gimple_register_cfg_hooks ();
2329 /* If we are inlining just region of the function, make sure to connect new entry
2330 to ENTRY_BLOCK_PTR. Since new entry can be part of loop, we must compute
2331 frequency and probability of ENTRY_BLOCK_PTR based on the frequencies and
2332 probabilities of edges incoming from nonduplicated region. */
2338 FOR_EACH_EDGE (e
, ei
, new_entry
->preds
)
2341 incoming_frequency
+= EDGE_FREQUENCY (e
);
2342 incoming_count
+= e
->count
;
2344 incoming_count
= apply_scale (incoming_count
, count_scale
);
2346 = apply_scale ((gcov_type
)incoming_frequency
, frequency_scale
);
2347 ENTRY_BLOCK_PTR
->count
= incoming_count
;
2348 ENTRY_BLOCK_PTR
->frequency
= incoming_frequency
;
2351 /* Must have a CFG here at this point. */
2352 gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION
2353 (DECL_STRUCT_FUNCTION (callee_fndecl
)));
2355 cfun_to_copy
= id
->src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2357 ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy
)->aux
= entry_block_map
;
2358 EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy
)->aux
= exit_block_map
;
2359 entry_block_map
->aux
= ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy
);
2360 exit_block_map
->aux
= EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy
);
2362 /* Duplicate any exception-handling regions. */
2364 id
->eh_map
= duplicate_eh_regions (cfun_to_copy
, NULL
, id
->eh_lp_nr
,
2367 /* Use aux pointers to map the original blocks to copy. */
2368 FOR_EACH_BB_FN (bb
, cfun_to_copy
)
2369 if (!blocks_to_copy
|| bitmap_bit_p (blocks_to_copy
, bb
->index
))
2371 basic_block new_bb
= copy_bb (id
, bb
, frequency_scale
, count_scale
);
2374 new_bb
->loop_father
= entry_block_map
->loop_father
;
2377 last
= last_basic_block
;
2379 /* Now that we've duplicated the blocks, duplicate their edges. */
2380 bool can_make_abormal_goto
2381 = id
->gimple_call
&& stmt_can_make_abnormal_goto (id
->gimple_call
);
2382 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2384 || (bb
->index
> 0 && bitmap_bit_p (blocks_to_copy
, bb
->index
)))
2385 need_debug_cleanup
|= copy_edges_for_bb (bb
, count_scale
, exit_block_map
,
2386 can_make_abormal_goto
);
2390 edge e
= make_edge (entry_block_map
, (basic_block
)new_entry
->aux
, EDGE_FALLTHRU
);
2391 e
->probability
= REG_BR_PROB_BASE
;
2392 e
->count
= incoming_count
;
2395 /* Duplicate the loop tree, if available and wanted. */
2396 if (loops_for_fn (src_cfun
) != NULL
2397 && current_loops
!= NULL
)
2399 copy_loops (blocks_to_copy
, entry_block_map
->loop_father
,
2400 get_loop (src_cfun
, 0));
2401 /* Defer to cfgcleanup to update loop-father fields of basic-blocks. */
2402 loops_state_set (LOOPS_NEED_FIXUP
);
2403 cfun
->has_force_vect_loops
|= src_cfun
->has_force_vect_loops
;
2404 cfun
->has_simduid_loops
|= src_cfun
->has_simduid_loops
;
2407 /* If the loop tree in the source function needed fixup, mark the
2408 destination loop tree for fixup, too. */
2409 if (loops_for_fn (src_cfun
)->state
& LOOPS_NEED_FIXUP
)
2410 loops_state_set (LOOPS_NEED_FIXUP
);
2412 if (gimple_in_ssa_p (cfun
))
2413 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2415 || (bb
->index
> 0 && bitmap_bit_p (blocks_to_copy
, bb
->index
)))
2416 copy_phis_for_bb (bb
, id
);
2418 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2421 if (need_debug_cleanup
2422 && bb
->index
!= ENTRY_BLOCK
2423 && bb
->index
!= EXIT_BLOCK
)
2424 maybe_move_debug_stmts_to_successors (id
, (basic_block
) bb
->aux
);
2425 /* Update call edge destinations. This can not be done before loop
2426 info is updated, because we may split basic blocks. */
2427 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
)
2428 redirect_all_calls (id
, (basic_block
)bb
->aux
);
2429 ((basic_block
)bb
->aux
)->aux
= NULL
;
2433 /* Zero out AUX fields of newly created block during EH edge
2435 for (; last
< last_basic_block
; last
++)
2437 if (need_debug_cleanup
)
2438 maybe_move_debug_stmts_to_successors (id
, BASIC_BLOCK (last
));
2439 BASIC_BLOCK (last
)->aux
= NULL
;
2440 /* Update call edge destinations. This can not be done before loop
2441 info is updated, because we may split basic blocks. */
2442 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
)
2443 redirect_all_calls (id
, BASIC_BLOCK (last
));
2445 entry_block_map
->aux
= NULL
;
2446 exit_block_map
->aux
= NULL
;
2450 pointer_map_destroy (id
->eh_map
);
2457 /* Copy the debug STMT using ID. We deal with these statements in a
2458 special way: if any variable in their VALUE expression wasn't
2459 remapped yet, we won't remap it, because that would get decl uids
2460 out of sync, causing codegen differences between -g and -g0. If
2461 this arises, we drop the VALUE expression altogether. */
2464 copy_debug_stmt (gimple stmt
, copy_body_data
*id
)
2467 struct walk_stmt_info wi
;
2469 if (gimple_block (stmt
))
2471 n
= (tree
*) pointer_map_contains (id
->decl_map
, gimple_block (stmt
));
2472 gimple_set_block (stmt
, n
? *n
: id
->block
);
2475 /* Remap all the operands in COPY. */
2476 memset (&wi
, 0, sizeof (wi
));
2479 processing_debug_stmt
= 1;
2481 if (gimple_debug_source_bind_p (stmt
))
2482 t
= gimple_debug_source_bind_get_var (stmt
);
2484 t
= gimple_debug_bind_get_var (stmt
);
2486 if (TREE_CODE (t
) == PARM_DECL
&& id
->debug_map
2487 && (n
= (tree
*) pointer_map_contains (id
->debug_map
, t
)))
2489 gcc_assert (TREE_CODE (*n
) == VAR_DECL
);
2492 else if (TREE_CODE (t
) == VAR_DECL
2493 && !is_global_var (t
)
2494 && !pointer_map_contains (id
->decl_map
, t
))
2495 /* T is a non-localized variable. */;
2497 walk_tree (&t
, remap_gimple_op_r
, &wi
, NULL
);
2499 if (gimple_debug_bind_p (stmt
))
2501 gimple_debug_bind_set_var (stmt
, t
);
2503 if (gimple_debug_bind_has_value_p (stmt
))
2504 walk_tree (gimple_debug_bind_get_value_ptr (stmt
),
2505 remap_gimple_op_r
, &wi
, NULL
);
2507 /* Punt if any decl couldn't be remapped. */
2508 if (processing_debug_stmt
< 0)
2509 gimple_debug_bind_reset_value (stmt
);
2511 else if (gimple_debug_source_bind_p (stmt
))
2513 gimple_debug_source_bind_set_var (stmt
, t
);
2514 walk_tree (gimple_debug_source_bind_get_value_ptr (stmt
),
2515 remap_gimple_op_r
, &wi
, NULL
);
2516 /* When inlining and source bind refers to one of the optimized
2517 away parameters, change the source bind into normal debug bind
2518 referring to the corresponding DEBUG_EXPR_DECL that should have
2519 been bound before the call stmt. */
2520 t
= gimple_debug_source_bind_get_value (stmt
);
2522 && TREE_CODE (t
) == PARM_DECL
2525 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (id
->src_fn
);
2527 if (debug_args
!= NULL
)
2529 for (i
= 0; i
< vec_safe_length (*debug_args
); i
+= 2)
2530 if ((**debug_args
)[i
] == DECL_ORIGIN (t
)
2531 && TREE_CODE ((**debug_args
)[i
+ 1]) == DEBUG_EXPR_DECL
)
2533 t
= (**debug_args
)[i
+ 1];
2534 stmt
->gsbase
.subcode
= GIMPLE_DEBUG_BIND
;
2535 gimple_debug_bind_set_value (stmt
, t
);
2542 processing_debug_stmt
= 0;
2547 /* Process deferred debug stmts. In order to give values better odds
2548 of being successfully remapped, we delay the processing of debug
2549 stmts until all other stmts that might require remapping are
2553 copy_debug_stmts (copy_body_data
*id
)
2558 if (!id
->debug_stmts
.exists ())
2561 FOR_EACH_VEC_ELT (id
->debug_stmts
, i
, stmt
)
2562 copy_debug_stmt (stmt
, id
);
2564 id
->debug_stmts
.release ();
2567 /* Make a copy of the body of SRC_FN so that it can be inserted inline in
2568 another function. */
2571 copy_tree_body (copy_body_data
*id
)
2573 tree fndecl
= id
->src_fn
;
2574 tree body
= DECL_SAVED_TREE (fndecl
);
2576 walk_tree (&body
, copy_tree_body_r
, id
, NULL
);
2581 /* Make a copy of the body of FN so that it can be inserted inline in
2582 another function. */
2585 copy_body (copy_body_data
*id
, gcov_type count
, int frequency_scale
,
2586 basic_block entry_block_map
, basic_block exit_block_map
,
2587 bitmap blocks_to_copy
, basic_block new_entry
)
2589 tree fndecl
= id
->src_fn
;
2592 /* If this body has a CFG, walk CFG and copy. */
2593 gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (fndecl
)));
2594 body
= copy_cfg_body (id
, count
, frequency_scale
, entry_block_map
, exit_block_map
,
2595 blocks_to_copy
, new_entry
);
2596 copy_debug_stmts (id
);
2601 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
2602 defined in function FN, or of a data member thereof. */
2605 self_inlining_addr_expr (tree value
, tree fn
)
2609 if (TREE_CODE (value
) != ADDR_EXPR
)
2612 var
= get_base_address (TREE_OPERAND (value
, 0));
2614 return var
&& auto_var_in_fn_p (var
, fn
);
2617 /* Append to BB a debug annotation that binds VAR to VALUE, inheriting
2618 lexical block and line number information from base_stmt, if given,
2619 or from the last stmt of the block otherwise. */
2622 insert_init_debug_bind (copy_body_data
*id
,
2623 basic_block bb
, tree var
, tree value
,
2627 gimple_stmt_iterator gsi
;
2630 if (!gimple_in_ssa_p (id
->src_cfun
))
2633 if (!MAY_HAVE_DEBUG_STMTS
)
2636 tracked_var
= target_for_debug_bind (var
);
2642 gsi
= gsi_last_bb (bb
);
2643 if (!base_stmt
&& !gsi_end_p (gsi
))
2644 base_stmt
= gsi_stmt (gsi
);
2647 note
= gimple_build_debug_bind (tracked_var
, value
, base_stmt
);
2651 if (!gsi_end_p (gsi
))
2652 gsi_insert_after (&gsi
, note
, GSI_SAME_STMT
);
2654 gsi_insert_before (&gsi
, note
, GSI_SAME_STMT
);
2661 insert_init_stmt (copy_body_data
*id
, basic_block bb
, gimple init_stmt
)
2663 /* If VAR represents a zero-sized variable, it's possible that the
2664 assignment statement may result in no gimple statements. */
2667 gimple_stmt_iterator si
= gsi_last_bb (bb
);
2669 /* We can end up with init statements that store to a non-register
2670 from a rhs with a conversion. Handle that here by forcing the
2671 rhs into a temporary. gimple_regimplify_operands is not
2672 prepared to do this for us. */
2673 if (!is_gimple_debug (init_stmt
)
2674 && !is_gimple_reg (gimple_assign_lhs (init_stmt
))
2675 && is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (init_stmt
)))
2676 && gimple_assign_rhs_class (init_stmt
) == GIMPLE_UNARY_RHS
)
2678 tree rhs
= build1 (gimple_assign_rhs_code (init_stmt
),
2679 gimple_expr_type (init_stmt
),
2680 gimple_assign_rhs1 (init_stmt
));
2681 rhs
= force_gimple_operand_gsi (&si
, rhs
, true, NULL_TREE
, false,
2683 gimple_assign_set_rhs_code (init_stmt
, TREE_CODE (rhs
));
2684 gimple_assign_set_rhs1 (init_stmt
, rhs
);
2686 gsi_insert_after (&si
, init_stmt
, GSI_NEW_STMT
);
2687 gimple_regimplify_operands (init_stmt
, &si
);
2689 if (!is_gimple_debug (init_stmt
) && MAY_HAVE_DEBUG_STMTS
)
2691 tree def
= gimple_assign_lhs (init_stmt
);
2692 insert_init_debug_bind (id
, bb
, def
, def
, init_stmt
);
2697 /* Initialize parameter P with VALUE. If needed, produce init statement
2698 at the end of BB. When BB is NULL, we return init statement to be
2701 setup_one_parameter (copy_body_data
*id
, tree p
, tree value
, tree fn
,
2702 basic_block bb
, tree
*vars
)
2704 gimple init_stmt
= NULL
;
2707 tree def
= (gimple_in_ssa_p (cfun
)
2708 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
2711 && value
!= error_mark_node
2712 && !useless_type_conversion_p (TREE_TYPE (p
), TREE_TYPE (value
)))
2714 /* If we can match up types by promotion/demotion do so. */
2715 if (fold_convertible_p (TREE_TYPE (p
), value
))
2716 rhs
= fold_convert (TREE_TYPE (p
), value
);
2719 /* ??? For valid programs we should not end up here.
2720 Still if we end up with truly mismatched types here, fall back
2721 to using a VIEW_CONVERT_EXPR or a literal zero to not leak invalid
2722 GIMPLE to the following passes. */
2723 if (!is_gimple_reg_type (TREE_TYPE (value
))
2724 || TYPE_SIZE (TREE_TYPE (p
)) == TYPE_SIZE (TREE_TYPE (value
)))
2725 rhs
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (p
), value
);
2727 rhs
= build_zero_cst (TREE_TYPE (p
));
2731 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
2732 here since the type of this decl must be visible to the calling
2734 var
= copy_decl_to_var (p
, id
);
2736 /* Declare this new variable. */
2737 DECL_CHAIN (var
) = *vars
;
2740 /* Make gimplifier happy about this variable. */
2741 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
2743 /* If the parameter is never assigned to, has no SSA_NAMEs created,
2744 we would not need to create a new variable here at all, if it
2745 weren't for debug info. Still, we can just use the argument
2747 if (TREE_READONLY (p
)
2748 && !TREE_ADDRESSABLE (p
)
2749 && value
&& !TREE_SIDE_EFFECTS (value
)
2752 /* We may produce non-gimple trees by adding NOPs or introduce
2753 invalid sharing when operand is not really constant.
2754 It is not big deal to prohibit constant propagation here as
2755 we will constant propagate in DOM1 pass anyway. */
2756 if (is_gimple_min_invariant (value
)
2757 && useless_type_conversion_p (TREE_TYPE (p
),
2759 /* We have to be very careful about ADDR_EXPR. Make sure
2760 the base variable isn't a local variable of the inlined
2761 function, e.g., when doing recursive inlining, direct or
2762 mutually-recursive or whatever, which is why we don't
2763 just test whether fn == current_function_decl. */
2764 && ! self_inlining_addr_expr (value
, fn
))
2766 insert_decl_map (id
, p
, value
);
2767 insert_debug_decl_map (id
, p
, var
);
2768 return insert_init_debug_bind (id
, bb
, var
, value
, NULL
);
2772 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
2773 that way, when the PARM_DECL is encountered, it will be
2774 automatically replaced by the VAR_DECL. */
2775 insert_decl_map (id
, p
, var
);
2777 /* Even if P was TREE_READONLY, the new VAR should not be.
2778 In the original code, we would have constructed a
2779 temporary, and then the function body would have never
2780 changed the value of P. However, now, we will be
2781 constructing VAR directly. The constructor body may
2782 change its value multiple times as it is being
2783 constructed. Therefore, it must not be TREE_READONLY;
2784 the back-end assumes that TREE_READONLY variable is
2785 assigned to only once. */
2786 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p
)))
2787 TREE_READONLY (var
) = 0;
2789 /* If there is no setup required and we are in SSA, take the easy route
2790 replacing all SSA names representing the function parameter by the
2791 SSA name passed to function.
2793 We need to construct map for the variable anyway as it might be used
2794 in different SSA names when parameter is set in function.
2796 Do replacement at -O0 for const arguments replaced by constant.
2797 This is important for builtin_constant_p and other construct requiring
2798 constant argument to be visible in inlined function body. */
2799 if (gimple_in_ssa_p (cfun
) && rhs
&& def
&& is_gimple_reg (p
)
2801 || (TREE_READONLY (p
)
2802 && is_gimple_min_invariant (rhs
)))
2803 && (TREE_CODE (rhs
) == SSA_NAME
2804 || is_gimple_min_invariant (rhs
))
2805 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
2807 insert_decl_map (id
, def
, rhs
);
2808 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
2811 /* If the value of argument is never used, don't care about initializing
2813 if (optimize
&& gimple_in_ssa_p (cfun
) && !def
&& is_gimple_reg (p
))
2815 gcc_assert (!value
|| !TREE_SIDE_EFFECTS (value
));
2816 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
2819 /* Initialize this VAR_DECL from the equivalent argument. Convert
2820 the argument to the proper type in case it was promoted. */
2823 if (rhs
== error_mark_node
)
2825 insert_decl_map (id
, p
, var
);
2826 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
2829 STRIP_USELESS_TYPE_CONVERSION (rhs
);
2831 /* If we are in SSA form properly remap the default definition
2832 or assign to a dummy SSA name if the parameter is unused and
2833 we are not optimizing. */
2834 if (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
))
2838 def
= remap_ssa_name (def
, id
);
2839 init_stmt
= gimple_build_assign (def
, rhs
);
2840 SSA_NAME_IS_DEFAULT_DEF (def
) = 0;
2841 set_ssa_default_def (cfun
, var
, NULL
);
2845 def
= make_ssa_name (var
, NULL
);
2846 init_stmt
= gimple_build_assign (def
, rhs
);
2850 init_stmt
= gimple_build_assign (var
, rhs
);
2852 if (bb
&& init_stmt
)
2853 insert_init_stmt (id
, bb
, init_stmt
);
2858 /* Generate code to initialize the parameters of the function at the
2859 top of the stack in ID from the GIMPLE_CALL STMT. */
2862 initialize_inlined_parameters (copy_body_data
*id
, gimple stmt
,
2863 tree fn
, basic_block bb
)
2868 tree vars
= NULL_TREE
;
2869 tree static_chain
= gimple_call_chain (stmt
);
2871 /* Figure out what the parameters are. */
2872 parms
= DECL_ARGUMENTS (fn
);
2874 /* Loop through the parameter declarations, replacing each with an
2875 equivalent VAR_DECL, appropriately initialized. */
2876 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
2879 val
= i
< gimple_call_num_args (stmt
) ? gimple_call_arg (stmt
, i
) : NULL
;
2880 setup_one_parameter (id
, p
, val
, fn
, bb
, &vars
);
2882 /* After remapping parameters remap their types. This has to be done
2883 in a second loop over all parameters to appropriately remap
2884 variable sized arrays when the size is specified in a
2885 parameter following the array. */
2886 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
2888 tree
*varp
= (tree
*) pointer_map_contains (id
->decl_map
, p
);
2890 && TREE_CODE (*varp
) == VAR_DECL
)
2892 tree def
= (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
)
2893 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
2895 TREE_TYPE (var
) = remap_type (TREE_TYPE (var
), id
);
2896 /* Also remap the default definition if it was remapped
2897 to the default definition of the parameter replacement
2898 by the parameter setup. */
2901 tree
*defp
= (tree
*) pointer_map_contains (id
->decl_map
, def
);
2903 && TREE_CODE (*defp
) == SSA_NAME
2904 && SSA_NAME_VAR (*defp
) == var
)
2905 TREE_TYPE (*defp
) = TREE_TYPE (var
);
2910 /* Initialize the static chain. */
2911 p
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
2912 gcc_assert (fn
!= current_function_decl
);
2915 /* No static chain? Seems like a bug in tree-nested.c. */
2916 gcc_assert (static_chain
);
2918 setup_one_parameter (id
, p
, static_chain
, fn
, bb
, &vars
);
2921 declare_inline_vars (id
->block
, vars
);
2925 /* Declare a return variable to replace the RESULT_DECL for the
2926 function we are calling. An appropriate DECL_STMT is returned.
2927 The USE_STMT is filled to contain a use of the declaration to
2928 indicate the return value of the function.
2930 RETURN_SLOT, if non-null is place where to store the result. It
2931 is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null,
2932 was the LHS of the MODIFY_EXPR to which this call is the RHS.
2934 The return value is a (possibly null) value that holds the result
2935 as seen by the caller. */
2938 declare_return_variable (copy_body_data
*id
, tree return_slot
, tree modify_dest
,
2939 basic_block entry_bb
)
2941 tree callee
= id
->src_fn
;
2942 tree result
= DECL_RESULT (callee
);
2943 tree callee_type
= TREE_TYPE (result
);
2947 /* Handle type-mismatches in the function declaration return type
2948 vs. the call expression. */
2950 caller_type
= TREE_TYPE (modify_dest
);
2952 caller_type
= TREE_TYPE (TREE_TYPE (callee
));
2954 /* We don't need to do anything for functions that don't return anything. */
2955 if (VOID_TYPE_P (callee_type
))
2958 /* If there was a return slot, then the return value is the
2959 dereferenced address of that object. */
2962 /* The front end shouldn't have used both return_slot and
2963 a modify expression. */
2964 gcc_assert (!modify_dest
);
2965 if (DECL_BY_REFERENCE (result
))
2967 tree return_slot_addr
= build_fold_addr_expr (return_slot
);
2968 STRIP_USELESS_TYPE_CONVERSION (return_slot_addr
);
2970 /* We are going to construct *&return_slot and we can't do that
2971 for variables believed to be not addressable.
2973 FIXME: This check possibly can match, because values returned
2974 via return slot optimization are not believed to have address
2975 taken by alias analysis. */
2976 gcc_assert (TREE_CODE (return_slot
) != SSA_NAME
);
2977 var
= return_slot_addr
;
2982 gcc_assert (TREE_CODE (var
) != SSA_NAME
);
2983 TREE_ADDRESSABLE (var
) |= TREE_ADDRESSABLE (result
);
2985 if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
2986 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
2987 && !DECL_GIMPLE_REG_P (result
)
2989 DECL_GIMPLE_REG_P (var
) = 0;
2994 /* All types requiring non-trivial constructors should have been handled. */
2995 gcc_assert (!TREE_ADDRESSABLE (callee_type
));
2997 /* Attempt to avoid creating a new temporary variable. */
2999 && TREE_CODE (modify_dest
) != SSA_NAME
)
3001 bool use_it
= false;
3003 /* We can't use MODIFY_DEST if there's type promotion involved. */
3004 if (!useless_type_conversion_p (callee_type
, caller_type
))
3007 /* ??? If we're assigning to a variable sized type, then we must
3008 reuse the destination variable, because we've no good way to
3009 create variable sized temporaries at this point. */
3010 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type
)) != INTEGER_CST
)
3013 /* If the callee cannot possibly modify MODIFY_DEST, then we can
3014 reuse it as the result of the call directly. Don't do this if
3015 it would promote MODIFY_DEST to addressable. */
3016 else if (TREE_ADDRESSABLE (result
))
3020 tree base_m
= get_base_address (modify_dest
);
3022 /* If the base isn't a decl, then it's a pointer, and we don't
3023 know where that's going to go. */
3024 if (!DECL_P (base_m
))
3026 else if (is_global_var (base_m
))
3028 else if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
3029 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
3030 && !DECL_GIMPLE_REG_P (result
)
3031 && DECL_GIMPLE_REG_P (base_m
))
3033 else if (!TREE_ADDRESSABLE (base_m
))
3045 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type
)) == INTEGER_CST
);
3047 var
= copy_result_decl_to_var (result
, id
);
3048 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
3050 /* Do not have the rest of GCC warn about this variable as it should
3051 not be visible to the user. */
3052 TREE_NO_WARNING (var
) = 1;
3054 declare_inline_vars (id
->block
, var
);
3056 /* Build the use expr. If the return type of the function was
3057 promoted, convert it back to the expected type. */
3059 if (!useless_type_conversion_p (caller_type
, TREE_TYPE (var
)))
3061 /* If we can match up types by promotion/demotion do so. */
3062 if (fold_convertible_p (caller_type
, var
))
3063 use
= fold_convert (caller_type
, var
);
3066 /* ??? For valid programs we should not end up here.
3067 Still if we end up with truly mismatched types here, fall back
3068 to using a MEM_REF to not leak invalid GIMPLE to the following
3070 /* Prevent var from being written into SSA form. */
3071 if (TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
3072 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
)
3073 DECL_GIMPLE_REG_P (var
) = false;
3074 else if (is_gimple_reg_type (TREE_TYPE (var
)))
3075 TREE_ADDRESSABLE (var
) = true;
3076 use
= fold_build2 (MEM_REF
, caller_type
,
3077 build_fold_addr_expr (var
),
3078 build_int_cst (ptr_type_node
, 0));
3082 STRIP_USELESS_TYPE_CONVERSION (use
);
3084 if (DECL_BY_REFERENCE (result
))
3086 TREE_ADDRESSABLE (var
) = 1;
3087 var
= build_fold_addr_expr (var
);
3091 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
3092 way, when the RESULT_DECL is encountered, it will be
3093 automatically replaced by the VAR_DECL.
3095 When returning by reference, ensure that RESULT_DECL remaps to
3097 if (DECL_BY_REFERENCE (result
)
3098 && !is_gimple_val (var
))
3100 tree temp
= create_tmp_var (TREE_TYPE (result
), "retvalptr");
3101 insert_decl_map (id
, result
, temp
);
3102 /* When RESULT_DECL is in SSA form, we need to remap and initialize
3103 it's default_def SSA_NAME. */
3104 if (gimple_in_ssa_p (id
->src_cfun
)
3105 && is_gimple_reg (result
))
3107 temp
= make_ssa_name (temp
, NULL
);
3108 insert_decl_map (id
, ssa_default_def (id
->src_cfun
, result
), temp
);
3110 insert_init_stmt (id
, entry_bb
, gimple_build_assign (temp
, var
));
3113 insert_decl_map (id
, result
, var
);
3115 /* Remember this so we can ignore it in remap_decls. */
3121 /* Callback through walk_tree. Determine if a DECL_INITIAL makes reference
3122 to a local label. */
3125 has_label_address_in_static_1 (tree
*nodep
, int *walk_subtrees
, void *fnp
)
3128 tree fn
= (tree
) fnp
;
3130 if (TREE_CODE (node
) == LABEL_DECL
&& DECL_CONTEXT (node
) == fn
)
3139 /* Determine if the function can be copied. If so return NULL. If
3140 not return a string describng the reason for failure. */
3143 copy_forbidden (struct function
*fun
, tree fndecl
)
3145 const char *reason
= fun
->cannot_be_copied_reason
;
3149 /* Only examine the function once. */
3150 if (fun
->cannot_be_copied_set
)
3153 /* We cannot copy a function that receives a non-local goto
3154 because we cannot remap the destination label used in the
3155 function that is performing the non-local goto. */
3156 /* ??? Actually, this should be possible, if we work at it.
3157 No doubt there's just a handful of places that simply
3158 assume it doesn't happen and don't substitute properly. */
3159 if (fun
->has_nonlocal_label
)
3161 reason
= G_("function %q+F can never be copied "
3162 "because it receives a non-local goto");
3166 FOR_EACH_LOCAL_DECL (fun
, ix
, decl
)
3167 if (TREE_CODE (decl
) == VAR_DECL
3168 && TREE_STATIC (decl
)
3169 && !DECL_EXTERNAL (decl
)
3170 && DECL_INITIAL (decl
)
3171 && walk_tree_without_duplicates (&DECL_INITIAL (decl
),
3172 has_label_address_in_static_1
,
3175 reason
= G_("function %q+F can never be copied because it saves "
3176 "address of local label in a static variable");
3181 fun
->cannot_be_copied_reason
= reason
;
3182 fun
->cannot_be_copied_set
= true;
3187 static const char *inline_forbidden_reason
;
3189 /* A callback for walk_gimple_seq to handle statements. Returns non-null
3190 iff a function can not be inlined. Also sets the reason why. */
3193 inline_forbidden_p_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
3194 struct walk_stmt_info
*wip
)
3196 tree fn
= (tree
) wip
->info
;
3198 gimple stmt
= gsi_stmt (*gsi
);
3200 switch (gimple_code (stmt
))
3203 /* Refuse to inline alloca call unless user explicitly forced so as
3204 this may change program's memory overhead drastically when the
3205 function using alloca is called in loop. In GCC present in
3206 SPEC2000 inlining into schedule_block cause it to require 2GB of
3207 RAM instead of 256MB. Don't do so for alloca calls emitted for
3208 VLA objects as those can't cause unbounded growth (they're always
3209 wrapped inside stack_save/stack_restore regions. */
3210 if (gimple_alloca_call_p (stmt
)
3211 && !gimple_call_alloca_for_var_p (stmt
)
3212 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
3214 inline_forbidden_reason
3215 = G_("function %q+F can never be inlined because it uses "
3216 "alloca (override using the always_inline attribute)");
3217 *handled_ops_p
= true;
3221 t
= gimple_call_fndecl (stmt
);
3225 /* We cannot inline functions that call setjmp. */
3226 if (setjmp_call_p (t
))
3228 inline_forbidden_reason
3229 = G_("function %q+F can never be inlined because it uses setjmp");
3230 *handled_ops_p
= true;
3234 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
3235 switch (DECL_FUNCTION_CODE (t
))
3237 /* We cannot inline functions that take a variable number of
3239 case BUILT_IN_VA_START
:
3240 case BUILT_IN_NEXT_ARG
:
3241 case BUILT_IN_VA_END
:
3242 inline_forbidden_reason
3243 = G_("function %q+F can never be inlined because it "
3244 "uses variable argument lists");
3245 *handled_ops_p
= true;
3248 case BUILT_IN_LONGJMP
:
3249 /* We can't inline functions that call __builtin_longjmp at
3250 all. The non-local goto machinery really requires the
3251 destination be in a different function. If we allow the
3252 function calling __builtin_longjmp to be inlined into the
3253 function calling __builtin_setjmp, Things will Go Awry. */
3254 inline_forbidden_reason
3255 = G_("function %q+F can never be inlined because "
3256 "it uses setjmp-longjmp exception handling");
3257 *handled_ops_p
= true;
3260 case BUILT_IN_NONLOCAL_GOTO
:
3262 inline_forbidden_reason
3263 = G_("function %q+F can never be inlined because "
3264 "it uses non-local goto");
3265 *handled_ops_p
= true;
3268 case BUILT_IN_RETURN
:
3269 case BUILT_IN_APPLY_ARGS
:
3270 /* If a __builtin_apply_args caller would be inlined,
3271 it would be saving arguments of the function it has
3272 been inlined into. Similarly __builtin_return would
3273 return from the function the inline has been inlined into. */
3274 inline_forbidden_reason
3275 = G_("function %q+F can never be inlined because "
3276 "it uses __builtin_return or __builtin_apply_args");
3277 *handled_ops_p
= true;
3286 t
= gimple_goto_dest (stmt
);
3288 /* We will not inline a function which uses computed goto. The
3289 addresses of its local labels, which may be tucked into
3290 global storage, are of course not constant across
3291 instantiations, which causes unexpected behavior. */
3292 if (TREE_CODE (t
) != LABEL_DECL
)
3294 inline_forbidden_reason
3295 = G_("function %q+F can never be inlined "
3296 "because it contains a computed goto");
3297 *handled_ops_p
= true;
3306 *handled_ops_p
= false;
3310 /* Return true if FNDECL is a function that cannot be inlined into
3314 inline_forbidden_p (tree fndecl
)
3316 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
3317 struct walk_stmt_info wi
;
3318 struct pointer_set_t
*visited_nodes
;
3320 bool forbidden_p
= false;
3322 /* First check for shared reasons not to copy the code. */
3323 inline_forbidden_reason
= copy_forbidden (fun
, fndecl
);
3324 if (inline_forbidden_reason
!= NULL
)
3327 /* Next, walk the statements of the function looking for
3328 constraucts we can't handle, or are non-optimal for inlining. */
3329 visited_nodes
= pointer_set_create ();
3330 memset (&wi
, 0, sizeof (wi
));
3331 wi
.info
= (void *) fndecl
;
3332 wi
.pset
= visited_nodes
;
3334 FOR_EACH_BB_FN (bb
, fun
)
3337 gimple_seq seq
= bb_seq (bb
);
3338 ret
= walk_gimple_seq (seq
, inline_forbidden_p_stmt
, NULL
, &wi
);
3339 forbidden_p
= (ret
!= NULL
);
3344 pointer_set_destroy (visited_nodes
);
3348 /* Return false if the function FNDECL cannot be inlined on account of its
3349 attributes, true otherwise. */
3351 function_attribute_inlinable_p (const_tree fndecl
)
3353 if (targetm
.attribute_table
)
3357 for (a
= DECL_ATTRIBUTES (fndecl
); a
; a
= TREE_CHAIN (a
))
3359 const_tree name
= TREE_PURPOSE (a
);
3362 for (i
= 0; targetm
.attribute_table
[i
].name
!= NULL
; i
++)
3363 if (is_attribute_p (targetm
.attribute_table
[i
].name
, name
))
3364 return targetm
.function_attribute_inlinable_p (fndecl
);
3371 /* Returns nonzero if FN is a function that does not have any
3372 fundamental inline blocking properties. */
3375 tree_inlinable_function_p (tree fn
)
3377 bool inlinable
= true;
3381 /* If we've already decided this function shouldn't be inlined,
3382 there's no need to check again. */
3383 if (DECL_UNINLINABLE (fn
))
3386 /* We only warn for functions declared `inline' by the user. */
3387 do_warning
= (warn_inline
3388 && DECL_DECLARED_INLINE_P (fn
)
3389 && !DECL_NO_INLINE_WARNING_P (fn
)
3390 && !DECL_IN_SYSTEM_HEADER (fn
));
3392 always_inline
= lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
));
3395 && always_inline
== NULL
)
3398 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3399 "is suppressed using -fno-inline", fn
);
3403 else if (!function_attribute_inlinable_p (fn
))
3406 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3407 "uses attributes conflicting with inlining", fn
);
3411 else if (inline_forbidden_p (fn
))
3413 /* See if we should warn about uninlinable functions. Previously,
3414 some of these warnings would be issued while trying to expand
3415 the function inline, but that would cause multiple warnings
3416 about functions that would for example call alloca. But since
3417 this a property of the function, just one warning is enough.
3418 As a bonus we can now give more details about the reason why a
3419 function is not inlinable. */
3421 error (inline_forbidden_reason
, fn
);
3422 else if (do_warning
)
3423 warning (OPT_Winline
, inline_forbidden_reason
, fn
);
3428 /* Squirrel away the result so that we don't have to check again. */
3429 DECL_UNINLINABLE (fn
) = !inlinable
;
3434 /* Estimate the cost of a memory move. Use machine dependent
3435 word size and take possible memcpy call into account. */
3438 estimate_move_cost (tree type
)
3442 gcc_assert (!VOID_TYPE_P (type
));
3444 if (TREE_CODE (type
) == VECTOR_TYPE
)
3446 enum machine_mode inner
= TYPE_MODE (TREE_TYPE (type
));
3447 enum machine_mode simd
3448 = targetm
.vectorize
.preferred_simd_mode (inner
);
3449 int simd_mode_size
= GET_MODE_SIZE (simd
);
3450 return ((GET_MODE_SIZE (TYPE_MODE (type
)) + simd_mode_size
- 1)
3454 size
= int_size_in_bytes (type
);
3456 if (size
< 0 || size
> MOVE_MAX_PIECES
* MOVE_RATIO (!optimize_size
))
3457 /* Cost of a memcpy call, 3 arguments and the call. */
3460 return ((size
+ MOVE_MAX_PIECES
- 1) / MOVE_MAX_PIECES
);
3463 /* Returns cost of operation CODE, according to WEIGHTS */
3466 estimate_operator_cost (enum tree_code code
, eni_weights
*weights
,
3467 tree op1 ATTRIBUTE_UNUSED
, tree op2
)
3471 /* These are "free" conversions, or their presumed cost
3472 is folded into other operations. */
3477 case VIEW_CONVERT_EXPR
:
3480 /* Assign cost of 1 to usual operations.
3481 ??? We may consider mapping RTL costs to this. */
3487 case POINTER_PLUS_EXPR
:
3490 case MULT_HIGHPART_EXPR
:
3493 case ADDR_SPACE_CONVERT_EXPR
:
3494 case FIXED_CONVERT_EXPR
:
3495 case FIX_TRUNC_EXPR
:
3507 case VEC_LSHIFT_EXPR
:
3508 case VEC_RSHIFT_EXPR
:
3515 case TRUTH_ANDIF_EXPR
:
3516 case TRUTH_ORIF_EXPR
:
3517 case TRUTH_AND_EXPR
:
3519 case TRUTH_XOR_EXPR
:
3520 case TRUTH_NOT_EXPR
:
3529 case UNORDERED_EXPR
:
3540 case PREDECREMENT_EXPR
:
3541 case PREINCREMENT_EXPR
:
3542 case POSTDECREMENT_EXPR
:
3543 case POSTINCREMENT_EXPR
:
3545 case REALIGN_LOAD_EXPR
:
3547 case REDUC_MAX_EXPR
:
3548 case REDUC_MIN_EXPR
:
3549 case REDUC_PLUS_EXPR
:
3550 case WIDEN_SUM_EXPR
:
3551 case WIDEN_MULT_EXPR
:
3553 case WIDEN_MULT_PLUS_EXPR
:
3554 case WIDEN_MULT_MINUS_EXPR
:
3555 case WIDEN_LSHIFT_EXPR
:
3557 case VEC_WIDEN_MULT_HI_EXPR
:
3558 case VEC_WIDEN_MULT_LO_EXPR
:
3559 case VEC_WIDEN_MULT_EVEN_EXPR
:
3560 case VEC_WIDEN_MULT_ODD_EXPR
:
3561 case VEC_UNPACK_HI_EXPR
:
3562 case VEC_UNPACK_LO_EXPR
:
3563 case VEC_UNPACK_FLOAT_HI_EXPR
:
3564 case VEC_UNPACK_FLOAT_LO_EXPR
:
3565 case VEC_PACK_TRUNC_EXPR
:
3566 case VEC_PACK_SAT_EXPR
:
3567 case VEC_PACK_FIX_TRUNC_EXPR
:
3568 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3569 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3573 /* Few special cases of expensive operations. This is useful
3574 to avoid inlining on functions having too many of these. */
3575 case TRUNC_DIV_EXPR
:
3577 case FLOOR_DIV_EXPR
:
3578 case ROUND_DIV_EXPR
:
3579 case EXACT_DIV_EXPR
:
3580 case TRUNC_MOD_EXPR
:
3582 case FLOOR_MOD_EXPR
:
3583 case ROUND_MOD_EXPR
:
3585 if (TREE_CODE (op2
) != INTEGER_CST
)
3586 return weights
->div_mod_cost
;
3590 /* We expect a copy assignment with no operator. */
3591 gcc_assert (get_gimple_rhs_class (code
) == GIMPLE_SINGLE_RHS
);
3597 /* Estimate number of instructions that will be created by expanding
3598 the statements in the statement sequence STMTS.
3599 WEIGHTS contains weights attributed to various constructs. */
3602 int estimate_num_insns_seq (gimple_seq stmts
, eni_weights
*weights
)
3605 gimple_stmt_iterator gsi
;
3608 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3609 cost
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
3615 /* Estimate number of instructions that will be created by expanding STMT.
3616 WEIGHTS contains weights attributed to various constructs. */
3619 estimate_num_insns (gimple stmt
, eni_weights
*weights
)
3622 enum gimple_code code
= gimple_code (stmt
);
3629 /* Try to estimate the cost of assignments. We have three cases to
3631 1) Simple assignments to registers;
3632 2) Stores to things that must live in memory. This includes
3633 "normal" stores to scalars, but also assignments of large
3634 structures, or constructors of big arrays;
3636 Let us look at the first two cases, assuming we have "a = b + C":
3637 <GIMPLE_ASSIGN <var_decl "a">
3638 <plus_expr <var_decl "b"> <constant C>>
3639 If "a" is a GIMPLE register, the assignment to it is free on almost
3640 any target, because "a" usually ends up in a real register. Hence
3641 the only cost of this expression comes from the PLUS_EXPR, and we
3642 can ignore the GIMPLE_ASSIGN.
3643 If "a" is not a GIMPLE register, the assignment to "a" will most
3644 likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost
3645 of moving something into "a", which we compute using the function
3646 estimate_move_cost. */
3647 if (gimple_clobber_p (stmt
))
3648 return 0; /* ={v} {CLOBBER} stmt expands to nothing. */
3650 lhs
= gimple_assign_lhs (stmt
);
3651 rhs
= gimple_assign_rhs1 (stmt
);
3655 /* Account for the cost of moving to / from memory. */
3656 if (gimple_store_p (stmt
))
3657 cost
+= estimate_move_cost (TREE_TYPE (lhs
));
3658 if (gimple_assign_load_p (stmt
))
3659 cost
+= estimate_move_cost (TREE_TYPE (rhs
));
3661 cost
+= estimate_operator_cost (gimple_assign_rhs_code (stmt
), weights
,
3662 gimple_assign_rhs1 (stmt
),
3663 get_gimple_rhs_class (gimple_assign_rhs_code (stmt
))
3664 == GIMPLE_BINARY_RHS
3665 ? gimple_assign_rhs2 (stmt
) : NULL
);
3669 cost
= 1 + estimate_operator_cost (gimple_cond_code (stmt
), weights
,
3670 gimple_op (stmt
, 0),
3671 gimple_op (stmt
, 1));
3675 /* Take into account cost of the switch + guess 2 conditional jumps for
3678 TODO: once the switch expansion logic is sufficiently separated, we can
3679 do better job on estimating cost of the switch. */
3680 if (weights
->time_based
)
3681 cost
= floor_log2 (gimple_switch_num_labels (stmt
)) * 2;
3683 cost
= gimple_switch_num_labels (stmt
) * 2;
3688 tree decl
= gimple_call_fndecl (stmt
);
3689 struct cgraph_node
*node
= NULL
;
3691 /* Do not special case builtins where we see the body.
3692 This just confuse inliner. */
3693 if (!decl
|| !(node
= cgraph_get_node (decl
)) || node
->symbol
.definition
)
3695 /* For buitins that are likely expanded to nothing or
3696 inlined do not account operand costs. */
3697 else if (is_simple_builtin (decl
))
3699 else if (is_inexpensive_builtin (decl
))
3700 return weights
->target_builtin_call_cost
;
3701 else if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
3703 /* We canonicalize x * x to pow (x, 2.0) with -ffast-math, so
3704 specialize the cheap expansion we do here.
3705 ??? This asks for a more general solution. */
3706 switch (DECL_FUNCTION_CODE (decl
))
3711 if (TREE_CODE (gimple_call_arg (stmt
, 1)) == REAL_CST
3712 && REAL_VALUES_EQUAL
3713 (TREE_REAL_CST (gimple_call_arg (stmt
, 1)), dconst2
))
3714 return estimate_operator_cost (MULT_EXPR
, weights
,
3715 gimple_call_arg (stmt
, 0),
3716 gimple_call_arg (stmt
, 0));
3724 cost
= node
? weights
->call_cost
: weights
->indirect_call_cost
;
3725 if (gimple_call_lhs (stmt
))
3726 cost
+= estimate_move_cost (TREE_TYPE (gimple_call_lhs (stmt
)));
3727 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
3729 tree arg
= gimple_call_arg (stmt
, i
);
3730 cost
+= estimate_move_cost (TREE_TYPE (arg
));
3736 return weights
->return_cost
;
3742 case GIMPLE_PREDICT
:
3748 int count
= asm_str_count (gimple_asm_string (stmt
));
3749 /* 1000 means infinity. This avoids overflows later
3750 with very long asm statements. */
3757 /* This is either going to be an external function call with one
3758 argument, or two register copy statements plus a goto. */
3761 case GIMPLE_EH_DISPATCH
:
3762 /* ??? This is going to turn into a switch statement. Ideally
3763 we'd have a look at the eh region and estimate the number of
3768 return estimate_num_insns_seq (gimple_bind_body (stmt
), weights
);
3770 case GIMPLE_EH_FILTER
:
3771 return estimate_num_insns_seq (gimple_eh_filter_failure (stmt
), weights
);
3774 return estimate_num_insns_seq (gimple_catch_handler (stmt
), weights
);
3777 return (estimate_num_insns_seq (gimple_try_eval (stmt
), weights
)
3778 + estimate_num_insns_seq (gimple_try_cleanup (stmt
), weights
));
3780 /* OpenMP directives are generally very expensive. */
3782 case GIMPLE_OMP_RETURN
:
3783 case GIMPLE_OMP_SECTIONS_SWITCH
:
3784 case GIMPLE_OMP_ATOMIC_STORE
:
3785 case GIMPLE_OMP_CONTINUE
:
3786 /* ...except these, which are cheap. */
3789 case GIMPLE_OMP_ATOMIC_LOAD
:
3790 return weights
->omp_cost
;
3792 case GIMPLE_OMP_FOR
:
3793 return (weights
->omp_cost
3794 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
)
3795 + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt
), weights
));
3797 case GIMPLE_OMP_PARALLEL
:
3798 case GIMPLE_OMP_TASK
:
3799 case GIMPLE_OMP_CRITICAL
:
3800 case GIMPLE_OMP_MASTER
:
3801 case GIMPLE_OMP_ORDERED
:
3802 case GIMPLE_OMP_SECTION
:
3803 case GIMPLE_OMP_SECTIONS
:
3804 case GIMPLE_OMP_SINGLE
:
3805 return (weights
->omp_cost
3806 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
));
3808 case GIMPLE_TRANSACTION
:
3809 return (weights
->tm_cost
3810 + estimate_num_insns_seq (gimple_transaction_body (stmt
),
3820 /* Estimate number of instructions that will be created by expanding
3821 function FNDECL. WEIGHTS contains weights attributed to various
3825 estimate_num_insns_fn (tree fndecl
, eni_weights
*weights
)
3827 struct function
*my_function
= DECL_STRUCT_FUNCTION (fndecl
);
3828 gimple_stmt_iterator bsi
;
3832 gcc_assert (my_function
&& my_function
->cfg
);
3833 FOR_EACH_BB_FN (bb
, my_function
)
3835 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
3836 n
+= estimate_num_insns (gsi_stmt (bsi
), weights
);
3843 /* Initializes weights used by estimate_num_insns. */
3846 init_inline_once (void)
3848 eni_size_weights
.call_cost
= 1;
3849 eni_size_weights
.indirect_call_cost
= 3;
3850 eni_size_weights
.target_builtin_call_cost
= 1;
3851 eni_size_weights
.div_mod_cost
= 1;
3852 eni_size_weights
.omp_cost
= 40;
3853 eni_size_weights
.tm_cost
= 10;
3854 eni_size_weights
.time_based
= false;
3855 eni_size_weights
.return_cost
= 1;
3857 /* Estimating time for call is difficult, since we have no idea what the
3858 called function does. In the current uses of eni_time_weights,
3859 underestimating the cost does less harm than overestimating it, so
3860 we choose a rather small value here. */
3861 eni_time_weights
.call_cost
= 10;
3862 eni_time_weights
.indirect_call_cost
= 15;
3863 eni_time_weights
.target_builtin_call_cost
= 1;
3864 eni_time_weights
.div_mod_cost
= 10;
3865 eni_time_weights
.omp_cost
= 40;
3866 eni_time_weights
.tm_cost
= 40;
3867 eni_time_weights
.time_based
= true;
3868 eni_time_weights
.return_cost
= 2;
3871 /* Estimate the number of instructions in a gimple_seq. */
3874 count_insns_seq (gimple_seq seq
, eni_weights
*weights
)
3876 gimple_stmt_iterator gsi
;
3878 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3879 n
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
3885 /* Install new lexical TREE_BLOCK underneath 'current_block'. */
3888 prepend_lexical_block (tree current_block
, tree new_block
)
3890 BLOCK_CHAIN (new_block
) = BLOCK_SUBBLOCKS (current_block
);
3891 BLOCK_SUBBLOCKS (current_block
) = new_block
;
3892 BLOCK_SUPERCONTEXT (new_block
) = current_block
;
3895 /* Add local variables from CALLEE to CALLER. */
3898 add_local_variables (struct function
*callee
, struct function
*caller
,
3904 FOR_EACH_LOCAL_DECL (callee
, ix
, var
)
3905 if (!can_be_nonlocal (var
, id
))
3907 tree new_var
= remap_decl (var
, id
);
3909 /* Remap debug-expressions. */
3910 if (TREE_CODE (new_var
) == VAR_DECL
3911 && DECL_HAS_DEBUG_EXPR_P (var
)
3914 tree tem
= DECL_DEBUG_EXPR (var
);
3915 bool old_regimplify
= id
->regimplify
;
3916 id
->remapping_type_depth
++;
3917 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
3918 id
->remapping_type_depth
--;
3919 id
->regimplify
= old_regimplify
;
3920 SET_DECL_DEBUG_EXPR (new_var
, tem
);
3921 DECL_HAS_DEBUG_EXPR_P (new_var
) = 1;
3923 add_local_decl (caller
, new_var
);
3927 /* If STMT is a GIMPLE_CALL, replace it with its inline expansion. */
3930 expand_call_inline (basic_block bb
, gimple stmt
, copy_body_data
*id
)
3934 struct pointer_map_t
*st
, *dst
;
3937 location_t saved_location
;
3938 struct cgraph_edge
*cg_edge
;
3939 cgraph_inline_failed_t reason
;
3940 basic_block return_block
;
3942 gimple_stmt_iterator gsi
, stmt_gsi
;
3943 bool successfully_inlined
= FALSE
;
3944 bool purge_dead_abnormal_edges
;
3946 /* Set input_location here so we get the right instantiation context
3947 if we call instantiate_decl from inlinable_function_p. */
3948 /* FIXME: instantiate_decl isn't called by inlinable_function_p. */
3949 saved_location
= input_location
;
3950 input_location
= gimple_location (stmt
);
3952 /* From here on, we're only interested in CALL_EXPRs. */
3953 if (gimple_code (stmt
) != GIMPLE_CALL
)
3956 cg_edge
= cgraph_edge (id
->dst_node
, stmt
);
3957 gcc_checking_assert (cg_edge
);
3958 /* First, see if we can figure out what function is being called.
3959 If we cannot, then there is no hope of inlining the function. */
3960 if (cg_edge
->indirect_unknown_callee
)
3962 fn
= cg_edge
->callee
->symbol
.decl
;
3963 gcc_checking_assert (fn
);
3965 /* If FN is a declaration of a function in a nested scope that was
3966 globally declared inline, we don't set its DECL_INITIAL.
3967 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
3968 C++ front-end uses it for cdtors to refer to their internal
3969 declarations, that are not real functions. Fortunately those
3970 don't have trees to be saved, so we can tell by checking their
3972 if (!DECL_INITIAL (fn
)
3973 && DECL_ABSTRACT_ORIGIN (fn
)
3974 && gimple_has_body_p (DECL_ABSTRACT_ORIGIN (fn
)))
3975 fn
= DECL_ABSTRACT_ORIGIN (fn
);
3977 /* Don't try to inline functions that are not well-suited to inlining. */
3978 if (cg_edge
->inline_failed
)
3980 reason
= cg_edge
->inline_failed
;
3981 /* If this call was originally indirect, we do not want to emit any
3982 inlining related warnings or sorry messages because there are no
3983 guarantees regarding those. */
3984 if (cg_edge
->indirect_inlining_edge
)
3987 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
))
3988 /* For extern inline functions that get redefined we always
3989 silently ignored always_inline flag. Better behaviour would
3990 be to be able to keep both bodies and use extern inline body
3991 for inlining, but we can't do that because frontends overwrite
3993 && !cg_edge
->callee
->local
.redefined_extern_inline
3994 /* During early inline pass, report only when optimization is
3996 && (cgraph_global_info_ready
3998 /* PR 20090218-1_0.c. Body can be provided by another module. */
3999 && (reason
!= CIF_BODY_NOT_AVAILABLE
|| !flag_generate_lto
))
4001 error ("inlining failed in call to always_inline %q+F: %s", fn
,
4002 cgraph_inline_failed_string (reason
));
4003 error ("called from here");
4005 else if (warn_inline
4006 && DECL_DECLARED_INLINE_P (fn
)
4007 && !DECL_NO_INLINE_WARNING_P (fn
)
4008 && !DECL_IN_SYSTEM_HEADER (fn
)
4009 && reason
!= CIF_UNSPECIFIED
4010 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn
))
4011 /* Do not warn about not inlined recursive calls. */
4012 && !cgraph_edge_recursive_p (cg_edge
)
4013 /* Avoid warnings during early inline pass. */
4014 && cgraph_global_info_ready
)
4016 warning (OPT_Winline
, "inlining failed in call to %q+F: %s",
4017 fn
, _(cgraph_inline_failed_string (reason
)));
4018 warning (OPT_Winline
, "called from here");
4022 fn
= cg_edge
->callee
->symbol
.decl
;
4023 cgraph_get_body (cg_edge
->callee
);
4025 #ifdef ENABLE_CHECKING
4026 if (cg_edge
->callee
->symbol
.decl
!= id
->dst_node
->symbol
.decl
)
4027 verify_cgraph_node (cg_edge
->callee
);
4030 /* We will be inlining this callee. */
4031 id
->eh_lp_nr
= lookup_stmt_eh_lp (stmt
);
4033 /* Update the callers EH personality. */
4034 if (DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->symbol
.decl
))
4035 DECL_FUNCTION_PERSONALITY (cg_edge
->caller
->symbol
.decl
)
4036 = DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->symbol
.decl
);
4038 /* Split the block holding the GIMPLE_CALL. */
4039 e
= split_block (bb
, stmt
);
4041 return_block
= e
->dest
;
4044 /* split_block splits after the statement; work around this by
4045 moving the call into the second block manually. Not pretty,
4046 but seems easier than doing the CFG manipulation by hand
4047 when the GIMPLE_CALL is in the last statement of BB. */
4048 stmt_gsi
= gsi_last_bb (bb
);
4049 gsi_remove (&stmt_gsi
, false);
4051 /* If the GIMPLE_CALL was in the last statement of BB, it may have
4052 been the source of abnormal edges. In this case, schedule
4053 the removal of dead abnormal edges. */
4054 gsi
= gsi_start_bb (return_block
);
4055 if (gsi_end_p (gsi
))
4057 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
4058 purge_dead_abnormal_edges
= true;
4062 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
4063 purge_dead_abnormal_edges
= false;
4066 stmt_gsi
= gsi_start_bb (return_block
);
4068 /* Build a block containing code to initialize the arguments, the
4069 actual inline expansion of the body, and a label for the return
4070 statements within the function to jump to. The type of the
4071 statement expression is the return type of the function call.
4072 ??? If the call does not have an associated block then we will
4073 remap all callee blocks to NULL, effectively dropping most of
4074 its debug information. This should only happen for calls to
4075 artificial decls inserted by the compiler itself. We need to
4076 either link the inlined blocks into the caller block tree or
4077 not refer to them in any way to not break GC for locations. */
4078 if (gimple_block (stmt
))
4080 id
->block
= make_node (BLOCK
);
4081 BLOCK_ABSTRACT_ORIGIN (id
->block
) = fn
;
4082 BLOCK_SOURCE_LOCATION (id
->block
) = LOCATION_LOCUS (input_location
);
4083 prepend_lexical_block (gimple_block (stmt
), id
->block
);
4086 /* Local declarations will be replaced by their equivalents in this
4089 id
->decl_map
= pointer_map_create ();
4090 dst
= id
->debug_map
;
4091 id
->debug_map
= NULL
;
4093 /* Record the function we are about to inline. */
4095 id
->src_node
= cg_edge
->callee
;
4096 id
->src_cfun
= DECL_STRUCT_FUNCTION (fn
);
4097 id
->gimple_call
= stmt
;
4099 gcc_assert (!id
->src_cfun
->after_inlining
);
4102 if (lookup_attribute ("cold", DECL_ATTRIBUTES (fn
)))
4104 gimple_stmt_iterator si
= gsi_last_bb (bb
);
4105 gsi_insert_after (&si
, gimple_build_predict (PRED_COLD_FUNCTION
,
4109 initialize_inlined_parameters (id
, stmt
, fn
, bb
);
4111 if (DECL_INITIAL (fn
))
4113 if (gimple_block (stmt
))
4117 prepend_lexical_block (id
->block
,
4118 remap_blocks (DECL_INITIAL (fn
), id
));
4119 gcc_checking_assert (BLOCK_SUBBLOCKS (id
->block
)
4120 && (BLOCK_CHAIN (BLOCK_SUBBLOCKS (id
->block
))
4122 /* Move vars for PARM_DECLs from DECL_INITIAL block to id->block,
4123 otherwise for DWARF DW_TAG_formal_parameter will not be children of
4124 DW_TAG_inlined_subroutine, but of a DW_TAG_lexical_block
4125 under it. The parameters can be then evaluated in the debugger,
4126 but don't show in backtraces. */
4127 for (var
= &BLOCK_VARS (BLOCK_SUBBLOCKS (id
->block
)); *var
; )
4128 if (TREE_CODE (DECL_ORIGIN (*var
)) == PARM_DECL
)
4131 *var
= TREE_CHAIN (v
);
4132 TREE_CHAIN (v
) = BLOCK_VARS (id
->block
);
4133 BLOCK_VARS (id
->block
) = v
;
4136 var
= &TREE_CHAIN (*var
);
4139 remap_blocks_to_null (DECL_INITIAL (fn
), id
);
4142 /* Return statements in the function body will be replaced by jumps
4143 to the RET_LABEL. */
4144 gcc_assert (DECL_INITIAL (fn
));
4145 gcc_assert (TREE_CODE (DECL_INITIAL (fn
)) == BLOCK
);
4147 /* Find the LHS to which the result of this call is assigned. */
4149 if (gimple_call_lhs (stmt
))
4151 modify_dest
= gimple_call_lhs (stmt
);
4153 /* The function which we are inlining might not return a value,
4154 in which case we should issue a warning that the function
4155 does not return a value. In that case the optimizers will
4156 see that the variable to which the value is assigned was not
4157 initialized. We do not want to issue a warning about that
4158 uninitialized variable. */
4159 if (DECL_P (modify_dest
))
4160 TREE_NO_WARNING (modify_dest
) = 1;
4162 if (gimple_call_return_slot_opt_p (stmt
))
4164 return_slot
= modify_dest
;
4171 /* If we are inlining a call to the C++ operator new, we don't want
4172 to use type based alias analysis on the return value. Otherwise
4173 we may get confused if the compiler sees that the inlined new
4174 function returns a pointer which was just deleted. See bug
4176 if (DECL_IS_OPERATOR_NEW (fn
))
4182 /* Declare the return variable for the function. */
4183 use_retvar
= declare_return_variable (id
, return_slot
, modify_dest
, bb
);
4185 /* Add local vars in this inlined callee to caller. */
4186 add_local_variables (id
->src_cfun
, cfun
, id
);
4188 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4190 fprintf (dump_file
, "Inlining ");
4191 print_generic_expr (dump_file
, id
->src_fn
, 0);
4192 fprintf (dump_file
, " to ");
4193 print_generic_expr (dump_file
, id
->dst_fn
, 0);
4194 fprintf (dump_file
, " with frequency %i\n", cg_edge
->frequency
);
4197 /* This is it. Duplicate the callee body. Assume callee is
4198 pre-gimplified. Note that we must not alter the caller
4199 function in any way before this point, as this CALL_EXPR may be
4200 a self-referential call; if we're calling ourselves, we need to
4201 duplicate our body before altering anything. */
4202 copy_body (id
, bb
->count
,
4203 GCOV_COMPUTE_SCALE (cg_edge
->frequency
, CGRAPH_FREQ_BASE
),
4204 bb
, return_block
, NULL
, NULL
);
4206 /* Reset the escaped solution. */
4207 if (cfun
->gimple_df
)
4208 pt_solution_reset (&cfun
->gimple_df
->escaped
);
4213 pointer_map_destroy (id
->debug_map
);
4214 id
->debug_map
= dst
;
4216 pointer_map_destroy (id
->decl_map
);
4219 /* Unlink the calls virtual operands before replacing it. */
4220 unlink_stmt_vdef (stmt
);
4222 /* If the inlined function returns a result that we care about,
4223 substitute the GIMPLE_CALL with an assignment of the return
4224 variable to the LHS of the call. That is, if STMT was
4225 'a = foo (...)', substitute the call with 'a = USE_RETVAR'. */
4226 if (use_retvar
&& gimple_call_lhs (stmt
))
4228 gimple old_stmt
= stmt
;
4229 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), use_retvar
);
4230 gsi_replace (&stmt_gsi
, stmt
, false);
4231 maybe_clean_or_replace_eh_stmt (old_stmt
, stmt
);
4235 /* Handle the case of inlining a function with no return
4236 statement, which causes the return value to become undefined. */
4237 if (gimple_call_lhs (stmt
)
4238 && TREE_CODE (gimple_call_lhs (stmt
)) == SSA_NAME
)
4240 tree name
= gimple_call_lhs (stmt
);
4241 tree var
= SSA_NAME_VAR (name
);
4242 tree def
= ssa_default_def (cfun
, var
);
4246 /* If the variable is used undefined, make this name
4247 undefined via a move. */
4248 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), def
);
4249 gsi_replace (&stmt_gsi
, stmt
, true);
4253 /* Otherwise make this variable undefined. */
4254 gsi_remove (&stmt_gsi
, true);
4255 set_ssa_default_def (cfun
, var
, name
);
4256 SSA_NAME_DEF_STMT (name
) = gimple_build_nop ();
4260 gsi_remove (&stmt_gsi
, true);
4263 if (purge_dead_abnormal_edges
)
4265 gimple_purge_dead_eh_edges (return_block
);
4266 gimple_purge_dead_abnormal_call_edges (return_block
);
4269 /* If the value of the new expression is ignored, that's OK. We
4270 don't warn about this for CALL_EXPRs, so we shouldn't warn about
4271 the equivalent inlined version either. */
4272 if (is_gimple_assign (stmt
))
4274 gcc_assert (gimple_assign_single_p (stmt
)
4275 || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
)));
4276 TREE_USED (gimple_assign_rhs1 (stmt
)) = 1;
4279 /* Output the inlining info for this abstract function, since it has been
4280 inlined. If we don't do this now, we can lose the information about the
4281 variables in the function when the blocks get blown away as soon as we
4282 remove the cgraph node. */
4283 if (gimple_block (stmt
))
4284 (*debug_hooks
->outlining_inline_function
) (cg_edge
->callee
->symbol
.decl
);
4286 /* Update callgraph if needed. */
4287 cgraph_remove_node (cg_edge
->callee
);
4289 id
->block
= NULL_TREE
;
4290 successfully_inlined
= TRUE
;
4293 input_location
= saved_location
;
4294 return successfully_inlined
;
4297 /* Expand call statements reachable from STMT_P.
4298 We can only have CALL_EXPRs as the "toplevel" tree code or nested
4299 in a MODIFY_EXPR. */
4302 gimple_expand_calls_inline (basic_block bb
, copy_body_data
*id
)
4304 gimple_stmt_iterator gsi
;
4306 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4308 gimple stmt
= gsi_stmt (gsi
);
4310 if (is_gimple_call (stmt
)
4311 && expand_call_inline (bb
, stmt
, id
))
4319 /* Walk all basic blocks created after FIRST and try to fold every statement
4320 in the STATEMENTS pointer set. */
4323 fold_marked_statements (int first
, struct pointer_set_t
*statements
)
4325 for (; first
< n_basic_blocks
; first
++)
4326 if (BASIC_BLOCK (first
))
4328 gimple_stmt_iterator gsi
;
4330 for (gsi
= gsi_start_bb (BASIC_BLOCK (first
));
4333 if (pointer_set_contains (statements
, gsi_stmt (gsi
)))
4335 gimple old_stmt
= gsi_stmt (gsi
);
4336 tree old_decl
= is_gimple_call (old_stmt
) ? gimple_call_fndecl (old_stmt
) : 0;
4338 if (old_decl
&& DECL_BUILT_IN (old_decl
))
4340 /* Folding builtins can create multiple instructions,
4341 we need to look at all of them. */
4342 gimple_stmt_iterator i2
= gsi
;
4344 if (fold_stmt (&gsi
))
4347 /* If a builtin at the end of a bb folded into nothing,
4348 the following loop won't work. */
4349 if (gsi_end_p (gsi
))
4351 cgraph_update_edges_for_call_stmt (old_stmt
,
4356 i2
= gsi_start_bb (BASIC_BLOCK (first
));
4361 new_stmt
= gsi_stmt (i2
);
4362 update_stmt (new_stmt
);
4363 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4366 if (new_stmt
== gsi_stmt (gsi
))
4368 /* It is okay to check only for the very last
4369 of these statements. If it is a throwing
4370 statement nothing will change. If it isn't
4371 this can remove EH edges. If that weren't
4372 correct then because some intermediate stmts
4373 throw, but not the last one. That would mean
4374 we'd have to split the block, which we can't
4375 here and we'd loose anyway. And as builtins
4376 probably never throw, this all
4378 if (maybe_clean_or_replace_eh_stmt (old_stmt
,
4380 gimple_purge_dead_eh_edges (BASIC_BLOCK (first
));
4387 else if (fold_stmt (&gsi
))
4389 /* Re-read the statement from GSI as fold_stmt() may
4391 gimple new_stmt
= gsi_stmt (gsi
);
4392 update_stmt (new_stmt
);
4394 if (is_gimple_call (old_stmt
)
4395 || is_gimple_call (new_stmt
))
4396 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4399 if (maybe_clean_or_replace_eh_stmt (old_stmt
, new_stmt
))
4400 gimple_purge_dead_eh_edges (BASIC_BLOCK (first
));
4406 /* Return true if BB has at least one abnormal outgoing edge. */
4409 has_abnormal_outgoing_edge_p (basic_block bb
)
4414 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
4415 if (e
->flags
& EDGE_ABNORMAL
)
4421 /* Expand calls to inline functions in the body of FN. */
4424 optimize_inline_calls (tree fn
)
4428 int last
= n_basic_blocks
;
4429 struct gimplify_ctx gctx
;
4430 bool inlined_p
= false;
4433 memset (&id
, 0, sizeof (id
));
4435 id
.src_node
= id
.dst_node
= cgraph_get_node (fn
);
4436 gcc_assert (id
.dst_node
->symbol
.definition
);
4438 /* Or any functions that aren't finished yet. */
4439 if (current_function_decl
)
4440 id
.dst_fn
= current_function_decl
;
4442 id
.copy_decl
= copy_decl_maybe_to_var
;
4443 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
4444 id
.transform_new_cfg
= false;
4445 id
.transform_return_to_modify
= true;
4446 id
.transform_lang_insert_block
= NULL
;
4447 id
.statements_to_fold
= pointer_set_create ();
4449 push_gimplify_context (&gctx
);
4451 /* We make no attempts to keep dominance info up-to-date. */
4452 free_dominance_info (CDI_DOMINATORS
);
4453 free_dominance_info (CDI_POST_DOMINATORS
);
4455 /* Register specific gimple functions. */
4456 gimple_register_cfg_hooks ();
4458 /* Reach the trees by walking over the CFG, and note the
4459 enclosing basic-blocks in the call edges. */
4460 /* We walk the blocks going forward, because inlined function bodies
4461 will split id->current_basic_block, and the new blocks will
4462 follow it; we'll trudge through them, processing their CALL_EXPRs
4465 inlined_p
|= gimple_expand_calls_inline (bb
, &id
);
4467 pop_gimplify_context (NULL
);
4469 #ifdef ENABLE_CHECKING
4471 struct cgraph_edge
*e
;
4473 verify_cgraph_node (id
.dst_node
);
4475 /* Double check that we inlined everything we are supposed to inline. */
4476 for (e
= id
.dst_node
->callees
; e
; e
= e
->next_callee
)
4477 gcc_assert (e
->inline_failed
);
4481 /* Fold queued statements. */
4482 fold_marked_statements (last
, id
.statements_to_fold
);
4483 pointer_set_destroy (id
.statements_to_fold
);
4485 gcc_assert (!id
.debug_stmts
.exists ());
4487 /* If we didn't inline into the function there is nothing to do. */
4491 /* Renumber the lexical scoping (non-code) blocks consecutively. */
4494 delete_unreachable_blocks_update_callgraph (&id
);
4495 #ifdef ENABLE_CHECKING
4496 verify_cgraph_node (id
.dst_node
);
4499 /* It would be nice to check SSA/CFG/statement consistency here, but it is
4500 not possible yet - the IPA passes might make various functions to not
4501 throw and they don't care to proactively update local EH info. This is
4502 done later in fixup_cfg pass that also execute the verification. */
4503 return (TODO_update_ssa
4505 | (gimple_in_ssa_p (cfun
) ? TODO_remove_unused_locals
: 0)
4506 | (gimple_in_ssa_p (cfun
) ? TODO_update_address_taken
: 0)
4507 | (profile_status
!= PROFILE_ABSENT
? TODO_rebuild_frequencies
: 0));
4510 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
4513 copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
4515 enum tree_code code
= TREE_CODE (*tp
);
4516 enum tree_code_class cl
= TREE_CODE_CLASS (code
);
4518 /* We make copies of most nodes. */
4519 if (IS_EXPR_CODE_CLASS (cl
)
4520 || code
== TREE_LIST
4522 || code
== TYPE_DECL
4523 || code
== OMP_CLAUSE
)
4525 /* Because the chain gets clobbered when we make a copy, we save it
4527 tree chain
= NULL_TREE
, new_tree
;
4529 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
4530 chain
= TREE_CHAIN (*tp
);
4532 /* Copy the node. */
4533 new_tree
= copy_node (*tp
);
4535 /* Propagate mudflap marked-ness. */
4536 if (flag_mudflap
&& mf_marked_p (*tp
))
4541 /* Now, restore the chain, if appropriate. That will cause
4542 walk_tree to walk into the chain as well. */
4543 if (code
== PARM_DECL
4544 || code
== TREE_LIST
4545 || code
== OMP_CLAUSE
)
4546 TREE_CHAIN (*tp
) = chain
;
4548 /* For now, we don't update BLOCKs when we make copies. So, we
4549 have to nullify all BIND_EXPRs. */
4550 if (TREE_CODE (*tp
) == BIND_EXPR
)
4551 BIND_EXPR_BLOCK (*tp
) = NULL_TREE
;
4553 else if (code
== CONSTRUCTOR
)
4555 /* CONSTRUCTOR nodes need special handling because
4556 we need to duplicate the vector of elements. */
4559 new_tree
= copy_node (*tp
);
4561 /* Propagate mudflap marked-ness. */
4562 if (flag_mudflap
&& mf_marked_p (*tp
))
4565 CONSTRUCTOR_ELTS (new_tree
) = vec_safe_copy (CONSTRUCTOR_ELTS (*tp
));
4568 else if (code
== STATEMENT_LIST
)
4569 /* We used to just abort on STATEMENT_LIST, but we can run into them
4570 with statement-expressions (c++/40975). */
4571 copy_statement_list (tp
);
4572 else if (TREE_CODE_CLASS (code
) == tcc_type
)
4574 else if (TREE_CODE_CLASS (code
) == tcc_declaration
)
4576 else if (TREE_CODE_CLASS (code
) == tcc_constant
)
4581 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
4582 information indicating to what new SAVE_EXPR this one should be mapped,
4583 use that one. Otherwise, create a new node and enter it in ST. FN is
4584 the function into which the copy will be placed. */
4587 remap_save_expr (tree
*tp
, void *st_
, int *walk_subtrees
)
4589 struct pointer_map_t
*st
= (struct pointer_map_t
*) st_
;
4593 /* See if we already encountered this SAVE_EXPR. */
4594 n
= (tree
*) pointer_map_contains (st
, *tp
);
4596 /* If we didn't already remap this SAVE_EXPR, do so now. */
4599 t
= copy_node (*tp
);
4601 /* Remember this SAVE_EXPR. */
4602 *pointer_map_insert (st
, *tp
) = t
;
4603 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
4604 *pointer_map_insert (st
, t
) = t
;
4608 /* We've already walked into this SAVE_EXPR; don't do it again. */
4613 /* Replace this SAVE_EXPR with the copy. */
4617 /* Called via walk_gimple_seq. If *GSIP points to a GIMPLE_LABEL for a local
4618 label, copies the declaration and enters it in the splay_tree in DATA (which
4619 is really a 'copy_body_data *'. */
4622 mark_local_labels_stmt (gimple_stmt_iterator
*gsip
,
4623 bool *handled_ops_p ATTRIBUTE_UNUSED
,
4624 struct walk_stmt_info
*wi
)
4626 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4627 gimple stmt
= gsi_stmt (*gsip
);
4629 if (gimple_code (stmt
) == GIMPLE_LABEL
)
4631 tree decl
= gimple_label_label (stmt
);
4633 /* Copy the decl and remember the copy. */
4634 insert_decl_map (id
, decl
, id
->copy_decl (decl
, id
));
4641 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
4642 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
4643 remaps all local declarations to appropriate replacements in gimple
4647 replace_locals_op (tree
*tp
, int *walk_subtrees
, void *data
)
4649 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
4650 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4651 struct pointer_map_t
*st
= id
->decl_map
;
4655 /* Only a local declaration (variable or label). */
4656 if ((TREE_CODE (expr
) == VAR_DECL
4657 && !TREE_STATIC (expr
))
4658 || TREE_CODE (expr
) == LABEL_DECL
)
4660 /* Lookup the declaration. */
4661 n
= (tree
*) pointer_map_contains (st
, expr
);
4663 /* If it's there, remap it. */
4668 else if (TREE_CODE (expr
) == STATEMENT_LIST
4669 || TREE_CODE (expr
) == BIND_EXPR
4670 || TREE_CODE (expr
) == SAVE_EXPR
)
4672 else if (TREE_CODE (expr
) == TARGET_EXPR
)
4674 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
4675 It's OK for this to happen if it was part of a subtree that
4676 isn't immediately expanded, such as operand 2 of another
4678 if (!TREE_OPERAND (expr
, 1))
4680 TREE_OPERAND (expr
, 1) = TREE_OPERAND (expr
, 3);
4681 TREE_OPERAND (expr
, 3) = NULL_TREE
;
4685 /* Keep iterating. */
4690 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
4691 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
4692 remaps all local declarations to appropriate replacements in gimple
4696 replace_locals_stmt (gimple_stmt_iterator
*gsip
,
4697 bool *handled_ops_p ATTRIBUTE_UNUSED
,
4698 struct walk_stmt_info
*wi
)
4700 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4701 gimple stmt
= gsi_stmt (*gsip
);
4703 if (gimple_code (stmt
) == GIMPLE_BIND
)
4705 tree block
= gimple_bind_block (stmt
);
4709 remap_block (&block
, id
);
4710 gimple_bind_set_block (stmt
, block
);
4713 /* This will remap a lot of the same decls again, but this should be
4715 if (gimple_bind_vars (stmt
))
4716 gimple_bind_set_vars (stmt
, remap_decls (gimple_bind_vars (stmt
),
4720 /* Keep iterating. */
4725 /* Copies everything in SEQ and replaces variables and labels local to
4726 current_function_decl. */
4729 copy_gimple_seq_and_replace_locals (gimple_seq seq
)
4732 struct walk_stmt_info wi
;
4733 struct pointer_set_t
*visited
;
4736 /* There's nothing to do for NULL_TREE. */
4741 memset (&id
, 0, sizeof (id
));
4742 id
.src_fn
= current_function_decl
;
4743 id
.dst_fn
= current_function_decl
;
4744 id
.decl_map
= pointer_map_create ();
4745 id
.debug_map
= NULL
;
4747 id
.copy_decl
= copy_decl_no_change
;
4748 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
4749 id
.transform_new_cfg
= false;
4750 id
.transform_return_to_modify
= false;
4751 id
.transform_lang_insert_block
= NULL
;
4753 /* Walk the tree once to find local labels. */
4754 memset (&wi
, 0, sizeof (wi
));
4755 visited
= pointer_set_create ();
4758 walk_gimple_seq (seq
, mark_local_labels_stmt
, NULL
, &wi
);
4759 pointer_set_destroy (visited
);
4761 copy
= gimple_seq_copy (seq
);
4763 /* Walk the copy, remapping decls. */
4764 memset (&wi
, 0, sizeof (wi
));
4766 walk_gimple_seq (copy
, replace_locals_stmt
, replace_locals_op
, &wi
);
4769 pointer_map_destroy (id
.decl_map
);
4771 pointer_map_destroy (id
.debug_map
);
4777 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
4780 debug_find_tree_1 (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
, void *data
)
4789 debug_find_tree (tree top
, tree search
)
4791 return walk_tree_without_duplicates (&top
, debug_find_tree_1
, search
) != 0;
4795 /* Declare the variables created by the inliner. Add all the variables in
4796 VARS to BIND_EXPR. */
4799 declare_inline_vars (tree block
, tree vars
)
4802 for (t
= vars
; t
; t
= DECL_CHAIN (t
))
4804 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
4805 gcc_assert (!TREE_STATIC (t
) && !TREE_ASM_WRITTEN (t
));
4806 add_local_decl (cfun
, t
);
4810 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), vars
);
4813 /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN,
4814 but now it will be in the TO_FN. PARM_TO_VAR means enable PARM_DECL to
4815 VAR_DECL translation. */
4818 copy_decl_for_dup_finish (copy_body_data
*id
, tree decl
, tree copy
)
4820 /* Don't generate debug information for the copy if we wouldn't have
4821 generated it for the copy either. */
4822 DECL_ARTIFICIAL (copy
) = DECL_ARTIFICIAL (decl
);
4823 DECL_IGNORED_P (copy
) = DECL_IGNORED_P (decl
);
4825 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
4826 declaration inspired this copy. */
4827 DECL_ABSTRACT_ORIGIN (copy
) = DECL_ORIGIN (decl
);
4829 /* The new variable/label has no RTL, yet. */
4830 if (CODE_CONTAINS_STRUCT (TREE_CODE (copy
), TS_DECL_WRTL
)
4831 && !TREE_STATIC (copy
) && !DECL_EXTERNAL (copy
))
4832 SET_DECL_RTL (copy
, 0);
4834 /* These args would always appear unused, if not for this. */
4835 TREE_USED (copy
) = 1;
4837 /* Set the context for the new declaration. */
4838 if (!DECL_CONTEXT (decl
))
4839 /* Globals stay global. */
4841 else if (DECL_CONTEXT (decl
) != id
->src_fn
)
4842 /* Things that weren't in the scope of the function we're inlining
4843 from aren't in the scope we're inlining to, either. */
4845 else if (TREE_STATIC (decl
))
4846 /* Function-scoped static variables should stay in the original
4850 /* Ordinary automatic local variables are now in the scope of the
4852 DECL_CONTEXT (copy
) = id
->dst_fn
;
4858 copy_decl_to_var (tree decl
, copy_body_data
*id
)
4862 gcc_assert (TREE_CODE (decl
) == PARM_DECL
4863 || TREE_CODE (decl
) == RESULT_DECL
);
4865 type
= TREE_TYPE (decl
);
4867 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
4868 VAR_DECL
, DECL_NAME (decl
), type
);
4869 if (DECL_PT_UID_SET_P (decl
))
4870 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
4871 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
4872 TREE_READONLY (copy
) = TREE_READONLY (decl
);
4873 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
4874 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
4876 return copy_decl_for_dup_finish (id
, decl
, copy
);
4879 /* Like copy_decl_to_var, but create a return slot object instead of a
4880 pointer variable for return by invisible reference. */
4883 copy_result_decl_to_var (tree decl
, copy_body_data
*id
)
4887 gcc_assert (TREE_CODE (decl
) == PARM_DECL
4888 || TREE_CODE (decl
) == RESULT_DECL
);
4890 type
= TREE_TYPE (decl
);
4891 if (DECL_BY_REFERENCE (decl
))
4892 type
= TREE_TYPE (type
);
4894 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
4895 VAR_DECL
, DECL_NAME (decl
), type
);
4896 if (DECL_PT_UID_SET_P (decl
))
4897 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
4898 TREE_READONLY (copy
) = TREE_READONLY (decl
);
4899 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
4900 if (!DECL_BY_REFERENCE (decl
))
4902 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
4903 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
4906 return copy_decl_for_dup_finish (id
, decl
, copy
);
4910 copy_decl_no_change (tree decl
, copy_body_data
*id
)
4914 copy
= copy_node (decl
);
4916 /* The COPY is not abstract; it will be generated in DST_FN. */
4917 DECL_ABSTRACT (copy
) = 0;
4918 lang_hooks
.dup_lang_specific_decl (copy
);
4920 /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
4921 been taken; it's for internal bookkeeping in expand_goto_internal. */
4922 if (TREE_CODE (copy
) == LABEL_DECL
)
4924 TREE_ADDRESSABLE (copy
) = 0;
4925 LABEL_DECL_UID (copy
) = -1;
4928 return copy_decl_for_dup_finish (id
, decl
, copy
);
4932 copy_decl_maybe_to_var (tree decl
, copy_body_data
*id
)
4934 if (TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
)
4935 return copy_decl_to_var (decl
, id
);
4937 return copy_decl_no_change (decl
, id
);
4940 /* Return a copy of the function's argument tree. */
4942 copy_arguments_for_versioning (tree orig_parm
, copy_body_data
* id
,
4943 bitmap args_to_skip
, tree
*vars
)
4946 tree new_parm
= NULL
;
4951 for (arg
= orig_parm
; arg
; arg
= DECL_CHAIN (arg
), i
++)
4952 if (!args_to_skip
|| !bitmap_bit_p (args_to_skip
, i
))
4954 tree new_tree
= remap_decl (arg
, id
);
4955 if (TREE_CODE (new_tree
) != PARM_DECL
)
4956 new_tree
= id
->copy_decl (arg
, id
);
4957 lang_hooks
.dup_lang_specific_decl (new_tree
);
4959 parg
= &DECL_CHAIN (new_tree
);
4961 else if (!pointer_map_contains (id
->decl_map
, arg
))
4963 /* Make an equivalent VAR_DECL. If the argument was used
4964 as temporary variable later in function, the uses will be
4965 replaced by local variable. */
4966 tree var
= copy_decl_to_var (arg
, id
);
4967 insert_decl_map (id
, arg
, var
);
4968 /* Declare this new variable. */
4969 DECL_CHAIN (var
) = *vars
;
4975 /* Return a copy of the function's static chain. */
4977 copy_static_chain (tree static_chain
, copy_body_data
* id
)
4979 tree
*chain_copy
, *pvar
;
4981 chain_copy
= &static_chain
;
4982 for (pvar
= chain_copy
; *pvar
; pvar
= &DECL_CHAIN (*pvar
))
4984 tree new_tree
= remap_decl (*pvar
, id
);
4985 lang_hooks
.dup_lang_specific_decl (new_tree
);
4986 DECL_CHAIN (new_tree
) = DECL_CHAIN (*pvar
);
4989 return static_chain
;
4992 /* Return true if the function is allowed to be versioned.
4993 This is a guard for the versioning functionality. */
4996 tree_versionable_function_p (tree fndecl
)
4998 return (!lookup_attribute ("noclone", DECL_ATTRIBUTES (fndecl
))
4999 && copy_forbidden (DECL_STRUCT_FUNCTION (fndecl
), fndecl
) == NULL
);
5002 /* Delete all unreachable basic blocks and update callgraph.
5003 Doing so is somewhat nontrivial because we need to update all clones and
5004 remove inline function that become unreachable. */
5007 delete_unreachable_blocks_update_callgraph (copy_body_data
*id
)
5009 bool changed
= false;
5010 basic_block b
, next_bb
;
5012 find_unreachable_blocks ();
5014 /* Delete all unreachable basic blocks. */
5016 for (b
= ENTRY_BLOCK_PTR
->next_bb
; b
!= EXIT_BLOCK_PTR
; b
= next_bb
)
5018 next_bb
= b
->next_bb
;
5020 if (!(b
->flags
& BB_REACHABLE
))
5022 gimple_stmt_iterator bsi
;
5024 for (bsi
= gsi_start_bb (b
); !gsi_end_p (bsi
); gsi_next (&bsi
))
5026 struct cgraph_edge
*e
;
5027 struct cgraph_node
*node
;
5029 ipa_remove_stmt_references ((symtab_node
)id
->dst_node
, gsi_stmt (bsi
));
5031 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
5032 &&(e
= cgraph_edge (id
->dst_node
, gsi_stmt (bsi
))) != NULL
)
5034 if (!e
->inline_failed
)
5035 cgraph_remove_node_and_inline_clones (e
->callee
, id
->dst_node
);
5037 cgraph_remove_edge (e
);
5039 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
5040 && id
->dst_node
->clones
)
5041 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
5043 ipa_remove_stmt_references ((symtab_node
)node
, gsi_stmt (bsi
));
5044 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
5045 && (e
= cgraph_edge (node
, gsi_stmt (bsi
))) != NULL
)
5047 if (!e
->inline_failed
)
5048 cgraph_remove_node_and_inline_clones (e
->callee
, id
->dst_node
);
5050 cgraph_remove_edge (e
);
5054 node
= node
->clones
;
5055 else if (node
->next_sibling_clone
)
5056 node
= node
->next_sibling_clone
;
5059 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5060 node
= node
->clone_of
;
5061 if (node
!= id
->dst_node
)
5062 node
= node
->next_sibling_clone
;
5066 delete_basic_block (b
);
5074 /* Update clone info after duplication. */
5077 update_clone_info (copy_body_data
* id
)
5079 struct cgraph_node
*node
;
5080 if (!id
->dst_node
->clones
)
5082 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
5084 /* First update replace maps to match the new body. */
5085 if (node
->clone
.tree_map
)
5088 for (i
= 0; i
< vec_safe_length (node
->clone
.tree_map
); i
++)
5090 struct ipa_replace_map
*replace_info
;
5091 replace_info
= (*node
->clone
.tree_map
)[i
];
5092 walk_tree (&replace_info
->old_tree
, copy_tree_body_r
, id
, NULL
);
5093 walk_tree (&replace_info
->new_tree
, copy_tree_body_r
, id
, NULL
);
5097 node
= node
->clones
;
5098 else if (node
->next_sibling_clone
)
5099 node
= node
->next_sibling_clone
;
5102 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5103 node
= node
->clone_of
;
5104 if (node
!= id
->dst_node
)
5105 node
= node
->next_sibling_clone
;
5110 /* Create a copy of a function's tree.
5111 OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
5112 of the original function and the new copied function
5113 respectively. In case we want to replace a DECL
5114 tree with another tree while duplicating the function's
5115 body, TREE_MAP represents the mapping between these
5116 trees. If UPDATE_CLONES is set, the call_stmt fields
5117 of edges of clones of the function will be updated.
5119 If non-NULL ARGS_TO_SKIP determine function parameters to remove
5121 If SKIP_RETURN is true, the new version will return void.
5122 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
5123 If non_NULL NEW_ENTRY determine new entry BB of the clone.
5126 tree_function_versioning (tree old_decl
, tree new_decl
,
5127 vec
<ipa_replace_map_p
, va_gc
> *tree_map
,
5128 bool update_clones
, bitmap args_to_skip
,
5129 bool skip_return
, bitmap blocks_to_copy
,
5130 basic_block new_entry
)
5132 struct cgraph_node
*old_version_node
;
5133 struct cgraph_node
*new_version_node
;
5137 struct ipa_replace_map
*replace_info
;
5138 basic_block old_entry_block
, bb
;
5139 vec
<gimple
> init_stmts
;
5140 init_stmts
.create (10);
5141 tree vars
= NULL_TREE
;
5143 gcc_assert (TREE_CODE (old_decl
) == FUNCTION_DECL
5144 && TREE_CODE (new_decl
) == FUNCTION_DECL
);
5145 DECL_POSSIBLY_INLINED (old_decl
) = 1;
5147 old_version_node
= cgraph_get_node (old_decl
);
5148 gcc_checking_assert (old_version_node
);
5149 new_version_node
= cgraph_get_node (new_decl
);
5150 gcc_checking_assert (new_version_node
);
5152 /* Copy over debug args. */
5153 if (DECL_HAS_DEBUG_ARGS_P (old_decl
))
5155 vec
<tree
, va_gc
> **new_debug_args
, **old_debug_args
;
5156 gcc_checking_assert (decl_debug_args_lookup (new_decl
) == NULL
);
5157 DECL_HAS_DEBUG_ARGS_P (new_decl
) = 0;
5158 old_debug_args
= decl_debug_args_lookup (old_decl
);
5161 new_debug_args
= decl_debug_args_insert (new_decl
);
5162 *new_debug_args
= vec_safe_copy (*old_debug_args
);
5166 /* Output the inlining info for this abstract function, since it has been
5167 inlined. If we don't do this now, we can lose the information about the
5168 variables in the function when the blocks get blown away as soon as we
5169 remove the cgraph node. */
5170 (*debug_hooks
->outlining_inline_function
) (old_decl
);
5172 DECL_ARTIFICIAL (new_decl
) = 1;
5173 DECL_ABSTRACT_ORIGIN (new_decl
) = DECL_ORIGIN (old_decl
);
5174 if (DECL_ORIGIN (old_decl
) == old_decl
)
5175 old_version_node
->used_as_abstract_origin
= true;
5176 DECL_FUNCTION_PERSONALITY (new_decl
) = DECL_FUNCTION_PERSONALITY (old_decl
);
5178 /* Prepare the data structures for the tree copy. */
5179 memset (&id
, 0, sizeof (id
));
5181 /* Generate a new name for the new version. */
5182 id
.statements_to_fold
= pointer_set_create ();
5184 id
.decl_map
= pointer_map_create ();
5185 id
.debug_map
= NULL
;
5186 id
.src_fn
= old_decl
;
5187 id
.dst_fn
= new_decl
;
5188 id
.src_node
= old_version_node
;
5189 id
.dst_node
= new_version_node
;
5190 id
.src_cfun
= DECL_STRUCT_FUNCTION (old_decl
);
5191 id
.blocks_to_copy
= blocks_to_copy
;
5192 if (id
.src_node
->ipa_transforms_to_apply
.exists ())
5194 vec
<ipa_opt_pass
> old_transforms_to_apply
5195 = id
.dst_node
->ipa_transforms_to_apply
;
5198 id
.dst_node
->ipa_transforms_to_apply
5199 = id
.src_node
->ipa_transforms_to_apply
.copy ();
5200 for (i
= 0; i
< old_transforms_to_apply
.length (); i
++)
5201 id
.dst_node
->ipa_transforms_to_apply
.safe_push (old_transforms_to_apply
[i
]);
5202 old_transforms_to_apply
.release ();
5205 id
.copy_decl
= copy_decl_no_change
;
5206 id
.transform_call_graph_edges
5207 = update_clones
? CB_CGE_MOVE_CLONES
: CB_CGE_MOVE
;
5208 id
.transform_new_cfg
= true;
5209 id
.transform_return_to_modify
= false;
5210 id
.transform_lang_insert_block
= NULL
;
5212 old_entry_block
= ENTRY_BLOCK_PTR_FOR_FUNCTION
5213 (DECL_STRUCT_FUNCTION (old_decl
));
5214 DECL_RESULT (new_decl
) = DECL_RESULT (old_decl
);
5215 DECL_ARGUMENTS (new_decl
) = DECL_ARGUMENTS (old_decl
);
5216 initialize_cfun (new_decl
, old_decl
,
5217 old_entry_block
->count
);
5218 DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
->ipa_pta
5219 = id
.src_cfun
->gimple_df
->ipa_pta
;
5221 /* Copy the function's static chain. */
5222 p
= DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
;
5224 DECL_STRUCT_FUNCTION (new_decl
)->static_chain_decl
=
5225 copy_static_chain (DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
,
5228 /* If there's a tree_map, prepare for substitution. */
5230 for (i
= 0; i
< tree_map
->length (); i
++)
5233 replace_info
= (*tree_map
)[i
];
5234 if (replace_info
->replace_p
)
5236 if (!replace_info
->old_tree
)
5238 int i
= replace_info
->parm_num
;
5242 for (parm
= DECL_ARGUMENTS (old_decl
); i
; parm
= DECL_CHAIN (parm
))
5244 replace_info
->old_tree
= parm
;
5245 req_type
= TREE_TYPE (parm
);
5246 if (!useless_type_conversion_p (req_type
, TREE_TYPE (replace_info
->new_tree
)))
5248 if (fold_convertible_p (req_type
, replace_info
->new_tree
))
5249 replace_info
->new_tree
= fold_build1 (NOP_EXPR
, req_type
, replace_info
->new_tree
);
5250 else if (TYPE_SIZE (req_type
) == TYPE_SIZE (TREE_TYPE (replace_info
->new_tree
)))
5251 replace_info
->new_tree
= fold_build1 (VIEW_CONVERT_EXPR
, req_type
, replace_info
->new_tree
);
5256 fprintf (dump_file
, " const ");
5257 print_generic_expr (dump_file
, replace_info
->new_tree
, 0);
5258 fprintf (dump_file
, " can't be converted to param ");
5259 print_generic_expr (dump_file
, parm
, 0);
5260 fprintf (dump_file
, "\n");
5262 replace_info
->old_tree
= NULL
;
5267 gcc_assert (TREE_CODE (replace_info
->old_tree
) == PARM_DECL
);
5268 if (replace_info
->old_tree
)
5270 init
= setup_one_parameter (&id
, replace_info
->old_tree
,
5271 replace_info
->new_tree
, id
.src_fn
,
5275 init_stmts
.safe_push (init
);
5279 /* Copy the function's arguments. */
5280 if (DECL_ARGUMENTS (old_decl
) != NULL_TREE
)
5281 DECL_ARGUMENTS (new_decl
) =
5282 copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl
), &id
,
5283 args_to_skip
, &vars
);
5285 DECL_INITIAL (new_decl
) = remap_blocks (DECL_INITIAL (id
.src_fn
), &id
);
5286 BLOCK_SUPERCONTEXT (DECL_INITIAL (new_decl
)) = new_decl
;
5288 declare_inline_vars (DECL_INITIAL (new_decl
), vars
);
5290 if (!vec_safe_is_empty (DECL_STRUCT_FUNCTION (old_decl
)->local_decls
))
5291 /* Add local vars. */
5292 add_local_variables (DECL_STRUCT_FUNCTION (old_decl
), cfun
, &id
);
5294 if (DECL_RESULT (old_decl
) == NULL_TREE
)
5296 else if (skip_return
&& !VOID_TYPE_P (TREE_TYPE (DECL_RESULT (old_decl
))))
5298 DECL_RESULT (new_decl
)
5299 = build_decl (DECL_SOURCE_LOCATION (DECL_RESULT (old_decl
)),
5300 RESULT_DECL
, NULL_TREE
, void_type_node
);
5301 DECL_CONTEXT (DECL_RESULT (new_decl
)) = new_decl
;
5302 cfun
->returns_struct
= 0;
5303 cfun
->returns_pcc_struct
= 0;
5308 DECL_RESULT (new_decl
) = remap_decl (DECL_RESULT (old_decl
), &id
);
5309 lang_hooks
.dup_lang_specific_decl (DECL_RESULT (new_decl
));
5310 if (gimple_in_ssa_p (id
.src_cfun
)
5311 && DECL_BY_REFERENCE (DECL_RESULT (old_decl
))
5312 && (old_name
= ssa_default_def (id
.src_cfun
, DECL_RESULT (old_decl
))))
5314 tree new_name
= make_ssa_name (DECL_RESULT (new_decl
), NULL
);
5315 insert_decl_map (&id
, old_name
, new_name
);
5316 SSA_NAME_DEF_STMT (new_name
) = gimple_build_nop ();
5317 set_ssa_default_def (cfun
, DECL_RESULT (new_decl
), new_name
);
5321 /* Set up the destination functions loop tree. */
5322 if (loops_for_fn (DECL_STRUCT_FUNCTION (old_decl
)) != NULL
)
5324 cfun
->curr_properties
&= ~PROP_loops
;
5325 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
5326 cfun
->curr_properties
|= PROP_loops
;
5329 /* Copy the Function's body. */
5330 copy_body (&id
, old_entry_block
->count
, REG_BR_PROB_BASE
,
5331 ENTRY_BLOCK_PTR
, EXIT_BLOCK_PTR
, blocks_to_copy
, new_entry
);
5333 /* Renumber the lexical scoping (non-code) blocks consecutively. */
5334 number_blocks (new_decl
);
5336 /* We want to create the BB unconditionally, so that the addition of
5337 debug stmts doesn't affect BB count, which may in the end cause
5338 codegen differences. */
5339 bb
= split_edge (single_succ_edge (ENTRY_BLOCK_PTR
));
5340 while (init_stmts
.length ())
5341 insert_init_stmt (&id
, bb
, init_stmts
.pop ());
5342 update_clone_info (&id
);
5344 /* Remap the nonlocal_goto_save_area, if any. */
5345 if (cfun
->nonlocal_goto_save_area
)
5347 struct walk_stmt_info wi
;
5349 memset (&wi
, 0, sizeof (wi
));
5351 walk_tree (&cfun
->nonlocal_goto_save_area
, remap_gimple_op_r
, &wi
, NULL
);
5355 pointer_map_destroy (id
.decl_map
);
5357 pointer_map_destroy (id
.debug_map
);
5358 free_dominance_info (CDI_DOMINATORS
);
5359 free_dominance_info (CDI_POST_DOMINATORS
);
5361 fold_marked_statements (0, id
.statements_to_fold
);
5362 pointer_set_destroy (id
.statements_to_fold
);
5363 fold_cond_expr_cond ();
5364 delete_unreachable_blocks_update_callgraph (&id
);
5365 if (id
.dst_node
->symbol
.definition
)
5366 cgraph_rebuild_references ();
5367 update_ssa (TODO_update_ssa
);
5369 /* After partial cloning we need to rescale frequencies, so they are
5370 within proper range in the cloned function. */
5373 struct cgraph_edge
*e
;
5374 rebuild_frequencies ();
5376 new_version_node
->count
= ENTRY_BLOCK_PTR
->count
;
5377 for (e
= new_version_node
->callees
; e
; e
= e
->next_callee
)
5379 basic_block bb
= gimple_bb (e
->call_stmt
);
5380 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
5382 e
->count
= bb
->count
;
5384 for (e
= new_version_node
->indirect_calls
; e
; e
= e
->next_callee
)
5386 basic_block bb
= gimple_bb (e
->call_stmt
);
5387 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
5389 e
->count
= bb
->count
;
5393 free_dominance_info (CDI_DOMINATORS
);
5394 free_dominance_info (CDI_POST_DOMINATORS
);
5396 gcc_assert (!id
.debug_stmts
.exists ());
5397 init_stmts
.release ();
5402 /* EXP is CALL_EXPR present in a GENERIC expression tree. Try to integrate
5403 the callee and return the inlined body on success. */
5406 maybe_inline_call_in_expr (tree exp
)
5408 tree fn
= get_callee_fndecl (exp
);
5410 /* We can only try to inline "const" functions. */
5411 if (fn
&& TREE_READONLY (fn
) && DECL_SAVED_TREE (fn
))
5413 struct pointer_map_t
*decl_map
= pointer_map_create ();
5414 call_expr_arg_iterator iter
;
5418 /* Remap the parameters. */
5419 for (param
= DECL_ARGUMENTS (fn
), arg
= first_call_expr_arg (exp
, &iter
);
5421 param
= DECL_CHAIN (param
), arg
= next_call_expr_arg (&iter
))
5422 *pointer_map_insert (decl_map
, param
) = arg
;
5424 memset (&id
, 0, sizeof (id
));
5426 id
.dst_fn
= current_function_decl
;
5427 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
5428 id
.decl_map
= decl_map
;
5430 id
.copy_decl
= copy_decl_no_change
;
5431 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5432 id
.transform_new_cfg
= false;
5433 id
.transform_return_to_modify
= true;
5434 id
.transform_lang_insert_block
= NULL
;
5436 /* Make sure not to unshare trees behind the front-end's back
5437 since front-end specific mechanisms may rely on sharing. */
5438 id
.regimplify
= false;
5439 id
.do_not_unshare
= true;
5441 /* We're not inside any EH region. */
5444 t
= copy_tree_body (&id
);
5445 pointer_map_destroy (decl_map
);
5447 /* We can only return something suitable for use in a GENERIC
5449 if (TREE_CODE (t
) == MODIFY_EXPR
)
5450 return TREE_OPERAND (t
, 1);
5456 /* Duplicate a type, fields and all. */
5459 build_duplicate_type (tree type
)
5461 struct copy_body_data id
;
5463 memset (&id
, 0, sizeof (id
));
5464 id
.src_fn
= current_function_decl
;
5465 id
.dst_fn
= current_function_decl
;
5467 id
.decl_map
= pointer_map_create ();
5468 id
.debug_map
= NULL
;
5469 id
.copy_decl
= copy_decl_no_change
;
5471 type
= remap_type_1 (type
, &id
);
5473 pointer_map_destroy (id
.decl_map
);
5475 pointer_map_destroy (id
.debug_map
);
5477 TYPE_CANONICAL (type
) = type
;