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
);
754 /* Return true if DECL is a parameter or a SSA_NAME for a parameter. */
759 if (TREE_CODE (decl
) == SSA_NAME
)
761 decl
= SSA_NAME_VAR (decl
);
766 return (TREE_CODE (decl
) == PARM_DECL
);
769 /* Remap the GIMPLE operand pointed to by *TP. DATA is really a
770 'struct walk_stmt_info *'. DATA->INFO is a 'copy_body_data *'.
771 WALK_SUBTREES is used to indicate walk_gimple_op whether to keep
772 recursing into the children nodes of *TP. */
775 remap_gimple_op_r (tree
*tp
, int *walk_subtrees
, void *data
)
777 struct walk_stmt_info
*wi_p
= (struct walk_stmt_info
*) data
;
778 copy_body_data
*id
= (copy_body_data
*) wi_p
->info
;
779 tree fn
= id
->src_fn
;
781 if (TREE_CODE (*tp
) == SSA_NAME
)
783 *tp
= remap_ssa_name (*tp
, id
);
787 else if (auto_var_in_fn_p (*tp
, fn
))
789 /* Local variables and labels need to be replaced by equivalent
790 variables. We don't want to copy static variables; there's
791 only one of those, no matter how many times we inline the
792 containing function. Similarly for globals from an outer
796 /* Remap the declaration. */
797 new_decl
= remap_decl (*tp
, id
);
798 gcc_assert (new_decl
);
799 /* Replace this variable with the copy. */
800 STRIP_TYPE_NOPS (new_decl
);
801 /* ??? The C++ frontend uses void * pointer zero to initialize
802 any other type. This confuses the middle-end type verification.
803 As cloned bodies do not go through gimplification again the fixup
804 there doesn't trigger. */
805 if (TREE_CODE (new_decl
) == INTEGER_CST
806 && !useless_type_conversion_p (TREE_TYPE (*tp
), TREE_TYPE (new_decl
)))
807 new_decl
= fold_convert (TREE_TYPE (*tp
), new_decl
);
811 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
813 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
815 else if (TREE_CODE (*tp
) == LABEL_DECL
816 && (!DECL_CONTEXT (*tp
)
817 || decl_function_context (*tp
) == id
->src_fn
))
818 /* These may need to be remapped for EH handling. */
819 *tp
= remap_decl (*tp
, id
);
820 else if (TREE_CODE (*tp
) == FIELD_DECL
)
822 /* If the enclosing record type is variably_modified_type_p, the field
823 has already been remapped. Otherwise, it need not be. */
824 tree
*n
= (tree
*) pointer_map_contains (id
->decl_map
, *tp
);
829 else if (TYPE_P (*tp
))
830 /* Types may need remapping as well. */
831 *tp
= remap_type (*tp
, id
);
832 else if (CONSTANT_CLASS_P (*tp
))
834 /* If this is a constant, we have to copy the node iff the type
835 will be remapped. copy_tree_r will not copy a constant. */
836 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
838 if (new_type
== TREE_TYPE (*tp
))
841 else if (TREE_CODE (*tp
) == INTEGER_CST
)
842 *tp
= build_int_cst_wide (new_type
, TREE_INT_CST_LOW (*tp
),
843 TREE_INT_CST_HIGH (*tp
));
846 *tp
= copy_node (*tp
);
847 TREE_TYPE (*tp
) = new_type
;
852 /* Otherwise, just copy the node. Note that copy_tree_r already
853 knows not to copy VAR_DECLs, etc., so this is safe. */
855 if (TREE_CODE (*tp
) == MEM_REF
)
857 /* We need to re-canonicalize MEM_REFs from inline substitutions
858 that can happen when a pointer argument is an ADDR_EXPR.
859 Recurse here manually to allow that. */
860 tree ptr
= TREE_OPERAND (*tp
, 0);
861 tree type
= remap_type (TREE_TYPE (*tp
), id
);
863 walk_tree (&ptr
, remap_gimple_op_r
, data
, NULL
);
864 *tp
= fold_build2 (MEM_REF
, type
, ptr
, TREE_OPERAND (*tp
, 1));
865 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
866 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
867 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
868 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
869 remapped a parameter as the property might be valid only
870 for the parameter itself. */
871 if (TREE_THIS_NOTRAP (old
)
872 && (!is_parm (TREE_OPERAND (old
, 0))
873 || (!id
->transform_parameter
&& is_parm (ptr
))))
874 TREE_THIS_NOTRAP (*tp
) = 1;
879 /* Here is the "usual case". Copy this tree node, and then
880 tweak some special cases. */
881 copy_tree_r (tp
, walk_subtrees
, NULL
);
883 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
884 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
886 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
888 /* The copied TARGET_EXPR has never been expanded, even if the
889 original node was expanded already. */
890 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
891 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
893 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
895 /* Variable substitution need not be simple. In particular,
896 the MEM_REF substitution above. Make sure that
897 TREE_CONSTANT and friends are up-to-date. */
898 int invariant
= is_gimple_min_invariant (*tp
);
899 walk_tree (&TREE_OPERAND (*tp
, 0), remap_gimple_op_r
, data
, NULL
);
900 recompute_tree_invariant_for_addr_expr (*tp
);
902 /* If this used to be invariant, but is not any longer,
903 then regimplification is probably needed. */
904 if (invariant
&& !is_gimple_min_invariant (*tp
))
905 id
->regimplify
= true;
911 /* Update the TREE_BLOCK for the cloned expr. */
914 tree new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
915 tree old_block
= TREE_BLOCK (*tp
);
919 n
= (tree
*) pointer_map_contains (id
->decl_map
,
924 TREE_SET_BLOCK (*tp
, new_block
);
927 /* Keep iterating. */
932 /* Called from copy_body_id via walk_tree. DATA is really a
933 `copy_body_data *'. */
936 copy_tree_body_r (tree
*tp
, int *walk_subtrees
, void *data
)
938 copy_body_data
*id
= (copy_body_data
*) data
;
939 tree fn
= id
->src_fn
;
942 /* Begin by recognizing trees that we'll completely rewrite for the
943 inlining context. Our output for these trees is completely
944 different from out input (e.g. RETURN_EXPR is deleted, and morphs
945 into an edge). Further down, we'll handle trees that get
946 duplicated and/or tweaked. */
948 /* When requested, RETURN_EXPRs should be transformed to just the
949 contained MODIFY_EXPR. The branch semantics of the return will
950 be handled elsewhere by manipulating the CFG rather than a statement. */
951 if (TREE_CODE (*tp
) == RETURN_EXPR
&& id
->transform_return_to_modify
)
953 tree assignment
= TREE_OPERAND (*tp
, 0);
955 /* If we're returning something, just turn that into an
956 assignment into the equivalent of the original RESULT_DECL.
957 If the "assignment" is just the result decl, the result
958 decl has already been set (e.g. a recent "foo (&result_decl,
959 ...)"); just toss the entire RETURN_EXPR. */
960 if (assignment
&& TREE_CODE (assignment
) == MODIFY_EXPR
)
962 /* Replace the RETURN_EXPR with (a copy of) the
963 MODIFY_EXPR hanging underneath. */
964 *tp
= copy_node (assignment
);
966 else /* Else the RETURN_EXPR returns no value. */
969 return (tree
) (void *)1;
972 else if (TREE_CODE (*tp
) == SSA_NAME
)
974 *tp
= remap_ssa_name (*tp
, id
);
979 /* Local variables and labels need to be replaced by equivalent
980 variables. We don't want to copy static variables; there's only
981 one of those, no matter how many times we inline the containing
982 function. Similarly for globals from an outer function. */
983 else if (auto_var_in_fn_p (*tp
, fn
))
987 /* Remap the declaration. */
988 new_decl
= remap_decl (*tp
, id
);
989 gcc_assert (new_decl
);
990 /* Replace this variable with the copy. */
991 STRIP_TYPE_NOPS (new_decl
);
995 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
996 copy_statement_list (tp
);
997 else if (TREE_CODE (*tp
) == SAVE_EXPR
998 || TREE_CODE (*tp
) == TARGET_EXPR
)
999 remap_save_expr (tp
, id
->decl_map
, walk_subtrees
);
1000 else if (TREE_CODE (*tp
) == LABEL_DECL
1001 && (! DECL_CONTEXT (*tp
)
1002 || decl_function_context (*tp
) == id
->src_fn
))
1003 /* These may need to be remapped for EH handling. */
1004 *tp
= remap_decl (*tp
, id
);
1005 else if (TREE_CODE (*tp
) == BIND_EXPR
)
1006 copy_bind_expr (tp
, walk_subtrees
, id
);
1007 /* Types may need remapping as well. */
1008 else if (TYPE_P (*tp
))
1009 *tp
= remap_type (*tp
, id
);
1011 /* If this is a constant, we have to copy the node iff the type will be
1012 remapped. copy_tree_r will not copy a constant. */
1013 else if (CONSTANT_CLASS_P (*tp
))
1015 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
1017 if (new_type
== TREE_TYPE (*tp
))
1020 else if (TREE_CODE (*tp
) == INTEGER_CST
)
1021 *tp
= build_int_cst_wide (new_type
, TREE_INT_CST_LOW (*tp
),
1022 TREE_INT_CST_HIGH (*tp
));
1025 *tp
= copy_node (*tp
);
1026 TREE_TYPE (*tp
) = new_type
;
1030 /* Otherwise, just copy the node. Note that copy_tree_r already
1031 knows not to copy VAR_DECLs, etc., so this is safe. */
1034 /* Here we handle trees that are not completely rewritten.
1035 First we detect some inlining-induced bogosities for
1037 if (TREE_CODE (*tp
) == MODIFY_EXPR
1038 && TREE_OPERAND (*tp
, 0) == TREE_OPERAND (*tp
, 1)
1039 && (auto_var_in_fn_p (TREE_OPERAND (*tp
, 0), fn
)))
1041 /* Some assignments VAR = VAR; don't generate any rtl code
1042 and thus don't count as variable modification. Avoid
1043 keeping bogosities like 0 = 0. */
1044 tree decl
= TREE_OPERAND (*tp
, 0), value
;
1047 n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
1051 STRIP_TYPE_NOPS (value
);
1052 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1054 *tp
= build_empty_stmt (EXPR_LOCATION (*tp
));
1055 return copy_tree_body_r (tp
, walk_subtrees
, data
);
1059 else if (TREE_CODE (*tp
) == INDIRECT_REF
)
1061 /* Get rid of *& from inline substitutions that can happen when a
1062 pointer argument is an ADDR_EXPR. */
1063 tree decl
= TREE_OPERAND (*tp
, 0);
1064 tree
*n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
1067 /* If we happen to get an ADDR_EXPR in n->value, strip
1068 it manually here as we'll eventually get ADDR_EXPRs
1069 which lie about their types pointed to. In this case
1070 build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
1071 but we absolutely rely on that. As fold_indirect_ref
1072 does other useful transformations, try that first, though. */
1073 tree type
= TREE_TYPE (*tp
);
1074 tree ptr
= id
->do_not_unshare
? *n
: unshare_expr (*n
);
1076 *tp
= gimple_fold_indirect_ref (ptr
);
1079 if (TREE_CODE (ptr
) == ADDR_EXPR
)
1082 = fold_indirect_ref_1 (EXPR_LOCATION (ptr
), type
, ptr
);
1083 /* ??? We should either assert here or build
1084 a VIEW_CONVERT_EXPR instead of blindly leaking
1085 incompatible types to our IL. */
1087 *tp
= TREE_OPERAND (ptr
, 0);
1091 *tp
= build1 (INDIRECT_REF
, type
, ptr
);
1092 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1093 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1094 TREE_READONLY (*tp
) = TREE_READONLY (old
);
1095 /* We cannot propagate the TREE_THIS_NOTRAP flag if we
1096 have remapped a parameter as the property might be
1097 valid only for the parameter itself. */
1098 if (TREE_THIS_NOTRAP (old
)
1099 && (!is_parm (TREE_OPERAND (old
, 0))
1100 || (!id
->transform_parameter
&& is_parm (ptr
))))
1101 TREE_THIS_NOTRAP (*tp
) = 1;
1108 else if (TREE_CODE (*tp
) == MEM_REF
)
1110 /* We need to re-canonicalize MEM_REFs from inline substitutions
1111 that can happen when a pointer argument is an ADDR_EXPR.
1112 Recurse here manually to allow that. */
1113 tree ptr
= TREE_OPERAND (*tp
, 0);
1114 tree type
= remap_type (TREE_TYPE (*tp
), id
);
1116 walk_tree (&ptr
, copy_tree_body_r
, data
, NULL
);
1117 *tp
= fold_build2 (MEM_REF
, type
, ptr
, TREE_OPERAND (*tp
, 1));
1118 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1119 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1120 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
1121 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
1122 remapped a parameter as the property might be valid only
1123 for the parameter itself. */
1124 if (TREE_THIS_NOTRAP (old
)
1125 && (!is_parm (TREE_OPERAND (old
, 0))
1126 || (!id
->transform_parameter
&& is_parm (ptr
))))
1127 TREE_THIS_NOTRAP (*tp
) = 1;
1132 /* Here is the "usual case". Copy this tree node, and then
1133 tweak some special cases. */
1134 copy_tree_r (tp
, walk_subtrees
, NULL
);
1136 /* If EXPR has block defined, map it to newly constructed block.
1137 When inlining we want EXPRs without block appear in the block
1138 of function call if we are not remapping a type. */
1141 new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
1142 if (TREE_BLOCK (*tp
))
1145 n
= (tree
*) pointer_map_contains (id
->decl_map
,
1150 TREE_SET_BLOCK (*tp
, new_block
);
1153 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
1154 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
1156 /* The copied TARGET_EXPR has never been expanded, even if the
1157 original node was expanded already. */
1158 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
1160 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
1161 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
1164 /* Variable substitution need not be simple. In particular, the
1165 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
1166 and friends are up-to-date. */
1167 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
1169 int invariant
= is_gimple_min_invariant (*tp
);
1170 walk_tree (&TREE_OPERAND (*tp
, 0), copy_tree_body_r
, id
, NULL
);
1172 /* Handle the case where we substituted an INDIRECT_REF
1173 into the operand of the ADDR_EXPR. */
1174 if (TREE_CODE (TREE_OPERAND (*tp
, 0)) == INDIRECT_REF
)
1175 *tp
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0);
1177 recompute_tree_invariant_for_addr_expr (*tp
);
1179 /* If this used to be invariant, but is not any longer,
1180 then regimplification is probably needed. */
1181 if (invariant
&& !is_gimple_min_invariant (*tp
))
1182 id
->regimplify
= true;
1188 /* Keep iterating. */
1192 /* Helper for remap_gimple_stmt. Given an EH region number for the
1193 source function, map that to the duplicate EH region number in
1194 the destination function. */
1197 remap_eh_region_nr (int old_nr
, copy_body_data
*id
)
1199 eh_region old_r
, new_r
;
1202 old_r
= get_eh_region_from_number_fn (id
->src_cfun
, old_nr
);
1203 slot
= pointer_map_contains (id
->eh_map
, old_r
);
1204 new_r
= (eh_region
) *slot
;
1206 return new_r
->index
;
1209 /* Similar, but operate on INTEGER_CSTs. */
1212 remap_eh_region_tree_nr (tree old_t_nr
, copy_body_data
*id
)
1216 old_nr
= tree_low_cst (old_t_nr
, 0);
1217 new_nr
= remap_eh_region_nr (old_nr
, id
);
1219 return build_int_cst (integer_type_node
, new_nr
);
1222 /* Helper for copy_bb. Remap statement STMT using the inlining
1223 information in ID. Return the new statement copy. */
1226 remap_gimple_stmt (gimple stmt
, copy_body_data
*id
)
1229 struct walk_stmt_info wi
;
1230 bool skip_first
= false;
1232 /* Begin by recognizing trees that we'll completely rewrite for the
1233 inlining context. Our output for these trees is completely
1234 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1235 into an edge). Further down, we'll handle trees that get
1236 duplicated and/or tweaked. */
1238 /* When requested, GIMPLE_RETURNs should be transformed to just the
1239 contained GIMPLE_ASSIGN. The branch semantics of the return will
1240 be handled elsewhere by manipulating the CFG rather than the
1242 if (gimple_code (stmt
) == GIMPLE_RETURN
&& id
->transform_return_to_modify
)
1244 tree retval
= gimple_return_retval (stmt
);
1246 /* If we're returning something, just turn that into an
1247 assignment into the equivalent of the original RESULT_DECL.
1248 If RETVAL is just the result decl, the result decl has
1249 already been set (e.g. a recent "foo (&result_decl, ...)");
1250 just toss the entire GIMPLE_RETURN. */
1252 && (TREE_CODE (retval
) != RESULT_DECL
1253 && (TREE_CODE (retval
) != SSA_NAME
1254 || ! SSA_NAME_VAR (retval
)
1255 || TREE_CODE (SSA_NAME_VAR (retval
)) != RESULT_DECL
)))
1257 copy
= gimple_build_assign (id
->retvar
, retval
);
1258 /* id->retvar is already substituted. Skip it on later remapping. */
1262 return gimple_build_nop ();
1264 else if (gimple_has_substatements (stmt
))
1268 /* When cloning bodies from the C++ front end, we will be handed bodies
1269 in High GIMPLE form. Handle here all the High GIMPLE statements that
1270 have embedded statements. */
1271 switch (gimple_code (stmt
))
1274 copy
= copy_gimple_bind (stmt
, id
);
1278 s1
= remap_gimple_seq (gimple_catch_handler (stmt
), id
);
1279 copy
= gimple_build_catch (gimple_catch_types (stmt
), s1
);
1282 case GIMPLE_EH_FILTER
:
1283 s1
= remap_gimple_seq (gimple_eh_filter_failure (stmt
), id
);
1284 copy
= gimple_build_eh_filter (gimple_eh_filter_types (stmt
), s1
);
1288 s1
= remap_gimple_seq (gimple_try_eval (stmt
), id
);
1289 s2
= remap_gimple_seq (gimple_try_cleanup (stmt
), id
);
1290 copy
= gimple_build_try (s1
, s2
, gimple_try_kind (stmt
));
1293 case GIMPLE_WITH_CLEANUP_EXPR
:
1294 s1
= remap_gimple_seq (gimple_wce_cleanup (stmt
), id
);
1295 copy
= gimple_build_wce (s1
);
1298 case GIMPLE_OMP_PARALLEL
:
1299 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1300 copy
= gimple_build_omp_parallel
1302 gimple_omp_parallel_clauses (stmt
),
1303 gimple_omp_parallel_child_fn (stmt
),
1304 gimple_omp_parallel_data_arg (stmt
));
1307 case GIMPLE_OMP_TASK
:
1308 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1309 copy
= gimple_build_omp_task
1311 gimple_omp_task_clauses (stmt
),
1312 gimple_omp_task_child_fn (stmt
),
1313 gimple_omp_task_data_arg (stmt
),
1314 gimple_omp_task_copy_fn (stmt
),
1315 gimple_omp_task_arg_size (stmt
),
1316 gimple_omp_task_arg_align (stmt
));
1319 case GIMPLE_OMP_FOR
:
1320 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1321 s2
= remap_gimple_seq (gimple_omp_for_pre_body (stmt
), id
);
1322 copy
= gimple_build_omp_for (s1
, gimple_omp_for_kind (stmt
),
1323 gimple_omp_for_clauses (stmt
),
1324 gimple_omp_for_collapse (stmt
), s2
);
1327 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1329 gimple_omp_for_set_index (copy
, i
,
1330 gimple_omp_for_index (stmt
, i
));
1331 gimple_omp_for_set_initial (copy
, i
,
1332 gimple_omp_for_initial (stmt
, i
));
1333 gimple_omp_for_set_final (copy
, i
,
1334 gimple_omp_for_final (stmt
, i
));
1335 gimple_omp_for_set_incr (copy
, i
,
1336 gimple_omp_for_incr (stmt
, i
));
1337 gimple_omp_for_set_cond (copy
, i
,
1338 gimple_omp_for_cond (stmt
, i
));
1343 case GIMPLE_OMP_MASTER
:
1344 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1345 copy
= gimple_build_omp_master (s1
);
1348 case GIMPLE_OMP_ORDERED
:
1349 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1350 copy
= gimple_build_omp_ordered (s1
);
1353 case GIMPLE_OMP_SECTION
:
1354 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1355 copy
= gimple_build_omp_section (s1
);
1358 case GIMPLE_OMP_SECTIONS
:
1359 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1360 copy
= gimple_build_omp_sections
1361 (s1
, gimple_omp_sections_clauses (stmt
));
1364 case GIMPLE_OMP_SINGLE
:
1365 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1366 copy
= gimple_build_omp_single
1367 (s1
, gimple_omp_single_clauses (stmt
));
1370 case GIMPLE_OMP_CRITICAL
:
1371 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1373 = gimple_build_omp_critical (s1
, gimple_omp_critical_name (stmt
));
1376 case GIMPLE_TRANSACTION
:
1377 s1
= remap_gimple_seq (gimple_transaction_body (stmt
), id
);
1378 copy
= gimple_build_transaction (s1
, gimple_transaction_label (stmt
));
1379 gimple_transaction_set_subcode (copy
, gimple_transaction_subcode (stmt
));
1388 if (gimple_assign_copy_p (stmt
)
1389 && gimple_assign_lhs (stmt
) == gimple_assign_rhs1 (stmt
)
1390 && auto_var_in_fn_p (gimple_assign_lhs (stmt
), id
->src_fn
))
1392 /* Here we handle statements that are not completely rewritten.
1393 First we detect some inlining-induced bogosities for
1396 /* Some assignments VAR = VAR; don't generate any rtl code
1397 and thus don't count as variable modification. Avoid
1398 keeping bogosities like 0 = 0. */
1399 tree decl
= gimple_assign_lhs (stmt
), value
;
1402 n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
1406 STRIP_TYPE_NOPS (value
);
1407 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1408 return gimple_build_nop ();
1412 /* For *ptr_N ={v} {CLOBBER}, if ptr_N is SSA_NAME defined
1413 in a block that we aren't copying during tree_function_versioning,
1414 just drop the clobber stmt. */
1415 if (id
->blocks_to_copy
&& gimple_clobber_p (stmt
))
1417 tree lhs
= gimple_assign_lhs (stmt
);
1418 if (TREE_CODE (lhs
) == MEM_REF
1419 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == SSA_NAME
)
1421 gimple def_stmt
= SSA_NAME_DEF_STMT (TREE_OPERAND (lhs
, 0));
1422 if (gimple_bb (def_stmt
)
1423 && !bitmap_bit_p (id
->blocks_to_copy
,
1424 gimple_bb (def_stmt
)->index
))
1425 return gimple_build_nop ();
1429 if (gimple_debug_bind_p (stmt
))
1431 copy
= gimple_build_debug_bind (gimple_debug_bind_get_var (stmt
),
1432 gimple_debug_bind_get_value (stmt
),
1434 id
->debug_stmts
.safe_push (copy
);
1437 if (gimple_debug_source_bind_p (stmt
))
1439 copy
= gimple_build_debug_source_bind
1440 (gimple_debug_source_bind_get_var (stmt
),
1441 gimple_debug_source_bind_get_value (stmt
), stmt
);
1442 id
->debug_stmts
.safe_push (copy
);
1446 /* Create a new deep copy of the statement. */
1447 copy
= gimple_copy (stmt
);
1449 /* Remap the region numbers for __builtin_eh_{pointer,filter},
1450 RESX and EH_DISPATCH. */
1452 switch (gimple_code (copy
))
1456 tree r
, fndecl
= gimple_call_fndecl (copy
);
1457 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
1458 switch (DECL_FUNCTION_CODE (fndecl
))
1460 case BUILT_IN_EH_COPY_VALUES
:
1461 r
= gimple_call_arg (copy
, 1);
1462 r
= remap_eh_region_tree_nr (r
, id
);
1463 gimple_call_set_arg (copy
, 1, r
);
1466 case BUILT_IN_EH_POINTER
:
1467 case BUILT_IN_EH_FILTER
:
1468 r
= gimple_call_arg (copy
, 0);
1469 r
= remap_eh_region_tree_nr (r
, id
);
1470 gimple_call_set_arg (copy
, 0, r
);
1477 /* Reset alias info if we didn't apply measures to
1478 keep it valid over inlining by setting DECL_PT_UID. */
1479 if (!id
->src_cfun
->gimple_df
1480 || !id
->src_cfun
->gimple_df
->ipa_pta
)
1481 gimple_call_reset_alias_info (copy
);
1487 int r
= gimple_resx_region (copy
);
1488 r
= remap_eh_region_nr (r
, id
);
1489 gimple_resx_set_region (copy
, r
);
1493 case GIMPLE_EH_DISPATCH
:
1495 int r
= gimple_eh_dispatch_region (copy
);
1496 r
= remap_eh_region_nr (r
, id
);
1497 gimple_eh_dispatch_set_region (copy
, r
);
1506 /* If STMT has a block defined, map it to the newly constructed
1508 if (gimple_block (copy
))
1511 n
= (tree
*) pointer_map_contains (id
->decl_map
, gimple_block (copy
));
1513 gimple_set_block (copy
, *n
);
1516 if (gimple_debug_bind_p (copy
) || gimple_debug_source_bind_p (copy
))
1519 /* Remap all the operands in COPY. */
1520 memset (&wi
, 0, sizeof (wi
));
1523 walk_tree (gimple_op_ptr (copy
, 1), remap_gimple_op_r
, &wi
, NULL
);
1525 walk_gimple_op (copy
, remap_gimple_op_r
, &wi
);
1527 /* Clear the copied virtual operands. We are not remapping them here
1528 but are going to recreate them from scratch. */
1529 if (gimple_has_mem_ops (copy
))
1531 gimple_set_vdef (copy
, NULL_TREE
);
1532 gimple_set_vuse (copy
, NULL_TREE
);
1539 /* Copy basic block, scale profile accordingly. Edges will be taken care of
1543 copy_bb (copy_body_data
*id
, basic_block bb
, int frequency_scale
,
1544 gcov_type count_scale
)
1546 gimple_stmt_iterator gsi
, copy_gsi
, seq_gsi
;
1547 basic_block copy_basic_block
;
1552 /* Search for previous copied basic block. */
1555 prev
= prev
->prev_bb
;
1557 /* create_basic_block() will append every new block to
1558 basic_block_info automatically. */
1559 copy_basic_block
= create_basic_block (NULL
, (void *) 0,
1560 (basic_block
) prev
->aux
);
1561 copy_basic_block
->count
= apply_scale (bb
->count
, count_scale
);
1563 /* We are going to rebuild frequencies from scratch. These values
1564 have just small importance to drive canonicalize_loop_headers. */
1565 freq
= apply_scale ((gcov_type
)bb
->frequency
, frequency_scale
);
1567 /* We recompute frequencies after inlining, so this is quite safe. */
1568 if (freq
> BB_FREQ_MAX
)
1570 copy_basic_block
->frequency
= freq
;
1572 copy_gsi
= gsi_start_bb (copy_basic_block
);
1574 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1576 gimple stmt
= gsi_stmt (gsi
);
1577 gimple orig_stmt
= stmt
;
1579 id
->regimplify
= false;
1580 stmt
= remap_gimple_stmt (stmt
, id
);
1581 if (gimple_nop_p (stmt
))
1584 gimple_duplicate_stmt_histograms (cfun
, stmt
, id
->src_cfun
, orig_stmt
);
1587 /* With return slot optimization we can end up with
1588 non-gimple (foo *)&this->m, fix that here. */
1589 if (is_gimple_assign (stmt
)
1590 && gimple_assign_rhs_code (stmt
) == NOP_EXPR
1591 && !is_gimple_val (gimple_assign_rhs1 (stmt
)))
1594 new_rhs
= force_gimple_operand_gsi (&seq_gsi
,
1595 gimple_assign_rhs1 (stmt
),
1597 GSI_CONTINUE_LINKING
);
1598 gimple_assign_set_rhs1 (stmt
, new_rhs
);
1599 id
->regimplify
= false;
1602 gsi_insert_after (&seq_gsi
, stmt
, GSI_NEW_STMT
);
1605 gimple_regimplify_operands (stmt
, &seq_gsi
);
1607 /* If copy_basic_block has been empty at the start of this iteration,
1608 call gsi_start_bb again to get at the newly added statements. */
1609 if (gsi_end_p (copy_gsi
))
1610 copy_gsi
= gsi_start_bb (copy_basic_block
);
1612 gsi_next (©_gsi
);
1614 /* Process the new statement. The call to gimple_regimplify_operands
1615 possibly turned the statement into multiple statements, we
1616 need to process all of them. */
1621 stmt
= gsi_stmt (copy_gsi
);
1622 if (is_gimple_call (stmt
)
1623 && gimple_call_va_arg_pack_p (stmt
)
1626 /* __builtin_va_arg_pack () should be replaced by
1627 all arguments corresponding to ... in the caller. */
1631 size_t nargs
= gimple_call_num_args (id
->gimple_call
);
1634 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1637 /* Create the new array of arguments. */
1638 n
= nargs
+ gimple_call_num_args (stmt
);
1639 argarray
.create (n
);
1640 argarray
.safe_grow_cleared (n
);
1642 /* Copy all the arguments before '...' */
1643 memcpy (argarray
.address (),
1644 gimple_call_arg_ptr (stmt
, 0),
1645 gimple_call_num_args (stmt
) * sizeof (tree
));
1647 /* Append the arguments passed in '...' */
1648 memcpy (argarray
.address () + gimple_call_num_args (stmt
),
1649 gimple_call_arg_ptr (id
->gimple_call
, 0)
1650 + (gimple_call_num_args (id
->gimple_call
) - nargs
),
1651 nargs
* sizeof (tree
));
1653 new_call
= gimple_build_call_vec (gimple_call_fn (stmt
),
1656 argarray
.release ();
1658 /* Copy all GIMPLE_CALL flags, location and block, except
1659 GF_CALL_VA_ARG_PACK. */
1660 gimple_call_copy_flags (new_call
, stmt
);
1661 gimple_call_set_va_arg_pack (new_call
, false);
1662 gimple_set_location (new_call
, gimple_location (stmt
));
1663 gimple_set_block (new_call
, gimple_block (stmt
));
1664 gimple_call_set_lhs (new_call
, gimple_call_lhs (stmt
));
1666 gsi_replace (©_gsi
, new_call
, false);
1669 else if (is_gimple_call (stmt
)
1671 && (decl
= gimple_call_fndecl (stmt
))
1672 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
1673 && DECL_FUNCTION_CODE (decl
) == BUILT_IN_VA_ARG_PACK_LEN
)
1675 /* __builtin_va_arg_pack_len () should be replaced by
1676 the number of anonymous arguments. */
1677 size_t nargs
= gimple_call_num_args (id
->gimple_call
);
1681 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1684 count
= build_int_cst (integer_type_node
, nargs
);
1685 new_stmt
= gimple_build_assign (gimple_call_lhs (stmt
), count
);
1686 gsi_replace (©_gsi
, new_stmt
, false);
1690 /* Statements produced by inlining can be unfolded, especially
1691 when we constant propagated some operands. We can't fold
1692 them right now for two reasons:
1693 1) folding require SSA_NAME_DEF_STMTs to be correct
1694 2) we can't change function calls to builtins.
1695 So we just mark statement for later folding. We mark
1696 all new statements, instead just statements that has changed
1697 by some nontrivial substitution so even statements made
1698 foldable indirectly are updated. If this turns out to be
1699 expensive, copy_body can be told to watch for nontrivial
1701 if (id
->statements_to_fold
)
1702 pointer_set_insert (id
->statements_to_fold
, stmt
);
1704 /* We're duplicating a CALL_EXPR. Find any corresponding
1705 callgraph edges and update or duplicate them. */
1706 if (is_gimple_call (stmt
))
1708 struct cgraph_edge
*edge
;
1711 switch (id
->transform_call_graph_edges
)
1713 case CB_CGE_DUPLICATE
:
1714 edge
= cgraph_edge (id
->src_node
, orig_stmt
);
1717 int edge_freq
= edge
->frequency
;
1719 struct cgraph_edge
*old_edge
= edge
;
1720 edge
= cgraph_clone_edge (edge
, id
->dst_node
, stmt
,
1722 REG_BR_PROB_BASE
, CGRAPH_FREQ_BASE
,
1724 /* We could also just rescale the frequency, but
1725 doing so would introduce roundoff errors and make
1726 verifier unhappy. */
1727 new_freq
= compute_call_stmt_bb_frequency (id
->dst_node
->symbol
.decl
,
1730 /* Speculative calls consist of two edges - direct and indirect.
1731 Duplicate the whole thing and distribute frequencies accordingly. */
1732 if (edge
->speculative
)
1734 struct cgraph_edge
*direct
, *indirect
;
1735 struct ipa_ref
*ref
;
1737 gcc_assert (!edge
->indirect_unknown_callee
);
1738 cgraph_speculative_call_info (old_edge
, direct
, indirect
, ref
);
1739 indirect
= cgraph_clone_edge (indirect
, id
->dst_node
, stmt
,
1741 REG_BR_PROB_BASE
, CGRAPH_FREQ_BASE
,
1743 if (old_edge
->frequency
+ indirect
->frequency
)
1745 edge
->frequency
= MIN (RDIV ((gcov_type
)new_freq
* old_edge
->frequency
,
1746 (old_edge
->frequency
+ indirect
->frequency
)),
1748 indirect
->frequency
= MIN (RDIV ((gcov_type
)new_freq
* indirect
->frequency
,
1749 (old_edge
->frequency
+ indirect
->frequency
)),
1752 ipa_clone_ref (ref
, (symtab_node
)id
->dst_node
, stmt
);
1756 edge
->frequency
= new_freq
;
1758 && profile_status_for_function (cfun
) != PROFILE_ABSENT
1759 && (edge_freq
> edge
->frequency
+ 10
1760 || edge_freq
< edge
->frequency
- 10))
1762 fprintf (dump_file
, "Edge frequency estimated by "
1763 "cgraph %i diverge from inliner's estimate %i\n",
1767 "Orig bb: %i, orig bb freq %i, new bb freq %i\n",
1770 copy_basic_block
->frequency
);
1776 case CB_CGE_MOVE_CLONES
:
1777 cgraph_set_call_stmt_including_clones (id
->dst_node
,
1779 edge
= cgraph_edge (id
->dst_node
, stmt
);
1783 edge
= cgraph_edge (id
->dst_node
, orig_stmt
);
1785 cgraph_set_call_stmt (edge
, stmt
);
1792 /* Constant propagation on argument done during inlining
1793 may create new direct call. Produce an edge for it. */
1795 || (edge
->indirect_inlining_edge
1796 && id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
))
1797 && id
->dst_node
->symbol
.definition
1798 && (fn
= gimple_call_fndecl (stmt
)) != NULL
)
1800 struct cgraph_node
*dest
= cgraph_get_node (fn
);
1802 /* We have missing edge in the callgraph. This can happen
1803 when previous inlining turned an indirect call into a
1804 direct call by constant propagating arguments or we are
1805 producing dead clone (for further cloning). In all
1806 other cases we hit a bug (incorrect node sharing is the
1807 most common reason for missing edges). */
1808 gcc_assert (!dest
->symbol
.definition
1809 || dest
->symbol
.address_taken
1810 || !id
->src_node
->symbol
.definition
1811 || !id
->dst_node
->symbol
.definition
);
1812 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
)
1813 cgraph_create_edge_including_clones
1814 (id
->dst_node
, dest
, orig_stmt
, stmt
, bb
->count
,
1815 compute_call_stmt_bb_frequency (id
->dst_node
->symbol
.decl
,
1817 CIF_ORIGINALLY_INDIRECT_CALL
);
1819 cgraph_create_edge (id
->dst_node
, dest
, stmt
,
1821 compute_call_stmt_bb_frequency
1822 (id
->dst_node
->symbol
.decl
,
1823 copy_basic_block
))->inline_failed
1824 = CIF_ORIGINALLY_INDIRECT_CALL
;
1827 fprintf (dump_file
, "Created new direct edge to %s\n",
1828 cgraph_node_name (dest
));
1832 flags
= gimple_call_flags (stmt
);
1833 if (flags
& ECF_MAY_BE_ALLOCA
)
1834 cfun
->calls_alloca
= true;
1835 if (flags
& ECF_RETURNS_TWICE
)
1836 cfun
->calls_setjmp
= true;
1839 maybe_duplicate_eh_stmt_fn (cfun
, stmt
, id
->src_cfun
, orig_stmt
,
1840 id
->eh_map
, id
->eh_lp_nr
);
1842 if (gimple_in_ssa_p (cfun
) && !is_gimple_debug (stmt
))
1847 FOR_EACH_SSA_TREE_OPERAND (def
, stmt
, i
, SSA_OP_DEF
)
1848 if (TREE_CODE (def
) == SSA_NAME
)
1849 SSA_NAME_DEF_STMT (def
) = stmt
;
1852 gsi_next (©_gsi
);
1854 while (!gsi_end_p (copy_gsi
));
1856 copy_gsi
= gsi_last_bb (copy_basic_block
);
1859 return copy_basic_block
;
1862 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
1863 form is quite easy, since dominator relationship for old basic blocks does
1866 There is however exception where inlining might change dominator relation
1867 across EH edges from basic block within inlined functions destinating
1868 to landing pads in function we inline into.
1870 The function fills in PHI_RESULTs of such PHI nodes if they refer
1871 to gimple regs. Otherwise, the function mark PHI_RESULT of such
1872 PHI nodes for renaming. For non-gimple regs, renaming is safe: the
1873 EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
1874 set, and this means that there will be no overlapping live ranges
1875 for the underlying symbol.
1877 This might change in future if we allow redirecting of EH edges and
1878 we might want to change way build CFG pre-inlining to include
1879 all the possible edges then. */
1881 update_ssa_across_abnormal_edges (basic_block bb
, basic_block ret_bb
,
1882 bool can_throw
, bool nonlocal_goto
)
1887 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1889 || ((basic_block
)e
->dest
->aux
)->index
== ENTRY_BLOCK
)
1892 gimple_stmt_iterator si
;
1895 gcc_assert (e
->flags
& EDGE_EH
);
1898 gcc_assert (!(e
->flags
& EDGE_EH
));
1900 for (si
= gsi_start_phis (e
->dest
); !gsi_end_p (si
); gsi_next (&si
))
1904 phi
= gsi_stmt (si
);
1906 /* For abnormal goto/call edges the receiver can be the
1907 ENTRY_BLOCK. Do not assert this cannot happen. */
1909 gcc_assert ((e
->flags
& EDGE_EH
)
1910 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi
)));
1912 re
= find_edge (ret_bb
, e
->dest
);
1913 gcc_checking_assert (re
);
1914 gcc_assert ((re
->flags
& (EDGE_EH
| EDGE_ABNORMAL
))
1915 == (e
->flags
& (EDGE_EH
| EDGE_ABNORMAL
)));
1917 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, e
),
1918 USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, re
)));
1924 /* Copy edges from BB into its copy constructed earlier, scale profile
1925 accordingly. Edges will be taken care of later. Assume aux
1926 pointers to point to the copies of each BB. Return true if any
1927 debug stmts are left after a statement that must end the basic block. */
1930 copy_edges_for_bb (basic_block bb
, gcov_type count_scale
, basic_block ret_bb
,
1931 bool can_make_abnormal_goto
)
1933 basic_block new_bb
= (basic_block
) bb
->aux
;
1936 gimple_stmt_iterator si
;
1938 bool need_debug_cleanup
= false;
1940 /* Use the indices from the original blocks to create edges for the
1942 FOR_EACH_EDGE (old_edge
, ei
, bb
->succs
)
1943 if (!(old_edge
->flags
& EDGE_EH
))
1947 flags
= old_edge
->flags
;
1949 /* Return edges do get a FALLTHRU flag when the get inlined. */
1950 if (old_edge
->dest
->index
== EXIT_BLOCK
&& !old_edge
->flags
1951 && old_edge
->dest
->aux
!= EXIT_BLOCK_PTR
)
1952 flags
|= EDGE_FALLTHRU
;
1953 new_edge
= make_edge (new_bb
, (basic_block
) old_edge
->dest
->aux
, flags
);
1954 new_edge
->count
= apply_scale (old_edge
->count
, count_scale
);
1955 new_edge
->probability
= old_edge
->probability
;
1958 if (bb
->index
== ENTRY_BLOCK
|| bb
->index
== EXIT_BLOCK
)
1961 for (si
= gsi_start_bb (new_bb
); !gsi_end_p (si
);)
1964 bool can_throw
, nonlocal_goto
;
1966 copy_stmt
= gsi_stmt (si
);
1967 if (!is_gimple_debug (copy_stmt
))
1968 update_stmt (copy_stmt
);
1970 /* Do this before the possible split_block. */
1973 /* If this tree could throw an exception, there are two
1974 cases where we need to add abnormal edge(s): the
1975 tree wasn't in a region and there is a "current
1976 region" in the caller; or the original tree had
1977 EH edges. In both cases split the block after the tree,
1978 and add abnormal edge(s) as needed; we need both
1979 those from the callee and the caller.
1980 We check whether the copy can throw, because the const
1981 propagation can change an INDIRECT_REF which throws
1982 into a COMPONENT_REF which doesn't. If the copy
1983 can throw, the original could also throw. */
1984 can_throw
= stmt_can_throw_internal (copy_stmt
);
1985 nonlocal_goto
= stmt_can_make_abnormal_goto (copy_stmt
);
1987 if (can_throw
|| nonlocal_goto
)
1989 if (!gsi_end_p (si
))
1991 while (!gsi_end_p (si
) && is_gimple_debug (gsi_stmt (si
)))
1994 need_debug_cleanup
= true;
1996 if (!gsi_end_p (si
))
1997 /* Note that bb's predecessor edges aren't necessarily
1998 right at this point; split_block doesn't care. */
2000 edge e
= split_block (new_bb
, copy_stmt
);
2003 new_bb
->aux
= e
->src
->aux
;
2004 si
= gsi_start_bb (new_bb
);
2008 if (gimple_code (copy_stmt
) == GIMPLE_EH_DISPATCH
)
2009 make_eh_dispatch_edges (copy_stmt
);
2011 make_eh_edges (copy_stmt
);
2013 /* If the call we inline cannot make abnormal goto do not add
2014 additional abnormal edges but only retain those already present
2015 in the original function body. */
2016 nonlocal_goto
&= can_make_abnormal_goto
;
2018 make_abnormal_goto_edges (gimple_bb (copy_stmt
), true);
2020 if ((can_throw
|| nonlocal_goto
)
2021 && gimple_in_ssa_p (cfun
))
2022 update_ssa_across_abnormal_edges (gimple_bb (copy_stmt
), ret_bb
,
2023 can_throw
, nonlocal_goto
);
2025 return need_debug_cleanup
;
2028 /* Copy the PHIs. All blocks and edges are copied, some blocks
2029 was possibly split and new outgoing EH edges inserted.
2030 BB points to the block of original function and AUX pointers links
2031 the original and newly copied blocks. */
2034 copy_phis_for_bb (basic_block bb
, copy_body_data
*id
)
2036 basic_block
const new_bb
= (basic_block
) bb
->aux
;
2039 gimple_stmt_iterator si
;
2041 bool inserted
= false;
2043 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
2048 phi
= gsi_stmt (si
);
2049 res
= PHI_RESULT (phi
);
2051 if (!virtual_operand_p (res
))
2053 walk_tree (&new_res
, copy_tree_body_r
, id
, NULL
);
2054 new_phi
= create_phi_node (new_res
, new_bb
);
2055 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2057 edge old_edge
= find_edge ((basic_block
) new_edge
->src
->aux
, bb
);
2063 /* When doing partial cloning, we allow PHIs on the entry block
2064 as long as all the arguments are the same. Find any input
2065 edge to see argument to copy. */
2067 FOR_EACH_EDGE (old_edge
, ei2
, bb
->preds
)
2068 if (!old_edge
->src
->aux
)
2071 arg
= PHI_ARG_DEF_FROM_EDGE (phi
, old_edge
);
2073 walk_tree (&new_arg
, copy_tree_body_r
, id
, NULL
);
2074 gcc_assert (new_arg
);
2075 /* With return slot optimization we can end up with
2076 non-gimple (foo *)&this->m, fix that here. */
2077 if (TREE_CODE (new_arg
) != SSA_NAME
2078 && TREE_CODE (new_arg
) != FUNCTION_DECL
2079 && !is_gimple_val (new_arg
))
2081 gimple_seq stmts
= NULL
;
2082 new_arg
= force_gimple_operand (new_arg
, &stmts
, true, NULL
);
2083 gsi_insert_seq_on_edge (new_edge
, stmts
);
2086 locus
= gimple_phi_arg_location_from_edge (phi
, old_edge
);
2087 if (LOCATION_BLOCK (locus
))
2090 n
= (tree
*) pointer_map_contains (id
->decl_map
,
2091 LOCATION_BLOCK (locus
));
2093 locus
= COMBINE_LOCATION_DATA (line_table
, locus
, *n
);
2096 locus
= LOCATION_LOCUS (locus
);
2098 add_phi_arg (new_phi
, new_arg
, new_edge
, locus
);
2103 /* Commit the delayed edge insertions. */
2105 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2106 gsi_commit_one_edge_insert (new_edge
, NULL
);
2110 /* Wrapper for remap_decl so it can be used as a callback. */
2113 remap_decl_1 (tree decl
, void *data
)
2115 return remap_decl (decl
, (copy_body_data
*) data
);
2118 /* Build struct function and associated datastructures for the new clone
2119 NEW_FNDECL to be build. CALLEE_FNDECL is the original. Function changes
2120 the cfun to the function of new_fndecl (and current_function_decl too). */
2123 initialize_cfun (tree new_fndecl
, tree callee_fndecl
, gcov_type count
)
2125 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2126 gcov_type count_scale
;
2128 if (!DECL_ARGUMENTS (new_fndecl
))
2129 DECL_ARGUMENTS (new_fndecl
) = DECL_ARGUMENTS (callee_fndecl
);
2130 if (!DECL_RESULT (new_fndecl
))
2131 DECL_RESULT (new_fndecl
) = DECL_RESULT (callee_fndecl
);
2133 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
)
2135 = GCOV_COMPUTE_SCALE (count
,
2136 ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
);
2138 count_scale
= REG_BR_PROB_BASE
;
2140 /* Register specific tree functions. */
2141 gimple_register_cfg_hooks ();
2143 /* Get clean struct function. */
2144 push_struct_function (new_fndecl
);
2146 /* We will rebuild these, so just sanity check that they are empty. */
2147 gcc_assert (VALUE_HISTOGRAMS (cfun
) == NULL
);
2148 gcc_assert (cfun
->local_decls
== NULL
);
2149 gcc_assert (cfun
->cfg
== NULL
);
2150 gcc_assert (cfun
->decl
== new_fndecl
);
2152 /* Copy items we preserve during cloning. */
2153 cfun
->static_chain_decl
= src_cfun
->static_chain_decl
;
2154 cfun
->nonlocal_goto_save_area
= src_cfun
->nonlocal_goto_save_area
;
2155 cfun
->function_end_locus
= src_cfun
->function_end_locus
;
2156 cfun
->curr_properties
= src_cfun
->curr_properties
;
2157 cfun
->last_verified
= src_cfun
->last_verified
;
2158 cfun
->va_list_gpr_size
= src_cfun
->va_list_gpr_size
;
2159 cfun
->va_list_fpr_size
= src_cfun
->va_list_fpr_size
;
2160 cfun
->has_nonlocal_label
= src_cfun
->has_nonlocal_label
;
2161 cfun
->stdarg
= src_cfun
->stdarg
;
2162 cfun
->after_inlining
= src_cfun
->after_inlining
;
2163 cfun
->can_throw_non_call_exceptions
2164 = src_cfun
->can_throw_non_call_exceptions
;
2165 cfun
->can_delete_dead_exceptions
= src_cfun
->can_delete_dead_exceptions
;
2166 cfun
->returns_struct
= src_cfun
->returns_struct
;
2167 cfun
->returns_pcc_struct
= src_cfun
->returns_pcc_struct
;
2169 init_empty_tree_cfg ();
2171 profile_status_for_function (cfun
) = profile_status_for_function (src_cfun
);
2172 ENTRY_BLOCK_PTR
->count
=
2173 (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
* count_scale
/
2175 ENTRY_BLOCK_PTR
->frequency
2176 = ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->frequency
;
2177 EXIT_BLOCK_PTR
->count
=
2178 (EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
* count_scale
/
2180 EXIT_BLOCK_PTR
->frequency
=
2181 EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->frequency
;
2183 init_eh_for_function ();
2185 if (src_cfun
->gimple_df
)
2187 init_tree_ssa (cfun
);
2188 cfun
->gimple_df
->in_ssa_p
= true;
2189 init_ssa_operands (cfun
);
2193 /* Helper function for copy_cfg_body. Move debug stmts from the end
2194 of NEW_BB to the beginning of successor basic blocks when needed. If the
2195 successor has multiple predecessors, reset them, otherwise keep
2199 maybe_move_debug_stmts_to_successors (copy_body_data
*id
, basic_block new_bb
)
2203 gimple_stmt_iterator si
= gsi_last_nondebug_bb (new_bb
);
2206 || gsi_one_before_end_p (si
)
2207 || !(stmt_can_throw_internal (gsi_stmt (si
))
2208 || stmt_can_make_abnormal_goto (gsi_stmt (si
))))
2211 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
2213 gimple_stmt_iterator ssi
= gsi_last_bb (new_bb
);
2214 gimple_stmt_iterator dsi
= gsi_after_labels (e
->dest
);
2215 while (is_gimple_debug (gsi_stmt (ssi
)))
2217 gimple stmt
= gsi_stmt (ssi
), new_stmt
;
2221 /* For the last edge move the debug stmts instead of copying
2223 if (ei_one_before_end_p (ei
))
2227 if (!single_pred_p (e
->dest
) && gimple_debug_bind_p (stmt
))
2228 gimple_debug_bind_reset_value (stmt
);
2229 gsi_remove (&si
, false);
2230 gsi_insert_before (&dsi
, stmt
, GSI_SAME_STMT
);
2234 if (gimple_debug_bind_p (stmt
))
2236 var
= gimple_debug_bind_get_var (stmt
);
2237 if (single_pred_p (e
->dest
))
2239 value
= gimple_debug_bind_get_value (stmt
);
2240 value
= unshare_expr (value
);
2244 new_stmt
= gimple_build_debug_bind (var
, value
, stmt
);
2246 else if (gimple_debug_source_bind_p (stmt
))
2248 var
= gimple_debug_source_bind_get_var (stmt
);
2249 value
= gimple_debug_source_bind_get_value (stmt
);
2250 new_stmt
= gimple_build_debug_source_bind (var
, value
, stmt
);
2254 gsi_insert_before (&dsi
, new_stmt
, GSI_SAME_STMT
);
2255 id
->debug_stmts
.safe_push (new_stmt
);
2261 /* Make a copy of the sub-loops of SRC_PARENT and place them
2262 as siblings of DEST_PARENT. */
2265 copy_loops (copy_body_data
*id
,
2266 struct loop
*dest_parent
, struct loop
*src_parent
)
2268 struct loop
*src_loop
= src_parent
->inner
;
2271 if (!id
->blocks_to_copy
2272 || bitmap_bit_p (id
->blocks_to_copy
, src_loop
->header
->index
))
2274 struct loop
*dest_loop
= alloc_loop ();
2276 /* Assign the new loop its header and latch and associate
2277 those with the new loop. */
2278 if (src_loop
->header
!= NULL
)
2280 dest_loop
->header
= (basic_block
)src_loop
->header
->aux
;
2281 dest_loop
->header
->loop_father
= dest_loop
;
2283 if (src_loop
->latch
!= NULL
)
2285 dest_loop
->latch
= (basic_block
)src_loop
->latch
->aux
;
2286 dest_loop
->latch
->loop_father
= dest_loop
;
2289 /* Copy loop meta-data. */
2290 copy_loop_info (src_loop
, dest_loop
);
2292 /* Finally place it into the loop array and the loop tree. */
2293 place_new_loop (cfun
, dest_loop
);
2294 flow_loop_tree_node_add (dest_parent
, dest_loop
);
2296 if (src_loop
->simduid
)
2298 dest_loop
->simduid
= remap_decl (src_loop
->simduid
, id
);
2299 cfun
->has_simduid_loops
= true;
2301 if (src_loop
->force_vect
)
2303 dest_loop
->force_vect
= true;
2304 cfun
->has_force_vect_loops
= true;
2308 copy_loops (id
, dest_loop
, src_loop
);
2310 src_loop
= src_loop
->next
;
2314 /* Call cgraph_redirect_edge_call_stmt_to_callee on all calls in BB */
2317 redirect_all_calls (copy_body_data
* id
, basic_block bb
)
2319 gimple_stmt_iterator si
;
2320 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
2322 if (is_gimple_call (gsi_stmt (si
)))
2324 struct cgraph_edge
*edge
= cgraph_edge (id
->dst_node
, gsi_stmt (si
));
2326 cgraph_redirect_edge_call_stmt_to_callee (edge
);
2331 /* Make a copy of the body of FN so that it can be inserted inline in
2332 another function. Walks FN via CFG, returns new fndecl. */
2335 copy_cfg_body (copy_body_data
* id
, gcov_type count
, int frequency_scale
,
2336 basic_block entry_block_map
, basic_block exit_block_map
,
2337 basic_block new_entry
)
2339 tree callee_fndecl
= id
->src_fn
;
2340 /* Original cfun for the callee, doesn't change. */
2341 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2342 struct function
*cfun_to_copy
;
2344 tree new_fndecl
= NULL
;
2345 bool need_debug_cleanup
= false;
2346 gcov_type count_scale
;
2348 int incoming_frequency
= 0;
2349 gcov_type incoming_count
= 0;
2351 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
)
2353 = GCOV_COMPUTE_SCALE (count
,
2354 ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
);
2356 count_scale
= REG_BR_PROB_BASE
;
2358 /* Register specific tree functions. */
2359 gimple_register_cfg_hooks ();
2361 /* If we are inlining just region of the function, make sure to connect new entry
2362 to ENTRY_BLOCK_PTR. Since new entry can be part of loop, we must compute
2363 frequency and probability of ENTRY_BLOCK_PTR based on the frequencies and
2364 probabilities of edges incoming from nonduplicated region. */
2370 FOR_EACH_EDGE (e
, ei
, new_entry
->preds
)
2373 incoming_frequency
+= EDGE_FREQUENCY (e
);
2374 incoming_count
+= e
->count
;
2376 incoming_count
= apply_scale (incoming_count
, count_scale
);
2378 = apply_scale ((gcov_type
)incoming_frequency
, frequency_scale
);
2379 ENTRY_BLOCK_PTR
->count
= incoming_count
;
2380 ENTRY_BLOCK_PTR
->frequency
= incoming_frequency
;
2383 /* Must have a CFG here at this point. */
2384 gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION
2385 (DECL_STRUCT_FUNCTION (callee_fndecl
)));
2387 cfun_to_copy
= id
->src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2389 ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy
)->aux
= entry_block_map
;
2390 EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy
)->aux
= exit_block_map
;
2391 entry_block_map
->aux
= ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy
);
2392 exit_block_map
->aux
= EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy
);
2394 /* Duplicate any exception-handling regions. */
2396 id
->eh_map
= duplicate_eh_regions (cfun_to_copy
, NULL
, id
->eh_lp_nr
,
2399 /* Use aux pointers to map the original blocks to copy. */
2400 FOR_EACH_BB_FN (bb
, cfun_to_copy
)
2401 if (!id
->blocks_to_copy
|| bitmap_bit_p (id
->blocks_to_copy
, bb
->index
))
2403 basic_block new_bb
= copy_bb (id
, bb
, frequency_scale
, count_scale
);
2406 new_bb
->loop_father
= entry_block_map
->loop_father
;
2409 last
= last_basic_block
;
2411 /* Now that we've duplicated the blocks, duplicate their edges. */
2412 bool can_make_abormal_goto
2413 = id
->gimple_call
&& stmt_can_make_abnormal_goto (id
->gimple_call
);
2414 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2415 if (!id
->blocks_to_copy
2416 || (bb
->index
> 0 && bitmap_bit_p (id
->blocks_to_copy
, bb
->index
)))
2417 need_debug_cleanup
|= copy_edges_for_bb (bb
, count_scale
, exit_block_map
,
2418 can_make_abormal_goto
);
2422 edge e
= make_edge (entry_block_map
, (basic_block
)new_entry
->aux
, EDGE_FALLTHRU
);
2423 e
->probability
= REG_BR_PROB_BASE
;
2424 e
->count
= incoming_count
;
2427 /* Duplicate the loop tree, if available and wanted. */
2428 if (loops_for_fn (src_cfun
) != NULL
2429 && current_loops
!= NULL
)
2431 copy_loops (id
, entry_block_map
->loop_father
,
2432 get_loop (src_cfun
, 0));
2433 /* Defer to cfgcleanup to update loop-father fields of basic-blocks. */
2434 loops_state_set (LOOPS_NEED_FIXUP
);
2437 /* If the loop tree in the source function needed fixup, mark the
2438 destination loop tree for fixup, too. */
2439 if (loops_for_fn (src_cfun
)->state
& LOOPS_NEED_FIXUP
)
2440 loops_state_set (LOOPS_NEED_FIXUP
);
2442 if (gimple_in_ssa_p (cfun
))
2443 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2444 if (!id
->blocks_to_copy
2445 || (bb
->index
> 0 && bitmap_bit_p (id
->blocks_to_copy
, bb
->index
)))
2446 copy_phis_for_bb (bb
, id
);
2448 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2451 if (need_debug_cleanup
2452 && bb
->index
!= ENTRY_BLOCK
2453 && bb
->index
!= EXIT_BLOCK
)
2454 maybe_move_debug_stmts_to_successors (id
, (basic_block
) bb
->aux
);
2455 /* Update call edge destinations. This can not be done before loop
2456 info is updated, because we may split basic blocks. */
2457 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
)
2458 redirect_all_calls (id
, (basic_block
)bb
->aux
);
2459 ((basic_block
)bb
->aux
)->aux
= NULL
;
2463 /* Zero out AUX fields of newly created block during EH edge
2465 for (; last
< last_basic_block
; last
++)
2467 if (need_debug_cleanup
)
2468 maybe_move_debug_stmts_to_successors (id
, BASIC_BLOCK (last
));
2469 BASIC_BLOCK (last
)->aux
= NULL
;
2470 /* Update call edge destinations. This can not be done before loop
2471 info is updated, because we may split basic blocks. */
2472 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
)
2473 redirect_all_calls (id
, BASIC_BLOCK (last
));
2475 entry_block_map
->aux
= NULL
;
2476 exit_block_map
->aux
= NULL
;
2480 pointer_map_destroy (id
->eh_map
);
2487 /* Copy the debug STMT using ID. We deal with these statements in a
2488 special way: if any variable in their VALUE expression wasn't
2489 remapped yet, we won't remap it, because that would get decl uids
2490 out of sync, causing codegen differences between -g and -g0. If
2491 this arises, we drop the VALUE expression altogether. */
2494 copy_debug_stmt (gimple stmt
, copy_body_data
*id
)
2497 struct walk_stmt_info wi
;
2499 if (gimple_block (stmt
))
2501 n
= (tree
*) pointer_map_contains (id
->decl_map
, gimple_block (stmt
));
2502 gimple_set_block (stmt
, n
? *n
: id
->block
);
2505 /* Remap all the operands in COPY. */
2506 memset (&wi
, 0, sizeof (wi
));
2509 processing_debug_stmt
= 1;
2511 if (gimple_debug_source_bind_p (stmt
))
2512 t
= gimple_debug_source_bind_get_var (stmt
);
2514 t
= gimple_debug_bind_get_var (stmt
);
2516 if (TREE_CODE (t
) == PARM_DECL
&& id
->debug_map
2517 && (n
= (tree
*) pointer_map_contains (id
->debug_map
, t
)))
2519 gcc_assert (TREE_CODE (*n
) == VAR_DECL
);
2522 else if (TREE_CODE (t
) == VAR_DECL
2523 && !is_global_var (t
)
2524 && !pointer_map_contains (id
->decl_map
, t
))
2525 /* T is a non-localized variable. */;
2527 walk_tree (&t
, remap_gimple_op_r
, &wi
, NULL
);
2529 if (gimple_debug_bind_p (stmt
))
2531 gimple_debug_bind_set_var (stmt
, t
);
2533 if (gimple_debug_bind_has_value_p (stmt
))
2534 walk_tree (gimple_debug_bind_get_value_ptr (stmt
),
2535 remap_gimple_op_r
, &wi
, NULL
);
2537 /* Punt if any decl couldn't be remapped. */
2538 if (processing_debug_stmt
< 0)
2539 gimple_debug_bind_reset_value (stmt
);
2541 else if (gimple_debug_source_bind_p (stmt
))
2543 gimple_debug_source_bind_set_var (stmt
, t
);
2544 walk_tree (gimple_debug_source_bind_get_value_ptr (stmt
),
2545 remap_gimple_op_r
, &wi
, NULL
);
2546 /* When inlining and source bind refers to one of the optimized
2547 away parameters, change the source bind into normal debug bind
2548 referring to the corresponding DEBUG_EXPR_DECL that should have
2549 been bound before the call stmt. */
2550 t
= gimple_debug_source_bind_get_value (stmt
);
2552 && TREE_CODE (t
) == PARM_DECL
2555 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (id
->src_fn
);
2557 if (debug_args
!= NULL
)
2559 for (i
= 0; i
< vec_safe_length (*debug_args
); i
+= 2)
2560 if ((**debug_args
)[i
] == DECL_ORIGIN (t
)
2561 && TREE_CODE ((**debug_args
)[i
+ 1]) == DEBUG_EXPR_DECL
)
2563 t
= (**debug_args
)[i
+ 1];
2564 stmt
->gsbase
.subcode
= GIMPLE_DEBUG_BIND
;
2565 gimple_debug_bind_set_value (stmt
, t
);
2572 processing_debug_stmt
= 0;
2577 /* Process deferred debug stmts. In order to give values better odds
2578 of being successfully remapped, we delay the processing of debug
2579 stmts until all other stmts that might require remapping are
2583 copy_debug_stmts (copy_body_data
*id
)
2588 if (!id
->debug_stmts
.exists ())
2591 FOR_EACH_VEC_ELT (id
->debug_stmts
, i
, stmt
)
2592 copy_debug_stmt (stmt
, id
);
2594 id
->debug_stmts
.release ();
2597 /* Make a copy of the body of SRC_FN so that it can be inserted inline in
2598 another function. */
2601 copy_tree_body (copy_body_data
*id
)
2603 tree fndecl
= id
->src_fn
;
2604 tree body
= DECL_SAVED_TREE (fndecl
);
2606 walk_tree (&body
, copy_tree_body_r
, id
, NULL
);
2611 /* Make a copy of the body of FN so that it can be inserted inline in
2612 another function. */
2615 copy_body (copy_body_data
*id
, gcov_type count
, int frequency_scale
,
2616 basic_block entry_block_map
, basic_block exit_block_map
,
2617 basic_block new_entry
)
2619 tree fndecl
= id
->src_fn
;
2622 /* If this body has a CFG, walk CFG and copy. */
2623 gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (fndecl
)));
2624 body
= copy_cfg_body (id
, count
, frequency_scale
, entry_block_map
, exit_block_map
,
2626 copy_debug_stmts (id
);
2631 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
2632 defined in function FN, or of a data member thereof. */
2635 self_inlining_addr_expr (tree value
, tree fn
)
2639 if (TREE_CODE (value
) != ADDR_EXPR
)
2642 var
= get_base_address (TREE_OPERAND (value
, 0));
2644 return var
&& auto_var_in_fn_p (var
, fn
);
2647 /* Append to BB a debug annotation that binds VAR to VALUE, inheriting
2648 lexical block and line number information from base_stmt, if given,
2649 or from the last stmt of the block otherwise. */
2652 insert_init_debug_bind (copy_body_data
*id
,
2653 basic_block bb
, tree var
, tree value
,
2657 gimple_stmt_iterator gsi
;
2660 if (!gimple_in_ssa_p (id
->src_cfun
))
2663 if (!MAY_HAVE_DEBUG_STMTS
)
2666 tracked_var
= target_for_debug_bind (var
);
2672 gsi
= gsi_last_bb (bb
);
2673 if (!base_stmt
&& !gsi_end_p (gsi
))
2674 base_stmt
= gsi_stmt (gsi
);
2677 note
= gimple_build_debug_bind (tracked_var
, value
, base_stmt
);
2681 if (!gsi_end_p (gsi
))
2682 gsi_insert_after (&gsi
, note
, GSI_SAME_STMT
);
2684 gsi_insert_before (&gsi
, note
, GSI_SAME_STMT
);
2691 insert_init_stmt (copy_body_data
*id
, basic_block bb
, gimple init_stmt
)
2693 /* If VAR represents a zero-sized variable, it's possible that the
2694 assignment statement may result in no gimple statements. */
2697 gimple_stmt_iterator si
= gsi_last_bb (bb
);
2699 /* We can end up with init statements that store to a non-register
2700 from a rhs with a conversion. Handle that here by forcing the
2701 rhs into a temporary. gimple_regimplify_operands is not
2702 prepared to do this for us. */
2703 if (!is_gimple_debug (init_stmt
)
2704 && !is_gimple_reg (gimple_assign_lhs (init_stmt
))
2705 && is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (init_stmt
)))
2706 && gimple_assign_rhs_class (init_stmt
) == GIMPLE_UNARY_RHS
)
2708 tree rhs
= build1 (gimple_assign_rhs_code (init_stmt
),
2709 gimple_expr_type (init_stmt
),
2710 gimple_assign_rhs1 (init_stmt
));
2711 rhs
= force_gimple_operand_gsi (&si
, rhs
, true, NULL_TREE
, false,
2713 gimple_assign_set_rhs_code (init_stmt
, TREE_CODE (rhs
));
2714 gimple_assign_set_rhs1 (init_stmt
, rhs
);
2716 gsi_insert_after (&si
, init_stmt
, GSI_NEW_STMT
);
2717 gimple_regimplify_operands (init_stmt
, &si
);
2719 if (!is_gimple_debug (init_stmt
) && MAY_HAVE_DEBUG_STMTS
)
2721 tree def
= gimple_assign_lhs (init_stmt
);
2722 insert_init_debug_bind (id
, bb
, def
, def
, init_stmt
);
2727 /* Initialize parameter P with VALUE. If needed, produce init statement
2728 at the end of BB. When BB is NULL, we return init statement to be
2731 setup_one_parameter (copy_body_data
*id
, tree p
, tree value
, tree fn
,
2732 basic_block bb
, tree
*vars
)
2734 gimple init_stmt
= NULL
;
2737 tree def
= (gimple_in_ssa_p (cfun
)
2738 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
2741 && value
!= error_mark_node
2742 && !useless_type_conversion_p (TREE_TYPE (p
), TREE_TYPE (value
)))
2744 /* If we can match up types by promotion/demotion do so. */
2745 if (fold_convertible_p (TREE_TYPE (p
), value
))
2746 rhs
= fold_convert (TREE_TYPE (p
), value
);
2749 /* ??? For valid programs we should not end up here.
2750 Still if we end up with truly mismatched types here, fall back
2751 to using a VIEW_CONVERT_EXPR or a literal zero to not leak invalid
2752 GIMPLE to the following passes. */
2753 if (!is_gimple_reg_type (TREE_TYPE (value
))
2754 || TYPE_SIZE (TREE_TYPE (p
)) == TYPE_SIZE (TREE_TYPE (value
)))
2755 rhs
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (p
), value
);
2757 rhs
= build_zero_cst (TREE_TYPE (p
));
2761 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
2762 here since the type of this decl must be visible to the calling
2764 var
= copy_decl_to_var (p
, id
);
2766 /* Declare this new variable. */
2767 DECL_CHAIN (var
) = *vars
;
2770 /* Make gimplifier happy about this variable. */
2771 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
2773 /* If the parameter is never assigned to, has no SSA_NAMEs created,
2774 we would not need to create a new variable here at all, if it
2775 weren't for debug info. Still, we can just use the argument
2777 if (TREE_READONLY (p
)
2778 && !TREE_ADDRESSABLE (p
)
2779 && value
&& !TREE_SIDE_EFFECTS (value
)
2782 /* We may produce non-gimple trees by adding NOPs or introduce
2783 invalid sharing when operand is not really constant.
2784 It is not big deal to prohibit constant propagation here as
2785 we will constant propagate in DOM1 pass anyway. */
2786 if (is_gimple_min_invariant (value
)
2787 && useless_type_conversion_p (TREE_TYPE (p
),
2789 /* We have to be very careful about ADDR_EXPR. Make sure
2790 the base variable isn't a local variable of the inlined
2791 function, e.g., when doing recursive inlining, direct or
2792 mutually-recursive or whatever, which is why we don't
2793 just test whether fn == current_function_decl. */
2794 && ! self_inlining_addr_expr (value
, fn
))
2796 insert_decl_map (id
, p
, value
);
2797 insert_debug_decl_map (id
, p
, var
);
2798 return insert_init_debug_bind (id
, bb
, var
, value
, NULL
);
2802 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
2803 that way, when the PARM_DECL is encountered, it will be
2804 automatically replaced by the VAR_DECL. */
2805 insert_decl_map (id
, p
, var
);
2807 /* Even if P was TREE_READONLY, the new VAR should not be.
2808 In the original code, we would have constructed a
2809 temporary, and then the function body would have never
2810 changed the value of P. However, now, we will be
2811 constructing VAR directly. The constructor body may
2812 change its value multiple times as it is being
2813 constructed. Therefore, it must not be TREE_READONLY;
2814 the back-end assumes that TREE_READONLY variable is
2815 assigned to only once. */
2816 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p
)))
2817 TREE_READONLY (var
) = 0;
2819 /* If there is no setup required and we are in SSA, take the easy route
2820 replacing all SSA names representing the function parameter by the
2821 SSA name passed to function.
2823 We need to construct map for the variable anyway as it might be used
2824 in different SSA names when parameter is set in function.
2826 Do replacement at -O0 for const arguments replaced by constant.
2827 This is important for builtin_constant_p and other construct requiring
2828 constant argument to be visible in inlined function body. */
2829 if (gimple_in_ssa_p (cfun
) && rhs
&& def
&& is_gimple_reg (p
)
2831 || (TREE_READONLY (p
)
2832 && is_gimple_min_invariant (rhs
)))
2833 && (TREE_CODE (rhs
) == SSA_NAME
2834 || is_gimple_min_invariant (rhs
))
2835 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
2837 insert_decl_map (id
, def
, rhs
);
2838 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
2841 /* If the value of argument is never used, don't care about initializing
2843 if (optimize
&& gimple_in_ssa_p (cfun
) && !def
&& is_gimple_reg (p
))
2845 gcc_assert (!value
|| !TREE_SIDE_EFFECTS (value
));
2846 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
2849 /* Initialize this VAR_DECL from the equivalent argument. Convert
2850 the argument to the proper type in case it was promoted. */
2853 if (rhs
== error_mark_node
)
2855 insert_decl_map (id
, p
, var
);
2856 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
2859 STRIP_USELESS_TYPE_CONVERSION (rhs
);
2861 /* If we are in SSA form properly remap the default definition
2862 or assign to a dummy SSA name if the parameter is unused and
2863 we are not optimizing. */
2864 if (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
))
2868 def
= remap_ssa_name (def
, id
);
2869 init_stmt
= gimple_build_assign (def
, rhs
);
2870 SSA_NAME_IS_DEFAULT_DEF (def
) = 0;
2871 set_ssa_default_def (cfun
, var
, NULL
);
2875 def
= make_ssa_name (var
, NULL
);
2876 init_stmt
= gimple_build_assign (def
, rhs
);
2880 init_stmt
= gimple_build_assign (var
, rhs
);
2882 if (bb
&& init_stmt
)
2883 insert_init_stmt (id
, bb
, init_stmt
);
2888 /* Generate code to initialize the parameters of the function at the
2889 top of the stack in ID from the GIMPLE_CALL STMT. */
2892 initialize_inlined_parameters (copy_body_data
*id
, gimple stmt
,
2893 tree fn
, basic_block bb
)
2898 tree vars
= NULL_TREE
;
2899 tree static_chain
= gimple_call_chain (stmt
);
2901 /* Figure out what the parameters are. */
2902 parms
= DECL_ARGUMENTS (fn
);
2904 /* Loop through the parameter declarations, replacing each with an
2905 equivalent VAR_DECL, appropriately initialized. */
2906 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
2909 val
= i
< gimple_call_num_args (stmt
) ? gimple_call_arg (stmt
, i
) : NULL
;
2910 setup_one_parameter (id
, p
, val
, fn
, bb
, &vars
);
2912 /* After remapping parameters remap their types. This has to be done
2913 in a second loop over all parameters to appropriately remap
2914 variable sized arrays when the size is specified in a
2915 parameter following the array. */
2916 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
2918 tree
*varp
= (tree
*) pointer_map_contains (id
->decl_map
, p
);
2920 && TREE_CODE (*varp
) == VAR_DECL
)
2922 tree def
= (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
)
2923 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
2925 TREE_TYPE (var
) = remap_type (TREE_TYPE (var
), id
);
2926 /* Also remap the default definition if it was remapped
2927 to the default definition of the parameter replacement
2928 by the parameter setup. */
2931 tree
*defp
= (tree
*) pointer_map_contains (id
->decl_map
, def
);
2933 && TREE_CODE (*defp
) == SSA_NAME
2934 && SSA_NAME_VAR (*defp
) == var
)
2935 TREE_TYPE (*defp
) = TREE_TYPE (var
);
2940 /* Initialize the static chain. */
2941 p
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
2942 gcc_assert (fn
!= current_function_decl
);
2945 /* No static chain? Seems like a bug in tree-nested.c. */
2946 gcc_assert (static_chain
);
2948 setup_one_parameter (id
, p
, static_chain
, fn
, bb
, &vars
);
2951 declare_inline_vars (id
->block
, vars
);
2955 /* Declare a return variable to replace the RESULT_DECL for the
2956 function we are calling. An appropriate DECL_STMT is returned.
2957 The USE_STMT is filled to contain a use of the declaration to
2958 indicate the return value of the function.
2960 RETURN_SLOT, if non-null is place where to store the result. It
2961 is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null,
2962 was the LHS of the MODIFY_EXPR to which this call is the RHS.
2964 The return value is a (possibly null) value that holds the result
2965 as seen by the caller. */
2968 declare_return_variable (copy_body_data
*id
, tree return_slot
, tree modify_dest
,
2969 basic_block entry_bb
)
2971 tree callee
= id
->src_fn
;
2972 tree result
= DECL_RESULT (callee
);
2973 tree callee_type
= TREE_TYPE (result
);
2977 /* Handle type-mismatches in the function declaration return type
2978 vs. the call expression. */
2980 caller_type
= TREE_TYPE (modify_dest
);
2982 caller_type
= TREE_TYPE (TREE_TYPE (callee
));
2984 /* We don't need to do anything for functions that don't return anything. */
2985 if (VOID_TYPE_P (callee_type
))
2988 /* If there was a return slot, then the return value is the
2989 dereferenced address of that object. */
2992 /* The front end shouldn't have used both return_slot and
2993 a modify expression. */
2994 gcc_assert (!modify_dest
);
2995 if (DECL_BY_REFERENCE (result
))
2997 tree return_slot_addr
= build_fold_addr_expr (return_slot
);
2998 STRIP_USELESS_TYPE_CONVERSION (return_slot_addr
);
3000 /* We are going to construct *&return_slot and we can't do that
3001 for variables believed to be not addressable.
3003 FIXME: This check possibly can match, because values returned
3004 via return slot optimization are not believed to have address
3005 taken by alias analysis. */
3006 gcc_assert (TREE_CODE (return_slot
) != SSA_NAME
);
3007 var
= return_slot_addr
;
3012 gcc_assert (TREE_CODE (var
) != SSA_NAME
);
3013 TREE_ADDRESSABLE (var
) |= TREE_ADDRESSABLE (result
);
3015 if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
3016 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
3017 && !DECL_GIMPLE_REG_P (result
)
3019 DECL_GIMPLE_REG_P (var
) = 0;
3024 /* All types requiring non-trivial constructors should have been handled. */
3025 gcc_assert (!TREE_ADDRESSABLE (callee_type
));
3027 /* Attempt to avoid creating a new temporary variable. */
3029 && TREE_CODE (modify_dest
) != SSA_NAME
)
3031 bool use_it
= false;
3033 /* We can't use MODIFY_DEST if there's type promotion involved. */
3034 if (!useless_type_conversion_p (callee_type
, caller_type
))
3037 /* ??? If we're assigning to a variable sized type, then we must
3038 reuse the destination variable, because we've no good way to
3039 create variable sized temporaries at this point. */
3040 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type
)) != INTEGER_CST
)
3043 /* If the callee cannot possibly modify MODIFY_DEST, then we can
3044 reuse it as the result of the call directly. Don't do this if
3045 it would promote MODIFY_DEST to addressable. */
3046 else if (TREE_ADDRESSABLE (result
))
3050 tree base_m
= get_base_address (modify_dest
);
3052 /* If the base isn't a decl, then it's a pointer, and we don't
3053 know where that's going to go. */
3054 if (!DECL_P (base_m
))
3056 else if (is_global_var (base_m
))
3058 else if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
3059 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
3060 && !DECL_GIMPLE_REG_P (result
)
3061 && DECL_GIMPLE_REG_P (base_m
))
3063 else if (!TREE_ADDRESSABLE (base_m
))
3075 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type
)) == INTEGER_CST
);
3077 var
= copy_result_decl_to_var (result
, id
);
3078 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
3080 /* Do not have the rest of GCC warn about this variable as it should
3081 not be visible to the user. */
3082 TREE_NO_WARNING (var
) = 1;
3084 declare_inline_vars (id
->block
, var
);
3086 /* Build the use expr. If the return type of the function was
3087 promoted, convert it back to the expected type. */
3089 if (!useless_type_conversion_p (caller_type
, TREE_TYPE (var
)))
3091 /* If we can match up types by promotion/demotion do so. */
3092 if (fold_convertible_p (caller_type
, var
))
3093 use
= fold_convert (caller_type
, var
);
3096 /* ??? For valid programs we should not end up here.
3097 Still if we end up with truly mismatched types here, fall back
3098 to using a MEM_REF to not leak invalid GIMPLE to the following
3100 /* Prevent var from being written into SSA form. */
3101 if (TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
3102 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
)
3103 DECL_GIMPLE_REG_P (var
) = false;
3104 else if (is_gimple_reg_type (TREE_TYPE (var
)))
3105 TREE_ADDRESSABLE (var
) = true;
3106 use
= fold_build2 (MEM_REF
, caller_type
,
3107 build_fold_addr_expr (var
),
3108 build_int_cst (ptr_type_node
, 0));
3112 STRIP_USELESS_TYPE_CONVERSION (use
);
3114 if (DECL_BY_REFERENCE (result
))
3116 TREE_ADDRESSABLE (var
) = 1;
3117 var
= build_fold_addr_expr (var
);
3121 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
3122 way, when the RESULT_DECL is encountered, it will be
3123 automatically replaced by the VAR_DECL.
3125 When returning by reference, ensure that RESULT_DECL remaps to
3127 if (DECL_BY_REFERENCE (result
)
3128 && !is_gimple_val (var
))
3130 tree temp
= create_tmp_var (TREE_TYPE (result
), "retvalptr");
3131 insert_decl_map (id
, result
, temp
);
3132 /* When RESULT_DECL is in SSA form, we need to remap and initialize
3133 it's default_def SSA_NAME. */
3134 if (gimple_in_ssa_p (id
->src_cfun
)
3135 && is_gimple_reg (result
))
3137 temp
= make_ssa_name (temp
, NULL
);
3138 insert_decl_map (id
, ssa_default_def (id
->src_cfun
, result
), temp
);
3140 insert_init_stmt (id
, entry_bb
, gimple_build_assign (temp
, var
));
3143 insert_decl_map (id
, result
, var
);
3145 /* Remember this so we can ignore it in remap_decls. */
3151 /* Callback through walk_tree. Determine if a DECL_INITIAL makes reference
3152 to a local label. */
3155 has_label_address_in_static_1 (tree
*nodep
, int *walk_subtrees
, void *fnp
)
3158 tree fn
= (tree
) fnp
;
3160 if (TREE_CODE (node
) == LABEL_DECL
&& DECL_CONTEXT (node
) == fn
)
3169 /* Determine if the function can be copied. If so return NULL. If
3170 not return a string describng the reason for failure. */
3173 copy_forbidden (struct function
*fun
, tree fndecl
)
3175 const char *reason
= fun
->cannot_be_copied_reason
;
3179 /* Only examine the function once. */
3180 if (fun
->cannot_be_copied_set
)
3183 /* We cannot copy a function that receives a non-local goto
3184 because we cannot remap the destination label used in the
3185 function that is performing the non-local goto. */
3186 /* ??? Actually, this should be possible, if we work at it.
3187 No doubt there's just a handful of places that simply
3188 assume it doesn't happen and don't substitute properly. */
3189 if (fun
->has_nonlocal_label
)
3191 reason
= G_("function %q+F can never be copied "
3192 "because it receives a non-local goto");
3196 FOR_EACH_LOCAL_DECL (fun
, ix
, decl
)
3197 if (TREE_CODE (decl
) == VAR_DECL
3198 && TREE_STATIC (decl
)
3199 && !DECL_EXTERNAL (decl
)
3200 && DECL_INITIAL (decl
)
3201 && walk_tree_without_duplicates (&DECL_INITIAL (decl
),
3202 has_label_address_in_static_1
,
3205 reason
= G_("function %q+F can never be copied because it saves "
3206 "address of local label in a static variable");
3211 fun
->cannot_be_copied_reason
= reason
;
3212 fun
->cannot_be_copied_set
= true;
3217 static const char *inline_forbidden_reason
;
3219 /* A callback for walk_gimple_seq to handle statements. Returns non-null
3220 iff a function can not be inlined. Also sets the reason why. */
3223 inline_forbidden_p_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
3224 struct walk_stmt_info
*wip
)
3226 tree fn
= (tree
) wip
->info
;
3228 gimple stmt
= gsi_stmt (*gsi
);
3230 switch (gimple_code (stmt
))
3233 /* Refuse to inline alloca call unless user explicitly forced so as
3234 this may change program's memory overhead drastically when the
3235 function using alloca is called in loop. In GCC present in
3236 SPEC2000 inlining into schedule_block cause it to require 2GB of
3237 RAM instead of 256MB. Don't do so for alloca calls emitted for
3238 VLA objects as those can't cause unbounded growth (they're always
3239 wrapped inside stack_save/stack_restore regions. */
3240 if (gimple_alloca_call_p (stmt
)
3241 && !gimple_call_alloca_for_var_p (stmt
)
3242 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
3244 inline_forbidden_reason
3245 = G_("function %q+F can never be inlined because it uses "
3246 "alloca (override using the always_inline attribute)");
3247 *handled_ops_p
= true;
3251 t
= gimple_call_fndecl (stmt
);
3255 /* We cannot inline functions that call setjmp. */
3256 if (setjmp_call_p (t
))
3258 inline_forbidden_reason
3259 = G_("function %q+F can never be inlined because it uses setjmp");
3260 *handled_ops_p
= true;
3264 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
3265 switch (DECL_FUNCTION_CODE (t
))
3267 /* We cannot inline functions that take a variable number of
3269 case BUILT_IN_VA_START
:
3270 case BUILT_IN_NEXT_ARG
:
3271 case BUILT_IN_VA_END
:
3272 inline_forbidden_reason
3273 = G_("function %q+F can never be inlined because it "
3274 "uses variable argument lists");
3275 *handled_ops_p
= true;
3278 case BUILT_IN_LONGJMP
:
3279 /* We can't inline functions that call __builtin_longjmp at
3280 all. The non-local goto machinery really requires the
3281 destination be in a different function. If we allow the
3282 function calling __builtin_longjmp to be inlined into the
3283 function calling __builtin_setjmp, Things will Go Awry. */
3284 inline_forbidden_reason
3285 = G_("function %q+F can never be inlined because "
3286 "it uses setjmp-longjmp exception handling");
3287 *handled_ops_p
= true;
3290 case BUILT_IN_NONLOCAL_GOTO
:
3292 inline_forbidden_reason
3293 = G_("function %q+F can never be inlined because "
3294 "it uses non-local goto");
3295 *handled_ops_p
= true;
3298 case BUILT_IN_RETURN
:
3299 case BUILT_IN_APPLY_ARGS
:
3300 /* If a __builtin_apply_args caller would be inlined,
3301 it would be saving arguments of the function it has
3302 been inlined into. Similarly __builtin_return would
3303 return from the function the inline has been inlined into. */
3304 inline_forbidden_reason
3305 = G_("function %q+F can never be inlined because "
3306 "it uses __builtin_return or __builtin_apply_args");
3307 *handled_ops_p
= true;
3316 t
= gimple_goto_dest (stmt
);
3318 /* We will not inline a function which uses computed goto. The
3319 addresses of its local labels, which may be tucked into
3320 global storage, are of course not constant across
3321 instantiations, which causes unexpected behavior. */
3322 if (TREE_CODE (t
) != LABEL_DECL
)
3324 inline_forbidden_reason
3325 = G_("function %q+F can never be inlined "
3326 "because it contains a computed goto");
3327 *handled_ops_p
= true;
3336 *handled_ops_p
= false;
3340 /* Return true if FNDECL is a function that cannot be inlined into
3344 inline_forbidden_p (tree fndecl
)
3346 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
3347 struct walk_stmt_info wi
;
3348 struct pointer_set_t
*visited_nodes
;
3350 bool forbidden_p
= false;
3352 /* First check for shared reasons not to copy the code. */
3353 inline_forbidden_reason
= copy_forbidden (fun
, fndecl
);
3354 if (inline_forbidden_reason
!= NULL
)
3357 /* Next, walk the statements of the function looking for
3358 constraucts we can't handle, or are non-optimal for inlining. */
3359 visited_nodes
= pointer_set_create ();
3360 memset (&wi
, 0, sizeof (wi
));
3361 wi
.info
= (void *) fndecl
;
3362 wi
.pset
= visited_nodes
;
3364 FOR_EACH_BB_FN (bb
, fun
)
3367 gimple_seq seq
= bb_seq (bb
);
3368 ret
= walk_gimple_seq (seq
, inline_forbidden_p_stmt
, NULL
, &wi
);
3369 forbidden_p
= (ret
!= NULL
);
3374 pointer_set_destroy (visited_nodes
);
3378 /* Return false if the function FNDECL cannot be inlined on account of its
3379 attributes, true otherwise. */
3381 function_attribute_inlinable_p (const_tree fndecl
)
3383 if (targetm
.attribute_table
)
3387 for (a
= DECL_ATTRIBUTES (fndecl
); a
; a
= TREE_CHAIN (a
))
3389 const_tree name
= TREE_PURPOSE (a
);
3392 for (i
= 0; targetm
.attribute_table
[i
].name
!= NULL
; i
++)
3393 if (is_attribute_p (targetm
.attribute_table
[i
].name
, name
))
3394 return targetm
.function_attribute_inlinable_p (fndecl
);
3401 /* Returns nonzero if FN is a function that does not have any
3402 fundamental inline blocking properties. */
3405 tree_inlinable_function_p (tree fn
)
3407 bool inlinable
= true;
3411 /* If we've already decided this function shouldn't be inlined,
3412 there's no need to check again. */
3413 if (DECL_UNINLINABLE (fn
))
3416 /* We only warn for functions declared `inline' by the user. */
3417 do_warning
= (warn_inline
3418 && DECL_DECLARED_INLINE_P (fn
)
3419 && !DECL_NO_INLINE_WARNING_P (fn
)
3420 && !DECL_IN_SYSTEM_HEADER (fn
));
3422 always_inline
= lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
));
3425 && always_inline
== NULL
)
3428 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3429 "is suppressed using -fno-inline", fn
);
3433 else if (!function_attribute_inlinable_p (fn
))
3436 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3437 "uses attributes conflicting with inlining", fn
);
3441 else if (inline_forbidden_p (fn
))
3443 /* See if we should warn about uninlinable functions. Previously,
3444 some of these warnings would be issued while trying to expand
3445 the function inline, but that would cause multiple warnings
3446 about functions that would for example call alloca. But since
3447 this a property of the function, just one warning is enough.
3448 As a bonus we can now give more details about the reason why a
3449 function is not inlinable. */
3451 error (inline_forbidden_reason
, fn
);
3452 else if (do_warning
)
3453 warning (OPT_Winline
, inline_forbidden_reason
, fn
);
3458 /* Squirrel away the result so that we don't have to check again. */
3459 DECL_UNINLINABLE (fn
) = !inlinable
;
3464 /* Estimate the cost of a memory move. Use machine dependent
3465 word size and take possible memcpy call into account. */
3468 estimate_move_cost (tree type
)
3472 gcc_assert (!VOID_TYPE_P (type
));
3474 if (TREE_CODE (type
) == VECTOR_TYPE
)
3476 enum machine_mode inner
= TYPE_MODE (TREE_TYPE (type
));
3477 enum machine_mode simd
3478 = targetm
.vectorize
.preferred_simd_mode (inner
);
3479 int simd_mode_size
= GET_MODE_SIZE (simd
);
3480 return ((GET_MODE_SIZE (TYPE_MODE (type
)) + simd_mode_size
- 1)
3484 size
= int_size_in_bytes (type
);
3486 if (size
< 0 || size
> MOVE_MAX_PIECES
* MOVE_RATIO (!optimize_size
))
3487 /* Cost of a memcpy call, 3 arguments and the call. */
3490 return ((size
+ MOVE_MAX_PIECES
- 1) / MOVE_MAX_PIECES
);
3493 /* Returns cost of operation CODE, according to WEIGHTS */
3496 estimate_operator_cost (enum tree_code code
, eni_weights
*weights
,
3497 tree op1 ATTRIBUTE_UNUSED
, tree op2
)
3501 /* These are "free" conversions, or their presumed cost
3502 is folded into other operations. */
3507 case VIEW_CONVERT_EXPR
:
3510 /* Assign cost of 1 to usual operations.
3511 ??? We may consider mapping RTL costs to this. */
3517 case POINTER_PLUS_EXPR
:
3520 case MULT_HIGHPART_EXPR
:
3523 case ADDR_SPACE_CONVERT_EXPR
:
3524 case FIXED_CONVERT_EXPR
:
3525 case FIX_TRUNC_EXPR
:
3537 case VEC_LSHIFT_EXPR
:
3538 case VEC_RSHIFT_EXPR
:
3545 case TRUTH_ANDIF_EXPR
:
3546 case TRUTH_ORIF_EXPR
:
3547 case TRUTH_AND_EXPR
:
3549 case TRUTH_XOR_EXPR
:
3550 case TRUTH_NOT_EXPR
:
3559 case UNORDERED_EXPR
:
3570 case PREDECREMENT_EXPR
:
3571 case PREINCREMENT_EXPR
:
3572 case POSTDECREMENT_EXPR
:
3573 case POSTINCREMENT_EXPR
:
3575 case REALIGN_LOAD_EXPR
:
3577 case REDUC_MAX_EXPR
:
3578 case REDUC_MIN_EXPR
:
3579 case REDUC_PLUS_EXPR
:
3580 case WIDEN_SUM_EXPR
:
3581 case WIDEN_MULT_EXPR
:
3583 case WIDEN_MULT_PLUS_EXPR
:
3584 case WIDEN_MULT_MINUS_EXPR
:
3585 case WIDEN_LSHIFT_EXPR
:
3587 case VEC_WIDEN_MULT_HI_EXPR
:
3588 case VEC_WIDEN_MULT_LO_EXPR
:
3589 case VEC_WIDEN_MULT_EVEN_EXPR
:
3590 case VEC_WIDEN_MULT_ODD_EXPR
:
3591 case VEC_UNPACK_HI_EXPR
:
3592 case VEC_UNPACK_LO_EXPR
:
3593 case VEC_UNPACK_FLOAT_HI_EXPR
:
3594 case VEC_UNPACK_FLOAT_LO_EXPR
:
3595 case VEC_PACK_TRUNC_EXPR
:
3596 case VEC_PACK_SAT_EXPR
:
3597 case VEC_PACK_FIX_TRUNC_EXPR
:
3598 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3599 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3603 /* Few special cases of expensive operations. This is useful
3604 to avoid inlining on functions having too many of these. */
3605 case TRUNC_DIV_EXPR
:
3607 case FLOOR_DIV_EXPR
:
3608 case ROUND_DIV_EXPR
:
3609 case EXACT_DIV_EXPR
:
3610 case TRUNC_MOD_EXPR
:
3612 case FLOOR_MOD_EXPR
:
3613 case ROUND_MOD_EXPR
:
3615 if (TREE_CODE (op2
) != INTEGER_CST
)
3616 return weights
->div_mod_cost
;
3620 /* We expect a copy assignment with no operator. */
3621 gcc_assert (get_gimple_rhs_class (code
) == GIMPLE_SINGLE_RHS
);
3627 /* Estimate number of instructions that will be created by expanding
3628 the statements in the statement sequence STMTS.
3629 WEIGHTS contains weights attributed to various constructs. */
3632 int estimate_num_insns_seq (gimple_seq stmts
, eni_weights
*weights
)
3635 gimple_stmt_iterator gsi
;
3638 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3639 cost
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
3645 /* Estimate number of instructions that will be created by expanding STMT.
3646 WEIGHTS contains weights attributed to various constructs. */
3649 estimate_num_insns (gimple stmt
, eni_weights
*weights
)
3652 enum gimple_code code
= gimple_code (stmt
);
3659 /* Try to estimate the cost of assignments. We have three cases to
3661 1) Simple assignments to registers;
3662 2) Stores to things that must live in memory. This includes
3663 "normal" stores to scalars, but also assignments of large
3664 structures, or constructors of big arrays;
3666 Let us look at the first two cases, assuming we have "a = b + C":
3667 <GIMPLE_ASSIGN <var_decl "a">
3668 <plus_expr <var_decl "b"> <constant C>>
3669 If "a" is a GIMPLE register, the assignment to it is free on almost
3670 any target, because "a" usually ends up in a real register. Hence
3671 the only cost of this expression comes from the PLUS_EXPR, and we
3672 can ignore the GIMPLE_ASSIGN.
3673 If "a" is not a GIMPLE register, the assignment to "a" will most
3674 likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost
3675 of moving something into "a", which we compute using the function
3676 estimate_move_cost. */
3677 if (gimple_clobber_p (stmt
))
3678 return 0; /* ={v} {CLOBBER} stmt expands to nothing. */
3680 lhs
= gimple_assign_lhs (stmt
);
3681 rhs
= gimple_assign_rhs1 (stmt
);
3685 /* Account for the cost of moving to / from memory. */
3686 if (gimple_store_p (stmt
))
3687 cost
+= estimate_move_cost (TREE_TYPE (lhs
));
3688 if (gimple_assign_load_p (stmt
))
3689 cost
+= estimate_move_cost (TREE_TYPE (rhs
));
3691 cost
+= estimate_operator_cost (gimple_assign_rhs_code (stmt
), weights
,
3692 gimple_assign_rhs1 (stmt
),
3693 get_gimple_rhs_class (gimple_assign_rhs_code (stmt
))
3694 == GIMPLE_BINARY_RHS
3695 ? gimple_assign_rhs2 (stmt
) : NULL
);
3699 cost
= 1 + estimate_operator_cost (gimple_cond_code (stmt
), weights
,
3700 gimple_op (stmt
, 0),
3701 gimple_op (stmt
, 1));
3705 /* Take into account cost of the switch + guess 2 conditional jumps for
3708 TODO: once the switch expansion logic is sufficiently separated, we can
3709 do better job on estimating cost of the switch. */
3710 if (weights
->time_based
)
3711 cost
= floor_log2 (gimple_switch_num_labels (stmt
)) * 2;
3713 cost
= gimple_switch_num_labels (stmt
) * 2;
3718 tree decl
= gimple_call_fndecl (stmt
);
3719 struct cgraph_node
*node
= NULL
;
3721 /* Do not special case builtins where we see the body.
3722 This just confuse inliner. */
3723 if (!decl
|| !(node
= cgraph_get_node (decl
)) || node
->symbol
.definition
)
3725 /* For buitins that are likely expanded to nothing or
3726 inlined do not account operand costs. */
3727 else if (is_simple_builtin (decl
))
3729 else if (is_inexpensive_builtin (decl
))
3730 return weights
->target_builtin_call_cost
;
3731 else if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
3733 /* We canonicalize x * x to pow (x, 2.0) with -ffast-math, so
3734 specialize the cheap expansion we do here.
3735 ??? This asks for a more general solution. */
3736 switch (DECL_FUNCTION_CODE (decl
))
3741 if (TREE_CODE (gimple_call_arg (stmt
, 1)) == REAL_CST
3742 && REAL_VALUES_EQUAL
3743 (TREE_REAL_CST (gimple_call_arg (stmt
, 1)), dconst2
))
3744 return estimate_operator_cost (MULT_EXPR
, weights
,
3745 gimple_call_arg (stmt
, 0),
3746 gimple_call_arg (stmt
, 0));
3754 cost
= node
? weights
->call_cost
: weights
->indirect_call_cost
;
3755 if (gimple_call_lhs (stmt
))
3756 cost
+= estimate_move_cost (TREE_TYPE (gimple_call_lhs (stmt
)));
3757 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
3759 tree arg
= gimple_call_arg (stmt
, i
);
3760 cost
+= estimate_move_cost (TREE_TYPE (arg
));
3766 return weights
->return_cost
;
3772 case GIMPLE_PREDICT
:
3778 int count
= asm_str_count (gimple_asm_string (stmt
));
3779 /* 1000 means infinity. This avoids overflows later
3780 with very long asm statements. */
3787 /* This is either going to be an external function call with one
3788 argument, or two register copy statements plus a goto. */
3791 case GIMPLE_EH_DISPATCH
:
3792 /* ??? This is going to turn into a switch statement. Ideally
3793 we'd have a look at the eh region and estimate the number of
3798 return estimate_num_insns_seq (gimple_bind_body (stmt
), weights
);
3800 case GIMPLE_EH_FILTER
:
3801 return estimate_num_insns_seq (gimple_eh_filter_failure (stmt
), weights
);
3804 return estimate_num_insns_seq (gimple_catch_handler (stmt
), weights
);
3807 return (estimate_num_insns_seq (gimple_try_eval (stmt
), weights
)
3808 + estimate_num_insns_seq (gimple_try_cleanup (stmt
), weights
));
3810 /* OpenMP directives are generally very expensive. */
3812 case GIMPLE_OMP_RETURN
:
3813 case GIMPLE_OMP_SECTIONS_SWITCH
:
3814 case GIMPLE_OMP_ATOMIC_STORE
:
3815 case GIMPLE_OMP_CONTINUE
:
3816 /* ...except these, which are cheap. */
3819 case GIMPLE_OMP_ATOMIC_LOAD
:
3820 return weights
->omp_cost
;
3822 case GIMPLE_OMP_FOR
:
3823 return (weights
->omp_cost
3824 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
)
3825 + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt
), weights
));
3827 case GIMPLE_OMP_PARALLEL
:
3828 case GIMPLE_OMP_TASK
:
3829 case GIMPLE_OMP_CRITICAL
:
3830 case GIMPLE_OMP_MASTER
:
3831 case GIMPLE_OMP_ORDERED
:
3832 case GIMPLE_OMP_SECTION
:
3833 case GIMPLE_OMP_SECTIONS
:
3834 case GIMPLE_OMP_SINGLE
:
3835 return (weights
->omp_cost
3836 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
));
3838 case GIMPLE_TRANSACTION
:
3839 return (weights
->tm_cost
3840 + estimate_num_insns_seq (gimple_transaction_body (stmt
),
3850 /* Estimate number of instructions that will be created by expanding
3851 function FNDECL. WEIGHTS contains weights attributed to various
3855 estimate_num_insns_fn (tree fndecl
, eni_weights
*weights
)
3857 struct function
*my_function
= DECL_STRUCT_FUNCTION (fndecl
);
3858 gimple_stmt_iterator bsi
;
3862 gcc_assert (my_function
&& my_function
->cfg
);
3863 FOR_EACH_BB_FN (bb
, my_function
)
3865 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
3866 n
+= estimate_num_insns (gsi_stmt (bsi
), weights
);
3873 /* Initializes weights used by estimate_num_insns. */
3876 init_inline_once (void)
3878 eni_size_weights
.call_cost
= 1;
3879 eni_size_weights
.indirect_call_cost
= 3;
3880 eni_size_weights
.target_builtin_call_cost
= 1;
3881 eni_size_weights
.div_mod_cost
= 1;
3882 eni_size_weights
.omp_cost
= 40;
3883 eni_size_weights
.tm_cost
= 10;
3884 eni_size_weights
.time_based
= false;
3885 eni_size_weights
.return_cost
= 1;
3887 /* Estimating time for call is difficult, since we have no idea what the
3888 called function does. In the current uses of eni_time_weights,
3889 underestimating the cost does less harm than overestimating it, so
3890 we choose a rather small value here. */
3891 eni_time_weights
.call_cost
= 10;
3892 eni_time_weights
.indirect_call_cost
= 15;
3893 eni_time_weights
.target_builtin_call_cost
= 1;
3894 eni_time_weights
.div_mod_cost
= 10;
3895 eni_time_weights
.omp_cost
= 40;
3896 eni_time_weights
.tm_cost
= 40;
3897 eni_time_weights
.time_based
= true;
3898 eni_time_weights
.return_cost
= 2;
3901 /* Estimate the number of instructions in a gimple_seq. */
3904 count_insns_seq (gimple_seq seq
, eni_weights
*weights
)
3906 gimple_stmt_iterator gsi
;
3908 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3909 n
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
3915 /* Install new lexical TREE_BLOCK underneath 'current_block'. */
3918 prepend_lexical_block (tree current_block
, tree new_block
)
3920 BLOCK_CHAIN (new_block
) = BLOCK_SUBBLOCKS (current_block
);
3921 BLOCK_SUBBLOCKS (current_block
) = new_block
;
3922 BLOCK_SUPERCONTEXT (new_block
) = current_block
;
3925 /* Add local variables from CALLEE to CALLER. */
3928 add_local_variables (struct function
*callee
, struct function
*caller
,
3934 FOR_EACH_LOCAL_DECL (callee
, ix
, var
)
3935 if (!can_be_nonlocal (var
, id
))
3937 tree new_var
= remap_decl (var
, id
);
3939 /* Remap debug-expressions. */
3940 if (TREE_CODE (new_var
) == VAR_DECL
3941 && DECL_HAS_DEBUG_EXPR_P (var
)
3944 tree tem
= DECL_DEBUG_EXPR (var
);
3945 bool old_regimplify
= id
->regimplify
;
3946 id
->remapping_type_depth
++;
3947 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
3948 id
->remapping_type_depth
--;
3949 id
->regimplify
= old_regimplify
;
3950 SET_DECL_DEBUG_EXPR (new_var
, tem
);
3951 DECL_HAS_DEBUG_EXPR_P (new_var
) = 1;
3953 add_local_decl (caller
, new_var
);
3957 /* If STMT is a GIMPLE_CALL, replace it with its inline expansion. */
3960 expand_call_inline (basic_block bb
, gimple stmt
, copy_body_data
*id
)
3964 struct pointer_map_t
*st
, *dst
;
3967 location_t saved_location
;
3968 struct cgraph_edge
*cg_edge
;
3969 cgraph_inline_failed_t reason
;
3970 basic_block return_block
;
3972 gimple_stmt_iterator gsi
, stmt_gsi
;
3973 bool successfully_inlined
= FALSE
;
3974 bool purge_dead_abnormal_edges
;
3976 /* Set input_location here so we get the right instantiation context
3977 if we call instantiate_decl from inlinable_function_p. */
3978 /* FIXME: instantiate_decl isn't called by inlinable_function_p. */
3979 saved_location
= input_location
;
3980 input_location
= gimple_location (stmt
);
3982 /* From here on, we're only interested in CALL_EXPRs. */
3983 if (gimple_code (stmt
) != GIMPLE_CALL
)
3986 cg_edge
= cgraph_edge (id
->dst_node
, stmt
);
3987 gcc_checking_assert (cg_edge
);
3988 /* First, see if we can figure out what function is being called.
3989 If we cannot, then there is no hope of inlining the function. */
3990 if (cg_edge
->indirect_unknown_callee
)
3992 fn
= cg_edge
->callee
->symbol
.decl
;
3993 gcc_checking_assert (fn
);
3995 /* If FN is a declaration of a function in a nested scope that was
3996 globally declared inline, we don't set its DECL_INITIAL.
3997 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
3998 C++ front-end uses it for cdtors to refer to their internal
3999 declarations, that are not real functions. Fortunately those
4000 don't have trees to be saved, so we can tell by checking their
4002 if (!DECL_INITIAL (fn
)
4003 && DECL_ABSTRACT_ORIGIN (fn
)
4004 && gimple_has_body_p (DECL_ABSTRACT_ORIGIN (fn
)))
4005 fn
= DECL_ABSTRACT_ORIGIN (fn
);
4007 /* Don't try to inline functions that are not well-suited to inlining. */
4008 if (cg_edge
->inline_failed
)
4010 reason
= cg_edge
->inline_failed
;
4011 /* If this call was originally indirect, we do not want to emit any
4012 inlining related warnings or sorry messages because there are no
4013 guarantees regarding those. */
4014 if (cg_edge
->indirect_inlining_edge
)
4017 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
))
4018 /* For extern inline functions that get redefined we always
4019 silently ignored always_inline flag. Better behaviour would
4020 be to be able to keep both bodies and use extern inline body
4021 for inlining, but we can't do that because frontends overwrite
4023 && !cg_edge
->callee
->local
.redefined_extern_inline
4024 /* During early inline pass, report only when optimization is
4026 && (cgraph_global_info_ready
4028 /* PR 20090218-1_0.c. Body can be provided by another module. */
4029 && (reason
!= CIF_BODY_NOT_AVAILABLE
|| !flag_generate_lto
))
4031 error ("inlining failed in call to always_inline %q+F: %s", fn
,
4032 cgraph_inline_failed_string (reason
));
4033 error ("called from here");
4035 else if (warn_inline
4036 && DECL_DECLARED_INLINE_P (fn
)
4037 && !DECL_NO_INLINE_WARNING_P (fn
)
4038 && !DECL_IN_SYSTEM_HEADER (fn
)
4039 && reason
!= CIF_UNSPECIFIED
4040 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn
))
4041 /* Do not warn about not inlined recursive calls. */
4042 && !cgraph_edge_recursive_p (cg_edge
)
4043 /* Avoid warnings during early inline pass. */
4044 && cgraph_global_info_ready
)
4046 warning (OPT_Winline
, "inlining failed in call to %q+F: %s",
4047 fn
, _(cgraph_inline_failed_string (reason
)));
4048 warning (OPT_Winline
, "called from here");
4052 fn
= cg_edge
->callee
->symbol
.decl
;
4053 cgraph_get_body (cg_edge
->callee
);
4055 #ifdef ENABLE_CHECKING
4056 if (cg_edge
->callee
->symbol
.decl
!= id
->dst_node
->symbol
.decl
)
4057 verify_cgraph_node (cg_edge
->callee
);
4060 /* We will be inlining this callee. */
4061 id
->eh_lp_nr
= lookup_stmt_eh_lp (stmt
);
4063 /* Update the callers EH personality. */
4064 if (DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->symbol
.decl
))
4065 DECL_FUNCTION_PERSONALITY (cg_edge
->caller
->symbol
.decl
)
4066 = DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->symbol
.decl
);
4068 /* Split the block holding the GIMPLE_CALL. */
4069 e
= split_block (bb
, stmt
);
4071 return_block
= e
->dest
;
4074 /* split_block splits after the statement; work around this by
4075 moving the call into the second block manually. Not pretty,
4076 but seems easier than doing the CFG manipulation by hand
4077 when the GIMPLE_CALL is in the last statement of BB. */
4078 stmt_gsi
= gsi_last_bb (bb
);
4079 gsi_remove (&stmt_gsi
, false);
4081 /* If the GIMPLE_CALL was in the last statement of BB, it may have
4082 been the source of abnormal edges. In this case, schedule
4083 the removal of dead abnormal edges. */
4084 gsi
= gsi_start_bb (return_block
);
4085 if (gsi_end_p (gsi
))
4087 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
4088 purge_dead_abnormal_edges
= true;
4092 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
4093 purge_dead_abnormal_edges
= false;
4096 stmt_gsi
= gsi_start_bb (return_block
);
4098 /* Build a block containing code to initialize the arguments, the
4099 actual inline expansion of the body, and a label for the return
4100 statements within the function to jump to. The type of the
4101 statement expression is the return type of the function call.
4102 ??? If the call does not have an associated block then we will
4103 remap all callee blocks to NULL, effectively dropping most of
4104 its debug information. This should only happen for calls to
4105 artificial decls inserted by the compiler itself. We need to
4106 either link the inlined blocks into the caller block tree or
4107 not refer to them in any way to not break GC for locations. */
4108 if (gimple_block (stmt
))
4110 id
->block
= make_node (BLOCK
);
4111 BLOCK_ABSTRACT_ORIGIN (id
->block
) = fn
;
4112 BLOCK_SOURCE_LOCATION (id
->block
) = LOCATION_LOCUS (input_location
);
4113 prepend_lexical_block (gimple_block (stmt
), id
->block
);
4116 /* Local declarations will be replaced by their equivalents in this
4119 id
->decl_map
= pointer_map_create ();
4120 dst
= id
->debug_map
;
4121 id
->debug_map
= NULL
;
4123 /* Record the function we are about to inline. */
4125 id
->src_node
= cg_edge
->callee
;
4126 id
->src_cfun
= DECL_STRUCT_FUNCTION (fn
);
4127 id
->gimple_call
= stmt
;
4129 gcc_assert (!id
->src_cfun
->after_inlining
);
4132 if (lookup_attribute ("cold", DECL_ATTRIBUTES (fn
)))
4134 gimple_stmt_iterator si
= gsi_last_bb (bb
);
4135 gsi_insert_after (&si
, gimple_build_predict (PRED_COLD_FUNCTION
,
4139 initialize_inlined_parameters (id
, stmt
, fn
, bb
);
4141 if (DECL_INITIAL (fn
))
4143 if (gimple_block (stmt
))
4147 prepend_lexical_block (id
->block
,
4148 remap_blocks (DECL_INITIAL (fn
), id
));
4149 gcc_checking_assert (BLOCK_SUBBLOCKS (id
->block
)
4150 && (BLOCK_CHAIN (BLOCK_SUBBLOCKS (id
->block
))
4152 /* Move vars for PARM_DECLs from DECL_INITIAL block to id->block,
4153 otherwise for DWARF DW_TAG_formal_parameter will not be children of
4154 DW_TAG_inlined_subroutine, but of a DW_TAG_lexical_block
4155 under it. The parameters can be then evaluated in the debugger,
4156 but don't show in backtraces. */
4157 for (var
= &BLOCK_VARS (BLOCK_SUBBLOCKS (id
->block
)); *var
; )
4158 if (TREE_CODE (DECL_ORIGIN (*var
)) == PARM_DECL
)
4161 *var
= TREE_CHAIN (v
);
4162 TREE_CHAIN (v
) = BLOCK_VARS (id
->block
);
4163 BLOCK_VARS (id
->block
) = v
;
4166 var
= &TREE_CHAIN (*var
);
4169 remap_blocks_to_null (DECL_INITIAL (fn
), id
);
4172 /* Return statements in the function body will be replaced by jumps
4173 to the RET_LABEL. */
4174 gcc_assert (DECL_INITIAL (fn
));
4175 gcc_assert (TREE_CODE (DECL_INITIAL (fn
)) == BLOCK
);
4177 /* Find the LHS to which the result of this call is assigned. */
4179 if (gimple_call_lhs (stmt
))
4181 modify_dest
= gimple_call_lhs (stmt
);
4183 /* The function which we are inlining might not return a value,
4184 in which case we should issue a warning that the function
4185 does not return a value. In that case the optimizers will
4186 see that the variable to which the value is assigned was not
4187 initialized. We do not want to issue a warning about that
4188 uninitialized variable. */
4189 if (DECL_P (modify_dest
))
4190 TREE_NO_WARNING (modify_dest
) = 1;
4192 if (gimple_call_return_slot_opt_p (stmt
))
4194 return_slot
= modify_dest
;
4201 /* If we are inlining a call to the C++ operator new, we don't want
4202 to use type based alias analysis on the return value. Otherwise
4203 we may get confused if the compiler sees that the inlined new
4204 function returns a pointer which was just deleted. See bug
4206 if (DECL_IS_OPERATOR_NEW (fn
))
4212 /* Declare the return variable for the function. */
4213 use_retvar
= declare_return_variable (id
, return_slot
, modify_dest
, bb
);
4215 /* Add local vars in this inlined callee to caller. */
4216 add_local_variables (id
->src_cfun
, cfun
, id
);
4218 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4220 fprintf (dump_file
, "Inlining ");
4221 print_generic_expr (dump_file
, id
->src_fn
, 0);
4222 fprintf (dump_file
, " to ");
4223 print_generic_expr (dump_file
, id
->dst_fn
, 0);
4224 fprintf (dump_file
, " with frequency %i\n", cg_edge
->frequency
);
4227 /* This is it. Duplicate the callee body. Assume callee is
4228 pre-gimplified. Note that we must not alter the caller
4229 function in any way before this point, as this CALL_EXPR may be
4230 a self-referential call; if we're calling ourselves, we need to
4231 duplicate our body before altering anything. */
4232 copy_body (id
, bb
->count
,
4233 GCOV_COMPUTE_SCALE (cg_edge
->frequency
, CGRAPH_FREQ_BASE
),
4234 bb
, return_block
, NULL
);
4236 /* Reset the escaped solution. */
4237 if (cfun
->gimple_df
)
4238 pt_solution_reset (&cfun
->gimple_df
->escaped
);
4243 pointer_map_destroy (id
->debug_map
);
4244 id
->debug_map
= dst
;
4246 pointer_map_destroy (id
->decl_map
);
4249 /* Unlink the calls virtual operands before replacing it. */
4250 unlink_stmt_vdef (stmt
);
4252 /* If the inlined function returns a result that we care about,
4253 substitute the GIMPLE_CALL with an assignment of the return
4254 variable to the LHS of the call. That is, if STMT was
4255 'a = foo (...)', substitute the call with 'a = USE_RETVAR'. */
4256 if (use_retvar
&& gimple_call_lhs (stmt
))
4258 gimple old_stmt
= stmt
;
4259 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), use_retvar
);
4260 gsi_replace (&stmt_gsi
, stmt
, false);
4261 maybe_clean_or_replace_eh_stmt (old_stmt
, stmt
);
4265 /* Handle the case of inlining a function with no return
4266 statement, which causes the return value to become undefined. */
4267 if (gimple_call_lhs (stmt
)
4268 && TREE_CODE (gimple_call_lhs (stmt
)) == SSA_NAME
)
4270 tree name
= gimple_call_lhs (stmt
);
4271 tree var
= SSA_NAME_VAR (name
);
4272 tree def
= ssa_default_def (cfun
, var
);
4276 /* If the variable is used undefined, make this name
4277 undefined via a move. */
4278 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), def
);
4279 gsi_replace (&stmt_gsi
, stmt
, true);
4283 /* Otherwise make this variable undefined. */
4284 gsi_remove (&stmt_gsi
, true);
4285 set_ssa_default_def (cfun
, var
, name
);
4286 SSA_NAME_DEF_STMT (name
) = gimple_build_nop ();
4290 gsi_remove (&stmt_gsi
, true);
4293 if (purge_dead_abnormal_edges
)
4295 gimple_purge_dead_eh_edges (return_block
);
4296 gimple_purge_dead_abnormal_call_edges (return_block
);
4299 /* If the value of the new expression is ignored, that's OK. We
4300 don't warn about this for CALL_EXPRs, so we shouldn't warn about
4301 the equivalent inlined version either. */
4302 if (is_gimple_assign (stmt
))
4304 gcc_assert (gimple_assign_single_p (stmt
)
4305 || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
)));
4306 TREE_USED (gimple_assign_rhs1 (stmt
)) = 1;
4309 /* Output the inlining info for this abstract function, since it has been
4310 inlined. If we don't do this now, we can lose the information about the
4311 variables in the function when the blocks get blown away as soon as we
4312 remove the cgraph node. */
4313 if (gimple_block (stmt
))
4314 (*debug_hooks
->outlining_inline_function
) (cg_edge
->callee
->symbol
.decl
);
4316 /* Update callgraph if needed. */
4317 cgraph_remove_node (cg_edge
->callee
);
4319 id
->block
= NULL_TREE
;
4320 successfully_inlined
= TRUE
;
4323 input_location
= saved_location
;
4324 return successfully_inlined
;
4327 /* Expand call statements reachable from STMT_P.
4328 We can only have CALL_EXPRs as the "toplevel" tree code or nested
4329 in a MODIFY_EXPR. */
4332 gimple_expand_calls_inline (basic_block bb
, copy_body_data
*id
)
4334 gimple_stmt_iterator gsi
;
4336 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4338 gimple stmt
= gsi_stmt (gsi
);
4340 if (is_gimple_call (stmt
)
4341 && expand_call_inline (bb
, stmt
, id
))
4349 /* Walk all basic blocks created after FIRST and try to fold every statement
4350 in the STATEMENTS pointer set. */
4353 fold_marked_statements (int first
, struct pointer_set_t
*statements
)
4355 for (; first
< n_basic_blocks
; first
++)
4356 if (BASIC_BLOCK (first
))
4358 gimple_stmt_iterator gsi
;
4360 for (gsi
= gsi_start_bb (BASIC_BLOCK (first
));
4363 if (pointer_set_contains (statements
, gsi_stmt (gsi
)))
4365 gimple old_stmt
= gsi_stmt (gsi
);
4366 tree old_decl
= is_gimple_call (old_stmt
) ? gimple_call_fndecl (old_stmt
) : 0;
4368 if (old_decl
&& DECL_BUILT_IN (old_decl
))
4370 /* Folding builtins can create multiple instructions,
4371 we need to look at all of them. */
4372 gimple_stmt_iterator i2
= gsi
;
4374 if (fold_stmt (&gsi
))
4377 /* If a builtin at the end of a bb folded into nothing,
4378 the following loop won't work. */
4379 if (gsi_end_p (gsi
))
4381 cgraph_update_edges_for_call_stmt (old_stmt
,
4386 i2
= gsi_start_bb (BASIC_BLOCK (first
));
4391 new_stmt
= gsi_stmt (i2
);
4392 update_stmt (new_stmt
);
4393 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4396 if (new_stmt
== gsi_stmt (gsi
))
4398 /* It is okay to check only for the very last
4399 of these statements. If it is a throwing
4400 statement nothing will change. If it isn't
4401 this can remove EH edges. If that weren't
4402 correct then because some intermediate stmts
4403 throw, but not the last one. That would mean
4404 we'd have to split the block, which we can't
4405 here and we'd loose anyway. And as builtins
4406 probably never throw, this all
4408 if (maybe_clean_or_replace_eh_stmt (old_stmt
,
4410 gimple_purge_dead_eh_edges (BASIC_BLOCK (first
));
4417 else if (fold_stmt (&gsi
))
4419 /* Re-read the statement from GSI as fold_stmt() may
4421 gimple new_stmt
= gsi_stmt (gsi
);
4422 update_stmt (new_stmt
);
4424 if (is_gimple_call (old_stmt
)
4425 || is_gimple_call (new_stmt
))
4426 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4429 if (maybe_clean_or_replace_eh_stmt (old_stmt
, new_stmt
))
4430 gimple_purge_dead_eh_edges (BASIC_BLOCK (first
));
4436 /* Return true if BB has at least one abnormal outgoing edge. */
4439 has_abnormal_outgoing_edge_p (basic_block bb
)
4444 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
4445 if (e
->flags
& EDGE_ABNORMAL
)
4451 /* Expand calls to inline functions in the body of FN. */
4454 optimize_inline_calls (tree fn
)
4458 int last
= n_basic_blocks
;
4459 struct gimplify_ctx gctx
;
4460 bool inlined_p
= false;
4463 memset (&id
, 0, sizeof (id
));
4465 id
.src_node
= id
.dst_node
= cgraph_get_node (fn
);
4466 gcc_assert (id
.dst_node
->symbol
.definition
);
4468 /* Or any functions that aren't finished yet. */
4469 if (current_function_decl
)
4470 id
.dst_fn
= current_function_decl
;
4472 id
.copy_decl
= copy_decl_maybe_to_var
;
4473 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
4474 id
.transform_new_cfg
= false;
4475 id
.transform_return_to_modify
= true;
4476 id
.transform_parameter
= true;
4477 id
.transform_lang_insert_block
= NULL
;
4478 id
.statements_to_fold
= pointer_set_create ();
4480 push_gimplify_context (&gctx
);
4482 /* We make no attempts to keep dominance info up-to-date. */
4483 free_dominance_info (CDI_DOMINATORS
);
4484 free_dominance_info (CDI_POST_DOMINATORS
);
4486 /* Register specific gimple functions. */
4487 gimple_register_cfg_hooks ();
4489 /* Reach the trees by walking over the CFG, and note the
4490 enclosing basic-blocks in the call edges. */
4491 /* We walk the blocks going forward, because inlined function bodies
4492 will split id->current_basic_block, and the new blocks will
4493 follow it; we'll trudge through them, processing their CALL_EXPRs
4496 inlined_p
|= gimple_expand_calls_inline (bb
, &id
);
4498 pop_gimplify_context (NULL
);
4500 #ifdef ENABLE_CHECKING
4502 struct cgraph_edge
*e
;
4504 verify_cgraph_node (id
.dst_node
);
4506 /* Double check that we inlined everything we are supposed to inline. */
4507 for (e
= id
.dst_node
->callees
; e
; e
= e
->next_callee
)
4508 gcc_assert (e
->inline_failed
);
4512 /* Fold queued statements. */
4513 fold_marked_statements (last
, id
.statements_to_fold
);
4514 pointer_set_destroy (id
.statements_to_fold
);
4516 gcc_assert (!id
.debug_stmts
.exists ());
4518 /* If we didn't inline into the function there is nothing to do. */
4522 /* Renumber the lexical scoping (non-code) blocks consecutively. */
4525 delete_unreachable_blocks_update_callgraph (&id
);
4526 #ifdef ENABLE_CHECKING
4527 verify_cgraph_node (id
.dst_node
);
4530 /* It would be nice to check SSA/CFG/statement consistency here, but it is
4531 not possible yet - the IPA passes might make various functions to not
4532 throw and they don't care to proactively update local EH info. This is
4533 done later in fixup_cfg pass that also execute the verification. */
4534 return (TODO_update_ssa
4536 | (gimple_in_ssa_p (cfun
) ? TODO_remove_unused_locals
: 0)
4537 | (gimple_in_ssa_p (cfun
) ? TODO_update_address_taken
: 0)
4538 | (profile_status
!= PROFILE_ABSENT
? TODO_rebuild_frequencies
: 0));
4541 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
4544 copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
4546 enum tree_code code
= TREE_CODE (*tp
);
4547 enum tree_code_class cl
= TREE_CODE_CLASS (code
);
4549 /* We make copies of most nodes. */
4550 if (IS_EXPR_CODE_CLASS (cl
)
4551 || code
== TREE_LIST
4553 || code
== TYPE_DECL
4554 || code
== OMP_CLAUSE
)
4556 /* Because the chain gets clobbered when we make a copy, we save it
4558 tree chain
= NULL_TREE
, new_tree
;
4560 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
4561 chain
= TREE_CHAIN (*tp
);
4563 /* Copy the node. */
4564 new_tree
= copy_node (*tp
);
4566 /* Propagate mudflap marked-ness. */
4567 if (flag_mudflap
&& mf_marked_p (*tp
))
4572 /* Now, restore the chain, if appropriate. That will cause
4573 walk_tree to walk into the chain as well. */
4574 if (code
== PARM_DECL
4575 || code
== TREE_LIST
4576 || code
== OMP_CLAUSE
)
4577 TREE_CHAIN (*tp
) = chain
;
4579 /* For now, we don't update BLOCKs when we make copies. So, we
4580 have to nullify all BIND_EXPRs. */
4581 if (TREE_CODE (*tp
) == BIND_EXPR
)
4582 BIND_EXPR_BLOCK (*tp
) = NULL_TREE
;
4584 else if (code
== CONSTRUCTOR
)
4586 /* CONSTRUCTOR nodes need special handling because
4587 we need to duplicate the vector of elements. */
4590 new_tree
= copy_node (*tp
);
4592 /* Propagate mudflap marked-ness. */
4593 if (flag_mudflap
&& mf_marked_p (*tp
))
4596 CONSTRUCTOR_ELTS (new_tree
) = vec_safe_copy (CONSTRUCTOR_ELTS (*tp
));
4599 else if (code
== STATEMENT_LIST
)
4600 /* We used to just abort on STATEMENT_LIST, but we can run into them
4601 with statement-expressions (c++/40975). */
4602 copy_statement_list (tp
);
4603 else if (TREE_CODE_CLASS (code
) == tcc_type
)
4605 else if (TREE_CODE_CLASS (code
) == tcc_declaration
)
4607 else if (TREE_CODE_CLASS (code
) == tcc_constant
)
4612 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
4613 information indicating to what new SAVE_EXPR this one should be mapped,
4614 use that one. Otherwise, create a new node and enter it in ST. FN is
4615 the function into which the copy will be placed. */
4618 remap_save_expr (tree
*tp
, void *st_
, int *walk_subtrees
)
4620 struct pointer_map_t
*st
= (struct pointer_map_t
*) st_
;
4624 /* See if we already encountered this SAVE_EXPR. */
4625 n
= (tree
*) pointer_map_contains (st
, *tp
);
4627 /* If we didn't already remap this SAVE_EXPR, do so now. */
4630 t
= copy_node (*tp
);
4632 /* Remember this SAVE_EXPR. */
4633 *pointer_map_insert (st
, *tp
) = t
;
4634 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
4635 *pointer_map_insert (st
, t
) = t
;
4639 /* We've already walked into this SAVE_EXPR; don't do it again. */
4644 /* Replace this SAVE_EXPR with the copy. */
4648 /* Called via walk_gimple_seq. If *GSIP points to a GIMPLE_LABEL for a local
4649 label, copies the declaration and enters it in the splay_tree in DATA (which
4650 is really a 'copy_body_data *'. */
4653 mark_local_labels_stmt (gimple_stmt_iterator
*gsip
,
4654 bool *handled_ops_p ATTRIBUTE_UNUSED
,
4655 struct walk_stmt_info
*wi
)
4657 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4658 gimple stmt
= gsi_stmt (*gsip
);
4660 if (gimple_code (stmt
) == GIMPLE_LABEL
)
4662 tree decl
= gimple_label_label (stmt
);
4664 /* Copy the decl and remember the copy. */
4665 insert_decl_map (id
, decl
, id
->copy_decl (decl
, id
));
4672 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
4673 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
4674 remaps all local declarations to appropriate replacements in gimple
4678 replace_locals_op (tree
*tp
, int *walk_subtrees
, void *data
)
4680 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
4681 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4682 struct pointer_map_t
*st
= id
->decl_map
;
4686 /* Only a local declaration (variable or label). */
4687 if ((TREE_CODE (expr
) == VAR_DECL
4688 && !TREE_STATIC (expr
))
4689 || TREE_CODE (expr
) == LABEL_DECL
)
4691 /* Lookup the declaration. */
4692 n
= (tree
*) pointer_map_contains (st
, expr
);
4694 /* If it's there, remap it. */
4699 else if (TREE_CODE (expr
) == STATEMENT_LIST
4700 || TREE_CODE (expr
) == BIND_EXPR
4701 || TREE_CODE (expr
) == SAVE_EXPR
)
4703 else if (TREE_CODE (expr
) == TARGET_EXPR
)
4705 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
4706 It's OK for this to happen if it was part of a subtree that
4707 isn't immediately expanded, such as operand 2 of another
4709 if (!TREE_OPERAND (expr
, 1))
4711 TREE_OPERAND (expr
, 1) = TREE_OPERAND (expr
, 3);
4712 TREE_OPERAND (expr
, 3) = NULL_TREE
;
4716 /* Keep iterating. */
4721 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
4722 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
4723 remaps all local declarations to appropriate replacements in gimple
4727 replace_locals_stmt (gimple_stmt_iterator
*gsip
,
4728 bool *handled_ops_p ATTRIBUTE_UNUSED
,
4729 struct walk_stmt_info
*wi
)
4731 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4732 gimple stmt
= gsi_stmt (*gsip
);
4734 if (gimple_code (stmt
) == GIMPLE_BIND
)
4736 tree block
= gimple_bind_block (stmt
);
4740 remap_block (&block
, id
);
4741 gimple_bind_set_block (stmt
, block
);
4744 /* This will remap a lot of the same decls again, but this should be
4746 if (gimple_bind_vars (stmt
))
4747 gimple_bind_set_vars (stmt
, remap_decls (gimple_bind_vars (stmt
),
4751 /* Keep iterating. */
4756 /* Copies everything in SEQ and replaces variables and labels local to
4757 current_function_decl. */
4760 copy_gimple_seq_and_replace_locals (gimple_seq seq
)
4763 struct walk_stmt_info wi
;
4764 struct pointer_set_t
*visited
;
4767 /* There's nothing to do for NULL_TREE. */
4772 memset (&id
, 0, sizeof (id
));
4773 id
.src_fn
= current_function_decl
;
4774 id
.dst_fn
= current_function_decl
;
4775 id
.decl_map
= pointer_map_create ();
4776 id
.debug_map
= NULL
;
4778 id
.copy_decl
= copy_decl_no_change
;
4779 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
4780 id
.transform_new_cfg
= false;
4781 id
.transform_return_to_modify
= false;
4782 id
.transform_parameter
= false;
4783 id
.transform_lang_insert_block
= NULL
;
4785 /* Walk the tree once to find local labels. */
4786 memset (&wi
, 0, sizeof (wi
));
4787 visited
= pointer_set_create ();
4790 walk_gimple_seq (seq
, mark_local_labels_stmt
, NULL
, &wi
);
4791 pointer_set_destroy (visited
);
4793 copy
= gimple_seq_copy (seq
);
4795 /* Walk the copy, remapping decls. */
4796 memset (&wi
, 0, sizeof (wi
));
4798 walk_gimple_seq (copy
, replace_locals_stmt
, replace_locals_op
, &wi
);
4801 pointer_map_destroy (id
.decl_map
);
4803 pointer_map_destroy (id
.debug_map
);
4809 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
4812 debug_find_tree_1 (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
, void *data
)
4821 debug_find_tree (tree top
, tree search
)
4823 return walk_tree_without_duplicates (&top
, debug_find_tree_1
, search
) != 0;
4827 /* Declare the variables created by the inliner. Add all the variables in
4828 VARS to BIND_EXPR. */
4831 declare_inline_vars (tree block
, tree vars
)
4834 for (t
= vars
; t
; t
= DECL_CHAIN (t
))
4836 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
4837 gcc_assert (!TREE_STATIC (t
) && !TREE_ASM_WRITTEN (t
));
4838 add_local_decl (cfun
, t
);
4842 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), vars
);
4845 /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN,
4846 but now it will be in the TO_FN. PARM_TO_VAR means enable PARM_DECL to
4847 VAR_DECL translation. */
4850 copy_decl_for_dup_finish (copy_body_data
*id
, tree decl
, tree copy
)
4852 /* Don't generate debug information for the copy if we wouldn't have
4853 generated it for the copy either. */
4854 DECL_ARTIFICIAL (copy
) = DECL_ARTIFICIAL (decl
);
4855 DECL_IGNORED_P (copy
) = DECL_IGNORED_P (decl
);
4857 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
4858 declaration inspired this copy. */
4859 DECL_ABSTRACT_ORIGIN (copy
) = DECL_ORIGIN (decl
);
4861 /* The new variable/label has no RTL, yet. */
4862 if (CODE_CONTAINS_STRUCT (TREE_CODE (copy
), TS_DECL_WRTL
)
4863 && !TREE_STATIC (copy
) && !DECL_EXTERNAL (copy
))
4864 SET_DECL_RTL (copy
, 0);
4866 /* These args would always appear unused, if not for this. */
4867 TREE_USED (copy
) = 1;
4869 /* Set the context for the new declaration. */
4870 if (!DECL_CONTEXT (decl
))
4871 /* Globals stay global. */
4873 else if (DECL_CONTEXT (decl
) != id
->src_fn
)
4874 /* Things that weren't in the scope of the function we're inlining
4875 from aren't in the scope we're inlining to, either. */
4877 else if (TREE_STATIC (decl
))
4878 /* Function-scoped static variables should stay in the original
4882 /* Ordinary automatic local variables are now in the scope of the
4884 DECL_CONTEXT (copy
) = id
->dst_fn
;
4890 copy_decl_to_var (tree decl
, copy_body_data
*id
)
4894 gcc_assert (TREE_CODE (decl
) == PARM_DECL
4895 || TREE_CODE (decl
) == RESULT_DECL
);
4897 type
= TREE_TYPE (decl
);
4899 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
4900 VAR_DECL
, DECL_NAME (decl
), type
);
4901 if (DECL_PT_UID_SET_P (decl
))
4902 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
4903 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
4904 TREE_READONLY (copy
) = TREE_READONLY (decl
);
4905 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
4906 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
4908 return copy_decl_for_dup_finish (id
, decl
, copy
);
4911 /* Like copy_decl_to_var, but create a return slot object instead of a
4912 pointer variable for return by invisible reference. */
4915 copy_result_decl_to_var (tree decl
, copy_body_data
*id
)
4919 gcc_assert (TREE_CODE (decl
) == PARM_DECL
4920 || TREE_CODE (decl
) == RESULT_DECL
);
4922 type
= TREE_TYPE (decl
);
4923 if (DECL_BY_REFERENCE (decl
))
4924 type
= TREE_TYPE (type
);
4926 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
4927 VAR_DECL
, DECL_NAME (decl
), type
);
4928 if (DECL_PT_UID_SET_P (decl
))
4929 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
4930 TREE_READONLY (copy
) = TREE_READONLY (decl
);
4931 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
4932 if (!DECL_BY_REFERENCE (decl
))
4934 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
4935 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
4938 return copy_decl_for_dup_finish (id
, decl
, copy
);
4942 copy_decl_no_change (tree decl
, copy_body_data
*id
)
4946 copy
= copy_node (decl
);
4948 /* The COPY is not abstract; it will be generated in DST_FN. */
4949 DECL_ABSTRACT (copy
) = 0;
4950 lang_hooks
.dup_lang_specific_decl (copy
);
4952 /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
4953 been taken; it's for internal bookkeeping in expand_goto_internal. */
4954 if (TREE_CODE (copy
) == LABEL_DECL
)
4956 TREE_ADDRESSABLE (copy
) = 0;
4957 LABEL_DECL_UID (copy
) = -1;
4960 return copy_decl_for_dup_finish (id
, decl
, copy
);
4964 copy_decl_maybe_to_var (tree decl
, copy_body_data
*id
)
4966 if (TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
)
4967 return copy_decl_to_var (decl
, id
);
4969 return copy_decl_no_change (decl
, id
);
4972 /* Return a copy of the function's argument tree. */
4974 copy_arguments_for_versioning (tree orig_parm
, copy_body_data
* id
,
4975 bitmap args_to_skip
, tree
*vars
)
4978 tree new_parm
= NULL
;
4983 for (arg
= orig_parm
; arg
; arg
= DECL_CHAIN (arg
), i
++)
4984 if (!args_to_skip
|| !bitmap_bit_p (args_to_skip
, i
))
4986 tree new_tree
= remap_decl (arg
, id
);
4987 if (TREE_CODE (new_tree
) != PARM_DECL
)
4988 new_tree
= id
->copy_decl (arg
, id
);
4989 lang_hooks
.dup_lang_specific_decl (new_tree
);
4991 parg
= &DECL_CHAIN (new_tree
);
4993 else if (!pointer_map_contains (id
->decl_map
, arg
))
4995 /* Make an equivalent VAR_DECL. If the argument was used
4996 as temporary variable later in function, the uses will be
4997 replaced by local variable. */
4998 tree var
= copy_decl_to_var (arg
, id
);
4999 insert_decl_map (id
, arg
, var
);
5000 /* Declare this new variable. */
5001 DECL_CHAIN (var
) = *vars
;
5007 /* Return a copy of the function's static chain. */
5009 copy_static_chain (tree static_chain
, copy_body_data
* id
)
5011 tree
*chain_copy
, *pvar
;
5013 chain_copy
= &static_chain
;
5014 for (pvar
= chain_copy
; *pvar
; pvar
= &DECL_CHAIN (*pvar
))
5016 tree new_tree
= remap_decl (*pvar
, id
);
5017 lang_hooks
.dup_lang_specific_decl (new_tree
);
5018 DECL_CHAIN (new_tree
) = DECL_CHAIN (*pvar
);
5021 return static_chain
;
5024 /* Return true if the function is allowed to be versioned.
5025 This is a guard for the versioning functionality. */
5028 tree_versionable_function_p (tree fndecl
)
5030 return (!lookup_attribute ("noclone", DECL_ATTRIBUTES (fndecl
))
5031 && copy_forbidden (DECL_STRUCT_FUNCTION (fndecl
), fndecl
) == NULL
);
5034 /* Delete all unreachable basic blocks and update callgraph.
5035 Doing so is somewhat nontrivial because we need to update all clones and
5036 remove inline function that become unreachable. */
5039 delete_unreachable_blocks_update_callgraph (copy_body_data
*id
)
5041 bool changed
= false;
5042 basic_block b
, next_bb
;
5044 find_unreachable_blocks ();
5046 /* Delete all unreachable basic blocks. */
5048 for (b
= ENTRY_BLOCK_PTR
->next_bb
; b
!= EXIT_BLOCK_PTR
; b
= next_bb
)
5050 next_bb
= b
->next_bb
;
5052 if (!(b
->flags
& BB_REACHABLE
))
5054 gimple_stmt_iterator bsi
;
5056 for (bsi
= gsi_start_bb (b
); !gsi_end_p (bsi
); gsi_next (&bsi
))
5058 struct cgraph_edge
*e
;
5059 struct cgraph_node
*node
;
5061 ipa_remove_stmt_references ((symtab_node
)id
->dst_node
, gsi_stmt (bsi
));
5063 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
5064 &&(e
= cgraph_edge (id
->dst_node
, gsi_stmt (bsi
))) != NULL
)
5066 if (!e
->inline_failed
)
5067 cgraph_remove_node_and_inline_clones (e
->callee
, id
->dst_node
);
5069 cgraph_remove_edge (e
);
5071 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
5072 && id
->dst_node
->clones
)
5073 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
5075 ipa_remove_stmt_references ((symtab_node
)node
, gsi_stmt (bsi
));
5076 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
5077 && (e
= cgraph_edge (node
, gsi_stmt (bsi
))) != NULL
)
5079 if (!e
->inline_failed
)
5080 cgraph_remove_node_and_inline_clones (e
->callee
, id
->dst_node
);
5082 cgraph_remove_edge (e
);
5086 node
= node
->clones
;
5087 else if (node
->next_sibling_clone
)
5088 node
= node
->next_sibling_clone
;
5091 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5092 node
= node
->clone_of
;
5093 if (node
!= id
->dst_node
)
5094 node
= node
->next_sibling_clone
;
5098 delete_basic_block (b
);
5106 /* Update clone info after duplication. */
5109 update_clone_info (copy_body_data
* id
)
5111 struct cgraph_node
*node
;
5112 if (!id
->dst_node
->clones
)
5114 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
5116 /* First update replace maps to match the new body. */
5117 if (node
->clone
.tree_map
)
5120 for (i
= 0; i
< vec_safe_length (node
->clone
.tree_map
); i
++)
5122 struct ipa_replace_map
*replace_info
;
5123 replace_info
= (*node
->clone
.tree_map
)[i
];
5124 walk_tree (&replace_info
->old_tree
, copy_tree_body_r
, id
, NULL
);
5125 walk_tree (&replace_info
->new_tree
, copy_tree_body_r
, id
, NULL
);
5129 node
= node
->clones
;
5130 else if (node
->next_sibling_clone
)
5131 node
= node
->next_sibling_clone
;
5134 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5135 node
= node
->clone_of
;
5136 if (node
!= id
->dst_node
)
5137 node
= node
->next_sibling_clone
;
5142 /* Create a copy of a function's tree.
5143 OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
5144 of the original function and the new copied function
5145 respectively. In case we want to replace a DECL
5146 tree with another tree while duplicating the function's
5147 body, TREE_MAP represents the mapping between these
5148 trees. If UPDATE_CLONES is set, the call_stmt fields
5149 of edges of clones of the function will be updated.
5151 If non-NULL ARGS_TO_SKIP determine function parameters to remove
5153 If SKIP_RETURN is true, the new version will return void.
5154 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
5155 If non_NULL NEW_ENTRY determine new entry BB of the clone.
5158 tree_function_versioning (tree old_decl
, tree new_decl
,
5159 vec
<ipa_replace_map_p
, va_gc
> *tree_map
,
5160 bool update_clones
, bitmap args_to_skip
,
5161 bool skip_return
, bitmap blocks_to_copy
,
5162 basic_block new_entry
)
5164 struct cgraph_node
*old_version_node
;
5165 struct cgraph_node
*new_version_node
;
5169 struct ipa_replace_map
*replace_info
;
5170 basic_block old_entry_block
, bb
;
5171 vec
<gimple
> init_stmts
;
5172 init_stmts
.create (10);
5173 tree vars
= NULL_TREE
;
5175 gcc_assert (TREE_CODE (old_decl
) == FUNCTION_DECL
5176 && TREE_CODE (new_decl
) == FUNCTION_DECL
);
5177 DECL_POSSIBLY_INLINED (old_decl
) = 1;
5179 old_version_node
= cgraph_get_node (old_decl
);
5180 gcc_checking_assert (old_version_node
);
5181 new_version_node
= cgraph_get_node (new_decl
);
5182 gcc_checking_assert (new_version_node
);
5184 /* Copy over debug args. */
5185 if (DECL_HAS_DEBUG_ARGS_P (old_decl
))
5187 vec
<tree
, va_gc
> **new_debug_args
, **old_debug_args
;
5188 gcc_checking_assert (decl_debug_args_lookup (new_decl
) == NULL
);
5189 DECL_HAS_DEBUG_ARGS_P (new_decl
) = 0;
5190 old_debug_args
= decl_debug_args_lookup (old_decl
);
5193 new_debug_args
= decl_debug_args_insert (new_decl
);
5194 *new_debug_args
= vec_safe_copy (*old_debug_args
);
5198 /* Output the inlining info for this abstract function, since it has been
5199 inlined. If we don't do this now, we can lose the information about the
5200 variables in the function when the blocks get blown away as soon as we
5201 remove the cgraph node. */
5202 (*debug_hooks
->outlining_inline_function
) (old_decl
);
5204 DECL_ARTIFICIAL (new_decl
) = 1;
5205 DECL_ABSTRACT_ORIGIN (new_decl
) = DECL_ORIGIN (old_decl
);
5206 if (DECL_ORIGIN (old_decl
) == old_decl
)
5207 old_version_node
->used_as_abstract_origin
= true;
5208 DECL_FUNCTION_PERSONALITY (new_decl
) = DECL_FUNCTION_PERSONALITY (old_decl
);
5210 /* Prepare the data structures for the tree copy. */
5211 memset (&id
, 0, sizeof (id
));
5213 /* Generate a new name for the new version. */
5214 id
.statements_to_fold
= pointer_set_create ();
5216 id
.decl_map
= pointer_map_create ();
5217 id
.debug_map
= NULL
;
5218 id
.src_fn
= old_decl
;
5219 id
.dst_fn
= new_decl
;
5220 id
.src_node
= old_version_node
;
5221 id
.dst_node
= new_version_node
;
5222 id
.src_cfun
= DECL_STRUCT_FUNCTION (old_decl
);
5223 id
.blocks_to_copy
= blocks_to_copy
;
5224 if (id
.src_node
->ipa_transforms_to_apply
.exists ())
5226 vec
<ipa_opt_pass
> old_transforms_to_apply
5227 = id
.dst_node
->ipa_transforms_to_apply
;
5230 id
.dst_node
->ipa_transforms_to_apply
5231 = id
.src_node
->ipa_transforms_to_apply
.copy ();
5232 for (i
= 0; i
< old_transforms_to_apply
.length (); i
++)
5233 id
.dst_node
->ipa_transforms_to_apply
.safe_push (old_transforms_to_apply
[i
]);
5234 old_transforms_to_apply
.release ();
5237 id
.copy_decl
= copy_decl_no_change
;
5238 id
.transform_call_graph_edges
5239 = update_clones
? CB_CGE_MOVE_CLONES
: CB_CGE_MOVE
;
5240 id
.transform_new_cfg
= true;
5241 id
.transform_return_to_modify
= false;
5242 id
.transform_parameter
= false;
5243 id
.transform_lang_insert_block
= NULL
;
5245 old_entry_block
= ENTRY_BLOCK_PTR_FOR_FUNCTION
5246 (DECL_STRUCT_FUNCTION (old_decl
));
5247 DECL_RESULT (new_decl
) = DECL_RESULT (old_decl
);
5248 DECL_ARGUMENTS (new_decl
) = DECL_ARGUMENTS (old_decl
);
5249 initialize_cfun (new_decl
, old_decl
,
5250 old_entry_block
->count
);
5251 DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
->ipa_pta
5252 = id
.src_cfun
->gimple_df
->ipa_pta
;
5254 /* Copy the function's static chain. */
5255 p
= DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
;
5257 DECL_STRUCT_FUNCTION (new_decl
)->static_chain_decl
=
5258 copy_static_chain (DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
,
5261 /* If there's a tree_map, prepare for substitution. */
5263 for (i
= 0; i
< tree_map
->length (); i
++)
5266 replace_info
= (*tree_map
)[i
];
5267 if (replace_info
->replace_p
)
5269 if (!replace_info
->old_tree
)
5271 int i
= replace_info
->parm_num
;
5275 for (parm
= DECL_ARGUMENTS (old_decl
); i
; parm
= DECL_CHAIN (parm
))
5277 replace_info
->old_tree
= parm
;
5278 req_type
= TREE_TYPE (parm
);
5279 if (!useless_type_conversion_p (req_type
, TREE_TYPE (replace_info
->new_tree
)))
5281 if (fold_convertible_p (req_type
, replace_info
->new_tree
))
5282 replace_info
->new_tree
= fold_build1 (NOP_EXPR
, req_type
, replace_info
->new_tree
);
5283 else if (TYPE_SIZE (req_type
) == TYPE_SIZE (TREE_TYPE (replace_info
->new_tree
)))
5284 replace_info
->new_tree
= fold_build1 (VIEW_CONVERT_EXPR
, req_type
, replace_info
->new_tree
);
5289 fprintf (dump_file
, " const ");
5290 print_generic_expr (dump_file
, replace_info
->new_tree
, 0);
5291 fprintf (dump_file
, " can't be converted to param ");
5292 print_generic_expr (dump_file
, parm
, 0);
5293 fprintf (dump_file
, "\n");
5295 replace_info
->old_tree
= NULL
;
5300 gcc_assert (TREE_CODE (replace_info
->old_tree
) == PARM_DECL
);
5301 if (replace_info
->old_tree
)
5303 init
= setup_one_parameter (&id
, replace_info
->old_tree
,
5304 replace_info
->new_tree
, id
.src_fn
,
5308 init_stmts
.safe_push (init
);
5312 /* Copy the function's arguments. */
5313 if (DECL_ARGUMENTS (old_decl
) != NULL_TREE
)
5314 DECL_ARGUMENTS (new_decl
) =
5315 copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl
), &id
,
5316 args_to_skip
, &vars
);
5318 DECL_INITIAL (new_decl
) = remap_blocks (DECL_INITIAL (id
.src_fn
), &id
);
5319 BLOCK_SUPERCONTEXT (DECL_INITIAL (new_decl
)) = new_decl
;
5321 declare_inline_vars (DECL_INITIAL (new_decl
), vars
);
5323 if (!vec_safe_is_empty (DECL_STRUCT_FUNCTION (old_decl
)->local_decls
))
5324 /* Add local vars. */
5325 add_local_variables (DECL_STRUCT_FUNCTION (old_decl
), cfun
, &id
);
5327 if (DECL_RESULT (old_decl
) == NULL_TREE
)
5329 else if (skip_return
&& !VOID_TYPE_P (TREE_TYPE (DECL_RESULT (old_decl
))))
5331 DECL_RESULT (new_decl
)
5332 = build_decl (DECL_SOURCE_LOCATION (DECL_RESULT (old_decl
)),
5333 RESULT_DECL
, NULL_TREE
, void_type_node
);
5334 DECL_CONTEXT (DECL_RESULT (new_decl
)) = new_decl
;
5335 cfun
->returns_struct
= 0;
5336 cfun
->returns_pcc_struct
= 0;
5341 DECL_RESULT (new_decl
) = remap_decl (DECL_RESULT (old_decl
), &id
);
5342 lang_hooks
.dup_lang_specific_decl (DECL_RESULT (new_decl
));
5343 if (gimple_in_ssa_p (id
.src_cfun
)
5344 && DECL_BY_REFERENCE (DECL_RESULT (old_decl
))
5345 && (old_name
= ssa_default_def (id
.src_cfun
, DECL_RESULT (old_decl
))))
5347 tree new_name
= make_ssa_name (DECL_RESULT (new_decl
), NULL
);
5348 insert_decl_map (&id
, old_name
, new_name
);
5349 SSA_NAME_DEF_STMT (new_name
) = gimple_build_nop ();
5350 set_ssa_default_def (cfun
, DECL_RESULT (new_decl
), new_name
);
5354 /* Set up the destination functions loop tree. */
5355 if (loops_for_fn (DECL_STRUCT_FUNCTION (old_decl
)) != NULL
)
5357 cfun
->curr_properties
&= ~PROP_loops
;
5358 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
5359 cfun
->curr_properties
|= PROP_loops
;
5362 /* Copy the Function's body. */
5363 copy_body (&id
, old_entry_block
->count
, REG_BR_PROB_BASE
,
5364 ENTRY_BLOCK_PTR
, EXIT_BLOCK_PTR
, new_entry
);
5366 /* Renumber the lexical scoping (non-code) blocks consecutively. */
5367 number_blocks (new_decl
);
5369 /* We want to create the BB unconditionally, so that the addition of
5370 debug stmts doesn't affect BB count, which may in the end cause
5371 codegen differences. */
5372 bb
= split_edge (single_succ_edge (ENTRY_BLOCK_PTR
));
5373 while (init_stmts
.length ())
5374 insert_init_stmt (&id
, bb
, init_stmts
.pop ());
5375 update_clone_info (&id
);
5377 /* Remap the nonlocal_goto_save_area, if any. */
5378 if (cfun
->nonlocal_goto_save_area
)
5380 struct walk_stmt_info wi
;
5382 memset (&wi
, 0, sizeof (wi
));
5384 walk_tree (&cfun
->nonlocal_goto_save_area
, remap_gimple_op_r
, &wi
, NULL
);
5388 pointer_map_destroy (id
.decl_map
);
5390 pointer_map_destroy (id
.debug_map
);
5391 free_dominance_info (CDI_DOMINATORS
);
5392 free_dominance_info (CDI_POST_DOMINATORS
);
5394 fold_marked_statements (0, id
.statements_to_fold
);
5395 pointer_set_destroy (id
.statements_to_fold
);
5396 fold_cond_expr_cond ();
5397 delete_unreachable_blocks_update_callgraph (&id
);
5398 if (id
.dst_node
->symbol
.definition
)
5399 cgraph_rebuild_references ();
5400 update_ssa (TODO_update_ssa
);
5402 /* After partial cloning we need to rescale frequencies, so they are
5403 within proper range in the cloned function. */
5406 struct cgraph_edge
*e
;
5407 rebuild_frequencies ();
5409 new_version_node
->count
= ENTRY_BLOCK_PTR
->count
;
5410 for (e
= new_version_node
->callees
; e
; e
= e
->next_callee
)
5412 basic_block bb
= gimple_bb (e
->call_stmt
);
5413 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
5415 e
->count
= bb
->count
;
5417 for (e
= new_version_node
->indirect_calls
; e
; e
= e
->next_callee
)
5419 basic_block bb
= gimple_bb (e
->call_stmt
);
5420 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
5422 e
->count
= bb
->count
;
5426 free_dominance_info (CDI_DOMINATORS
);
5427 free_dominance_info (CDI_POST_DOMINATORS
);
5429 gcc_assert (!id
.debug_stmts
.exists ());
5430 init_stmts
.release ();
5435 /* EXP is CALL_EXPR present in a GENERIC expression tree. Try to integrate
5436 the callee and return the inlined body on success. */
5439 maybe_inline_call_in_expr (tree exp
)
5441 tree fn
= get_callee_fndecl (exp
);
5443 /* We can only try to inline "const" functions. */
5444 if (fn
&& TREE_READONLY (fn
) && DECL_SAVED_TREE (fn
))
5446 struct pointer_map_t
*decl_map
= pointer_map_create ();
5447 call_expr_arg_iterator iter
;
5451 /* Remap the parameters. */
5452 for (param
= DECL_ARGUMENTS (fn
), arg
= first_call_expr_arg (exp
, &iter
);
5454 param
= DECL_CHAIN (param
), arg
= next_call_expr_arg (&iter
))
5455 *pointer_map_insert (decl_map
, param
) = arg
;
5457 memset (&id
, 0, sizeof (id
));
5459 id
.dst_fn
= current_function_decl
;
5460 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
5461 id
.decl_map
= decl_map
;
5463 id
.copy_decl
= copy_decl_no_change
;
5464 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5465 id
.transform_new_cfg
= false;
5466 id
.transform_return_to_modify
= true;
5467 id
.transform_parameter
= true;
5468 id
.transform_lang_insert_block
= NULL
;
5470 /* Make sure not to unshare trees behind the front-end's back
5471 since front-end specific mechanisms may rely on sharing. */
5472 id
.regimplify
= false;
5473 id
.do_not_unshare
= true;
5475 /* We're not inside any EH region. */
5478 t
= copy_tree_body (&id
);
5479 pointer_map_destroy (decl_map
);
5481 /* We can only return something suitable for use in a GENERIC
5483 if (TREE_CODE (t
) == MODIFY_EXPR
)
5484 return TREE_OPERAND (t
, 1);
5490 /* Duplicate a type, fields and all. */
5493 build_duplicate_type (tree type
)
5495 struct copy_body_data id
;
5497 memset (&id
, 0, sizeof (id
));
5498 id
.src_fn
= current_function_decl
;
5499 id
.dst_fn
= current_function_decl
;
5501 id
.decl_map
= pointer_map_create ();
5502 id
.debug_map
= NULL
;
5503 id
.copy_decl
= copy_decl_no_change
;
5505 type
= remap_type_1 (type
, &id
);
5507 pointer_map_destroy (id
.decl_map
);
5509 pointer_map_destroy (id
.debug_map
);
5511 TYPE_CANONICAL (type
) = type
;