2 Copyright (C) 2001-2015 Free Software Foundation, Inc.
3 Contributed by Alexandre Oliva <aoliva@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
25 #include "diagnostic-core.h"
27 #include "stor-layout.h"
29 #include "tree-inline.h"
33 #include "insn-config.h"
35 #include "langhooks.h"
40 #include "hard-reg-set.h"
42 #include "dominance.h"
45 #include "basic-block.h"
46 #include "tree-iterator.h"
48 #include "tree-ssa-alias.h"
49 #include "internal-fn.h"
50 #include "gimple-fold.h"
52 #include "gimple-expr.h"
56 #include "gimple-iterator.h"
57 #include "gimplify-me.h"
58 #include "gimple-walk.h"
59 #include "gimple-ssa.h"
61 #include "tree-phinodes.h"
62 #include "ssa-iterators.h"
63 #include "stringpool.h"
64 #include "tree-ssanames.h"
65 #include "tree-into-ssa.h"
69 #include "tree-pretty-print.h"
73 #include "plugin-api.h"
76 #include "alloc-pool.h"
77 #include "symbol-summary.h"
79 #include "value-prof.h"
80 #include "tree-pass.h"
84 #include "tree-chkp.h"
86 #include "rtl.h" /* FIXME: For asm_str_count. */
88 /* I'm not real happy about this, but we need to handle gimple and
91 /* Inlining, Cloning, Versioning, Parallelization
93 Inlining: a function body is duplicated, but the PARM_DECLs are
94 remapped into VAR_DECLs, and non-void RETURN_EXPRs become
95 MODIFY_EXPRs that store to a dedicated returned-value variable.
96 The duplicated eh_region info of the copy will later be appended
97 to the info for the caller; the eh_region info in copied throwing
98 statements and RESX statements are adjusted accordingly.
100 Cloning: (only in C++) We have one body for a con/de/structor, and
101 multiple function decls, each with a unique parameter list.
102 Duplicate the body, using the given splay tree; some parameters
103 will become constants (like 0 or 1).
105 Versioning: a function body is duplicated and the result is a new
106 function rather than into blocks of an existing function as with
107 inlining. Some parameters will become constants.
109 Parallelization: a region of a function is duplicated resulting in
110 a new function. Variables may be replaced with complex expressions
111 to enable shared variable semantics.
113 All of these will simultaneously lookup any callgraph edges. If
114 we're going to inline the duplicated function body, and the given
115 function has some cloned callgraph nodes (one for each place this
116 function will be inlined) those callgraph edges will be duplicated.
117 If we're cloning the body, those callgraph edges will be
118 updated to point into the new body. (Note that the original
119 callgraph node and edge list will not be altered.)
121 See the CALL_EXPR handling case in copy_tree_body_r (). */
125 o In order to make inlining-on-trees work, we pessimized
126 function-local static constants. In particular, they are now
127 always output, even when not addressed. Fix this by treating
128 function-local static constants just like global static
129 constants; the back-end already knows not to output them if they
132 o Provide heuristics to clamp inlining of recursive template
136 /* Weights that estimate_num_insns uses to estimate the size of the
139 eni_weights eni_size_weights
;
141 /* Weights that estimate_num_insns uses to estimate the time necessary
142 to execute the produced code. */
144 eni_weights eni_time_weights
;
148 static tree
declare_return_variable (copy_body_data
*, tree
, tree
, tree
,
150 static void remap_block (tree
*, copy_body_data
*);
151 static void copy_bind_expr (tree
*, int *, copy_body_data
*);
152 static void declare_inline_vars (tree
, tree
);
153 static void remap_save_expr (tree
*, hash_map
<tree
, tree
> *, int *);
154 static void prepend_lexical_block (tree current_block
, tree new_block
);
155 static tree
copy_decl_to_var (tree
, copy_body_data
*);
156 static tree
copy_result_decl_to_var (tree
, copy_body_data
*);
157 static tree
copy_decl_maybe_to_var (tree
, copy_body_data
*);
158 static gimple_seq
remap_gimple_stmt (gimple
, copy_body_data
*);
159 static bool delete_unreachable_blocks_update_callgraph (copy_body_data
*id
);
160 static void insert_init_stmt (copy_body_data
*, basic_block
, gimple
);
162 /* Insert a tree->tree mapping for ID. Despite the name suggests
163 that the trees should be variables, it is used for more than that. */
166 insert_decl_map (copy_body_data
*id
, tree key
, tree value
)
168 id
->decl_map
->put (key
, value
);
170 /* Always insert an identity map as well. If we see this same new
171 node again, we won't want to duplicate it a second time. */
173 id
->decl_map
->put (value
, value
);
176 /* Insert a tree->tree mapping for ID. This is only used for
180 insert_debug_decl_map (copy_body_data
*id
, tree key
, tree value
)
182 if (!gimple_in_ssa_p (id
->src_cfun
))
185 if (!MAY_HAVE_DEBUG_STMTS
)
188 if (!target_for_debug_bind (key
))
191 gcc_assert (TREE_CODE (key
) == PARM_DECL
);
192 gcc_assert (TREE_CODE (value
) == VAR_DECL
);
195 id
->debug_map
= new hash_map
<tree
, tree
>;
197 id
->debug_map
->put (key
, value
);
200 /* If nonzero, we're remapping the contents of inlined debug
201 statements. If negative, an error has occurred, such as a
202 reference to a variable that isn't available in the inlined
204 static int processing_debug_stmt
= 0;
206 /* Construct new SSA name for old NAME. ID is the inline context. */
209 remap_ssa_name (tree name
, copy_body_data
*id
)
214 gcc_assert (TREE_CODE (name
) == SSA_NAME
);
216 n
= id
->decl_map
->get (name
);
218 return unshare_expr (*n
);
220 if (processing_debug_stmt
)
222 if (SSA_NAME_IS_DEFAULT_DEF (name
)
223 && TREE_CODE (SSA_NAME_VAR (name
)) == PARM_DECL
224 && id
->entry_bb
== NULL
225 && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (cfun
)))
227 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
229 gimple_stmt_iterator gsi
;
230 tree val
= SSA_NAME_VAR (name
);
232 n
= id
->decl_map
->get (val
);
235 if (TREE_CODE (val
) != PARM_DECL
)
237 processing_debug_stmt
= -1;
240 def_temp
= gimple_build_debug_source_bind (vexpr
, val
, NULL
);
241 DECL_ARTIFICIAL (vexpr
) = 1;
242 TREE_TYPE (vexpr
) = TREE_TYPE (name
);
243 DECL_MODE (vexpr
) = DECL_MODE (SSA_NAME_VAR (name
));
244 gsi
= gsi_after_labels (single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
245 gsi_insert_before (&gsi
, def_temp
, GSI_SAME_STMT
);
249 processing_debug_stmt
= -1;
253 /* Remap anonymous SSA names or SSA names of anonymous decls. */
254 var
= SSA_NAME_VAR (name
);
256 || (!SSA_NAME_IS_DEFAULT_DEF (name
)
257 && TREE_CODE (var
) == VAR_DECL
258 && !VAR_DECL_IS_VIRTUAL_OPERAND (var
)
259 && DECL_ARTIFICIAL (var
)
260 && DECL_IGNORED_P (var
)
261 && !DECL_NAME (var
)))
263 struct ptr_info_def
*pi
;
264 new_tree
= make_ssa_name (remap_type (TREE_TYPE (name
), id
));
265 if (!var
&& SSA_NAME_IDENTIFIER (name
))
266 SET_SSA_NAME_VAR_OR_IDENTIFIER (new_tree
, SSA_NAME_IDENTIFIER (name
));
267 insert_decl_map (id
, name
, new_tree
);
268 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
269 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
270 /* At least IPA points-to info can be directly transferred. */
271 if (id
->src_cfun
->gimple_df
272 && id
->src_cfun
->gimple_df
->ipa_pta
273 && (pi
= SSA_NAME_PTR_INFO (name
))
276 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
282 /* Do not set DEF_STMT yet as statement is not copied yet. We do that
284 new_tree
= remap_decl (var
, id
);
286 /* We might've substituted constant or another SSA_NAME for
289 Replace the SSA name representing RESULT_DECL by variable during
290 inlining: this saves us from need to introduce PHI node in a case
291 return value is just partly initialized. */
292 if ((TREE_CODE (new_tree
) == VAR_DECL
|| TREE_CODE (new_tree
) == PARM_DECL
)
293 && (!SSA_NAME_VAR (name
)
294 || TREE_CODE (SSA_NAME_VAR (name
)) != RESULT_DECL
295 || !id
->transform_return_to_modify
))
297 struct ptr_info_def
*pi
;
298 new_tree
= make_ssa_name (new_tree
);
299 insert_decl_map (id
, name
, new_tree
);
300 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
301 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
302 /* At least IPA points-to info can be directly transferred. */
303 if (id
->src_cfun
->gimple_df
304 && id
->src_cfun
->gimple_df
->ipa_pta
305 && (pi
= SSA_NAME_PTR_INFO (name
))
308 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
311 if (SSA_NAME_IS_DEFAULT_DEF (name
))
313 /* By inlining function having uninitialized variable, we might
314 extend the lifetime (variable might get reused). This cause
315 ICE in the case we end up extending lifetime of SSA name across
316 abnormal edge, but also increase register pressure.
318 We simply initialize all uninitialized vars by 0 except
319 for case we are inlining to very first BB. We can avoid
320 this for all BBs that are not inside strongly connected
321 regions of the CFG, but this is expensive to test. */
323 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
)
324 && (!SSA_NAME_VAR (name
)
325 || TREE_CODE (SSA_NAME_VAR (name
)) != PARM_DECL
)
326 && (id
->entry_bb
!= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
),
328 || EDGE_COUNT (id
->entry_bb
->preds
) != 1))
330 gimple_stmt_iterator gsi
= gsi_last_bb (id
->entry_bb
);
332 tree zero
= build_zero_cst (TREE_TYPE (new_tree
));
334 init_stmt
= gimple_build_assign (new_tree
, zero
);
335 gsi_insert_after (&gsi
, init_stmt
, GSI_NEW_STMT
);
336 SSA_NAME_IS_DEFAULT_DEF (new_tree
) = 0;
340 SSA_NAME_DEF_STMT (new_tree
) = gimple_build_nop ();
341 set_ssa_default_def (cfun
, SSA_NAME_VAR (new_tree
), new_tree
);
346 insert_decl_map (id
, name
, new_tree
);
350 /* Remap DECL during the copying of the BLOCK tree for the function. */
353 remap_decl (tree decl
, copy_body_data
*id
)
357 /* We only remap local variables in the current function. */
359 /* See if we have remapped this declaration. */
361 n
= id
->decl_map
->get (decl
);
363 if (!n
&& processing_debug_stmt
)
365 processing_debug_stmt
= -1;
369 /* If we didn't already have an equivalent for this declaration,
373 /* Make a copy of the variable or label. */
374 tree t
= id
->copy_decl (decl
, id
);
376 /* Remember it, so that if we encounter this local entity again
377 we can reuse this copy. Do this early because remap_type may
378 need this decl for TYPE_STUB_DECL. */
379 insert_decl_map (id
, decl
, t
);
384 /* Remap types, if necessary. */
385 TREE_TYPE (t
) = remap_type (TREE_TYPE (t
), id
);
386 if (TREE_CODE (t
) == TYPE_DECL
)
387 DECL_ORIGINAL_TYPE (t
) = remap_type (DECL_ORIGINAL_TYPE (t
), id
);
389 /* Remap sizes as necessary. */
390 walk_tree (&DECL_SIZE (t
), copy_tree_body_r
, id
, NULL
);
391 walk_tree (&DECL_SIZE_UNIT (t
), copy_tree_body_r
, id
, NULL
);
393 /* If fields, do likewise for offset and qualifier. */
394 if (TREE_CODE (t
) == FIELD_DECL
)
396 walk_tree (&DECL_FIELD_OFFSET (t
), copy_tree_body_r
, id
, NULL
);
397 if (TREE_CODE (DECL_CONTEXT (t
)) == QUAL_UNION_TYPE
)
398 walk_tree (&DECL_QUALIFIER (t
), copy_tree_body_r
, id
, NULL
);
404 if (id
->do_not_unshare
)
407 return unshare_expr (*n
);
411 remap_type_1 (tree type
, copy_body_data
*id
)
415 /* We do need a copy. build and register it now. If this is a pointer or
416 reference type, remap the designated type and make a new pointer or
418 if (TREE_CODE (type
) == POINTER_TYPE
)
420 new_tree
= build_pointer_type_for_mode (remap_type (TREE_TYPE (type
), id
),
422 TYPE_REF_CAN_ALIAS_ALL (type
));
423 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
424 new_tree
= build_type_attribute_qual_variant (new_tree
,
425 TYPE_ATTRIBUTES (type
),
427 insert_decl_map (id
, type
, new_tree
);
430 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
432 new_tree
= build_reference_type_for_mode (remap_type (TREE_TYPE (type
), id
),
434 TYPE_REF_CAN_ALIAS_ALL (type
));
435 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
436 new_tree
= build_type_attribute_qual_variant (new_tree
,
437 TYPE_ATTRIBUTES (type
),
439 insert_decl_map (id
, type
, new_tree
);
443 new_tree
= copy_node (type
);
445 insert_decl_map (id
, type
, new_tree
);
447 /* This is a new type, not a copy of an old type. Need to reassociate
448 variants. We can handle everything except the main variant lazily. */
449 t
= TYPE_MAIN_VARIANT (type
);
452 t
= remap_type (t
, id
);
453 TYPE_MAIN_VARIANT (new_tree
) = t
;
454 TYPE_NEXT_VARIANT (new_tree
) = TYPE_NEXT_VARIANT (t
);
455 TYPE_NEXT_VARIANT (t
) = new_tree
;
459 TYPE_MAIN_VARIANT (new_tree
) = new_tree
;
460 TYPE_NEXT_VARIANT (new_tree
) = NULL
;
463 if (TYPE_STUB_DECL (type
))
464 TYPE_STUB_DECL (new_tree
) = remap_decl (TYPE_STUB_DECL (type
), id
);
466 /* Lazily create pointer and reference types. */
467 TYPE_POINTER_TO (new_tree
) = NULL
;
468 TYPE_REFERENCE_TO (new_tree
) = NULL
;
470 /* Copy all types that may contain references to local variables; be sure to
471 preserve sharing in between type and its main variant when possible. */
472 switch (TREE_CODE (new_tree
))
476 case FIXED_POINT_TYPE
:
479 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
481 gcc_checking_assert (TYPE_MIN_VALUE (type
) == TYPE_MIN_VALUE (TYPE_MAIN_VARIANT (type
)));
482 gcc_checking_assert (TYPE_MAX_VALUE (type
) == TYPE_MAX_VALUE (TYPE_MAIN_VARIANT (type
)));
484 TYPE_MIN_VALUE (new_tree
) = TYPE_MIN_VALUE (TYPE_MAIN_VARIANT (new_tree
));
485 TYPE_MAX_VALUE (new_tree
) = TYPE_MAX_VALUE (TYPE_MAIN_VARIANT (new_tree
));
489 t
= TYPE_MIN_VALUE (new_tree
);
490 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
491 walk_tree (&TYPE_MIN_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
493 t
= TYPE_MAX_VALUE (new_tree
);
494 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
495 walk_tree (&TYPE_MAX_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
500 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
501 && TREE_TYPE (type
) == TREE_TYPE (TYPE_MAIN_VARIANT (type
)))
502 TREE_TYPE (new_tree
) = TREE_TYPE (TYPE_MAIN_VARIANT (new_tree
));
504 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
505 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
506 && TYPE_ARG_TYPES (type
) == TYPE_ARG_TYPES (TYPE_MAIN_VARIANT (type
)))
507 TYPE_ARG_TYPES (new_tree
) = TYPE_ARG_TYPES (TYPE_MAIN_VARIANT (new_tree
));
509 walk_tree (&TYPE_ARG_TYPES (new_tree
), copy_tree_body_r
, id
, NULL
);
513 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
514 && TREE_TYPE (type
) == TREE_TYPE (TYPE_MAIN_VARIANT (type
)))
515 TREE_TYPE (new_tree
) = TREE_TYPE (TYPE_MAIN_VARIANT (new_tree
));
517 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
519 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
521 gcc_checking_assert (TYPE_DOMAIN (type
) == TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)));
522 TYPE_DOMAIN (new_tree
) = TYPE_DOMAIN (TYPE_MAIN_VARIANT (new_tree
));
525 TYPE_DOMAIN (new_tree
) = remap_type (TYPE_DOMAIN (new_tree
), id
);
530 case QUAL_UNION_TYPE
:
531 if (TYPE_MAIN_VARIANT (type
) != type
532 && TYPE_FIELDS (type
) == TYPE_FIELDS (TYPE_MAIN_VARIANT (type
)))
533 TYPE_FIELDS (new_tree
) = TYPE_FIELDS (TYPE_MAIN_VARIANT (new_tree
));
538 for (f
= TYPE_FIELDS (new_tree
); f
; f
= DECL_CHAIN (f
))
540 t
= remap_decl (f
, id
);
541 DECL_CONTEXT (t
) = new_tree
;
545 TYPE_FIELDS (new_tree
) = nreverse (nf
);
551 /* Shouldn't have been thought variable sized. */
555 /* All variants of type share the same size, so use the already remaped data. */
556 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
558 gcc_checking_assert (TYPE_SIZE (type
) == TYPE_SIZE (TYPE_MAIN_VARIANT (type
)));
559 gcc_checking_assert (TYPE_SIZE_UNIT (type
) == TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type
)));
561 TYPE_SIZE (new_tree
) = TYPE_SIZE (TYPE_MAIN_VARIANT (new_tree
));
562 TYPE_SIZE_UNIT (new_tree
) = TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (new_tree
));
566 walk_tree (&TYPE_SIZE (new_tree
), copy_tree_body_r
, id
, NULL
);
567 walk_tree (&TYPE_SIZE_UNIT (new_tree
), copy_tree_body_r
, id
, NULL
);
574 remap_type (tree type
, copy_body_data
*id
)
582 /* See if we have remapped this type. */
583 node
= id
->decl_map
->get (type
);
587 /* The type only needs remapping if it's variably modified. */
588 if (! variably_modified_type_p (type
, id
->src_fn
))
590 insert_decl_map (id
, type
, type
);
594 id
->remapping_type_depth
++;
595 tmp
= remap_type_1 (type
, id
);
596 id
->remapping_type_depth
--;
601 /* Decide if DECL can be put into BLOCK_NONLOCAL_VARs. */
604 can_be_nonlocal (tree decl
, copy_body_data
*id
)
606 /* We can not duplicate function decls. */
607 if (TREE_CODE (decl
) == FUNCTION_DECL
)
610 /* Local static vars must be non-local or we get multiple declaration
612 if (TREE_CODE (decl
) == VAR_DECL
613 && !auto_var_in_fn_p (decl
, id
->src_fn
))
620 remap_decls (tree decls
, vec
<tree
, va_gc
> **nonlocalized_list
,
624 tree new_decls
= NULL_TREE
;
626 /* Remap its variables. */
627 for (old_var
= decls
; old_var
; old_var
= DECL_CHAIN (old_var
))
631 if (can_be_nonlocal (old_var
, id
))
633 /* We need to add this variable to the local decls as otherwise
634 nothing else will do so. */
635 if (TREE_CODE (old_var
) == VAR_DECL
636 && ! DECL_EXTERNAL (old_var
))
637 add_local_decl (cfun
, old_var
);
638 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
639 && !DECL_IGNORED_P (old_var
)
640 && nonlocalized_list
)
641 vec_safe_push (*nonlocalized_list
, old_var
);
645 /* Remap the variable. */
646 new_var
= remap_decl (old_var
, id
);
648 /* If we didn't remap this variable, we can't mess with its
649 TREE_CHAIN. If we remapped this variable to the return slot, it's
650 already declared somewhere else, so don't declare it here. */
652 if (new_var
== id
->retvar
)
656 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
657 && !DECL_IGNORED_P (old_var
)
658 && nonlocalized_list
)
659 vec_safe_push (*nonlocalized_list
, old_var
);
663 gcc_assert (DECL_P (new_var
));
664 DECL_CHAIN (new_var
) = new_decls
;
667 /* Also copy value-expressions. */
668 if (TREE_CODE (new_var
) == VAR_DECL
669 && DECL_HAS_VALUE_EXPR_P (new_var
))
671 tree tem
= DECL_VALUE_EXPR (new_var
);
672 bool old_regimplify
= id
->regimplify
;
673 id
->remapping_type_depth
++;
674 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
675 id
->remapping_type_depth
--;
676 id
->regimplify
= old_regimplify
;
677 SET_DECL_VALUE_EXPR (new_var
, tem
);
682 return nreverse (new_decls
);
685 /* Copy the BLOCK to contain remapped versions of the variables
686 therein. And hook the new block into the block-tree. */
689 remap_block (tree
*block
, copy_body_data
*id
)
694 /* Make the new block. */
696 new_block
= make_node (BLOCK
);
697 TREE_USED (new_block
) = TREE_USED (old_block
);
698 BLOCK_ABSTRACT_ORIGIN (new_block
) = old_block
;
699 BLOCK_SOURCE_LOCATION (new_block
) = BLOCK_SOURCE_LOCATION (old_block
);
700 BLOCK_NONLOCALIZED_VARS (new_block
)
701 = vec_safe_copy (BLOCK_NONLOCALIZED_VARS (old_block
));
704 /* Remap its variables. */
705 BLOCK_VARS (new_block
) = remap_decls (BLOCK_VARS (old_block
),
706 &BLOCK_NONLOCALIZED_VARS (new_block
),
709 if (id
->transform_lang_insert_block
)
710 id
->transform_lang_insert_block (new_block
);
712 /* Remember the remapped block. */
713 insert_decl_map (id
, old_block
, new_block
);
716 /* Copy the whole block tree and root it in id->block. */
718 remap_blocks (tree block
, copy_body_data
*id
)
721 tree new_tree
= block
;
726 remap_block (&new_tree
, id
);
727 gcc_assert (new_tree
!= block
);
728 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
729 prepend_lexical_block (new_tree
, remap_blocks (t
, id
));
730 /* Blocks are in arbitrary order, but make things slightly prettier and do
731 not swap order when producing a copy. */
732 BLOCK_SUBBLOCKS (new_tree
) = blocks_nreverse (BLOCK_SUBBLOCKS (new_tree
));
736 /* Remap the block tree rooted at BLOCK to nothing. */
738 remap_blocks_to_null (tree block
, copy_body_data
*id
)
741 insert_decl_map (id
, block
, NULL_TREE
);
742 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
743 remap_blocks_to_null (t
, id
);
747 copy_statement_list (tree
*tp
)
749 tree_stmt_iterator oi
, ni
;
752 new_tree
= alloc_stmt_list ();
753 ni
= tsi_start (new_tree
);
754 oi
= tsi_start (*tp
);
755 TREE_TYPE (new_tree
) = TREE_TYPE (*tp
);
758 for (; !tsi_end_p (oi
); tsi_next (&oi
))
760 tree stmt
= tsi_stmt (oi
);
761 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
762 /* This copy is not redundant; tsi_link_after will smash this
763 STATEMENT_LIST into the end of the one we're building, and we
764 don't want to do that with the original. */
765 copy_statement_list (&stmt
);
766 tsi_link_after (&ni
, stmt
, TSI_CONTINUE_LINKING
);
771 copy_bind_expr (tree
*tp
, int *walk_subtrees
, copy_body_data
*id
)
773 tree block
= BIND_EXPR_BLOCK (*tp
);
774 /* Copy (and replace) the statement. */
775 copy_tree_r (tp
, walk_subtrees
, NULL
);
778 remap_block (&block
, id
);
779 BIND_EXPR_BLOCK (*tp
) = block
;
782 if (BIND_EXPR_VARS (*tp
))
783 /* This will remap a lot of the same decls again, but this should be
785 BIND_EXPR_VARS (*tp
) = remap_decls (BIND_EXPR_VARS (*tp
), NULL
, id
);
789 /* Create a new gimple_seq by remapping all the statements in BODY
790 using the inlining information in ID. */
793 remap_gimple_seq (gimple_seq body
, copy_body_data
*id
)
795 gimple_stmt_iterator si
;
796 gimple_seq new_body
= NULL
;
798 for (si
= gsi_start (body
); !gsi_end_p (si
); gsi_next (&si
))
800 gimple_seq new_stmts
= remap_gimple_stmt (gsi_stmt (si
), id
);
801 gimple_seq_add_seq (&new_body
, new_stmts
);
808 /* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its
809 block using the mapping information in ID. */
812 copy_gimple_bind (gbind
*stmt
, copy_body_data
*id
)
815 tree new_block
, new_vars
;
816 gimple_seq body
, new_body
;
818 /* Copy the statement. Note that we purposely don't use copy_stmt
819 here because we need to remap statements as we copy. */
820 body
= gimple_bind_body (stmt
);
821 new_body
= remap_gimple_seq (body
, id
);
823 new_block
= gimple_bind_block (stmt
);
825 remap_block (&new_block
, id
);
827 /* This will remap a lot of the same decls again, but this should be
829 new_vars
= gimple_bind_vars (stmt
);
831 new_vars
= remap_decls (new_vars
, NULL
, id
);
833 new_bind
= gimple_build_bind (new_vars
, new_body
, new_block
);
838 /* Return true if DECL is a parameter or a SSA_NAME for a parameter. */
843 if (TREE_CODE (decl
) == SSA_NAME
)
845 decl
= SSA_NAME_VAR (decl
);
850 return (TREE_CODE (decl
) == PARM_DECL
);
853 /* Remap the dependence CLIQUE from the source to the destination function
854 as specified in ID. */
856 static unsigned short
857 remap_dependence_clique (copy_body_data
*id
, unsigned short clique
)
861 if (!id
->dependence_map
)
863 = new hash_map
<unsigned short, unsigned short, dependence_hasher
>;
865 unsigned short &newc
= id
->dependence_map
->get_or_insert (clique
, &existed
);
867 newc
= ++cfun
->last_clique
;
871 /* Remap the GIMPLE operand pointed to by *TP. DATA is really a
872 'struct walk_stmt_info *'. DATA->INFO is a 'copy_body_data *'.
873 WALK_SUBTREES is used to indicate walk_gimple_op whether to keep
874 recursing into the children nodes of *TP. */
877 remap_gimple_op_r (tree
*tp
, int *walk_subtrees
, void *data
)
879 struct walk_stmt_info
*wi_p
= (struct walk_stmt_info
*) data
;
880 copy_body_data
*id
= (copy_body_data
*) wi_p
->info
;
881 tree fn
= id
->src_fn
;
883 if (TREE_CODE (*tp
) == SSA_NAME
)
885 *tp
= remap_ssa_name (*tp
, id
);
889 else if (auto_var_in_fn_p (*tp
, fn
))
891 /* Local variables and labels need to be replaced by equivalent
892 variables. We don't want to copy static variables; there's
893 only one of those, no matter how many times we inline the
894 containing function. Similarly for globals from an outer
898 /* Remap the declaration. */
899 new_decl
= remap_decl (*tp
, id
);
900 gcc_assert (new_decl
);
901 /* Replace this variable with the copy. */
902 STRIP_TYPE_NOPS (new_decl
);
903 /* ??? The C++ frontend uses void * pointer zero to initialize
904 any other type. This confuses the middle-end type verification.
905 As cloned bodies do not go through gimplification again the fixup
906 there doesn't trigger. */
907 if (TREE_CODE (new_decl
) == INTEGER_CST
908 && !useless_type_conversion_p (TREE_TYPE (*tp
), TREE_TYPE (new_decl
)))
909 new_decl
= fold_convert (TREE_TYPE (*tp
), new_decl
);
913 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
915 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
917 else if (TREE_CODE (*tp
) == LABEL_DECL
918 && (!DECL_CONTEXT (*tp
)
919 || decl_function_context (*tp
) == id
->src_fn
))
920 /* These may need to be remapped for EH handling. */
921 *tp
= remap_decl (*tp
, id
);
922 else if (TREE_CODE (*tp
) == FIELD_DECL
)
924 /* If the enclosing record type is variably_modified_type_p, the field
925 has already been remapped. Otherwise, it need not be. */
926 tree
*n
= id
->decl_map
->get (*tp
);
931 else if (TYPE_P (*tp
))
932 /* Types may need remapping as well. */
933 *tp
= remap_type (*tp
, id
);
934 else if (CONSTANT_CLASS_P (*tp
))
936 /* If this is a constant, we have to copy the node iff the type
937 will be remapped. copy_tree_r will not copy a constant. */
938 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
940 if (new_type
== TREE_TYPE (*tp
))
943 else if (TREE_CODE (*tp
) == INTEGER_CST
)
944 *tp
= wide_int_to_tree (new_type
, *tp
);
947 *tp
= copy_node (*tp
);
948 TREE_TYPE (*tp
) = new_type
;
953 /* Otherwise, just copy the node. Note that copy_tree_r already
954 knows not to copy VAR_DECLs, etc., so this is safe. */
956 if (TREE_CODE (*tp
) == MEM_REF
)
958 /* We need to re-canonicalize MEM_REFs from inline substitutions
959 that can happen when a pointer argument is an ADDR_EXPR.
960 Recurse here manually to allow that. */
961 tree ptr
= TREE_OPERAND (*tp
, 0);
962 tree type
= remap_type (TREE_TYPE (*tp
), id
);
964 walk_tree (&ptr
, remap_gimple_op_r
, data
, NULL
);
965 *tp
= fold_build2 (MEM_REF
, type
, ptr
, TREE_OPERAND (*tp
, 1));
966 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
967 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
968 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
969 if (MR_DEPENDENCE_CLIQUE (old
) != 0)
971 MR_DEPENDENCE_CLIQUE (*tp
)
972 = remap_dependence_clique (id
, MR_DEPENDENCE_CLIQUE (old
));
973 MR_DEPENDENCE_BASE (*tp
) = MR_DEPENDENCE_BASE (old
);
975 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
976 remapped a parameter as the property might be valid only
977 for the parameter itself. */
978 if (TREE_THIS_NOTRAP (old
)
979 && (!is_parm (TREE_OPERAND (old
, 0))
980 || (!id
->transform_parameter
&& is_parm (ptr
))))
981 TREE_THIS_NOTRAP (*tp
) = 1;
986 /* Here is the "usual case". Copy this tree node, and then
987 tweak some special cases. */
988 copy_tree_r (tp
, walk_subtrees
, NULL
);
990 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
991 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
993 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
995 /* The copied TARGET_EXPR has never been expanded, even if the
996 original node was expanded already. */
997 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
998 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
1000 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
1002 /* Variable substitution need not be simple. In particular,
1003 the MEM_REF substitution above. Make sure that
1004 TREE_CONSTANT and friends are up-to-date. */
1005 int invariant
= is_gimple_min_invariant (*tp
);
1006 walk_tree (&TREE_OPERAND (*tp
, 0), remap_gimple_op_r
, data
, NULL
);
1007 recompute_tree_invariant_for_addr_expr (*tp
);
1009 /* If this used to be invariant, but is not any longer,
1010 then regimplification is probably needed. */
1011 if (invariant
&& !is_gimple_min_invariant (*tp
))
1012 id
->regimplify
= true;
1018 /* Update the TREE_BLOCK for the cloned expr. */
1021 tree new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
1022 tree old_block
= TREE_BLOCK (*tp
);
1026 n
= id
->decl_map
->get (TREE_BLOCK (*tp
));
1030 TREE_SET_BLOCK (*tp
, new_block
);
1033 /* Keep iterating. */
1038 /* Called from copy_body_id via walk_tree. DATA is really a
1039 `copy_body_data *'. */
1042 copy_tree_body_r (tree
*tp
, int *walk_subtrees
, void *data
)
1044 copy_body_data
*id
= (copy_body_data
*) data
;
1045 tree fn
= id
->src_fn
;
1048 /* Begin by recognizing trees that we'll completely rewrite for the
1049 inlining context. Our output for these trees is completely
1050 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1051 into an edge). Further down, we'll handle trees that get
1052 duplicated and/or tweaked. */
1054 /* When requested, RETURN_EXPRs should be transformed to just the
1055 contained MODIFY_EXPR. The branch semantics of the return will
1056 be handled elsewhere by manipulating the CFG rather than a statement. */
1057 if (TREE_CODE (*tp
) == RETURN_EXPR
&& id
->transform_return_to_modify
)
1059 tree assignment
= TREE_OPERAND (*tp
, 0);
1061 /* If we're returning something, just turn that into an
1062 assignment into the equivalent of the original RESULT_DECL.
1063 If the "assignment" is just the result decl, the result
1064 decl has already been set (e.g. a recent "foo (&result_decl,
1065 ...)"); just toss the entire RETURN_EXPR. */
1066 if (assignment
&& TREE_CODE (assignment
) == MODIFY_EXPR
)
1068 /* Replace the RETURN_EXPR with (a copy of) the
1069 MODIFY_EXPR hanging underneath. */
1070 *tp
= copy_node (assignment
);
1072 else /* Else the RETURN_EXPR returns no value. */
1075 return (tree
) (void *)1;
1078 else if (TREE_CODE (*tp
) == SSA_NAME
)
1080 *tp
= remap_ssa_name (*tp
, id
);
1085 /* Local variables and labels need to be replaced by equivalent
1086 variables. We don't want to copy static variables; there's only
1087 one of those, no matter how many times we inline the containing
1088 function. Similarly for globals from an outer function. */
1089 else if (auto_var_in_fn_p (*tp
, fn
))
1093 /* Remap the declaration. */
1094 new_decl
= remap_decl (*tp
, id
);
1095 gcc_assert (new_decl
);
1096 /* Replace this variable with the copy. */
1097 STRIP_TYPE_NOPS (new_decl
);
1101 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
1102 copy_statement_list (tp
);
1103 else if (TREE_CODE (*tp
) == SAVE_EXPR
1104 || TREE_CODE (*tp
) == TARGET_EXPR
)
1105 remap_save_expr (tp
, id
->decl_map
, walk_subtrees
);
1106 else if (TREE_CODE (*tp
) == LABEL_DECL
1107 && (! DECL_CONTEXT (*tp
)
1108 || decl_function_context (*tp
) == id
->src_fn
))
1109 /* These may need to be remapped for EH handling. */
1110 *tp
= remap_decl (*tp
, id
);
1111 else if (TREE_CODE (*tp
) == BIND_EXPR
)
1112 copy_bind_expr (tp
, walk_subtrees
, id
);
1113 /* Types may need remapping as well. */
1114 else if (TYPE_P (*tp
))
1115 *tp
= remap_type (*tp
, id
);
1117 /* If this is a constant, we have to copy the node iff the type will be
1118 remapped. copy_tree_r will not copy a constant. */
1119 else if (CONSTANT_CLASS_P (*tp
))
1121 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
1123 if (new_type
== TREE_TYPE (*tp
))
1126 else if (TREE_CODE (*tp
) == INTEGER_CST
)
1127 *tp
= wide_int_to_tree (new_type
, *tp
);
1130 *tp
= copy_node (*tp
);
1131 TREE_TYPE (*tp
) = new_type
;
1135 /* Otherwise, just copy the node. Note that copy_tree_r already
1136 knows not to copy VAR_DECLs, etc., so this is safe. */
1139 /* Here we handle trees that are not completely rewritten.
1140 First we detect some inlining-induced bogosities for
1142 if (TREE_CODE (*tp
) == MODIFY_EXPR
1143 && TREE_OPERAND (*tp
, 0) == TREE_OPERAND (*tp
, 1)
1144 && (auto_var_in_fn_p (TREE_OPERAND (*tp
, 0), fn
)))
1146 /* Some assignments VAR = VAR; don't generate any rtl code
1147 and thus don't count as variable modification. Avoid
1148 keeping bogosities like 0 = 0. */
1149 tree decl
= TREE_OPERAND (*tp
, 0), value
;
1152 n
= id
->decl_map
->get (decl
);
1156 STRIP_TYPE_NOPS (value
);
1157 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1159 *tp
= build_empty_stmt (EXPR_LOCATION (*tp
));
1160 return copy_tree_body_r (tp
, walk_subtrees
, data
);
1164 else if (TREE_CODE (*tp
) == INDIRECT_REF
)
1166 /* Get rid of *& from inline substitutions that can happen when a
1167 pointer argument is an ADDR_EXPR. */
1168 tree decl
= TREE_OPERAND (*tp
, 0);
1169 tree
*n
= id
->decl_map
->get (decl
);
1172 /* If we happen to get an ADDR_EXPR in n->value, strip
1173 it manually here as we'll eventually get ADDR_EXPRs
1174 which lie about their types pointed to. In this case
1175 build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
1176 but we absolutely rely on that. As fold_indirect_ref
1177 does other useful transformations, try that first, though. */
1178 tree type
= TREE_TYPE (*tp
);
1179 tree ptr
= id
->do_not_unshare
? *n
: unshare_expr (*n
);
1181 *tp
= gimple_fold_indirect_ref (ptr
);
1184 if (TREE_CODE (ptr
) == ADDR_EXPR
)
1187 = fold_indirect_ref_1 (EXPR_LOCATION (ptr
), type
, ptr
);
1188 /* ??? We should either assert here or build
1189 a VIEW_CONVERT_EXPR instead of blindly leaking
1190 incompatible types to our IL. */
1192 *tp
= TREE_OPERAND (ptr
, 0);
1196 *tp
= build1 (INDIRECT_REF
, type
, ptr
);
1197 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1198 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1199 TREE_READONLY (*tp
) = TREE_READONLY (old
);
1200 /* We cannot propagate the TREE_THIS_NOTRAP flag if we
1201 have remapped a parameter as the property might be
1202 valid only for the parameter itself. */
1203 if (TREE_THIS_NOTRAP (old
)
1204 && (!is_parm (TREE_OPERAND (old
, 0))
1205 || (!id
->transform_parameter
&& is_parm (ptr
))))
1206 TREE_THIS_NOTRAP (*tp
) = 1;
1213 else if (TREE_CODE (*tp
) == MEM_REF
)
1215 /* We need to re-canonicalize MEM_REFs from inline substitutions
1216 that can happen when a pointer argument is an ADDR_EXPR.
1217 Recurse here manually to allow that. */
1218 tree ptr
= TREE_OPERAND (*tp
, 0);
1219 tree type
= remap_type (TREE_TYPE (*tp
), id
);
1221 walk_tree (&ptr
, copy_tree_body_r
, data
, NULL
);
1222 *tp
= fold_build2 (MEM_REF
, type
, ptr
, TREE_OPERAND (*tp
, 1));
1223 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1224 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1225 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
1226 if (MR_DEPENDENCE_CLIQUE (old
) != 0)
1228 MR_DEPENDENCE_CLIQUE (*tp
)
1229 = remap_dependence_clique (id
, MR_DEPENDENCE_CLIQUE (old
));
1230 MR_DEPENDENCE_BASE (*tp
) = MR_DEPENDENCE_BASE (old
);
1232 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
1233 remapped a parameter as the property might be valid only
1234 for the parameter itself. */
1235 if (TREE_THIS_NOTRAP (old
)
1236 && (!is_parm (TREE_OPERAND (old
, 0))
1237 || (!id
->transform_parameter
&& is_parm (ptr
))))
1238 TREE_THIS_NOTRAP (*tp
) = 1;
1243 /* Here is the "usual case". Copy this tree node, and then
1244 tweak some special cases. */
1245 copy_tree_r (tp
, walk_subtrees
, NULL
);
1247 /* If EXPR has block defined, map it to newly constructed block.
1248 When inlining we want EXPRs without block appear in the block
1249 of function call if we are not remapping a type. */
1252 new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
1253 if (TREE_BLOCK (*tp
))
1256 n
= id
->decl_map
->get (TREE_BLOCK (*tp
));
1260 TREE_SET_BLOCK (*tp
, new_block
);
1263 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
1264 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
1266 /* The copied TARGET_EXPR has never been expanded, even if the
1267 original node was expanded already. */
1268 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
1270 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
1271 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
1274 /* Variable substitution need not be simple. In particular, the
1275 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
1276 and friends are up-to-date. */
1277 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
1279 int invariant
= is_gimple_min_invariant (*tp
);
1280 walk_tree (&TREE_OPERAND (*tp
, 0), copy_tree_body_r
, id
, NULL
);
1282 /* Handle the case where we substituted an INDIRECT_REF
1283 into the operand of the ADDR_EXPR. */
1284 if (TREE_CODE (TREE_OPERAND (*tp
, 0)) == INDIRECT_REF
)
1285 *tp
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0);
1287 recompute_tree_invariant_for_addr_expr (*tp
);
1289 /* If this used to be invariant, but is not any longer,
1290 then regimplification is probably needed. */
1291 if (invariant
&& !is_gimple_min_invariant (*tp
))
1292 id
->regimplify
= true;
1298 /* Keep iterating. */
1302 /* Helper for remap_gimple_stmt. Given an EH region number for the
1303 source function, map that to the duplicate EH region number in
1304 the destination function. */
1307 remap_eh_region_nr (int old_nr
, copy_body_data
*id
)
1309 eh_region old_r
, new_r
;
1311 old_r
= get_eh_region_from_number_fn (id
->src_cfun
, old_nr
);
1312 new_r
= static_cast<eh_region
> (*id
->eh_map
->get (old_r
));
1314 return new_r
->index
;
1317 /* Similar, but operate on INTEGER_CSTs. */
1320 remap_eh_region_tree_nr (tree old_t_nr
, copy_body_data
*id
)
1324 old_nr
= tree_to_shwi (old_t_nr
);
1325 new_nr
= remap_eh_region_nr (old_nr
, id
);
1327 return build_int_cst (integer_type_node
, new_nr
);
1330 /* Helper for copy_bb. Remap statement STMT using the inlining
1331 information in ID. Return the new statement copy. */
1334 remap_gimple_stmt (gimple stmt
, copy_body_data
*id
)
1337 struct walk_stmt_info wi
;
1338 bool skip_first
= false;
1339 gimple_seq stmts
= NULL
;
1341 /* Begin by recognizing trees that we'll completely rewrite for the
1342 inlining context. Our output for these trees is completely
1343 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1344 into an edge). Further down, we'll handle trees that get
1345 duplicated and/or tweaked. */
1347 /* When requested, GIMPLE_RETURNs should be transformed to just the
1348 contained GIMPLE_ASSIGN. The branch semantics of the return will
1349 be handled elsewhere by manipulating the CFG rather than the
1351 if (gimple_code (stmt
) == GIMPLE_RETURN
&& id
->transform_return_to_modify
)
1353 tree retval
= gimple_return_retval (as_a
<greturn
*> (stmt
));
1354 tree retbnd
= gimple_return_retbnd (stmt
);
1355 tree bndslot
= id
->retbnd
;
1357 if (retbnd
&& bndslot
)
1359 gimple bndcopy
= gimple_build_assign (bndslot
, retbnd
);
1360 memset (&wi
, 0, sizeof (wi
));
1362 walk_gimple_op (bndcopy
, remap_gimple_op_r
, &wi
);
1363 gimple_seq_add_stmt (&stmts
, bndcopy
);
1366 /* If we're returning something, just turn that into an
1367 assignment into the equivalent of the original RESULT_DECL.
1368 If RETVAL is just the result decl, the result decl has
1369 already been set (e.g. a recent "foo (&result_decl, ...)");
1370 just toss the entire GIMPLE_RETURN. */
1372 && (TREE_CODE (retval
) != RESULT_DECL
1373 && (TREE_CODE (retval
) != SSA_NAME
1374 || ! SSA_NAME_VAR (retval
)
1375 || TREE_CODE (SSA_NAME_VAR (retval
)) != RESULT_DECL
)))
1377 copy
= gimple_build_assign (id
->do_not_unshare
1378 ? id
->retvar
: unshare_expr (id
->retvar
),
1380 /* id->retvar is already substituted. Skip it on later remapping. */
1383 /* We need to copy bounds if return structure with pointers into
1384 instrumented function. */
1385 if (chkp_function_instrumented_p (id
->dst_fn
)
1387 && !BOUNDED_P (id
->retvar
)
1388 && chkp_type_has_pointer (TREE_TYPE (id
->retvar
)))
1389 id
->assign_stmts
.safe_push (copy
);
1395 else if (gimple_has_substatements (stmt
))
1399 /* When cloning bodies from the C++ front end, we will be handed bodies
1400 in High GIMPLE form. Handle here all the High GIMPLE statements that
1401 have embedded statements. */
1402 switch (gimple_code (stmt
))
1405 copy
= copy_gimple_bind (as_a
<gbind
*> (stmt
), id
);
1410 gcatch
*catch_stmt
= as_a
<gcatch
*> (stmt
);
1411 s1
= remap_gimple_seq (gimple_catch_handler (catch_stmt
), id
);
1412 copy
= gimple_build_catch (gimple_catch_types (catch_stmt
), s1
);
1416 case GIMPLE_EH_FILTER
:
1417 s1
= remap_gimple_seq (gimple_eh_filter_failure (stmt
), id
);
1418 copy
= gimple_build_eh_filter (gimple_eh_filter_types (stmt
), s1
);
1422 s1
= remap_gimple_seq (gimple_try_eval (stmt
), id
);
1423 s2
= remap_gimple_seq (gimple_try_cleanup (stmt
), id
);
1424 copy
= gimple_build_try (s1
, s2
, gimple_try_kind (stmt
));
1427 case GIMPLE_WITH_CLEANUP_EXPR
:
1428 s1
= remap_gimple_seq (gimple_wce_cleanup (stmt
), id
);
1429 copy
= gimple_build_wce (s1
);
1432 case GIMPLE_OMP_PARALLEL
:
1434 gomp_parallel
*omp_par_stmt
= as_a
<gomp_parallel
*> (stmt
);
1435 s1
= remap_gimple_seq (gimple_omp_body (omp_par_stmt
), id
);
1436 copy
= gimple_build_omp_parallel
1438 gimple_omp_parallel_clauses (omp_par_stmt
),
1439 gimple_omp_parallel_child_fn (omp_par_stmt
),
1440 gimple_omp_parallel_data_arg (omp_par_stmt
));
1444 case GIMPLE_OMP_TASK
:
1445 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1446 copy
= gimple_build_omp_task
1448 gimple_omp_task_clauses (stmt
),
1449 gimple_omp_task_child_fn (stmt
),
1450 gimple_omp_task_data_arg (stmt
),
1451 gimple_omp_task_copy_fn (stmt
),
1452 gimple_omp_task_arg_size (stmt
),
1453 gimple_omp_task_arg_align (stmt
));
1456 case GIMPLE_OMP_FOR
:
1457 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1458 s2
= remap_gimple_seq (gimple_omp_for_pre_body (stmt
), id
);
1459 copy
= gimple_build_omp_for (s1
, gimple_omp_for_kind (stmt
),
1460 gimple_omp_for_clauses (stmt
),
1461 gimple_omp_for_collapse (stmt
), s2
);
1464 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1466 gimple_omp_for_set_index (copy
, i
,
1467 gimple_omp_for_index (stmt
, i
));
1468 gimple_omp_for_set_initial (copy
, i
,
1469 gimple_omp_for_initial (stmt
, i
));
1470 gimple_omp_for_set_final (copy
, i
,
1471 gimple_omp_for_final (stmt
, i
));
1472 gimple_omp_for_set_incr (copy
, i
,
1473 gimple_omp_for_incr (stmt
, i
));
1474 gimple_omp_for_set_cond (copy
, i
,
1475 gimple_omp_for_cond (stmt
, i
));
1480 case GIMPLE_OMP_MASTER
:
1481 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1482 copy
= gimple_build_omp_master (s1
);
1485 case GIMPLE_OMP_TASKGROUP
:
1486 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1487 copy
= gimple_build_omp_taskgroup (s1
);
1490 case GIMPLE_OMP_ORDERED
:
1491 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1492 copy
= gimple_build_omp_ordered (s1
);
1495 case GIMPLE_OMP_SECTION
:
1496 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1497 copy
= gimple_build_omp_section (s1
);
1500 case GIMPLE_OMP_SECTIONS
:
1501 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1502 copy
= gimple_build_omp_sections
1503 (s1
, gimple_omp_sections_clauses (stmt
));
1506 case GIMPLE_OMP_SINGLE
:
1507 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1508 copy
= gimple_build_omp_single
1509 (s1
, gimple_omp_single_clauses (stmt
));
1512 case GIMPLE_OMP_TARGET
:
1513 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1514 copy
= gimple_build_omp_target
1515 (s1
, gimple_omp_target_kind (stmt
),
1516 gimple_omp_target_clauses (stmt
));
1519 case GIMPLE_OMP_TEAMS
:
1520 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1521 copy
= gimple_build_omp_teams
1522 (s1
, gimple_omp_teams_clauses (stmt
));
1525 case GIMPLE_OMP_CRITICAL
:
1526 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1527 copy
= gimple_build_omp_critical (s1
,
1528 gimple_omp_critical_name (
1529 as_a
<gomp_critical
*> (stmt
)));
1532 case GIMPLE_TRANSACTION
:
1534 gtransaction
*old_trans_stmt
= as_a
<gtransaction
*> (stmt
);
1535 gtransaction
*new_trans_stmt
;
1536 s1
= remap_gimple_seq (gimple_transaction_body (old_trans_stmt
),
1538 copy
= new_trans_stmt
1539 = gimple_build_transaction (
1541 gimple_transaction_label (old_trans_stmt
));
1542 gimple_transaction_set_subcode (
1544 gimple_transaction_subcode (old_trans_stmt
));
1554 if (gimple_assign_copy_p (stmt
)
1555 && gimple_assign_lhs (stmt
) == gimple_assign_rhs1 (stmt
)
1556 && auto_var_in_fn_p (gimple_assign_lhs (stmt
), id
->src_fn
))
1558 /* Here we handle statements that are not completely rewritten.
1559 First we detect some inlining-induced bogosities for
1562 /* Some assignments VAR = VAR; don't generate any rtl code
1563 and thus don't count as variable modification. Avoid
1564 keeping bogosities like 0 = 0. */
1565 tree decl
= gimple_assign_lhs (stmt
), value
;
1568 n
= id
->decl_map
->get (decl
);
1572 STRIP_TYPE_NOPS (value
);
1573 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1578 /* For *ptr_N ={v} {CLOBBER}, if ptr_N is SSA_NAME defined
1579 in a block that we aren't copying during tree_function_versioning,
1580 just drop the clobber stmt. */
1581 if (id
->blocks_to_copy
&& gimple_clobber_p (stmt
))
1583 tree lhs
= gimple_assign_lhs (stmt
);
1584 if (TREE_CODE (lhs
) == MEM_REF
1585 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == SSA_NAME
)
1587 gimple def_stmt
= SSA_NAME_DEF_STMT (TREE_OPERAND (lhs
, 0));
1588 if (gimple_bb (def_stmt
)
1589 && !bitmap_bit_p (id
->blocks_to_copy
,
1590 gimple_bb (def_stmt
)->index
))
1595 if (gimple_debug_bind_p (stmt
))
1598 = gimple_build_debug_bind (gimple_debug_bind_get_var (stmt
),
1599 gimple_debug_bind_get_value (stmt
),
1601 id
->debug_stmts
.safe_push (copy
);
1602 gimple_seq_add_stmt (&stmts
, copy
);
1605 if (gimple_debug_source_bind_p (stmt
))
1607 gdebug
*copy
= gimple_build_debug_source_bind
1608 (gimple_debug_source_bind_get_var (stmt
),
1609 gimple_debug_source_bind_get_value (stmt
),
1611 id
->debug_stmts
.safe_push (copy
);
1612 gimple_seq_add_stmt (&stmts
, copy
);
1616 /* Create a new deep copy of the statement. */
1617 copy
= gimple_copy (stmt
);
1619 /* Clear flags that need revisiting. */
1620 if (gcall
*call_stmt
= dyn_cast
<gcall
*> (copy
))
1622 if (gimple_call_tail_p (call_stmt
))
1623 gimple_call_set_tail (call_stmt
, false);
1624 if (gimple_call_from_thunk_p (call_stmt
))
1625 gimple_call_set_from_thunk (call_stmt
, false);
1628 /* Remap the region numbers for __builtin_eh_{pointer,filter},
1629 RESX and EH_DISPATCH. */
1631 switch (gimple_code (copy
))
1635 tree r
, fndecl
= gimple_call_fndecl (copy
);
1636 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
1637 switch (DECL_FUNCTION_CODE (fndecl
))
1639 case BUILT_IN_EH_COPY_VALUES
:
1640 r
= gimple_call_arg (copy
, 1);
1641 r
= remap_eh_region_tree_nr (r
, id
);
1642 gimple_call_set_arg (copy
, 1, r
);
1645 case BUILT_IN_EH_POINTER
:
1646 case BUILT_IN_EH_FILTER
:
1647 r
= gimple_call_arg (copy
, 0);
1648 r
= remap_eh_region_tree_nr (r
, id
);
1649 gimple_call_set_arg (copy
, 0, r
);
1656 /* Reset alias info if we didn't apply measures to
1657 keep it valid over inlining by setting DECL_PT_UID. */
1658 if (!id
->src_cfun
->gimple_df
1659 || !id
->src_cfun
->gimple_df
->ipa_pta
)
1660 gimple_call_reset_alias_info (as_a
<gcall
*> (copy
));
1666 gresx
*resx_stmt
= as_a
<gresx
*> (copy
);
1667 int r
= gimple_resx_region (resx_stmt
);
1668 r
= remap_eh_region_nr (r
, id
);
1669 gimple_resx_set_region (resx_stmt
, r
);
1673 case GIMPLE_EH_DISPATCH
:
1675 geh_dispatch
*eh_dispatch
= as_a
<geh_dispatch
*> (copy
);
1676 int r
= gimple_eh_dispatch_region (eh_dispatch
);
1677 r
= remap_eh_region_nr (r
, id
);
1678 gimple_eh_dispatch_set_region (eh_dispatch
, r
);
1687 /* If STMT has a block defined, map it to the newly constructed
1689 if (gimple_block (copy
))
1692 n
= id
->decl_map
->get (gimple_block (copy
));
1694 gimple_set_block (copy
, *n
);
1697 if (gimple_debug_bind_p (copy
) || gimple_debug_source_bind_p (copy
))
1699 gimple_seq_add_stmt (&stmts
, copy
);
1703 /* Remap all the operands in COPY. */
1704 memset (&wi
, 0, sizeof (wi
));
1707 walk_tree (gimple_op_ptr (copy
, 1), remap_gimple_op_r
, &wi
, NULL
);
1709 walk_gimple_op (copy
, remap_gimple_op_r
, &wi
);
1711 /* Clear the copied virtual operands. We are not remapping them here
1712 but are going to recreate them from scratch. */
1713 if (gimple_has_mem_ops (copy
))
1715 gimple_set_vdef (copy
, NULL_TREE
);
1716 gimple_set_vuse (copy
, NULL_TREE
);
1719 gimple_seq_add_stmt (&stmts
, copy
);
1724 /* Copy basic block, scale profile accordingly. Edges will be taken care of
1728 copy_bb (copy_body_data
*id
, basic_block bb
, int frequency_scale
,
1729 gcov_type count_scale
)
1731 gimple_stmt_iterator gsi
, copy_gsi
, seq_gsi
;
1732 basic_block copy_basic_block
;
1737 /* Search for previous copied basic block. */
1740 prev
= prev
->prev_bb
;
1742 /* create_basic_block() will append every new block to
1743 basic_block_info automatically. */
1744 copy_basic_block
= create_basic_block (NULL
, (void *) 0,
1745 (basic_block
) prev
->aux
);
1746 copy_basic_block
->count
= apply_scale (bb
->count
, count_scale
);
1748 /* We are going to rebuild frequencies from scratch. These values
1749 have just small importance to drive canonicalize_loop_headers. */
1750 freq
= apply_scale ((gcov_type
)bb
->frequency
, frequency_scale
);
1752 /* We recompute frequencies after inlining, so this is quite safe. */
1753 if (freq
> BB_FREQ_MAX
)
1755 copy_basic_block
->frequency
= freq
;
1757 copy_gsi
= gsi_start_bb (copy_basic_block
);
1759 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1762 gimple stmt
= gsi_stmt (gsi
);
1763 gimple orig_stmt
= stmt
;
1764 gimple_stmt_iterator stmts_gsi
;
1765 bool stmt_added
= false;
1767 id
->regimplify
= false;
1768 stmts
= remap_gimple_stmt (stmt
, id
);
1770 if (gimple_seq_empty_p (stmts
))
1775 for (stmts_gsi
= gsi_start (stmts
);
1776 !gsi_end_p (stmts_gsi
); )
1778 stmt
= gsi_stmt (stmts_gsi
);
1780 /* Advance iterator now before stmt is moved to seq_gsi. */
1781 gsi_next (&stmts_gsi
);
1783 if (gimple_nop_p (stmt
))
1786 gimple_duplicate_stmt_histograms (cfun
, stmt
, id
->src_cfun
,
1789 /* With return slot optimization we can end up with
1790 non-gimple (foo *)&this->m, fix that here. */
1791 if (is_gimple_assign (stmt
)
1792 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
))
1793 && !is_gimple_val (gimple_assign_rhs1 (stmt
)))
1796 new_rhs
= force_gimple_operand_gsi (&seq_gsi
,
1797 gimple_assign_rhs1 (stmt
),
1799 GSI_CONTINUE_LINKING
);
1800 gimple_assign_set_rhs1 (stmt
, new_rhs
);
1801 id
->regimplify
= false;
1804 gsi_insert_after (&seq_gsi
, stmt
, GSI_NEW_STMT
);
1807 gimple_regimplify_operands (stmt
, &seq_gsi
);
1815 /* If copy_basic_block has been empty at the start of this iteration,
1816 call gsi_start_bb again to get at the newly added statements. */
1817 if (gsi_end_p (copy_gsi
))
1818 copy_gsi
= gsi_start_bb (copy_basic_block
);
1820 gsi_next (©_gsi
);
1822 /* Process the new statement. The call to gimple_regimplify_operands
1823 possibly turned the statement into multiple statements, we
1824 need to process all of them. */
1830 stmt
= gsi_stmt (copy_gsi
);
1831 call_stmt
= dyn_cast
<gcall
*> (stmt
);
1833 && gimple_call_va_arg_pack_p (call_stmt
)
1836 /* __builtin_va_arg_pack () should be replaced by
1837 all arguments corresponding to ... in the caller. */
1841 size_t nargs
= gimple_call_num_args (id
->call_stmt
);
1842 size_t n
, i
, nargs_to_copy
;
1843 bool remove_bounds
= false;
1845 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1848 /* Bounds should be removed from arg pack in case
1849 we handle not instrumented call in instrumented
1851 nargs_to_copy
= nargs
;
1852 if (gimple_call_with_bounds_p (id
->call_stmt
)
1853 && !gimple_call_with_bounds_p (stmt
))
1855 for (i
= gimple_call_num_args (id
->call_stmt
) - nargs
;
1856 i
< gimple_call_num_args (id
->call_stmt
);
1858 if (POINTER_BOUNDS_P (gimple_call_arg (id
->call_stmt
, i
)))
1860 remove_bounds
= true;
1863 /* Create the new array of arguments. */
1864 n
= nargs_to_copy
+ gimple_call_num_args (call_stmt
);
1865 argarray
.create (n
);
1866 argarray
.safe_grow_cleared (n
);
1868 /* Copy all the arguments before '...' */
1869 memcpy (argarray
.address (),
1870 gimple_call_arg_ptr (call_stmt
, 0),
1871 gimple_call_num_args (call_stmt
) * sizeof (tree
));
1875 /* Append the rest of arguments removing bounds. */
1876 unsigned cur
= gimple_call_num_args (call_stmt
);
1877 i
= gimple_call_num_args (id
->call_stmt
) - nargs
;
1878 for (i
= gimple_call_num_args (id
->call_stmt
) - nargs
;
1879 i
< gimple_call_num_args (id
->call_stmt
);
1881 if (!POINTER_BOUNDS_P (gimple_call_arg (id
->call_stmt
, i
)))
1882 argarray
[cur
++] = gimple_call_arg (id
->call_stmt
, i
);
1883 gcc_assert (cur
== n
);
1887 /* Append the arguments passed in '...' */
1888 memcpy (argarray
.address () + gimple_call_num_args (call_stmt
),
1889 gimple_call_arg_ptr (id
->call_stmt
, 0)
1890 + (gimple_call_num_args (id
->call_stmt
) - nargs
),
1891 nargs
* sizeof (tree
));
1894 new_call
= gimple_build_call_vec (gimple_call_fn (call_stmt
),
1897 argarray
.release ();
1899 /* Copy all GIMPLE_CALL flags, location and block, except
1900 GF_CALL_VA_ARG_PACK. */
1901 gimple_call_copy_flags (new_call
, call_stmt
);
1902 gimple_call_set_va_arg_pack (new_call
, false);
1903 gimple_set_location (new_call
, gimple_location (stmt
));
1904 gimple_set_block (new_call
, gimple_block (stmt
));
1905 gimple_call_set_lhs (new_call
, gimple_call_lhs (call_stmt
));
1907 gsi_replace (©_gsi
, new_call
, false);
1910 else if (is_gimple_call (stmt
)
1912 && (decl
= gimple_call_fndecl (stmt
))
1913 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
1914 && DECL_FUNCTION_CODE (decl
) == BUILT_IN_VA_ARG_PACK_LEN
)
1916 /* __builtin_va_arg_pack_len () should be replaced by
1917 the number of anonymous arguments. */
1918 size_t nargs
= gimple_call_num_args (id
->call_stmt
), i
;
1922 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1925 /* For instrumented calls we should ignore bounds. */
1926 for (i
= gimple_call_num_args (id
->call_stmt
) - nargs
;
1927 i
< gimple_call_num_args (id
->call_stmt
);
1929 if (POINTER_BOUNDS_P (gimple_call_arg (id
->call_stmt
, i
)))
1932 count
= build_int_cst (integer_type_node
, nargs
);
1933 new_stmt
= gimple_build_assign (gimple_call_lhs (stmt
), count
);
1934 gsi_replace (©_gsi
, new_stmt
, false);
1938 /* Statements produced by inlining can be unfolded, especially
1939 when we constant propagated some operands. We can't fold
1940 them right now for two reasons:
1941 1) folding require SSA_NAME_DEF_STMTs to be correct
1942 2) we can't change function calls to builtins.
1943 So we just mark statement for later folding. We mark
1944 all new statements, instead just statements that has changed
1945 by some nontrivial substitution so even statements made
1946 foldable indirectly are updated. If this turns out to be
1947 expensive, copy_body can be told to watch for nontrivial
1949 if (id
->statements_to_fold
)
1950 id
->statements_to_fold
->add (stmt
);
1952 /* We're duplicating a CALL_EXPR. Find any corresponding
1953 callgraph edges and update or duplicate them. */
1954 if (gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
))
1956 struct cgraph_edge
*edge
;
1958 switch (id
->transform_call_graph_edges
)
1960 case CB_CGE_DUPLICATE
:
1961 edge
= id
->src_node
->get_edge (orig_stmt
);
1964 int edge_freq
= edge
->frequency
;
1966 struct cgraph_edge
*old_edge
= edge
;
1967 edge
= edge
->clone (id
->dst_node
, call_stmt
,
1969 REG_BR_PROB_BASE
, CGRAPH_FREQ_BASE
,
1971 /* We could also just rescale the frequency, but
1972 doing so would introduce roundoff errors and make
1973 verifier unhappy. */
1974 new_freq
= compute_call_stmt_bb_frequency (id
->dst_node
->decl
,
1977 /* Speculative calls consist of two edges - direct and indirect.
1978 Duplicate the whole thing and distribute frequencies accordingly. */
1979 if (edge
->speculative
)
1981 struct cgraph_edge
*direct
, *indirect
;
1982 struct ipa_ref
*ref
;
1984 gcc_assert (!edge
->indirect_unknown_callee
);
1985 old_edge
->speculative_call_info (direct
, indirect
, ref
);
1986 indirect
= indirect
->clone (id
->dst_node
, call_stmt
,
1988 REG_BR_PROB_BASE
, CGRAPH_FREQ_BASE
,
1990 if (old_edge
->frequency
+ indirect
->frequency
)
1992 edge
->frequency
= MIN (RDIV ((gcov_type
)new_freq
* old_edge
->frequency
,
1993 (old_edge
->frequency
+ indirect
->frequency
)),
1995 indirect
->frequency
= MIN (RDIV ((gcov_type
)new_freq
* indirect
->frequency
,
1996 (old_edge
->frequency
+ indirect
->frequency
)),
1999 id
->dst_node
->clone_reference (ref
, stmt
);
2003 edge
->frequency
= new_freq
;
2005 && profile_status_for_fn (cfun
) != PROFILE_ABSENT
2006 && (edge_freq
> edge
->frequency
+ 10
2007 || edge_freq
< edge
->frequency
- 10))
2009 fprintf (dump_file
, "Edge frequency estimated by "
2010 "cgraph %i diverge from inliner's estimate %i\n",
2014 "Orig bb: %i, orig bb freq %i, new bb freq %i\n",
2017 copy_basic_block
->frequency
);
2023 case CB_CGE_MOVE_CLONES
:
2024 id
->dst_node
->set_call_stmt_including_clones (orig_stmt
,
2026 edge
= id
->dst_node
->get_edge (stmt
);
2030 edge
= id
->dst_node
->get_edge (orig_stmt
);
2032 edge
->set_call_stmt (call_stmt
);
2039 /* Constant propagation on argument done during inlining
2040 may create new direct call. Produce an edge for it. */
2042 || (edge
->indirect_inlining_edge
2043 && id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
))
2044 && id
->dst_node
->definition
2045 && (fn
= gimple_call_fndecl (stmt
)) != NULL
)
2047 struct cgraph_node
*dest
= cgraph_node::get (fn
);
2049 /* We have missing edge in the callgraph. This can happen
2050 when previous inlining turned an indirect call into a
2051 direct call by constant propagating arguments or we are
2052 producing dead clone (for further cloning). In all
2053 other cases we hit a bug (incorrect node sharing is the
2054 most common reason for missing edges). */
2055 gcc_assert (!dest
->definition
2056 || dest
->address_taken
2057 || !id
->src_node
->definition
2058 || !id
->dst_node
->definition
);
2059 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
)
2060 id
->dst_node
->create_edge_including_clones
2061 (dest
, orig_stmt
, call_stmt
, bb
->count
,
2062 compute_call_stmt_bb_frequency (id
->dst_node
->decl
,
2064 CIF_ORIGINALLY_INDIRECT_CALL
);
2066 id
->dst_node
->create_edge (dest
, call_stmt
,
2068 compute_call_stmt_bb_frequency
2069 (id
->dst_node
->decl
,
2070 copy_basic_block
))->inline_failed
2071 = CIF_ORIGINALLY_INDIRECT_CALL
;
2074 fprintf (dump_file
, "Created new direct edge to %s\n",
2079 notice_special_calls (as_a
<gcall
*> (stmt
));
2082 maybe_duplicate_eh_stmt_fn (cfun
, stmt
, id
->src_cfun
, orig_stmt
,
2083 id
->eh_map
, id
->eh_lp_nr
);
2085 if (gimple_in_ssa_p (cfun
) && !is_gimple_debug (stmt
))
2090 FOR_EACH_SSA_TREE_OPERAND (def
, stmt
, i
, SSA_OP_DEF
)
2091 if (TREE_CODE (def
) == SSA_NAME
)
2092 SSA_NAME_DEF_STMT (def
) = stmt
;
2095 gsi_next (©_gsi
);
2097 while (!gsi_end_p (copy_gsi
));
2099 copy_gsi
= gsi_last_bb (copy_basic_block
);
2102 return copy_basic_block
;
2105 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
2106 form is quite easy, since dominator relationship for old basic blocks does
2109 There is however exception where inlining might change dominator relation
2110 across EH edges from basic block within inlined functions destinating
2111 to landing pads in function we inline into.
2113 The function fills in PHI_RESULTs of such PHI nodes if they refer
2114 to gimple regs. Otherwise, the function mark PHI_RESULT of such
2115 PHI nodes for renaming. For non-gimple regs, renaming is safe: the
2116 EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
2117 set, and this means that there will be no overlapping live ranges
2118 for the underlying symbol.
2120 This might change in future if we allow redirecting of EH edges and
2121 we might want to change way build CFG pre-inlining to include
2122 all the possible edges then. */
2124 update_ssa_across_abnormal_edges (basic_block bb
, basic_block ret_bb
,
2125 bool can_throw
, bool nonlocal_goto
)
2130 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
2132 || ((basic_block
)e
->dest
->aux
)->index
== ENTRY_BLOCK
)
2138 gcc_assert (e
->flags
& EDGE_EH
);
2141 gcc_assert (!(e
->flags
& EDGE_EH
));
2143 for (si
= gsi_start_phis (e
->dest
); !gsi_end_p (si
); gsi_next (&si
))
2149 /* For abnormal goto/call edges the receiver can be the
2150 ENTRY_BLOCK. Do not assert this cannot happen. */
2152 gcc_assert ((e
->flags
& EDGE_EH
)
2153 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi
)));
2155 re
= find_edge (ret_bb
, e
->dest
);
2156 gcc_checking_assert (re
);
2157 gcc_assert ((re
->flags
& (EDGE_EH
| EDGE_ABNORMAL
))
2158 == (e
->flags
& (EDGE_EH
| EDGE_ABNORMAL
)));
2160 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, e
),
2161 USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, re
)));
2167 /* Copy edges from BB into its copy constructed earlier, scale profile
2168 accordingly. Edges will be taken care of later. Assume aux
2169 pointers to point to the copies of each BB. Return true if any
2170 debug stmts are left after a statement that must end the basic block. */
2173 copy_edges_for_bb (basic_block bb
, gcov_type count_scale
, basic_block ret_bb
,
2174 basic_block abnormal_goto_dest
)
2176 basic_block new_bb
= (basic_block
) bb
->aux
;
2179 gimple_stmt_iterator si
;
2181 bool need_debug_cleanup
= false;
2183 /* Use the indices from the original blocks to create edges for the
2185 FOR_EACH_EDGE (old_edge
, ei
, bb
->succs
)
2186 if (!(old_edge
->flags
& EDGE_EH
))
2190 flags
= old_edge
->flags
;
2192 /* Return edges do get a FALLTHRU flag when the get inlined. */
2193 if (old_edge
->dest
->index
== EXIT_BLOCK
2194 && !(old_edge
->flags
& (EDGE_TRUE_VALUE
|EDGE_FALSE_VALUE
|EDGE_FAKE
))
2195 && old_edge
->dest
->aux
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
2196 flags
|= EDGE_FALLTHRU
;
2197 new_edge
= make_edge (new_bb
, (basic_block
) old_edge
->dest
->aux
, flags
);
2198 new_edge
->count
= apply_scale (old_edge
->count
, count_scale
);
2199 new_edge
->probability
= old_edge
->probability
;
2202 if (bb
->index
== ENTRY_BLOCK
|| bb
->index
== EXIT_BLOCK
)
2205 for (si
= gsi_start_bb (new_bb
); !gsi_end_p (si
);)
2208 bool can_throw
, nonlocal_goto
;
2210 copy_stmt
= gsi_stmt (si
);
2211 if (!is_gimple_debug (copy_stmt
))
2212 update_stmt (copy_stmt
);
2214 /* Do this before the possible split_block. */
2217 /* If this tree could throw an exception, there are two
2218 cases where we need to add abnormal edge(s): the
2219 tree wasn't in a region and there is a "current
2220 region" in the caller; or the original tree had
2221 EH edges. In both cases split the block after the tree,
2222 and add abnormal edge(s) as needed; we need both
2223 those from the callee and the caller.
2224 We check whether the copy can throw, because the const
2225 propagation can change an INDIRECT_REF which throws
2226 into a COMPONENT_REF which doesn't. If the copy
2227 can throw, the original could also throw. */
2228 can_throw
= stmt_can_throw_internal (copy_stmt
);
2230 = (stmt_can_make_abnormal_goto (copy_stmt
)
2231 && !computed_goto_p (copy_stmt
));
2233 if (can_throw
|| nonlocal_goto
)
2235 if (!gsi_end_p (si
))
2237 while (!gsi_end_p (si
) && is_gimple_debug (gsi_stmt (si
)))
2240 need_debug_cleanup
= true;
2242 if (!gsi_end_p (si
))
2243 /* Note that bb's predecessor edges aren't necessarily
2244 right at this point; split_block doesn't care. */
2246 edge e
= split_block (new_bb
, copy_stmt
);
2249 new_bb
->aux
= e
->src
->aux
;
2250 si
= gsi_start_bb (new_bb
);
2254 if (gimple_code (copy_stmt
) == GIMPLE_EH_DISPATCH
)
2255 make_eh_dispatch_edges (as_a
<geh_dispatch
*> (copy_stmt
));
2257 make_eh_edges (copy_stmt
);
2259 /* If the call we inline cannot make abnormal goto do not add
2260 additional abnormal edges but only retain those already present
2261 in the original function body. */
2262 if (abnormal_goto_dest
== NULL
)
2263 nonlocal_goto
= false;
2266 basic_block copy_stmt_bb
= gimple_bb (copy_stmt
);
2268 if (get_abnormal_succ_dispatcher (copy_stmt_bb
))
2269 nonlocal_goto
= false;
2270 /* ABNORMAL_DISPATCHER (1) is for longjmp/setjmp or nonlocal gotos
2271 in OpenMP regions which aren't allowed to be left abnormally.
2272 So, no need to add abnormal edge in that case. */
2273 else if (is_gimple_call (copy_stmt
)
2274 && gimple_call_internal_p (copy_stmt
)
2275 && (gimple_call_internal_fn (copy_stmt
)
2276 == IFN_ABNORMAL_DISPATCHER
)
2277 && gimple_call_arg (copy_stmt
, 0) == boolean_true_node
)
2278 nonlocal_goto
= false;
2280 make_edge (copy_stmt_bb
, abnormal_goto_dest
, EDGE_ABNORMAL
);
2283 if ((can_throw
|| nonlocal_goto
)
2284 && gimple_in_ssa_p (cfun
))
2285 update_ssa_across_abnormal_edges (gimple_bb (copy_stmt
), ret_bb
,
2286 can_throw
, nonlocal_goto
);
2288 return need_debug_cleanup
;
2291 /* Copy the PHIs. All blocks and edges are copied, some blocks
2292 was possibly split and new outgoing EH edges inserted.
2293 BB points to the block of original function and AUX pointers links
2294 the original and newly copied blocks. */
2297 copy_phis_for_bb (basic_block bb
, copy_body_data
*id
)
2299 basic_block
const new_bb
= (basic_block
) bb
->aux
;
2304 bool inserted
= false;
2306 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
2312 res
= PHI_RESULT (phi
);
2314 if (!virtual_operand_p (res
))
2316 walk_tree (&new_res
, copy_tree_body_r
, id
, NULL
);
2317 new_phi
= create_phi_node (new_res
, new_bb
);
2318 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2320 edge old_edge
= find_edge ((basic_block
) new_edge
->src
->aux
, bb
);
2326 /* When doing partial cloning, we allow PHIs on the entry block
2327 as long as all the arguments are the same. Find any input
2328 edge to see argument to copy. */
2330 FOR_EACH_EDGE (old_edge
, ei2
, bb
->preds
)
2331 if (!old_edge
->src
->aux
)
2334 arg
= PHI_ARG_DEF_FROM_EDGE (phi
, old_edge
);
2336 walk_tree (&new_arg
, copy_tree_body_r
, id
, NULL
);
2337 gcc_assert (new_arg
);
2338 /* With return slot optimization we can end up with
2339 non-gimple (foo *)&this->m, fix that here. */
2340 if (TREE_CODE (new_arg
) != SSA_NAME
2341 && TREE_CODE (new_arg
) != FUNCTION_DECL
2342 && !is_gimple_val (new_arg
))
2344 gimple_seq stmts
= NULL
;
2345 new_arg
= force_gimple_operand (new_arg
, &stmts
, true, NULL
);
2346 gsi_insert_seq_on_edge (new_edge
, stmts
);
2349 locus
= gimple_phi_arg_location_from_edge (phi
, old_edge
);
2350 if (LOCATION_BLOCK (locus
))
2353 n
= id
->decl_map
->get (LOCATION_BLOCK (locus
));
2356 locus
= COMBINE_LOCATION_DATA (line_table
, locus
, *n
);
2358 locus
= LOCATION_LOCUS (locus
);
2361 locus
= LOCATION_LOCUS (locus
);
2363 add_phi_arg (new_phi
, new_arg
, new_edge
, locus
);
2368 /* Commit the delayed edge insertions. */
2370 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2371 gsi_commit_one_edge_insert (new_edge
, NULL
);
2375 /* Wrapper for remap_decl so it can be used as a callback. */
2378 remap_decl_1 (tree decl
, void *data
)
2380 return remap_decl (decl
, (copy_body_data
*) data
);
2383 /* Build struct function and associated datastructures for the new clone
2384 NEW_FNDECL to be build. CALLEE_FNDECL is the original. Function changes
2385 the cfun to the function of new_fndecl (and current_function_decl too). */
2388 initialize_cfun (tree new_fndecl
, tree callee_fndecl
, gcov_type count
)
2390 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2391 gcov_type count_scale
;
2393 if (!DECL_ARGUMENTS (new_fndecl
))
2394 DECL_ARGUMENTS (new_fndecl
) = DECL_ARGUMENTS (callee_fndecl
);
2395 if (!DECL_RESULT (new_fndecl
))
2396 DECL_RESULT (new_fndecl
) = DECL_RESULT (callee_fndecl
);
2398 if (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
)
2400 = GCOV_COMPUTE_SCALE (count
,
2401 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
);
2403 count_scale
= REG_BR_PROB_BASE
;
2405 /* Register specific tree functions. */
2406 gimple_register_cfg_hooks ();
2408 /* Get clean struct function. */
2409 push_struct_function (new_fndecl
);
2411 /* We will rebuild these, so just sanity check that they are empty. */
2412 gcc_assert (VALUE_HISTOGRAMS (cfun
) == NULL
);
2413 gcc_assert (cfun
->local_decls
== NULL
);
2414 gcc_assert (cfun
->cfg
== NULL
);
2415 gcc_assert (cfun
->decl
== new_fndecl
);
2417 /* Copy items we preserve during cloning. */
2418 cfun
->static_chain_decl
= src_cfun
->static_chain_decl
;
2419 cfun
->nonlocal_goto_save_area
= src_cfun
->nonlocal_goto_save_area
;
2420 cfun
->function_end_locus
= src_cfun
->function_end_locus
;
2421 cfun
->curr_properties
= src_cfun
->curr_properties
;
2422 cfun
->last_verified
= src_cfun
->last_verified
;
2423 cfun
->va_list_gpr_size
= src_cfun
->va_list_gpr_size
;
2424 cfun
->va_list_fpr_size
= src_cfun
->va_list_fpr_size
;
2425 cfun
->has_nonlocal_label
= src_cfun
->has_nonlocal_label
;
2426 cfun
->stdarg
= src_cfun
->stdarg
;
2427 cfun
->after_inlining
= src_cfun
->after_inlining
;
2428 cfun
->can_throw_non_call_exceptions
2429 = src_cfun
->can_throw_non_call_exceptions
;
2430 cfun
->can_delete_dead_exceptions
= src_cfun
->can_delete_dead_exceptions
;
2431 cfun
->returns_struct
= src_cfun
->returns_struct
;
2432 cfun
->returns_pcc_struct
= src_cfun
->returns_pcc_struct
;
2434 init_empty_tree_cfg ();
2436 profile_status_for_fn (cfun
) = profile_status_for_fn (src_cfun
);
2437 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
=
2438 (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
* count_scale
/
2440 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
2441 = ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->frequency
;
2442 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
=
2443 (EXIT_BLOCK_PTR_FOR_FN (src_cfun
)->count
* count_scale
/
2445 EXIT_BLOCK_PTR_FOR_FN (cfun
)->frequency
=
2446 EXIT_BLOCK_PTR_FOR_FN (src_cfun
)->frequency
;
2448 init_eh_for_function ();
2450 if (src_cfun
->gimple_df
)
2452 init_tree_ssa (cfun
);
2453 cfun
->gimple_df
->in_ssa_p
= true;
2454 init_ssa_operands (cfun
);
2458 /* Helper function for copy_cfg_body. Move debug stmts from the end
2459 of NEW_BB to the beginning of successor basic blocks when needed. If the
2460 successor has multiple predecessors, reset them, otherwise keep
2464 maybe_move_debug_stmts_to_successors (copy_body_data
*id
, basic_block new_bb
)
2468 gimple_stmt_iterator si
= gsi_last_nondebug_bb (new_bb
);
2471 || gsi_one_before_end_p (si
)
2472 || !(stmt_can_throw_internal (gsi_stmt (si
))
2473 || stmt_can_make_abnormal_goto (gsi_stmt (si
))))
2476 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
2478 gimple_stmt_iterator ssi
= gsi_last_bb (new_bb
);
2479 gimple_stmt_iterator dsi
= gsi_after_labels (e
->dest
);
2480 while (is_gimple_debug (gsi_stmt (ssi
)))
2482 gimple stmt
= gsi_stmt (ssi
);
2487 /* For the last edge move the debug stmts instead of copying
2489 if (ei_one_before_end_p (ei
))
2493 if (!single_pred_p (e
->dest
) && gimple_debug_bind_p (stmt
))
2494 gimple_debug_bind_reset_value (stmt
);
2495 gsi_remove (&si
, false);
2496 gsi_insert_before (&dsi
, stmt
, GSI_SAME_STMT
);
2500 if (gimple_debug_bind_p (stmt
))
2502 var
= gimple_debug_bind_get_var (stmt
);
2503 if (single_pred_p (e
->dest
))
2505 value
= gimple_debug_bind_get_value (stmt
);
2506 value
= unshare_expr (value
);
2510 new_stmt
= gimple_build_debug_bind (var
, value
, stmt
);
2512 else if (gimple_debug_source_bind_p (stmt
))
2514 var
= gimple_debug_source_bind_get_var (stmt
);
2515 value
= gimple_debug_source_bind_get_value (stmt
);
2516 new_stmt
= gimple_build_debug_source_bind (var
, value
, stmt
);
2520 gsi_insert_before (&dsi
, new_stmt
, GSI_SAME_STMT
);
2521 id
->debug_stmts
.safe_push (new_stmt
);
2527 /* Make a copy of the sub-loops of SRC_PARENT and place them
2528 as siblings of DEST_PARENT. */
2531 copy_loops (copy_body_data
*id
,
2532 struct loop
*dest_parent
, struct loop
*src_parent
)
2534 struct loop
*src_loop
= src_parent
->inner
;
2537 if (!id
->blocks_to_copy
2538 || bitmap_bit_p (id
->blocks_to_copy
, src_loop
->header
->index
))
2540 struct loop
*dest_loop
= alloc_loop ();
2542 /* Assign the new loop its header and latch and associate
2543 those with the new loop. */
2544 dest_loop
->header
= (basic_block
)src_loop
->header
->aux
;
2545 dest_loop
->header
->loop_father
= dest_loop
;
2546 if (src_loop
->latch
!= NULL
)
2548 dest_loop
->latch
= (basic_block
)src_loop
->latch
->aux
;
2549 dest_loop
->latch
->loop_father
= dest_loop
;
2552 /* Copy loop meta-data. */
2553 copy_loop_info (src_loop
, dest_loop
);
2555 /* Finally place it into the loop array and the loop tree. */
2556 place_new_loop (cfun
, dest_loop
);
2557 flow_loop_tree_node_add (dest_parent
, dest_loop
);
2559 dest_loop
->safelen
= src_loop
->safelen
;
2560 dest_loop
->dont_vectorize
= src_loop
->dont_vectorize
;
2561 if (src_loop
->force_vectorize
)
2563 dest_loop
->force_vectorize
= true;
2564 cfun
->has_force_vectorize_loops
= true;
2566 if (src_loop
->simduid
)
2568 dest_loop
->simduid
= remap_decl (src_loop
->simduid
, id
);
2569 cfun
->has_simduid_loops
= true;
2573 copy_loops (id
, dest_loop
, src_loop
);
2575 src_loop
= src_loop
->next
;
2579 /* Call cgraph_redirect_edge_call_stmt_to_callee on all calls in BB */
2582 redirect_all_calls (copy_body_data
* id
, basic_block bb
)
2584 gimple_stmt_iterator si
;
2585 gimple last
= last_stmt (bb
);
2586 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
2588 gimple stmt
= gsi_stmt (si
);
2589 if (is_gimple_call (stmt
))
2591 struct cgraph_edge
*edge
= id
->dst_node
->get_edge (stmt
);
2594 edge
->redirect_call_stmt_to_callee ();
2595 if (stmt
== last
&& id
->call_stmt
&& maybe_clean_eh_stmt (stmt
))
2596 gimple_purge_dead_eh_edges (bb
);
2602 /* Convert estimated frequencies into counts for NODE, scaling COUNT
2603 with each bb's frequency. Used when NODE has a 0-weight entry
2604 but we are about to inline it into a non-zero count call bb.
2605 See the comments for handle_missing_profiles() in predict.c for
2606 when this can happen for COMDATs. */
2609 freqs_to_counts (struct cgraph_node
*node
, gcov_type count
)
2614 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
2616 FOR_ALL_BB_FN(bb
, fn
)
2618 bb
->count
= apply_scale (count
,
2619 GCOV_COMPUTE_SCALE (bb
->frequency
, BB_FREQ_MAX
));
2620 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
2621 e
->count
= apply_probability (e
->src
->count
, e
->probability
);
2625 /* Make a copy of the body of FN so that it can be inserted inline in
2626 another function. Walks FN via CFG, returns new fndecl. */
2629 copy_cfg_body (copy_body_data
* id
, gcov_type count
, int frequency_scale
,
2630 basic_block entry_block_map
, basic_block exit_block_map
,
2631 basic_block new_entry
)
2633 tree callee_fndecl
= id
->src_fn
;
2634 /* Original cfun for the callee, doesn't change. */
2635 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2636 struct function
*cfun_to_copy
;
2638 tree new_fndecl
= NULL
;
2639 bool need_debug_cleanup
= false;
2640 gcov_type count_scale
;
2642 int incoming_frequency
= 0;
2643 gcov_type incoming_count
= 0;
2645 /* This can happen for COMDAT routines that end up with 0 counts
2646 despite being called (see the comments for handle_missing_profiles()
2647 in predict.c as to why). Apply counts to the blocks in the callee
2648 before inlining, using the guessed edge frequencies, so that we don't
2649 end up with a 0-count inline body which can confuse downstream
2650 optimizations such as function splitting. */
2651 if (!ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
&& count
)
2653 /* Apply the larger of the call bb count and the total incoming
2654 call edge count to the callee. */
2655 gcov_type in_count
= 0;
2656 struct cgraph_edge
*in_edge
;
2657 for (in_edge
= id
->src_node
->callers
; in_edge
;
2658 in_edge
= in_edge
->next_caller
)
2659 in_count
+= in_edge
->count
;
2660 freqs_to_counts (id
->src_node
, count
> in_count
? count
: in_count
);
2663 if (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
)
2665 = GCOV_COMPUTE_SCALE (count
,
2666 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
);
2668 count_scale
= REG_BR_PROB_BASE
;
2670 /* Register specific tree functions. */
2671 gimple_register_cfg_hooks ();
2673 /* If we are inlining just region of the function, make sure to connect
2674 new entry to ENTRY_BLOCK_PTR_FOR_FN (cfun). Since new entry can be
2675 part of loop, we must compute frequency and probability of
2676 ENTRY_BLOCK_PTR_FOR_FN (cfun) based on the frequencies and
2677 probabilities of edges incoming from nonduplicated region. */
2683 FOR_EACH_EDGE (e
, ei
, new_entry
->preds
)
2686 incoming_frequency
+= EDGE_FREQUENCY (e
);
2687 incoming_count
+= e
->count
;
2689 incoming_count
= apply_scale (incoming_count
, count_scale
);
2691 = apply_scale ((gcov_type
)incoming_frequency
, frequency_scale
);
2692 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= incoming_count
;
2693 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
= incoming_frequency
;
2696 /* Must have a CFG here at this point. */
2697 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN
2698 (DECL_STRUCT_FUNCTION (callee_fndecl
)));
2700 cfun_to_copy
= id
->src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2702 ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy
)->aux
= entry_block_map
;
2703 EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy
)->aux
= exit_block_map
;
2704 entry_block_map
->aux
= ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy
);
2705 exit_block_map
->aux
= EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy
);
2707 /* Duplicate any exception-handling regions. */
2709 id
->eh_map
= duplicate_eh_regions (cfun_to_copy
, NULL
, id
->eh_lp_nr
,
2712 /* Use aux pointers to map the original blocks to copy. */
2713 FOR_EACH_BB_FN (bb
, cfun_to_copy
)
2714 if (!id
->blocks_to_copy
|| bitmap_bit_p (id
->blocks_to_copy
, bb
->index
))
2716 basic_block new_bb
= copy_bb (id
, bb
, frequency_scale
, count_scale
);
2719 new_bb
->loop_father
= entry_block_map
->loop_father
;
2722 last
= last_basic_block_for_fn (cfun
);
2724 /* Now that we've duplicated the blocks, duplicate their edges. */
2725 basic_block abnormal_goto_dest
= NULL
;
2727 && stmt_can_make_abnormal_goto (id
->call_stmt
))
2729 gimple_stmt_iterator gsi
= gsi_for_stmt (id
->call_stmt
);
2731 bb
= gimple_bb (id
->call_stmt
);
2733 if (gsi_end_p (gsi
))
2734 abnormal_goto_dest
= get_abnormal_succ_dispatcher (bb
);
2736 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2737 if (!id
->blocks_to_copy
2738 || (bb
->index
> 0 && bitmap_bit_p (id
->blocks_to_copy
, bb
->index
)))
2739 need_debug_cleanup
|= copy_edges_for_bb (bb
, count_scale
, exit_block_map
,
2740 abnormal_goto_dest
);
2744 edge e
= make_edge (entry_block_map
, (basic_block
)new_entry
->aux
, EDGE_FALLTHRU
);
2745 e
->probability
= REG_BR_PROB_BASE
;
2746 e
->count
= incoming_count
;
2749 /* Duplicate the loop tree, if available and wanted. */
2750 if (loops_for_fn (src_cfun
) != NULL
2751 && current_loops
!= NULL
)
2753 copy_loops (id
, entry_block_map
->loop_father
,
2754 get_loop (src_cfun
, 0));
2755 /* Defer to cfgcleanup to update loop-father fields of basic-blocks. */
2756 loops_state_set (LOOPS_NEED_FIXUP
);
2759 /* If the loop tree in the source function needed fixup, mark the
2760 destination loop tree for fixup, too. */
2761 if (loops_for_fn (src_cfun
)->state
& LOOPS_NEED_FIXUP
)
2762 loops_state_set (LOOPS_NEED_FIXUP
);
2764 if (gimple_in_ssa_p (cfun
))
2765 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2766 if (!id
->blocks_to_copy
2767 || (bb
->index
> 0 && bitmap_bit_p (id
->blocks_to_copy
, bb
->index
)))
2768 copy_phis_for_bb (bb
, id
);
2770 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2773 if (need_debug_cleanup
2774 && bb
->index
!= ENTRY_BLOCK
2775 && bb
->index
!= EXIT_BLOCK
)
2776 maybe_move_debug_stmts_to_successors (id
, (basic_block
) bb
->aux
);
2777 /* Update call edge destinations. This can not be done before loop
2778 info is updated, because we may split basic blocks. */
2779 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
)
2780 redirect_all_calls (id
, (basic_block
)bb
->aux
);
2781 ((basic_block
)bb
->aux
)->aux
= NULL
;
2785 /* Zero out AUX fields of newly created block during EH edge
2787 for (; last
< last_basic_block_for_fn (cfun
); last
++)
2789 if (need_debug_cleanup
)
2790 maybe_move_debug_stmts_to_successors (id
,
2791 BASIC_BLOCK_FOR_FN (cfun
, last
));
2792 BASIC_BLOCK_FOR_FN (cfun
, last
)->aux
= NULL
;
2793 /* Update call edge destinations. This can not be done before loop
2794 info is updated, because we may split basic blocks. */
2795 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
)
2796 redirect_all_calls (id
, BASIC_BLOCK_FOR_FN (cfun
, last
));
2798 entry_block_map
->aux
= NULL
;
2799 exit_block_map
->aux
= NULL
;
2806 if (id
->dependence_map
)
2808 delete id
->dependence_map
;
2809 id
->dependence_map
= NULL
;
2815 /* Copy the debug STMT using ID. We deal with these statements in a
2816 special way: if any variable in their VALUE expression wasn't
2817 remapped yet, we won't remap it, because that would get decl uids
2818 out of sync, causing codegen differences between -g and -g0. If
2819 this arises, we drop the VALUE expression altogether. */
2822 copy_debug_stmt (gdebug
*stmt
, copy_body_data
*id
)
2825 struct walk_stmt_info wi
;
2827 if (gimple_block (stmt
))
2829 n
= id
->decl_map
->get (gimple_block (stmt
));
2830 gimple_set_block (stmt
, n
? *n
: id
->block
);
2833 /* Remap all the operands in COPY. */
2834 memset (&wi
, 0, sizeof (wi
));
2837 processing_debug_stmt
= 1;
2839 if (gimple_debug_source_bind_p (stmt
))
2840 t
= gimple_debug_source_bind_get_var (stmt
);
2842 t
= gimple_debug_bind_get_var (stmt
);
2844 if (TREE_CODE (t
) == PARM_DECL
&& id
->debug_map
2845 && (n
= id
->debug_map
->get (t
)))
2847 gcc_assert (TREE_CODE (*n
) == VAR_DECL
);
2850 else if (TREE_CODE (t
) == VAR_DECL
2851 && !is_global_var (t
)
2852 && !id
->decl_map
->get (t
))
2853 /* T is a non-localized variable. */;
2855 walk_tree (&t
, remap_gimple_op_r
, &wi
, NULL
);
2857 if (gimple_debug_bind_p (stmt
))
2859 gimple_debug_bind_set_var (stmt
, t
);
2861 if (gimple_debug_bind_has_value_p (stmt
))
2862 walk_tree (gimple_debug_bind_get_value_ptr (stmt
),
2863 remap_gimple_op_r
, &wi
, NULL
);
2865 /* Punt if any decl couldn't be remapped. */
2866 if (processing_debug_stmt
< 0)
2867 gimple_debug_bind_reset_value (stmt
);
2869 else if (gimple_debug_source_bind_p (stmt
))
2871 gimple_debug_source_bind_set_var (stmt
, t
);
2872 walk_tree (gimple_debug_source_bind_get_value_ptr (stmt
),
2873 remap_gimple_op_r
, &wi
, NULL
);
2874 /* When inlining and source bind refers to one of the optimized
2875 away parameters, change the source bind into normal debug bind
2876 referring to the corresponding DEBUG_EXPR_DECL that should have
2877 been bound before the call stmt. */
2878 t
= gimple_debug_source_bind_get_value (stmt
);
2880 && TREE_CODE (t
) == PARM_DECL
2883 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (id
->src_fn
);
2885 if (debug_args
!= NULL
)
2887 for (i
= 0; i
< vec_safe_length (*debug_args
); i
+= 2)
2888 if ((**debug_args
)[i
] == DECL_ORIGIN (t
)
2889 && TREE_CODE ((**debug_args
)[i
+ 1]) == DEBUG_EXPR_DECL
)
2891 t
= (**debug_args
)[i
+ 1];
2892 stmt
->subcode
= GIMPLE_DEBUG_BIND
;
2893 gimple_debug_bind_set_value (stmt
, t
);
2900 processing_debug_stmt
= 0;
2905 /* Process deferred debug stmts. In order to give values better odds
2906 of being successfully remapped, we delay the processing of debug
2907 stmts until all other stmts that might require remapping are
2911 copy_debug_stmts (copy_body_data
*id
)
2916 if (!id
->debug_stmts
.exists ())
2919 FOR_EACH_VEC_ELT (id
->debug_stmts
, i
, stmt
)
2920 copy_debug_stmt (stmt
, id
);
2922 id
->debug_stmts
.release ();
2925 /* Make a copy of the body of SRC_FN so that it can be inserted inline in
2926 another function. */
2929 copy_tree_body (copy_body_data
*id
)
2931 tree fndecl
= id
->src_fn
;
2932 tree body
= DECL_SAVED_TREE (fndecl
);
2934 walk_tree (&body
, copy_tree_body_r
, id
, NULL
);
2939 /* Make a copy of the body of FN so that it can be inserted inline in
2940 another function. */
2943 copy_body (copy_body_data
*id
, gcov_type count
, int frequency_scale
,
2944 basic_block entry_block_map
, basic_block exit_block_map
,
2945 basic_block new_entry
)
2947 tree fndecl
= id
->src_fn
;
2950 /* If this body has a CFG, walk CFG and copy. */
2951 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (fndecl
)));
2952 body
= copy_cfg_body (id
, count
, frequency_scale
, entry_block_map
, exit_block_map
,
2954 copy_debug_stmts (id
);
2959 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
2960 defined in function FN, or of a data member thereof. */
2963 self_inlining_addr_expr (tree value
, tree fn
)
2967 if (TREE_CODE (value
) != ADDR_EXPR
)
2970 var
= get_base_address (TREE_OPERAND (value
, 0));
2972 return var
&& auto_var_in_fn_p (var
, fn
);
2975 /* Append to BB a debug annotation that binds VAR to VALUE, inheriting
2976 lexical block and line number information from base_stmt, if given,
2977 or from the last stmt of the block otherwise. */
2980 insert_init_debug_bind (copy_body_data
*id
,
2981 basic_block bb
, tree var
, tree value
,
2985 gimple_stmt_iterator gsi
;
2988 if (!gimple_in_ssa_p (id
->src_cfun
))
2991 if (!MAY_HAVE_DEBUG_STMTS
)
2994 tracked_var
= target_for_debug_bind (var
);
3000 gsi
= gsi_last_bb (bb
);
3001 if (!base_stmt
&& !gsi_end_p (gsi
))
3002 base_stmt
= gsi_stmt (gsi
);
3005 note
= gimple_build_debug_bind (tracked_var
, value
, base_stmt
);
3009 if (!gsi_end_p (gsi
))
3010 gsi_insert_after (&gsi
, note
, GSI_SAME_STMT
);
3012 gsi_insert_before (&gsi
, note
, GSI_SAME_STMT
);
3019 insert_init_stmt (copy_body_data
*id
, basic_block bb
, gimple init_stmt
)
3021 /* If VAR represents a zero-sized variable, it's possible that the
3022 assignment statement may result in no gimple statements. */
3025 gimple_stmt_iterator si
= gsi_last_bb (bb
);
3027 /* We can end up with init statements that store to a non-register
3028 from a rhs with a conversion. Handle that here by forcing the
3029 rhs into a temporary. gimple_regimplify_operands is not
3030 prepared to do this for us. */
3031 if (!is_gimple_debug (init_stmt
)
3032 && !is_gimple_reg (gimple_assign_lhs (init_stmt
))
3033 && is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (init_stmt
)))
3034 && gimple_assign_rhs_class (init_stmt
) == GIMPLE_UNARY_RHS
)
3036 tree rhs
= build1 (gimple_assign_rhs_code (init_stmt
),
3037 gimple_expr_type (init_stmt
),
3038 gimple_assign_rhs1 (init_stmt
));
3039 rhs
= force_gimple_operand_gsi (&si
, rhs
, true, NULL_TREE
, false,
3041 gimple_assign_set_rhs_code (init_stmt
, TREE_CODE (rhs
));
3042 gimple_assign_set_rhs1 (init_stmt
, rhs
);
3044 gsi_insert_after (&si
, init_stmt
, GSI_NEW_STMT
);
3045 gimple_regimplify_operands (init_stmt
, &si
);
3047 if (!is_gimple_debug (init_stmt
) && MAY_HAVE_DEBUG_STMTS
)
3049 tree def
= gimple_assign_lhs (init_stmt
);
3050 insert_init_debug_bind (id
, bb
, def
, def
, init_stmt
);
3055 /* Initialize parameter P with VALUE. If needed, produce init statement
3056 at the end of BB. When BB is NULL, we return init statement to be
3059 setup_one_parameter (copy_body_data
*id
, tree p
, tree value
, tree fn
,
3060 basic_block bb
, tree
*vars
)
3062 gimple init_stmt
= NULL
;
3065 tree def
= (gimple_in_ssa_p (cfun
)
3066 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
3069 && value
!= error_mark_node
3070 && !useless_type_conversion_p (TREE_TYPE (p
), TREE_TYPE (value
)))
3072 /* If we can match up types by promotion/demotion do so. */
3073 if (fold_convertible_p (TREE_TYPE (p
), value
))
3074 rhs
= fold_convert (TREE_TYPE (p
), value
);
3077 /* ??? For valid programs we should not end up here.
3078 Still if we end up with truly mismatched types here, fall back
3079 to using a VIEW_CONVERT_EXPR or a literal zero to not leak invalid
3080 GIMPLE to the following passes. */
3081 if (!is_gimple_reg_type (TREE_TYPE (value
))
3082 || TYPE_SIZE (TREE_TYPE (p
)) == TYPE_SIZE (TREE_TYPE (value
)))
3083 rhs
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (p
), value
);
3085 rhs
= build_zero_cst (TREE_TYPE (p
));
3089 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
3090 here since the type of this decl must be visible to the calling
3092 var
= copy_decl_to_var (p
, id
);
3094 /* Declare this new variable. */
3095 DECL_CHAIN (var
) = *vars
;
3098 /* Make gimplifier happy about this variable. */
3099 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
3101 /* If the parameter is never assigned to, has no SSA_NAMEs created,
3102 we would not need to create a new variable here at all, if it
3103 weren't for debug info. Still, we can just use the argument
3105 if (TREE_READONLY (p
)
3106 && !TREE_ADDRESSABLE (p
)
3107 && value
&& !TREE_SIDE_EFFECTS (value
)
3110 /* We may produce non-gimple trees by adding NOPs or introduce
3111 invalid sharing when operand is not really constant.
3112 It is not big deal to prohibit constant propagation here as
3113 we will constant propagate in DOM1 pass anyway. */
3114 if (is_gimple_min_invariant (value
)
3115 && useless_type_conversion_p (TREE_TYPE (p
),
3117 /* We have to be very careful about ADDR_EXPR. Make sure
3118 the base variable isn't a local variable of the inlined
3119 function, e.g., when doing recursive inlining, direct or
3120 mutually-recursive or whatever, which is why we don't
3121 just test whether fn == current_function_decl. */
3122 && ! self_inlining_addr_expr (value
, fn
))
3124 insert_decl_map (id
, p
, value
);
3125 insert_debug_decl_map (id
, p
, var
);
3126 return insert_init_debug_bind (id
, bb
, var
, value
, NULL
);
3130 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
3131 that way, when the PARM_DECL is encountered, it will be
3132 automatically replaced by the VAR_DECL. */
3133 insert_decl_map (id
, p
, var
);
3135 /* Even if P was TREE_READONLY, the new VAR should not be.
3136 In the original code, we would have constructed a
3137 temporary, and then the function body would have never
3138 changed the value of P. However, now, we will be
3139 constructing VAR directly. The constructor body may
3140 change its value multiple times as it is being
3141 constructed. Therefore, it must not be TREE_READONLY;
3142 the back-end assumes that TREE_READONLY variable is
3143 assigned to only once. */
3144 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p
)))
3145 TREE_READONLY (var
) = 0;
3147 /* If there is no setup required and we are in SSA, take the easy route
3148 replacing all SSA names representing the function parameter by the
3149 SSA name passed to function.
3151 We need to construct map for the variable anyway as it might be used
3152 in different SSA names when parameter is set in function.
3154 Do replacement at -O0 for const arguments replaced by constant.
3155 This is important for builtin_constant_p and other construct requiring
3156 constant argument to be visible in inlined function body. */
3157 if (gimple_in_ssa_p (cfun
) && rhs
&& def
&& is_gimple_reg (p
)
3159 || (TREE_READONLY (p
)
3160 && is_gimple_min_invariant (rhs
)))
3161 && (TREE_CODE (rhs
) == SSA_NAME
3162 || is_gimple_min_invariant (rhs
))
3163 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
3165 insert_decl_map (id
, def
, rhs
);
3166 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3169 /* If the value of argument is never used, don't care about initializing
3171 if (optimize
&& gimple_in_ssa_p (cfun
) && !def
&& is_gimple_reg (p
))
3173 gcc_assert (!value
|| !TREE_SIDE_EFFECTS (value
));
3174 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3177 /* Initialize this VAR_DECL from the equivalent argument. Convert
3178 the argument to the proper type in case it was promoted. */
3181 if (rhs
== error_mark_node
)
3183 insert_decl_map (id
, p
, var
);
3184 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3187 STRIP_USELESS_TYPE_CONVERSION (rhs
);
3189 /* If we are in SSA form properly remap the default definition
3190 or assign to a dummy SSA name if the parameter is unused and
3191 we are not optimizing. */
3192 if (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
))
3196 def
= remap_ssa_name (def
, id
);
3197 init_stmt
= gimple_build_assign (def
, rhs
);
3198 SSA_NAME_IS_DEFAULT_DEF (def
) = 0;
3199 set_ssa_default_def (cfun
, var
, NULL
);
3203 def
= make_ssa_name (var
);
3204 init_stmt
= gimple_build_assign (def
, rhs
);
3208 init_stmt
= gimple_build_assign (var
, rhs
);
3210 if (bb
&& init_stmt
)
3211 insert_init_stmt (id
, bb
, init_stmt
);
3216 /* Generate code to initialize the parameters of the function at the
3217 top of the stack in ID from the GIMPLE_CALL STMT. */
3220 initialize_inlined_parameters (copy_body_data
*id
, gimple stmt
,
3221 tree fn
, basic_block bb
)
3226 tree vars
= NULL_TREE
;
3227 tree static_chain
= gimple_call_chain (stmt
);
3229 /* Figure out what the parameters are. */
3230 parms
= DECL_ARGUMENTS (fn
);
3232 /* Loop through the parameter declarations, replacing each with an
3233 equivalent VAR_DECL, appropriately initialized. */
3234 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
3237 val
= i
< gimple_call_num_args (stmt
) ? gimple_call_arg (stmt
, i
) : NULL
;
3238 setup_one_parameter (id
, p
, val
, fn
, bb
, &vars
);
3240 /* After remapping parameters remap their types. This has to be done
3241 in a second loop over all parameters to appropriately remap
3242 variable sized arrays when the size is specified in a
3243 parameter following the array. */
3244 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
3246 tree
*varp
= id
->decl_map
->get (p
);
3248 && TREE_CODE (*varp
) == VAR_DECL
)
3250 tree def
= (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
)
3251 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
3253 TREE_TYPE (var
) = remap_type (TREE_TYPE (var
), id
);
3254 /* Also remap the default definition if it was remapped
3255 to the default definition of the parameter replacement
3256 by the parameter setup. */
3259 tree
*defp
= id
->decl_map
->get (def
);
3261 && TREE_CODE (*defp
) == SSA_NAME
3262 && SSA_NAME_VAR (*defp
) == var
)
3263 TREE_TYPE (*defp
) = TREE_TYPE (var
);
3268 /* Initialize the static chain. */
3269 p
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
3270 gcc_assert (fn
!= current_function_decl
);
3273 /* No static chain? Seems like a bug in tree-nested.c. */
3274 gcc_assert (static_chain
);
3276 setup_one_parameter (id
, p
, static_chain
, fn
, bb
, &vars
);
3279 declare_inline_vars (id
->block
, vars
);
3283 /* Declare a return variable to replace the RESULT_DECL for the
3284 function we are calling. An appropriate DECL_STMT is returned.
3285 The USE_STMT is filled to contain a use of the declaration to
3286 indicate the return value of the function.
3288 RETURN_SLOT, if non-null is place where to store the result. It
3289 is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null,
3290 was the LHS of the MODIFY_EXPR to which this call is the RHS.
3292 RETURN_BOUNDS holds a destination for returned bounds.
3294 The return value is a (possibly null) value that holds the result
3295 as seen by the caller. */
3298 declare_return_variable (copy_body_data
*id
, tree return_slot
, tree modify_dest
,
3299 tree return_bounds
, basic_block entry_bb
)
3301 tree callee
= id
->src_fn
;
3302 tree result
= DECL_RESULT (callee
);
3303 tree callee_type
= TREE_TYPE (result
);
3307 /* Handle type-mismatches in the function declaration return type
3308 vs. the call expression. */
3310 caller_type
= TREE_TYPE (modify_dest
);
3312 caller_type
= TREE_TYPE (TREE_TYPE (callee
));
3314 /* We don't need to do anything for functions that don't return anything. */
3315 if (VOID_TYPE_P (callee_type
))
3318 /* If there was a return slot, then the return value is the
3319 dereferenced address of that object. */
3322 /* The front end shouldn't have used both return_slot and
3323 a modify expression. */
3324 gcc_assert (!modify_dest
);
3325 if (DECL_BY_REFERENCE (result
))
3327 tree return_slot_addr
= build_fold_addr_expr (return_slot
);
3328 STRIP_USELESS_TYPE_CONVERSION (return_slot_addr
);
3330 /* We are going to construct *&return_slot and we can't do that
3331 for variables believed to be not addressable.
3333 FIXME: This check possibly can match, because values returned
3334 via return slot optimization are not believed to have address
3335 taken by alias analysis. */
3336 gcc_assert (TREE_CODE (return_slot
) != SSA_NAME
);
3337 var
= return_slot_addr
;
3342 gcc_assert (TREE_CODE (var
) != SSA_NAME
);
3343 if (TREE_ADDRESSABLE (result
))
3344 mark_addressable (var
);
3346 if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
3347 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
3348 && !DECL_GIMPLE_REG_P (result
)
3350 DECL_GIMPLE_REG_P (var
) = 0;
3355 /* All types requiring non-trivial constructors should have been handled. */
3356 gcc_assert (!TREE_ADDRESSABLE (callee_type
));
3358 /* Attempt to avoid creating a new temporary variable. */
3360 && TREE_CODE (modify_dest
) != SSA_NAME
)
3362 bool use_it
= false;
3364 /* We can't use MODIFY_DEST if there's type promotion involved. */
3365 if (!useless_type_conversion_p (callee_type
, caller_type
))
3368 /* ??? If we're assigning to a variable sized type, then we must
3369 reuse the destination variable, because we've no good way to
3370 create variable sized temporaries at this point. */
3371 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type
)) != INTEGER_CST
)
3374 /* If the callee cannot possibly modify MODIFY_DEST, then we can
3375 reuse it as the result of the call directly. Don't do this if
3376 it would promote MODIFY_DEST to addressable. */
3377 else if (TREE_ADDRESSABLE (result
))
3381 tree base_m
= get_base_address (modify_dest
);
3383 /* If the base isn't a decl, then it's a pointer, and we don't
3384 know where that's going to go. */
3385 if (!DECL_P (base_m
))
3387 else if (is_global_var (base_m
))
3389 else if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
3390 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
3391 && !DECL_GIMPLE_REG_P (result
)
3392 && DECL_GIMPLE_REG_P (base_m
))
3394 else if (!TREE_ADDRESSABLE (base_m
))
3406 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type
)) == INTEGER_CST
);
3408 var
= copy_result_decl_to_var (result
, id
);
3409 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
3411 /* Do not have the rest of GCC warn about this variable as it should
3412 not be visible to the user. */
3413 TREE_NO_WARNING (var
) = 1;
3415 declare_inline_vars (id
->block
, var
);
3417 /* Build the use expr. If the return type of the function was
3418 promoted, convert it back to the expected type. */
3420 if (!useless_type_conversion_p (caller_type
, TREE_TYPE (var
)))
3422 /* If we can match up types by promotion/demotion do so. */
3423 if (fold_convertible_p (caller_type
, var
))
3424 use
= fold_convert (caller_type
, var
);
3427 /* ??? For valid programs we should not end up here.
3428 Still if we end up with truly mismatched types here, fall back
3429 to using a MEM_REF to not leak invalid GIMPLE to the following
3431 /* Prevent var from being written into SSA form. */
3432 if (TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
3433 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
)
3434 DECL_GIMPLE_REG_P (var
) = false;
3435 else if (is_gimple_reg_type (TREE_TYPE (var
)))
3436 TREE_ADDRESSABLE (var
) = true;
3437 use
= fold_build2 (MEM_REF
, caller_type
,
3438 build_fold_addr_expr (var
),
3439 build_int_cst (ptr_type_node
, 0));
3443 STRIP_USELESS_TYPE_CONVERSION (use
);
3445 if (DECL_BY_REFERENCE (result
))
3447 TREE_ADDRESSABLE (var
) = 1;
3448 var
= build_fold_addr_expr (var
);
3452 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
3453 way, when the RESULT_DECL is encountered, it will be
3454 automatically replaced by the VAR_DECL.
3456 When returning by reference, ensure that RESULT_DECL remaps to
3458 if (DECL_BY_REFERENCE (result
)
3459 && !is_gimple_val (var
))
3461 tree temp
= create_tmp_var (TREE_TYPE (result
), "retvalptr");
3462 insert_decl_map (id
, result
, temp
);
3463 /* When RESULT_DECL is in SSA form, we need to remap and initialize
3464 it's default_def SSA_NAME. */
3465 if (gimple_in_ssa_p (id
->src_cfun
)
3466 && is_gimple_reg (result
))
3468 temp
= make_ssa_name (temp
);
3469 insert_decl_map (id
, ssa_default_def (id
->src_cfun
, result
), temp
);
3471 insert_init_stmt (id
, entry_bb
, gimple_build_assign (temp
, var
));
3474 insert_decl_map (id
, result
, var
);
3476 /* Remember this so we can ignore it in remap_decls. */
3479 /* If returned bounds are used, then make var for them. */
3482 tree bndtemp
= create_tmp_var (pointer_bounds_type_node
, "retbnd");
3483 DECL_SEEN_IN_BIND_EXPR_P (bndtemp
) = 1;
3484 TREE_NO_WARNING (bndtemp
) = 1;
3485 declare_inline_vars (id
->block
, bndtemp
);
3487 id
->retbnd
= bndtemp
;
3488 insert_init_stmt (id
, entry_bb
,
3489 gimple_build_assign (bndtemp
, chkp_get_zero_bounds_var ()));
3495 /* Callback through walk_tree. Determine if a DECL_INITIAL makes reference
3496 to a local label. */
3499 has_label_address_in_static_1 (tree
*nodep
, int *walk_subtrees
, void *fnp
)
3502 tree fn
= (tree
) fnp
;
3504 if (TREE_CODE (node
) == LABEL_DECL
&& DECL_CONTEXT (node
) == fn
)
3513 /* Determine if the function can be copied. If so return NULL. If
3514 not return a string describng the reason for failure. */
3517 copy_forbidden (struct function
*fun
, tree fndecl
)
3519 const char *reason
= fun
->cannot_be_copied_reason
;
3523 /* Only examine the function once. */
3524 if (fun
->cannot_be_copied_set
)
3527 /* We cannot copy a function that receives a non-local goto
3528 because we cannot remap the destination label used in the
3529 function that is performing the non-local goto. */
3530 /* ??? Actually, this should be possible, if we work at it.
3531 No doubt there's just a handful of places that simply
3532 assume it doesn't happen and don't substitute properly. */
3533 if (fun
->has_nonlocal_label
)
3535 reason
= G_("function %q+F can never be copied "
3536 "because it receives a non-local goto");
3540 FOR_EACH_LOCAL_DECL (fun
, ix
, decl
)
3541 if (TREE_CODE (decl
) == VAR_DECL
3542 && TREE_STATIC (decl
)
3543 && !DECL_EXTERNAL (decl
)
3544 && DECL_INITIAL (decl
)
3545 && walk_tree_without_duplicates (&DECL_INITIAL (decl
),
3546 has_label_address_in_static_1
,
3549 reason
= G_("function %q+F can never be copied because it saves "
3550 "address of local label in a static variable");
3555 fun
->cannot_be_copied_reason
= reason
;
3556 fun
->cannot_be_copied_set
= true;
3561 static const char *inline_forbidden_reason
;
3563 /* A callback for walk_gimple_seq to handle statements. Returns non-null
3564 iff a function can not be inlined. Also sets the reason why. */
3567 inline_forbidden_p_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
3568 struct walk_stmt_info
*wip
)
3570 tree fn
= (tree
) wip
->info
;
3572 gimple stmt
= gsi_stmt (*gsi
);
3574 switch (gimple_code (stmt
))
3577 /* Refuse to inline alloca call unless user explicitly forced so as
3578 this may change program's memory overhead drastically when the
3579 function using alloca is called in loop. In GCC present in
3580 SPEC2000 inlining into schedule_block cause it to require 2GB of
3581 RAM instead of 256MB. Don't do so for alloca calls emitted for
3582 VLA objects as those can't cause unbounded growth (they're always
3583 wrapped inside stack_save/stack_restore regions. */
3584 if (gimple_alloca_call_p (stmt
)
3585 && !gimple_call_alloca_for_var_p (as_a
<gcall
*> (stmt
))
3586 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
3588 inline_forbidden_reason
3589 = G_("function %q+F can never be inlined because it uses "
3590 "alloca (override using the always_inline attribute)");
3591 *handled_ops_p
= true;
3595 t
= gimple_call_fndecl (stmt
);
3599 /* We cannot inline functions that call setjmp. */
3600 if (setjmp_call_p (t
))
3602 inline_forbidden_reason
3603 = G_("function %q+F can never be inlined because it uses setjmp");
3604 *handled_ops_p
= true;
3608 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
3609 switch (DECL_FUNCTION_CODE (t
))
3611 /* We cannot inline functions that take a variable number of
3613 case BUILT_IN_VA_START
:
3614 case BUILT_IN_NEXT_ARG
:
3615 case BUILT_IN_VA_END
:
3616 inline_forbidden_reason
3617 = G_("function %q+F can never be inlined because it "
3618 "uses variable argument lists");
3619 *handled_ops_p
= true;
3622 case BUILT_IN_LONGJMP
:
3623 /* We can't inline functions that call __builtin_longjmp at
3624 all. The non-local goto machinery really requires the
3625 destination be in a different function. If we allow the
3626 function calling __builtin_longjmp to be inlined into the
3627 function calling __builtin_setjmp, Things will Go Awry. */
3628 inline_forbidden_reason
3629 = G_("function %q+F can never be inlined because "
3630 "it uses setjmp-longjmp exception handling");
3631 *handled_ops_p
= true;
3634 case BUILT_IN_NONLOCAL_GOTO
:
3636 inline_forbidden_reason
3637 = G_("function %q+F can never be inlined because "
3638 "it uses non-local goto");
3639 *handled_ops_p
= true;
3642 case BUILT_IN_RETURN
:
3643 case BUILT_IN_APPLY_ARGS
:
3644 /* If a __builtin_apply_args caller would be inlined,
3645 it would be saving arguments of the function it has
3646 been inlined into. Similarly __builtin_return would
3647 return from the function the inline has been inlined into. */
3648 inline_forbidden_reason
3649 = G_("function %q+F can never be inlined because "
3650 "it uses __builtin_return or __builtin_apply_args");
3651 *handled_ops_p
= true;
3660 t
= gimple_goto_dest (stmt
);
3662 /* We will not inline a function which uses computed goto. The
3663 addresses of its local labels, which may be tucked into
3664 global storage, are of course not constant across
3665 instantiations, which causes unexpected behavior. */
3666 if (TREE_CODE (t
) != LABEL_DECL
)
3668 inline_forbidden_reason
3669 = G_("function %q+F can never be inlined "
3670 "because it contains a computed goto");
3671 *handled_ops_p
= true;
3680 *handled_ops_p
= false;
3684 /* Return true if FNDECL is a function that cannot be inlined into
3688 inline_forbidden_p (tree fndecl
)
3690 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
3691 struct walk_stmt_info wi
;
3693 bool forbidden_p
= false;
3695 /* First check for shared reasons not to copy the code. */
3696 inline_forbidden_reason
= copy_forbidden (fun
, fndecl
);
3697 if (inline_forbidden_reason
!= NULL
)
3700 /* Next, walk the statements of the function looking for
3701 constraucts we can't handle, or are non-optimal for inlining. */
3702 hash_set
<tree
> visited_nodes
;
3703 memset (&wi
, 0, sizeof (wi
));
3704 wi
.info
= (void *) fndecl
;
3705 wi
.pset
= &visited_nodes
;
3707 FOR_EACH_BB_FN (bb
, fun
)
3710 gimple_seq seq
= bb_seq (bb
);
3711 ret
= walk_gimple_seq (seq
, inline_forbidden_p_stmt
, NULL
, &wi
);
3712 forbidden_p
= (ret
!= NULL
);
3720 /* Return false if the function FNDECL cannot be inlined on account of its
3721 attributes, true otherwise. */
3723 function_attribute_inlinable_p (const_tree fndecl
)
3725 if (targetm
.attribute_table
)
3729 for (a
= DECL_ATTRIBUTES (fndecl
); a
; a
= TREE_CHAIN (a
))
3731 const_tree name
= TREE_PURPOSE (a
);
3734 for (i
= 0; targetm
.attribute_table
[i
].name
!= NULL
; i
++)
3735 if (is_attribute_p (targetm
.attribute_table
[i
].name
, name
))
3736 return targetm
.function_attribute_inlinable_p (fndecl
);
3743 /* Returns nonzero if FN is a function that does not have any
3744 fundamental inline blocking properties. */
3747 tree_inlinable_function_p (tree fn
)
3749 bool inlinable
= true;
3753 /* If we've already decided this function shouldn't be inlined,
3754 there's no need to check again. */
3755 if (DECL_UNINLINABLE (fn
))
3758 /* We only warn for functions declared `inline' by the user. */
3759 do_warning
= (warn_inline
3760 && DECL_DECLARED_INLINE_P (fn
)
3761 && !DECL_NO_INLINE_WARNING_P (fn
)
3762 && !DECL_IN_SYSTEM_HEADER (fn
));
3764 always_inline
= lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
));
3767 && always_inline
== NULL
)
3770 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3771 "is suppressed using -fno-inline", fn
);
3775 else if (!function_attribute_inlinable_p (fn
))
3778 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3779 "uses attributes conflicting with inlining", fn
);
3783 else if (inline_forbidden_p (fn
))
3785 /* See if we should warn about uninlinable functions. Previously,
3786 some of these warnings would be issued while trying to expand
3787 the function inline, but that would cause multiple warnings
3788 about functions that would for example call alloca. But since
3789 this a property of the function, just one warning is enough.
3790 As a bonus we can now give more details about the reason why a
3791 function is not inlinable. */
3793 error (inline_forbidden_reason
, fn
);
3794 else if (do_warning
)
3795 warning (OPT_Winline
, inline_forbidden_reason
, fn
);
3800 /* Squirrel away the result so that we don't have to check again. */
3801 DECL_UNINLINABLE (fn
) = !inlinable
;
3806 /* Estimate the cost of a memory move of type TYPE. Use machine dependent
3807 word size and take possible memcpy call into account and return
3808 cost based on whether optimizing for size or speed according to SPEED_P. */
3811 estimate_move_cost (tree type
, bool ARG_UNUSED (speed_p
))
3815 gcc_assert (!VOID_TYPE_P (type
));
3817 if (TREE_CODE (type
) == VECTOR_TYPE
)
3819 machine_mode inner
= TYPE_MODE (TREE_TYPE (type
));
3821 = targetm
.vectorize
.preferred_simd_mode (inner
);
3822 int simd_mode_size
= GET_MODE_SIZE (simd
);
3823 return ((GET_MODE_SIZE (TYPE_MODE (type
)) + simd_mode_size
- 1)
3827 size
= int_size_in_bytes (type
);
3829 if (size
< 0 || size
> MOVE_MAX_PIECES
* MOVE_RATIO (speed_p
))
3830 /* Cost of a memcpy call, 3 arguments and the call. */
3833 return ((size
+ MOVE_MAX_PIECES
- 1) / MOVE_MAX_PIECES
);
3836 /* Returns cost of operation CODE, according to WEIGHTS */
3839 estimate_operator_cost (enum tree_code code
, eni_weights
*weights
,
3840 tree op1 ATTRIBUTE_UNUSED
, tree op2
)
3844 /* These are "free" conversions, or their presumed cost
3845 is folded into other operations. */
3850 case VIEW_CONVERT_EXPR
:
3853 /* Assign cost of 1 to usual operations.
3854 ??? We may consider mapping RTL costs to this. */
3860 case POINTER_PLUS_EXPR
:
3863 case MULT_HIGHPART_EXPR
:
3866 case ADDR_SPACE_CONVERT_EXPR
:
3867 case FIXED_CONVERT_EXPR
:
3868 case FIX_TRUNC_EXPR
:
3886 case TRUTH_ANDIF_EXPR
:
3887 case TRUTH_ORIF_EXPR
:
3888 case TRUTH_AND_EXPR
:
3890 case TRUTH_XOR_EXPR
:
3891 case TRUTH_NOT_EXPR
:
3900 case UNORDERED_EXPR
:
3911 case PREDECREMENT_EXPR
:
3912 case PREINCREMENT_EXPR
:
3913 case POSTDECREMENT_EXPR
:
3914 case POSTINCREMENT_EXPR
:
3916 case REALIGN_LOAD_EXPR
:
3918 case REDUC_MAX_EXPR
:
3919 case REDUC_MIN_EXPR
:
3920 case REDUC_PLUS_EXPR
:
3921 case WIDEN_SUM_EXPR
:
3922 case WIDEN_MULT_EXPR
:
3925 case WIDEN_MULT_PLUS_EXPR
:
3926 case WIDEN_MULT_MINUS_EXPR
:
3927 case WIDEN_LSHIFT_EXPR
:
3929 case VEC_WIDEN_MULT_HI_EXPR
:
3930 case VEC_WIDEN_MULT_LO_EXPR
:
3931 case VEC_WIDEN_MULT_EVEN_EXPR
:
3932 case VEC_WIDEN_MULT_ODD_EXPR
:
3933 case VEC_UNPACK_HI_EXPR
:
3934 case VEC_UNPACK_LO_EXPR
:
3935 case VEC_UNPACK_FLOAT_HI_EXPR
:
3936 case VEC_UNPACK_FLOAT_LO_EXPR
:
3937 case VEC_PACK_TRUNC_EXPR
:
3938 case VEC_PACK_SAT_EXPR
:
3939 case VEC_PACK_FIX_TRUNC_EXPR
:
3940 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3941 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3945 /* Few special cases of expensive operations. This is useful
3946 to avoid inlining on functions having too many of these. */
3947 case TRUNC_DIV_EXPR
:
3949 case FLOOR_DIV_EXPR
:
3950 case ROUND_DIV_EXPR
:
3951 case EXACT_DIV_EXPR
:
3952 case TRUNC_MOD_EXPR
:
3954 case FLOOR_MOD_EXPR
:
3955 case ROUND_MOD_EXPR
:
3957 if (TREE_CODE (op2
) != INTEGER_CST
)
3958 return weights
->div_mod_cost
;
3962 /* We expect a copy assignment with no operator. */
3963 gcc_assert (get_gimple_rhs_class (code
) == GIMPLE_SINGLE_RHS
);
3969 /* Estimate number of instructions that will be created by expanding
3970 the statements in the statement sequence STMTS.
3971 WEIGHTS contains weights attributed to various constructs. */
3974 int estimate_num_insns_seq (gimple_seq stmts
, eni_weights
*weights
)
3977 gimple_stmt_iterator gsi
;
3980 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3981 cost
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
3987 /* Estimate number of instructions that will be created by expanding STMT.
3988 WEIGHTS contains weights attributed to various constructs. */
3991 estimate_num_insns (gimple stmt
, eni_weights
*weights
)
3994 enum gimple_code code
= gimple_code (stmt
);
4001 /* Try to estimate the cost of assignments. We have three cases to
4003 1) Simple assignments to registers;
4004 2) Stores to things that must live in memory. This includes
4005 "normal" stores to scalars, but also assignments of large
4006 structures, or constructors of big arrays;
4008 Let us look at the first two cases, assuming we have "a = b + C":
4009 <GIMPLE_ASSIGN <var_decl "a">
4010 <plus_expr <var_decl "b"> <constant C>>
4011 If "a" is a GIMPLE register, the assignment to it is free on almost
4012 any target, because "a" usually ends up in a real register. Hence
4013 the only cost of this expression comes from the PLUS_EXPR, and we
4014 can ignore the GIMPLE_ASSIGN.
4015 If "a" is not a GIMPLE register, the assignment to "a" will most
4016 likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost
4017 of moving something into "a", which we compute using the function
4018 estimate_move_cost. */
4019 if (gimple_clobber_p (stmt
))
4020 return 0; /* ={v} {CLOBBER} stmt expands to nothing. */
4022 lhs
= gimple_assign_lhs (stmt
);
4023 rhs
= gimple_assign_rhs1 (stmt
);
4027 /* Account for the cost of moving to / from memory. */
4028 if (gimple_store_p (stmt
))
4029 cost
+= estimate_move_cost (TREE_TYPE (lhs
), weights
->time_based
);
4030 if (gimple_assign_load_p (stmt
))
4031 cost
+= estimate_move_cost (TREE_TYPE (rhs
), weights
->time_based
);
4033 cost
+= estimate_operator_cost (gimple_assign_rhs_code (stmt
), weights
,
4034 gimple_assign_rhs1 (stmt
),
4035 get_gimple_rhs_class (gimple_assign_rhs_code (stmt
))
4036 == GIMPLE_BINARY_RHS
4037 ? gimple_assign_rhs2 (stmt
) : NULL
);
4041 cost
= 1 + estimate_operator_cost (gimple_cond_code (stmt
), weights
,
4042 gimple_op (stmt
, 0),
4043 gimple_op (stmt
, 1));
4048 gswitch
*switch_stmt
= as_a
<gswitch
*> (stmt
);
4049 /* Take into account cost of the switch + guess 2 conditional jumps for
4052 TODO: once the switch expansion logic is sufficiently separated, we can
4053 do better job on estimating cost of the switch. */
4054 if (weights
->time_based
)
4055 cost
= floor_log2 (gimple_switch_num_labels (switch_stmt
)) * 2;
4057 cost
= gimple_switch_num_labels (switch_stmt
) * 2;
4065 if (gimple_call_internal_p (stmt
))
4067 else if ((decl
= gimple_call_fndecl (stmt
))
4068 && DECL_BUILT_IN (decl
))
4070 /* Do not special case builtins where we see the body.
4071 This just confuse inliner. */
4072 struct cgraph_node
*node
;
4073 if (!(node
= cgraph_node::get (decl
))
4074 || node
->definition
)
4076 /* For buitins that are likely expanded to nothing or
4077 inlined do not account operand costs. */
4078 else if (is_simple_builtin (decl
))
4080 else if (is_inexpensive_builtin (decl
))
4081 return weights
->target_builtin_call_cost
;
4082 else if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
4084 /* We canonicalize x * x to pow (x, 2.0) with -ffast-math, so
4085 specialize the cheap expansion we do here.
4086 ??? This asks for a more general solution. */
4087 switch (DECL_FUNCTION_CODE (decl
))
4092 if (TREE_CODE (gimple_call_arg (stmt
, 1)) == REAL_CST
4093 && REAL_VALUES_EQUAL
4094 (TREE_REAL_CST (gimple_call_arg (stmt
, 1)), dconst2
))
4095 return estimate_operator_cost
4096 (MULT_EXPR
, weights
, gimple_call_arg (stmt
, 0),
4097 gimple_call_arg (stmt
, 0));
4106 cost
= decl
? weights
->call_cost
: weights
->indirect_call_cost
;
4107 if (gimple_call_lhs (stmt
))
4108 cost
+= estimate_move_cost (TREE_TYPE (gimple_call_lhs (stmt
)),
4109 weights
->time_based
);
4110 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
4112 tree arg
= gimple_call_arg (stmt
, i
);
4113 cost
+= estimate_move_cost (TREE_TYPE (arg
),
4114 weights
->time_based
);
4120 return weights
->return_cost
;
4126 case GIMPLE_PREDICT
:
4132 int count
= asm_str_count (gimple_asm_string (as_a
<gasm
*> (stmt
)));
4133 /* 1000 means infinity. This avoids overflows later
4134 with very long asm statements. */
4141 /* This is either going to be an external function call with one
4142 argument, or two register copy statements plus a goto. */
4145 case GIMPLE_EH_DISPATCH
:
4146 /* ??? This is going to turn into a switch statement. Ideally
4147 we'd have a look at the eh region and estimate the number of
4152 return estimate_num_insns_seq (
4153 gimple_bind_body (as_a
<gbind
*> (stmt
)),
4156 case GIMPLE_EH_FILTER
:
4157 return estimate_num_insns_seq (gimple_eh_filter_failure (stmt
), weights
);
4160 return estimate_num_insns_seq (gimple_catch_handler (
4161 as_a
<gcatch
*> (stmt
)),
4165 return (estimate_num_insns_seq (gimple_try_eval (stmt
), weights
)
4166 + estimate_num_insns_seq (gimple_try_cleanup (stmt
), weights
));
4168 /* OpenMP directives are generally very expensive. */
4170 case GIMPLE_OMP_RETURN
:
4171 case GIMPLE_OMP_SECTIONS_SWITCH
:
4172 case GIMPLE_OMP_ATOMIC_STORE
:
4173 case GIMPLE_OMP_CONTINUE
:
4174 /* ...except these, which are cheap. */
4177 case GIMPLE_OMP_ATOMIC_LOAD
:
4178 return weights
->omp_cost
;
4180 case GIMPLE_OMP_FOR
:
4181 return (weights
->omp_cost
4182 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
)
4183 + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt
), weights
));
4185 case GIMPLE_OMP_PARALLEL
:
4186 case GIMPLE_OMP_TASK
:
4187 case GIMPLE_OMP_CRITICAL
:
4188 case GIMPLE_OMP_MASTER
:
4189 case GIMPLE_OMP_TASKGROUP
:
4190 case GIMPLE_OMP_ORDERED
:
4191 case GIMPLE_OMP_SECTION
:
4192 case GIMPLE_OMP_SECTIONS
:
4193 case GIMPLE_OMP_SINGLE
:
4194 case GIMPLE_OMP_TARGET
:
4195 case GIMPLE_OMP_TEAMS
:
4196 return (weights
->omp_cost
4197 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
));
4199 case GIMPLE_TRANSACTION
:
4200 return (weights
->tm_cost
4201 + estimate_num_insns_seq (gimple_transaction_body (
4202 as_a
<gtransaction
*> (stmt
)),
4212 /* Estimate number of instructions that will be created by expanding
4213 function FNDECL. WEIGHTS contains weights attributed to various
4217 estimate_num_insns_fn (tree fndecl
, eni_weights
*weights
)
4219 struct function
*my_function
= DECL_STRUCT_FUNCTION (fndecl
);
4220 gimple_stmt_iterator bsi
;
4224 gcc_assert (my_function
&& my_function
->cfg
);
4225 FOR_EACH_BB_FN (bb
, my_function
)
4227 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
4228 n
+= estimate_num_insns (gsi_stmt (bsi
), weights
);
4235 /* Initializes weights used by estimate_num_insns. */
4238 init_inline_once (void)
4240 eni_size_weights
.call_cost
= 1;
4241 eni_size_weights
.indirect_call_cost
= 3;
4242 eni_size_weights
.target_builtin_call_cost
= 1;
4243 eni_size_weights
.div_mod_cost
= 1;
4244 eni_size_weights
.omp_cost
= 40;
4245 eni_size_weights
.tm_cost
= 10;
4246 eni_size_weights
.time_based
= false;
4247 eni_size_weights
.return_cost
= 1;
4249 /* Estimating time for call is difficult, since we have no idea what the
4250 called function does. In the current uses of eni_time_weights,
4251 underestimating the cost does less harm than overestimating it, so
4252 we choose a rather small value here. */
4253 eni_time_weights
.call_cost
= 10;
4254 eni_time_weights
.indirect_call_cost
= 15;
4255 eni_time_weights
.target_builtin_call_cost
= 1;
4256 eni_time_weights
.div_mod_cost
= 10;
4257 eni_time_weights
.omp_cost
= 40;
4258 eni_time_weights
.tm_cost
= 40;
4259 eni_time_weights
.time_based
= true;
4260 eni_time_weights
.return_cost
= 2;
4263 /* Estimate the number of instructions in a gimple_seq. */
4266 count_insns_seq (gimple_seq seq
, eni_weights
*weights
)
4268 gimple_stmt_iterator gsi
;
4270 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4271 n
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
4277 /* Install new lexical TREE_BLOCK underneath 'current_block'. */
4280 prepend_lexical_block (tree current_block
, tree new_block
)
4282 BLOCK_CHAIN (new_block
) = BLOCK_SUBBLOCKS (current_block
);
4283 BLOCK_SUBBLOCKS (current_block
) = new_block
;
4284 BLOCK_SUPERCONTEXT (new_block
) = current_block
;
4287 /* Add local variables from CALLEE to CALLER. */
4290 add_local_variables (struct function
*callee
, struct function
*caller
,
4296 FOR_EACH_LOCAL_DECL (callee
, ix
, var
)
4297 if (!can_be_nonlocal (var
, id
))
4299 tree new_var
= remap_decl (var
, id
);
4301 /* Remap debug-expressions. */
4302 if (TREE_CODE (new_var
) == VAR_DECL
4303 && DECL_HAS_DEBUG_EXPR_P (var
)
4306 tree tem
= DECL_DEBUG_EXPR (var
);
4307 bool old_regimplify
= id
->regimplify
;
4308 id
->remapping_type_depth
++;
4309 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
4310 id
->remapping_type_depth
--;
4311 id
->regimplify
= old_regimplify
;
4312 SET_DECL_DEBUG_EXPR (new_var
, tem
);
4313 DECL_HAS_DEBUG_EXPR_P (new_var
) = 1;
4315 add_local_decl (caller
, new_var
);
4319 /* If STMT is a GIMPLE_CALL, replace it with its inline expansion. */
4322 expand_call_inline (basic_block bb
, gimple stmt
, copy_body_data
*id
)
4326 hash_map
<tree
, tree
> *dst
;
4327 hash_map
<tree
, tree
> *st
= NULL
;
4330 tree return_bounds
= NULL
;
4331 location_t saved_location
;
4332 struct cgraph_edge
*cg_edge
;
4333 cgraph_inline_failed_t reason
;
4334 basic_block return_block
;
4336 gimple_stmt_iterator gsi
, stmt_gsi
;
4337 bool successfully_inlined
= FALSE
;
4338 bool purge_dead_abnormal_edges
;
4342 /* Set input_location here so we get the right instantiation context
4343 if we call instantiate_decl from inlinable_function_p. */
4344 /* FIXME: instantiate_decl isn't called by inlinable_function_p. */
4345 saved_location
= input_location
;
4346 input_location
= gimple_location (stmt
);
4348 /* From here on, we're only interested in CALL_EXPRs. */
4349 call_stmt
= dyn_cast
<gcall
*> (stmt
);
4353 cg_edge
= id
->dst_node
->get_edge (stmt
);
4354 gcc_checking_assert (cg_edge
);
4355 /* First, see if we can figure out what function is being called.
4356 If we cannot, then there is no hope of inlining the function. */
4357 if (cg_edge
->indirect_unknown_callee
)
4359 fn
= cg_edge
->callee
->decl
;
4360 gcc_checking_assert (fn
);
4362 /* If FN is a declaration of a function in a nested scope that was
4363 globally declared inline, we don't set its DECL_INITIAL.
4364 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
4365 C++ front-end uses it for cdtors to refer to their internal
4366 declarations, that are not real functions. Fortunately those
4367 don't have trees to be saved, so we can tell by checking their
4369 if (!DECL_INITIAL (fn
)
4370 && DECL_ABSTRACT_ORIGIN (fn
)
4371 && gimple_has_body_p (DECL_ABSTRACT_ORIGIN (fn
)))
4372 fn
= DECL_ABSTRACT_ORIGIN (fn
);
4374 /* Don't try to inline functions that are not well-suited to inlining. */
4375 if (cg_edge
->inline_failed
)
4377 reason
= cg_edge
->inline_failed
;
4378 /* If this call was originally indirect, we do not want to emit any
4379 inlining related warnings or sorry messages because there are no
4380 guarantees regarding those. */
4381 if (cg_edge
->indirect_inlining_edge
)
4384 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
))
4385 /* For extern inline functions that get redefined we always
4386 silently ignored always_inline flag. Better behaviour would
4387 be to be able to keep both bodies and use extern inline body
4388 for inlining, but we can't do that because frontends overwrite
4390 && !cg_edge
->callee
->local
.redefined_extern_inline
4391 /* During early inline pass, report only when optimization is
4393 && (symtab
->global_info_ready
4395 || cgraph_inline_failed_type (reason
) == CIF_FINAL_ERROR
)
4396 /* PR 20090218-1_0.c. Body can be provided by another module. */
4397 && (reason
!= CIF_BODY_NOT_AVAILABLE
|| !flag_generate_lto
))
4399 error ("inlining failed in call to always_inline %q+F: %s", fn
,
4400 cgraph_inline_failed_string (reason
));
4401 error ("called from here");
4403 else if (warn_inline
4404 && DECL_DECLARED_INLINE_P (fn
)
4405 && !DECL_NO_INLINE_WARNING_P (fn
)
4406 && !DECL_IN_SYSTEM_HEADER (fn
)
4407 && reason
!= CIF_UNSPECIFIED
4408 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn
))
4409 /* Do not warn about not inlined recursive calls. */
4410 && !cg_edge
->recursive_p ()
4411 /* Avoid warnings during early inline pass. */
4412 && symtab
->global_info_ready
)
4414 warning (OPT_Winline
, "inlining failed in call to %q+F: %s",
4415 fn
, _(cgraph_inline_failed_string (reason
)));
4416 warning (OPT_Winline
, "called from here");
4420 fn
= cg_edge
->callee
->decl
;
4421 cg_edge
->callee
->get_untransformed_body ();
4423 #ifdef ENABLE_CHECKING
4424 if (cg_edge
->callee
->decl
!= id
->dst_node
->decl
)
4425 cg_edge
->callee
->verify ();
4428 /* We will be inlining this callee. */
4429 id
->eh_lp_nr
= lookup_stmt_eh_lp (stmt
);
4430 id
->assign_stmts
.create (0);
4432 /* Update the callers EH personality. */
4433 if (DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->decl
))
4434 DECL_FUNCTION_PERSONALITY (cg_edge
->caller
->decl
)
4435 = DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->decl
);
4437 /* Split the block holding the GIMPLE_CALL. */
4438 e
= split_block (bb
, stmt
);
4440 return_block
= e
->dest
;
4443 /* split_block splits after the statement; work around this by
4444 moving the call into the second block manually. Not pretty,
4445 but seems easier than doing the CFG manipulation by hand
4446 when the GIMPLE_CALL is in the last statement of BB. */
4447 stmt_gsi
= gsi_last_bb (bb
);
4448 gsi_remove (&stmt_gsi
, false);
4450 /* If the GIMPLE_CALL was in the last statement of BB, it may have
4451 been the source of abnormal edges. In this case, schedule
4452 the removal of dead abnormal edges. */
4453 gsi
= gsi_start_bb (return_block
);
4454 if (gsi_end_p (gsi
))
4456 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
4457 purge_dead_abnormal_edges
= true;
4461 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
4462 purge_dead_abnormal_edges
= false;
4465 stmt_gsi
= gsi_start_bb (return_block
);
4467 /* Build a block containing code to initialize the arguments, the
4468 actual inline expansion of the body, and a label for the return
4469 statements within the function to jump to. The type of the
4470 statement expression is the return type of the function call.
4471 ??? If the call does not have an associated block then we will
4472 remap all callee blocks to NULL, effectively dropping most of
4473 its debug information. This should only happen for calls to
4474 artificial decls inserted by the compiler itself. We need to
4475 either link the inlined blocks into the caller block tree or
4476 not refer to them in any way to not break GC for locations. */
4477 if (gimple_block (stmt
))
4479 id
->block
= make_node (BLOCK
);
4480 BLOCK_ABSTRACT_ORIGIN (id
->block
) = fn
;
4481 BLOCK_SOURCE_LOCATION (id
->block
) = LOCATION_LOCUS (input_location
);
4482 prepend_lexical_block (gimple_block (stmt
), id
->block
);
4485 /* Local declarations will be replaced by their equivalents in this
4488 id
->decl_map
= new hash_map
<tree
, tree
>;
4489 dst
= id
->debug_map
;
4490 id
->debug_map
= NULL
;
4492 /* Record the function we are about to inline. */
4494 id
->src_node
= cg_edge
->callee
;
4495 id
->src_cfun
= DECL_STRUCT_FUNCTION (fn
);
4496 id
->call_stmt
= stmt
;
4498 gcc_assert (!id
->src_cfun
->after_inlining
);
4501 if (lookup_attribute ("cold", DECL_ATTRIBUTES (fn
)))
4503 gimple_stmt_iterator si
= gsi_last_bb (bb
);
4504 gsi_insert_after (&si
, gimple_build_predict (PRED_COLD_FUNCTION
,
4508 initialize_inlined_parameters (id
, stmt
, fn
, bb
);
4510 if (DECL_INITIAL (fn
))
4512 if (gimple_block (stmt
))
4516 prepend_lexical_block (id
->block
,
4517 remap_blocks (DECL_INITIAL (fn
), id
));
4518 gcc_checking_assert (BLOCK_SUBBLOCKS (id
->block
)
4519 && (BLOCK_CHAIN (BLOCK_SUBBLOCKS (id
->block
))
4521 /* Move vars for PARM_DECLs from DECL_INITIAL block to id->block,
4522 otherwise for DWARF DW_TAG_formal_parameter will not be children of
4523 DW_TAG_inlined_subroutine, but of a DW_TAG_lexical_block
4524 under it. The parameters can be then evaluated in the debugger,
4525 but don't show in backtraces. */
4526 for (var
= &BLOCK_VARS (BLOCK_SUBBLOCKS (id
->block
)); *var
; )
4527 if (TREE_CODE (DECL_ORIGIN (*var
)) == PARM_DECL
)
4530 *var
= TREE_CHAIN (v
);
4531 TREE_CHAIN (v
) = BLOCK_VARS (id
->block
);
4532 BLOCK_VARS (id
->block
) = v
;
4535 var
= &TREE_CHAIN (*var
);
4538 remap_blocks_to_null (DECL_INITIAL (fn
), id
);
4541 /* Return statements in the function body will be replaced by jumps
4542 to the RET_LABEL. */
4543 gcc_assert (DECL_INITIAL (fn
));
4544 gcc_assert (TREE_CODE (DECL_INITIAL (fn
)) == BLOCK
);
4546 /* Find the LHS to which the result of this call is assigned. */
4548 if (gimple_call_lhs (stmt
))
4550 modify_dest
= gimple_call_lhs (stmt
);
4552 /* Remember where to copy returned bounds. */
4553 if (gimple_call_with_bounds_p (stmt
)
4554 && TREE_CODE (modify_dest
) == SSA_NAME
)
4556 gcall
*retbnd
= chkp_retbnd_call_by_val (modify_dest
);
4559 return_bounds
= gimple_call_lhs (retbnd
);
4560 /* If returned bounds are not used then just
4561 remove unused call. */
4564 gimple_stmt_iterator iter
= gsi_for_stmt (retbnd
);
4565 gsi_remove (&iter
, true);
4570 /* The function which we are inlining might not return a value,
4571 in which case we should issue a warning that the function
4572 does not return a value. In that case the optimizers will
4573 see that the variable to which the value is assigned was not
4574 initialized. We do not want to issue a warning about that
4575 uninitialized variable. */
4576 if (DECL_P (modify_dest
))
4577 TREE_NO_WARNING (modify_dest
) = 1;
4579 if (gimple_call_return_slot_opt_p (call_stmt
))
4581 return_slot
= modify_dest
;
4588 /* If we are inlining a call to the C++ operator new, we don't want
4589 to use type based alias analysis on the return value. Otherwise
4590 we may get confused if the compiler sees that the inlined new
4591 function returns a pointer which was just deleted. See bug
4593 if (DECL_IS_OPERATOR_NEW (fn
))
4599 /* Declare the return variable for the function. */
4600 use_retvar
= declare_return_variable (id
, return_slot
, modify_dest
,
4603 /* Add local vars in this inlined callee to caller. */
4604 add_local_variables (id
->src_cfun
, cfun
, id
);
4606 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4608 fprintf (dump_file
, "Inlining ");
4609 print_generic_expr (dump_file
, id
->src_fn
, 0);
4610 fprintf (dump_file
, " to ");
4611 print_generic_expr (dump_file
, id
->dst_fn
, 0);
4612 fprintf (dump_file
, " with frequency %i\n", cg_edge
->frequency
);
4615 /* This is it. Duplicate the callee body. Assume callee is
4616 pre-gimplified. Note that we must not alter the caller
4617 function in any way before this point, as this CALL_EXPR may be
4618 a self-referential call; if we're calling ourselves, we need to
4619 duplicate our body before altering anything. */
4620 copy_body (id
, cg_edge
->callee
->count
,
4621 GCOV_COMPUTE_SCALE (cg_edge
->frequency
, CGRAPH_FREQ_BASE
),
4622 bb
, return_block
, NULL
);
4624 /* Reset the escaped solution. */
4625 if (cfun
->gimple_df
)
4626 pt_solution_reset (&cfun
->gimple_df
->escaped
);
4631 delete id
->debug_map
;
4632 id
->debug_map
= dst
;
4634 delete id
->decl_map
;
4637 /* Unlink the calls virtual operands before replacing it. */
4638 unlink_stmt_vdef (stmt
);
4639 if (gimple_vdef (stmt
)
4640 && TREE_CODE (gimple_vdef (stmt
)) == SSA_NAME
)
4641 release_ssa_name (gimple_vdef (stmt
));
4643 /* If the inlined function returns a result that we care about,
4644 substitute the GIMPLE_CALL with an assignment of the return
4645 variable to the LHS of the call. That is, if STMT was
4646 'a = foo (...)', substitute the call with 'a = USE_RETVAR'. */
4647 if (use_retvar
&& gimple_call_lhs (stmt
))
4649 gimple old_stmt
= stmt
;
4650 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), use_retvar
);
4651 gsi_replace (&stmt_gsi
, stmt
, false);
4652 maybe_clean_or_replace_eh_stmt (old_stmt
, stmt
);
4654 /* Copy bounds if we copy structure with bounds. */
4655 if (chkp_function_instrumented_p (id
->dst_fn
)
4656 && !BOUNDED_P (use_retvar
)
4657 && chkp_type_has_pointer (TREE_TYPE (use_retvar
)))
4658 id
->assign_stmts
.safe_push (stmt
);
4662 /* Handle the case of inlining a function with no return
4663 statement, which causes the return value to become undefined. */
4664 if (gimple_call_lhs (stmt
)
4665 && TREE_CODE (gimple_call_lhs (stmt
)) == SSA_NAME
)
4667 tree name
= gimple_call_lhs (stmt
);
4668 tree var
= SSA_NAME_VAR (name
);
4669 tree def
= ssa_default_def (cfun
, var
);
4673 /* If the variable is used undefined, make this name
4674 undefined via a move. */
4675 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), def
);
4676 gsi_replace (&stmt_gsi
, stmt
, true);
4680 /* Otherwise make this variable undefined. */
4681 gsi_remove (&stmt_gsi
, true);
4682 set_ssa_default_def (cfun
, var
, name
);
4683 SSA_NAME_DEF_STMT (name
) = gimple_build_nop ();
4687 gsi_remove (&stmt_gsi
, true);
4690 /* Put returned bounds into the correct place if required. */
4693 gimple old_stmt
= SSA_NAME_DEF_STMT (return_bounds
);
4694 gimple new_stmt
= gimple_build_assign (return_bounds
, id
->retbnd
);
4695 gimple_stmt_iterator bnd_gsi
= gsi_for_stmt (old_stmt
);
4696 unlink_stmt_vdef (old_stmt
);
4697 gsi_replace (&bnd_gsi
, new_stmt
, false);
4698 maybe_clean_or_replace_eh_stmt (old_stmt
, new_stmt
);
4699 cgraph_update_edges_for_call_stmt (old_stmt
,
4700 gimple_call_fndecl (old_stmt
),
4704 if (purge_dead_abnormal_edges
)
4706 gimple_purge_dead_eh_edges (return_block
);
4707 gimple_purge_dead_abnormal_call_edges (return_block
);
4710 /* If the value of the new expression is ignored, that's OK. We
4711 don't warn about this for CALL_EXPRs, so we shouldn't warn about
4712 the equivalent inlined version either. */
4713 if (is_gimple_assign (stmt
))
4715 gcc_assert (gimple_assign_single_p (stmt
)
4716 || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
)));
4717 TREE_USED (gimple_assign_rhs1 (stmt
)) = 1;
4720 /* Copy bounds for all generated assigns that need it. */
4721 for (i
= 0; i
< id
->assign_stmts
.length (); i
++)
4722 chkp_copy_bounds_for_assign (id
->assign_stmts
[i
], cg_edge
);
4723 id
->assign_stmts
.release ();
4725 /* Output the inlining info for this abstract function, since it has been
4726 inlined. If we don't do this now, we can lose the information about the
4727 variables in the function when the blocks get blown away as soon as we
4728 remove the cgraph node. */
4729 if (gimple_block (stmt
))
4730 (*debug_hooks
->outlining_inline_function
) (cg_edge
->callee
->decl
);
4732 /* Update callgraph if needed. */
4733 cg_edge
->callee
->remove ();
4735 id
->block
= NULL_TREE
;
4736 successfully_inlined
= TRUE
;
4739 input_location
= saved_location
;
4740 return successfully_inlined
;
4743 /* Expand call statements reachable from STMT_P.
4744 We can only have CALL_EXPRs as the "toplevel" tree code or nested
4745 in a MODIFY_EXPR. */
4748 gimple_expand_calls_inline (basic_block bb
, copy_body_data
*id
)
4750 gimple_stmt_iterator gsi
;
4752 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4754 gimple stmt
= gsi_stmt (gsi
);
4756 if (is_gimple_call (stmt
)
4757 && !gimple_call_internal_p (stmt
)
4758 && expand_call_inline (bb
, stmt
, id
))
4766 /* Walk all basic blocks created after FIRST and try to fold every statement
4767 in the STATEMENTS pointer set. */
4770 fold_marked_statements (int first
, hash_set
<gimple
> *statements
)
4772 for (; first
< n_basic_blocks_for_fn (cfun
); first
++)
4773 if (BASIC_BLOCK_FOR_FN (cfun
, first
))
4775 gimple_stmt_iterator gsi
;
4777 for (gsi
= gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, first
));
4780 if (statements
->contains (gsi_stmt (gsi
)))
4782 gimple old_stmt
= gsi_stmt (gsi
);
4783 tree old_decl
= is_gimple_call (old_stmt
) ? gimple_call_fndecl (old_stmt
) : 0;
4785 if (old_decl
&& DECL_BUILT_IN (old_decl
))
4787 /* Folding builtins can create multiple instructions,
4788 we need to look at all of them. */
4789 gimple_stmt_iterator i2
= gsi
;
4791 if (fold_stmt (&gsi
))
4794 /* If a builtin at the end of a bb folded into nothing,
4795 the following loop won't work. */
4796 if (gsi_end_p (gsi
))
4798 cgraph_update_edges_for_call_stmt (old_stmt
,
4803 i2
= gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, first
));
4808 new_stmt
= gsi_stmt (i2
);
4809 update_stmt (new_stmt
);
4810 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4813 if (new_stmt
== gsi_stmt (gsi
))
4815 /* It is okay to check only for the very last
4816 of these statements. If it is a throwing
4817 statement nothing will change. If it isn't
4818 this can remove EH edges. If that weren't
4819 correct then because some intermediate stmts
4820 throw, but not the last one. That would mean
4821 we'd have to split the block, which we can't
4822 here and we'd loose anyway. And as builtins
4823 probably never throw, this all
4825 if (maybe_clean_or_replace_eh_stmt (old_stmt
,
4827 gimple_purge_dead_eh_edges (
4828 BASIC_BLOCK_FOR_FN (cfun
, first
));
4835 else if (fold_stmt (&gsi
))
4837 /* Re-read the statement from GSI as fold_stmt() may
4839 gimple new_stmt
= gsi_stmt (gsi
);
4840 update_stmt (new_stmt
);
4842 if (is_gimple_call (old_stmt
)
4843 || is_gimple_call (new_stmt
))
4844 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4847 if (maybe_clean_or_replace_eh_stmt (old_stmt
, new_stmt
))
4848 gimple_purge_dead_eh_edges (BASIC_BLOCK_FOR_FN (cfun
,
4855 /* Expand calls to inline functions in the body of FN. */
4858 optimize_inline_calls (tree fn
)
4862 int last
= n_basic_blocks_for_fn (cfun
);
4863 bool inlined_p
= false;
4866 memset (&id
, 0, sizeof (id
));
4868 id
.src_node
= id
.dst_node
= cgraph_node::get (fn
);
4869 gcc_assert (id
.dst_node
->definition
);
4871 /* Or any functions that aren't finished yet. */
4872 if (current_function_decl
)
4873 id
.dst_fn
= current_function_decl
;
4875 id
.copy_decl
= copy_decl_maybe_to_var
;
4876 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
4877 id
.transform_new_cfg
= false;
4878 id
.transform_return_to_modify
= true;
4879 id
.transform_parameter
= true;
4880 id
.transform_lang_insert_block
= NULL
;
4881 id
.statements_to_fold
= new hash_set
<gimple
>;
4883 push_gimplify_context ();
4885 /* We make no attempts to keep dominance info up-to-date. */
4886 free_dominance_info (CDI_DOMINATORS
);
4887 free_dominance_info (CDI_POST_DOMINATORS
);
4889 /* Register specific gimple functions. */
4890 gimple_register_cfg_hooks ();
4892 /* Reach the trees by walking over the CFG, and note the
4893 enclosing basic-blocks in the call edges. */
4894 /* We walk the blocks going forward, because inlined function bodies
4895 will split id->current_basic_block, and the new blocks will
4896 follow it; we'll trudge through them, processing their CALL_EXPRs
4898 FOR_EACH_BB_FN (bb
, cfun
)
4899 inlined_p
|= gimple_expand_calls_inline (bb
, &id
);
4901 pop_gimplify_context (NULL
);
4903 #ifdef ENABLE_CHECKING
4905 struct cgraph_edge
*e
;
4907 id
.dst_node
->verify ();
4909 /* Double check that we inlined everything we are supposed to inline. */
4910 for (e
= id
.dst_node
->callees
; e
; e
= e
->next_callee
)
4911 gcc_assert (e
->inline_failed
);
4915 /* Fold queued statements. */
4916 fold_marked_statements (last
, id
.statements_to_fold
);
4917 delete id
.statements_to_fold
;
4919 gcc_assert (!id
.debug_stmts
.exists ());
4921 /* If we didn't inline into the function there is nothing to do. */
4925 /* Renumber the lexical scoping (non-code) blocks consecutively. */
4928 delete_unreachable_blocks_update_callgraph (&id
);
4929 #ifdef ENABLE_CHECKING
4930 id
.dst_node
->verify ();
4933 /* It would be nice to check SSA/CFG/statement consistency here, but it is
4934 not possible yet - the IPA passes might make various functions to not
4935 throw and they don't care to proactively update local EH info. This is
4936 done later in fixup_cfg pass that also execute the verification. */
4937 return (TODO_update_ssa
4939 | (gimple_in_ssa_p (cfun
) ? TODO_remove_unused_locals
: 0)
4940 | (gimple_in_ssa_p (cfun
) ? TODO_update_address_taken
: 0)
4941 | (profile_status_for_fn (cfun
) != PROFILE_ABSENT
4942 ? TODO_rebuild_frequencies
: 0));
4945 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
4948 copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
4950 enum tree_code code
= TREE_CODE (*tp
);
4951 enum tree_code_class cl
= TREE_CODE_CLASS (code
);
4953 /* We make copies of most nodes. */
4954 if (IS_EXPR_CODE_CLASS (cl
)
4955 || code
== TREE_LIST
4957 || code
== TYPE_DECL
4958 || code
== OMP_CLAUSE
)
4960 /* Because the chain gets clobbered when we make a copy, we save it
4962 tree chain
= NULL_TREE
, new_tree
;
4964 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
4965 chain
= TREE_CHAIN (*tp
);
4967 /* Copy the node. */
4968 new_tree
= copy_node (*tp
);
4972 /* Now, restore the chain, if appropriate. That will cause
4973 walk_tree to walk into the chain as well. */
4974 if (code
== PARM_DECL
4975 || code
== TREE_LIST
4976 || code
== OMP_CLAUSE
)
4977 TREE_CHAIN (*tp
) = chain
;
4979 /* For now, we don't update BLOCKs when we make copies. So, we
4980 have to nullify all BIND_EXPRs. */
4981 if (TREE_CODE (*tp
) == BIND_EXPR
)
4982 BIND_EXPR_BLOCK (*tp
) = NULL_TREE
;
4984 else if (code
== CONSTRUCTOR
)
4986 /* CONSTRUCTOR nodes need special handling because
4987 we need to duplicate the vector of elements. */
4990 new_tree
= copy_node (*tp
);
4991 CONSTRUCTOR_ELTS (new_tree
) = vec_safe_copy (CONSTRUCTOR_ELTS (*tp
));
4994 else if (code
== STATEMENT_LIST
)
4995 /* We used to just abort on STATEMENT_LIST, but we can run into them
4996 with statement-expressions (c++/40975). */
4997 copy_statement_list (tp
);
4998 else if (TREE_CODE_CLASS (code
) == tcc_type
)
5000 else if (TREE_CODE_CLASS (code
) == tcc_declaration
)
5002 else if (TREE_CODE_CLASS (code
) == tcc_constant
)
5007 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
5008 information indicating to what new SAVE_EXPR this one should be mapped,
5009 use that one. Otherwise, create a new node and enter it in ST. FN is
5010 the function into which the copy will be placed. */
5013 remap_save_expr (tree
*tp
, hash_map
<tree
, tree
> *st
, int *walk_subtrees
)
5018 /* See if we already encountered this SAVE_EXPR. */
5021 /* If we didn't already remap this SAVE_EXPR, do so now. */
5024 t
= copy_node (*tp
);
5026 /* Remember this SAVE_EXPR. */
5028 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
5033 /* We've already walked into this SAVE_EXPR; don't do it again. */
5038 /* Replace this SAVE_EXPR with the copy. */
5042 /* Called via walk_gimple_seq. If *GSIP points to a GIMPLE_LABEL for a local
5043 label, copies the declaration and enters it in the splay_tree in DATA (which
5044 is really a 'copy_body_data *'. */
5047 mark_local_labels_stmt (gimple_stmt_iterator
*gsip
,
5048 bool *handled_ops_p ATTRIBUTE_UNUSED
,
5049 struct walk_stmt_info
*wi
)
5051 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
5052 glabel
*stmt
= dyn_cast
<glabel
*> (gsi_stmt (*gsip
));
5056 tree decl
= gimple_label_label (stmt
);
5058 /* Copy the decl and remember the copy. */
5059 insert_decl_map (id
, decl
, id
->copy_decl (decl
, id
));
5066 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
5067 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
5068 remaps all local declarations to appropriate replacements in gimple
5072 replace_locals_op (tree
*tp
, int *walk_subtrees
, void *data
)
5074 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
5075 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
5076 hash_map
<tree
, tree
> *st
= id
->decl_map
;
5080 /* Only a local declaration (variable or label). */
5081 if ((TREE_CODE (expr
) == VAR_DECL
5082 && !TREE_STATIC (expr
))
5083 || TREE_CODE (expr
) == LABEL_DECL
)
5085 /* Lookup the declaration. */
5088 /* If it's there, remap it. */
5093 else if (TREE_CODE (expr
) == STATEMENT_LIST
5094 || TREE_CODE (expr
) == BIND_EXPR
5095 || TREE_CODE (expr
) == SAVE_EXPR
)
5097 else if (TREE_CODE (expr
) == TARGET_EXPR
)
5099 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
5100 It's OK for this to happen if it was part of a subtree that
5101 isn't immediately expanded, such as operand 2 of another
5103 if (!TREE_OPERAND (expr
, 1))
5105 TREE_OPERAND (expr
, 1) = TREE_OPERAND (expr
, 3);
5106 TREE_OPERAND (expr
, 3) = NULL_TREE
;
5110 /* Keep iterating. */
5115 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
5116 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
5117 remaps all local declarations to appropriate replacements in gimple
5121 replace_locals_stmt (gimple_stmt_iterator
*gsip
,
5122 bool *handled_ops_p ATTRIBUTE_UNUSED
,
5123 struct walk_stmt_info
*wi
)
5125 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
5126 gimple gs
= gsi_stmt (*gsip
);
5128 if (gbind
*stmt
= dyn_cast
<gbind
*> (gs
))
5130 tree block
= gimple_bind_block (stmt
);
5134 remap_block (&block
, id
);
5135 gimple_bind_set_block (stmt
, block
);
5138 /* This will remap a lot of the same decls again, but this should be
5140 if (gimple_bind_vars (stmt
))
5141 gimple_bind_set_vars (stmt
, remap_decls (gimple_bind_vars (stmt
),
5145 /* Keep iterating. */
5150 /* Copies everything in SEQ and replaces variables and labels local to
5151 current_function_decl. */
5154 copy_gimple_seq_and_replace_locals (gimple_seq seq
)
5157 struct walk_stmt_info wi
;
5160 /* There's nothing to do for NULL_TREE. */
5165 memset (&id
, 0, sizeof (id
));
5166 id
.src_fn
= current_function_decl
;
5167 id
.dst_fn
= current_function_decl
;
5168 id
.decl_map
= new hash_map
<tree
, tree
>;
5169 id
.debug_map
= NULL
;
5171 id
.copy_decl
= copy_decl_no_change
;
5172 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5173 id
.transform_new_cfg
= false;
5174 id
.transform_return_to_modify
= false;
5175 id
.transform_parameter
= false;
5176 id
.transform_lang_insert_block
= NULL
;
5178 /* Walk the tree once to find local labels. */
5179 memset (&wi
, 0, sizeof (wi
));
5180 hash_set
<tree
> visited
;
5183 walk_gimple_seq (seq
, mark_local_labels_stmt
, NULL
, &wi
);
5185 copy
= gimple_seq_copy (seq
);
5187 /* Walk the copy, remapping decls. */
5188 memset (&wi
, 0, sizeof (wi
));
5190 walk_gimple_seq (copy
, replace_locals_stmt
, replace_locals_op
, &wi
);
5195 delete id
.debug_map
;
5196 if (id
.dependence_map
)
5198 delete id
.dependence_map
;
5199 id
.dependence_map
= NULL
;
5206 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
5209 debug_find_tree_1 (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
, void *data
)
5218 debug_find_tree (tree top
, tree search
)
5220 return walk_tree_without_duplicates (&top
, debug_find_tree_1
, search
) != 0;
5224 /* Declare the variables created by the inliner. Add all the variables in
5225 VARS to BIND_EXPR. */
5228 declare_inline_vars (tree block
, tree vars
)
5231 for (t
= vars
; t
; t
= DECL_CHAIN (t
))
5233 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
5234 gcc_assert (!TREE_STATIC (t
) && !TREE_ASM_WRITTEN (t
));
5235 add_local_decl (cfun
, t
);
5239 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), vars
);
5242 /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN,
5243 but now it will be in the TO_FN. PARM_TO_VAR means enable PARM_DECL to
5244 VAR_DECL translation. */
5247 copy_decl_for_dup_finish (copy_body_data
*id
, tree decl
, tree copy
)
5249 /* Don't generate debug information for the copy if we wouldn't have
5250 generated it for the copy either. */
5251 DECL_ARTIFICIAL (copy
) = DECL_ARTIFICIAL (decl
);
5252 DECL_IGNORED_P (copy
) = DECL_IGNORED_P (decl
);
5254 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
5255 declaration inspired this copy. */
5256 DECL_ABSTRACT_ORIGIN (copy
) = DECL_ORIGIN (decl
);
5258 /* The new variable/label has no RTL, yet. */
5259 if (CODE_CONTAINS_STRUCT (TREE_CODE (copy
), TS_DECL_WRTL
)
5260 && !TREE_STATIC (copy
) && !DECL_EXTERNAL (copy
))
5261 SET_DECL_RTL (copy
, 0);
5263 /* These args would always appear unused, if not for this. */
5264 TREE_USED (copy
) = 1;
5266 /* Set the context for the new declaration. */
5267 if (!DECL_CONTEXT (decl
))
5268 /* Globals stay global. */
5270 else if (DECL_CONTEXT (decl
) != id
->src_fn
)
5271 /* Things that weren't in the scope of the function we're inlining
5272 from aren't in the scope we're inlining to, either. */
5274 else if (TREE_STATIC (decl
))
5275 /* Function-scoped static variables should stay in the original
5279 /* Ordinary automatic local variables are now in the scope of the
5281 DECL_CONTEXT (copy
) = id
->dst_fn
;
5287 copy_decl_to_var (tree decl
, copy_body_data
*id
)
5291 gcc_assert (TREE_CODE (decl
) == PARM_DECL
5292 || TREE_CODE (decl
) == RESULT_DECL
);
5294 type
= TREE_TYPE (decl
);
5296 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
5297 VAR_DECL
, DECL_NAME (decl
), type
);
5298 if (DECL_PT_UID_SET_P (decl
))
5299 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
5300 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
5301 TREE_READONLY (copy
) = TREE_READONLY (decl
);
5302 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
5303 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
5305 return copy_decl_for_dup_finish (id
, decl
, copy
);
5308 /* Like copy_decl_to_var, but create a return slot object instead of a
5309 pointer variable for return by invisible reference. */
5312 copy_result_decl_to_var (tree decl
, copy_body_data
*id
)
5316 gcc_assert (TREE_CODE (decl
) == PARM_DECL
5317 || TREE_CODE (decl
) == RESULT_DECL
);
5319 type
= TREE_TYPE (decl
);
5320 if (DECL_BY_REFERENCE (decl
))
5321 type
= TREE_TYPE (type
);
5323 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
5324 VAR_DECL
, DECL_NAME (decl
), type
);
5325 if (DECL_PT_UID_SET_P (decl
))
5326 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
5327 TREE_READONLY (copy
) = TREE_READONLY (decl
);
5328 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
5329 if (!DECL_BY_REFERENCE (decl
))
5331 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
5332 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
5335 return copy_decl_for_dup_finish (id
, decl
, copy
);
5339 copy_decl_no_change (tree decl
, copy_body_data
*id
)
5343 copy
= copy_node (decl
);
5345 /* The COPY is not abstract; it will be generated in DST_FN. */
5346 DECL_ABSTRACT_P (copy
) = false;
5347 lang_hooks
.dup_lang_specific_decl (copy
);
5349 /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
5350 been taken; it's for internal bookkeeping in expand_goto_internal. */
5351 if (TREE_CODE (copy
) == LABEL_DECL
)
5353 TREE_ADDRESSABLE (copy
) = 0;
5354 LABEL_DECL_UID (copy
) = -1;
5357 return copy_decl_for_dup_finish (id
, decl
, copy
);
5361 copy_decl_maybe_to_var (tree decl
, copy_body_data
*id
)
5363 if (TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
)
5364 return copy_decl_to_var (decl
, id
);
5366 return copy_decl_no_change (decl
, id
);
5369 /* Return a copy of the function's argument tree. */
5371 copy_arguments_for_versioning (tree orig_parm
, copy_body_data
* id
,
5372 bitmap args_to_skip
, tree
*vars
)
5375 tree new_parm
= NULL
;
5380 for (arg
= orig_parm
; arg
; arg
= DECL_CHAIN (arg
), i
++)
5381 if (!args_to_skip
|| !bitmap_bit_p (args_to_skip
, i
))
5383 tree new_tree
= remap_decl (arg
, id
);
5384 if (TREE_CODE (new_tree
) != PARM_DECL
)
5385 new_tree
= id
->copy_decl (arg
, id
);
5386 lang_hooks
.dup_lang_specific_decl (new_tree
);
5388 parg
= &DECL_CHAIN (new_tree
);
5390 else if (!id
->decl_map
->get (arg
))
5392 /* Make an equivalent VAR_DECL. If the argument was used
5393 as temporary variable later in function, the uses will be
5394 replaced by local variable. */
5395 tree var
= copy_decl_to_var (arg
, id
);
5396 insert_decl_map (id
, arg
, var
);
5397 /* Declare this new variable. */
5398 DECL_CHAIN (var
) = *vars
;
5404 /* Return a copy of the function's static chain. */
5406 copy_static_chain (tree static_chain
, copy_body_data
* id
)
5408 tree
*chain_copy
, *pvar
;
5410 chain_copy
= &static_chain
;
5411 for (pvar
= chain_copy
; *pvar
; pvar
= &DECL_CHAIN (*pvar
))
5413 tree new_tree
= remap_decl (*pvar
, id
);
5414 lang_hooks
.dup_lang_specific_decl (new_tree
);
5415 DECL_CHAIN (new_tree
) = DECL_CHAIN (*pvar
);
5418 return static_chain
;
5421 /* Return true if the function is allowed to be versioned.
5422 This is a guard for the versioning functionality. */
5425 tree_versionable_function_p (tree fndecl
)
5427 return (!lookup_attribute ("noclone", DECL_ATTRIBUTES (fndecl
))
5428 && copy_forbidden (DECL_STRUCT_FUNCTION (fndecl
), fndecl
) == NULL
);
5431 /* Delete all unreachable basic blocks and update callgraph.
5432 Doing so is somewhat nontrivial because we need to update all clones and
5433 remove inline function that become unreachable. */
5436 delete_unreachable_blocks_update_callgraph (copy_body_data
*id
)
5438 bool changed
= false;
5439 basic_block b
, next_bb
;
5441 find_unreachable_blocks ();
5443 /* Delete all unreachable basic blocks. */
5445 for (b
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
; b
5446 != EXIT_BLOCK_PTR_FOR_FN (cfun
); b
= next_bb
)
5448 next_bb
= b
->next_bb
;
5450 if (!(b
->flags
& BB_REACHABLE
))
5452 gimple_stmt_iterator bsi
;
5454 for (bsi
= gsi_start_bb (b
); !gsi_end_p (bsi
); gsi_next (&bsi
))
5456 struct cgraph_edge
*e
;
5457 struct cgraph_node
*node
;
5459 id
->dst_node
->remove_stmt_references (gsi_stmt (bsi
));
5461 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
5462 &&(e
= id
->dst_node
->get_edge (gsi_stmt (bsi
))) != NULL
)
5464 if (!e
->inline_failed
)
5465 e
->callee
->remove_symbol_and_inline_clones (id
->dst_node
);
5469 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
5470 && id
->dst_node
->clones
)
5471 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
5473 node
->remove_stmt_references (gsi_stmt (bsi
));
5474 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
5475 && (e
= node
->get_edge (gsi_stmt (bsi
))) != NULL
)
5477 if (!e
->inline_failed
)
5478 e
->callee
->remove_symbol_and_inline_clones (id
->dst_node
);
5484 node
= node
->clones
;
5485 else if (node
->next_sibling_clone
)
5486 node
= node
->next_sibling_clone
;
5489 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5490 node
= node
->clone_of
;
5491 if (node
!= id
->dst_node
)
5492 node
= node
->next_sibling_clone
;
5496 delete_basic_block (b
);
5504 /* Update clone info after duplication. */
5507 update_clone_info (copy_body_data
* id
)
5509 struct cgraph_node
*node
;
5510 if (!id
->dst_node
->clones
)
5512 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
5514 /* First update replace maps to match the new body. */
5515 if (node
->clone
.tree_map
)
5518 for (i
= 0; i
< vec_safe_length (node
->clone
.tree_map
); i
++)
5520 struct ipa_replace_map
*replace_info
;
5521 replace_info
= (*node
->clone
.tree_map
)[i
];
5522 walk_tree (&replace_info
->old_tree
, copy_tree_body_r
, id
, NULL
);
5523 walk_tree (&replace_info
->new_tree
, copy_tree_body_r
, id
, NULL
);
5527 node
= node
->clones
;
5528 else if (node
->next_sibling_clone
)
5529 node
= node
->next_sibling_clone
;
5532 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5533 node
= node
->clone_of
;
5534 if (node
!= id
->dst_node
)
5535 node
= node
->next_sibling_clone
;
5540 /* Create a copy of a function's tree.
5541 OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
5542 of the original function and the new copied function
5543 respectively. In case we want to replace a DECL
5544 tree with another tree while duplicating the function's
5545 body, TREE_MAP represents the mapping between these
5546 trees. If UPDATE_CLONES is set, the call_stmt fields
5547 of edges of clones of the function will be updated.
5549 If non-NULL ARGS_TO_SKIP determine function parameters to remove
5551 If SKIP_RETURN is true, the new version will return void.
5552 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
5553 If non_NULL NEW_ENTRY determine new entry BB of the clone.
5556 tree_function_versioning (tree old_decl
, tree new_decl
,
5557 vec
<ipa_replace_map
*, va_gc
> *tree_map
,
5558 bool update_clones
, bitmap args_to_skip
,
5559 bool skip_return
, bitmap blocks_to_copy
,
5560 basic_block new_entry
)
5562 struct cgraph_node
*old_version_node
;
5563 struct cgraph_node
*new_version_node
;
5567 struct ipa_replace_map
*replace_info
;
5568 basic_block old_entry_block
, bb
;
5569 auto_vec
<gimple
, 10> init_stmts
;
5570 tree vars
= NULL_TREE
;
5572 gcc_assert (TREE_CODE (old_decl
) == FUNCTION_DECL
5573 && TREE_CODE (new_decl
) == FUNCTION_DECL
);
5574 DECL_POSSIBLY_INLINED (old_decl
) = 1;
5576 old_version_node
= cgraph_node::get (old_decl
);
5577 gcc_checking_assert (old_version_node
);
5578 new_version_node
= cgraph_node::get (new_decl
);
5579 gcc_checking_assert (new_version_node
);
5581 /* Copy over debug args. */
5582 if (DECL_HAS_DEBUG_ARGS_P (old_decl
))
5584 vec
<tree
, va_gc
> **new_debug_args
, **old_debug_args
;
5585 gcc_checking_assert (decl_debug_args_lookup (new_decl
) == NULL
);
5586 DECL_HAS_DEBUG_ARGS_P (new_decl
) = 0;
5587 old_debug_args
= decl_debug_args_lookup (old_decl
);
5590 new_debug_args
= decl_debug_args_insert (new_decl
);
5591 *new_debug_args
= vec_safe_copy (*old_debug_args
);
5595 /* Output the inlining info for this abstract function, since it has been
5596 inlined. If we don't do this now, we can lose the information about the
5597 variables in the function when the blocks get blown away as soon as we
5598 remove the cgraph node. */
5599 (*debug_hooks
->outlining_inline_function
) (old_decl
);
5601 DECL_ARTIFICIAL (new_decl
) = 1;
5602 DECL_ABSTRACT_ORIGIN (new_decl
) = DECL_ORIGIN (old_decl
);
5603 if (DECL_ORIGIN (old_decl
) == old_decl
)
5604 old_version_node
->used_as_abstract_origin
= true;
5605 DECL_FUNCTION_PERSONALITY (new_decl
) = DECL_FUNCTION_PERSONALITY (old_decl
);
5607 /* Prepare the data structures for the tree copy. */
5608 memset (&id
, 0, sizeof (id
));
5610 /* Generate a new name for the new version. */
5611 id
.statements_to_fold
= new hash_set
<gimple
>;
5613 id
.decl_map
= new hash_map
<tree
, tree
>;
5614 id
.debug_map
= NULL
;
5615 id
.src_fn
= old_decl
;
5616 id
.dst_fn
= new_decl
;
5617 id
.src_node
= old_version_node
;
5618 id
.dst_node
= new_version_node
;
5619 id
.src_cfun
= DECL_STRUCT_FUNCTION (old_decl
);
5620 id
.blocks_to_copy
= blocks_to_copy
;
5622 id
.copy_decl
= copy_decl_no_change
;
5623 id
.transform_call_graph_edges
5624 = update_clones
? CB_CGE_MOVE_CLONES
: CB_CGE_MOVE
;
5625 id
.transform_new_cfg
= true;
5626 id
.transform_return_to_modify
= false;
5627 id
.transform_parameter
= false;
5628 id
.transform_lang_insert_block
= NULL
;
5630 old_entry_block
= ENTRY_BLOCK_PTR_FOR_FN
5631 (DECL_STRUCT_FUNCTION (old_decl
));
5632 DECL_RESULT (new_decl
) = DECL_RESULT (old_decl
);
5633 DECL_ARGUMENTS (new_decl
) = DECL_ARGUMENTS (old_decl
);
5634 initialize_cfun (new_decl
, old_decl
,
5635 old_entry_block
->count
);
5636 if (DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
)
5637 DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
->ipa_pta
5638 = id
.src_cfun
->gimple_df
->ipa_pta
;
5640 /* Copy the function's static chain. */
5641 p
= DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
;
5643 DECL_STRUCT_FUNCTION (new_decl
)->static_chain_decl
=
5644 copy_static_chain (DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
,
5647 /* If there's a tree_map, prepare for substitution. */
5649 for (i
= 0; i
< tree_map
->length (); i
++)
5652 replace_info
= (*tree_map
)[i
];
5653 if (replace_info
->replace_p
)
5655 if (!replace_info
->old_tree
)
5657 int i
= replace_info
->parm_num
;
5661 for (parm
= DECL_ARGUMENTS (old_decl
); i
; parm
= DECL_CHAIN (parm
))
5663 replace_info
->old_tree
= parm
;
5664 req_type
= TREE_TYPE (parm
);
5665 if (!useless_type_conversion_p (req_type
, TREE_TYPE (replace_info
->new_tree
)))
5667 if (fold_convertible_p (req_type
, replace_info
->new_tree
))
5668 replace_info
->new_tree
= fold_build1 (NOP_EXPR
, req_type
, replace_info
->new_tree
);
5669 else if (TYPE_SIZE (req_type
) == TYPE_SIZE (TREE_TYPE (replace_info
->new_tree
)))
5670 replace_info
->new_tree
= fold_build1 (VIEW_CONVERT_EXPR
, req_type
, replace_info
->new_tree
);
5675 fprintf (dump_file
, " const ");
5676 print_generic_expr (dump_file
, replace_info
->new_tree
, 0);
5677 fprintf (dump_file
, " can't be converted to param ");
5678 print_generic_expr (dump_file
, parm
, 0);
5679 fprintf (dump_file
, "\n");
5681 replace_info
->old_tree
= NULL
;
5686 gcc_assert (TREE_CODE (replace_info
->old_tree
) == PARM_DECL
);
5687 if (replace_info
->old_tree
)
5689 init
= setup_one_parameter (&id
, replace_info
->old_tree
,
5690 replace_info
->new_tree
, id
.src_fn
,
5694 init_stmts
.safe_push (init
);
5698 /* Copy the function's arguments. */
5699 if (DECL_ARGUMENTS (old_decl
) != NULL_TREE
)
5700 DECL_ARGUMENTS (new_decl
) =
5701 copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl
), &id
,
5702 args_to_skip
, &vars
);
5704 DECL_INITIAL (new_decl
) = remap_blocks (DECL_INITIAL (id
.src_fn
), &id
);
5705 BLOCK_SUPERCONTEXT (DECL_INITIAL (new_decl
)) = new_decl
;
5707 declare_inline_vars (DECL_INITIAL (new_decl
), vars
);
5709 if (!vec_safe_is_empty (DECL_STRUCT_FUNCTION (old_decl
)->local_decls
))
5710 /* Add local vars. */
5711 add_local_variables (DECL_STRUCT_FUNCTION (old_decl
), cfun
, &id
);
5713 if (DECL_RESULT (old_decl
) == NULL_TREE
)
5715 else if (skip_return
&& !VOID_TYPE_P (TREE_TYPE (DECL_RESULT (old_decl
))))
5717 DECL_RESULT (new_decl
)
5718 = build_decl (DECL_SOURCE_LOCATION (DECL_RESULT (old_decl
)),
5719 RESULT_DECL
, NULL_TREE
, void_type_node
);
5720 DECL_CONTEXT (DECL_RESULT (new_decl
)) = new_decl
;
5721 cfun
->returns_struct
= 0;
5722 cfun
->returns_pcc_struct
= 0;
5727 DECL_RESULT (new_decl
) = remap_decl (DECL_RESULT (old_decl
), &id
);
5728 lang_hooks
.dup_lang_specific_decl (DECL_RESULT (new_decl
));
5729 if (gimple_in_ssa_p (id
.src_cfun
)
5730 && DECL_BY_REFERENCE (DECL_RESULT (old_decl
))
5731 && (old_name
= ssa_default_def (id
.src_cfun
, DECL_RESULT (old_decl
))))
5733 tree new_name
= make_ssa_name (DECL_RESULT (new_decl
));
5734 insert_decl_map (&id
, old_name
, new_name
);
5735 SSA_NAME_DEF_STMT (new_name
) = gimple_build_nop ();
5736 set_ssa_default_def (cfun
, DECL_RESULT (new_decl
), new_name
);
5740 /* Set up the destination functions loop tree. */
5741 if (loops_for_fn (DECL_STRUCT_FUNCTION (old_decl
)) != NULL
)
5743 cfun
->curr_properties
&= ~PROP_loops
;
5744 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
5745 cfun
->curr_properties
|= PROP_loops
;
5748 /* Copy the Function's body. */
5749 copy_body (&id
, old_entry_block
->count
, REG_BR_PROB_BASE
,
5750 ENTRY_BLOCK_PTR_FOR_FN (cfun
), EXIT_BLOCK_PTR_FOR_FN (cfun
),
5753 /* Renumber the lexical scoping (non-code) blocks consecutively. */
5754 number_blocks (new_decl
);
5756 /* We want to create the BB unconditionally, so that the addition of
5757 debug stmts doesn't affect BB count, which may in the end cause
5758 codegen differences. */
5759 bb
= split_edge (single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
5760 while (init_stmts
.length ())
5761 insert_init_stmt (&id
, bb
, init_stmts
.pop ());
5762 update_clone_info (&id
);
5764 /* Remap the nonlocal_goto_save_area, if any. */
5765 if (cfun
->nonlocal_goto_save_area
)
5767 struct walk_stmt_info wi
;
5769 memset (&wi
, 0, sizeof (wi
));
5771 walk_tree (&cfun
->nonlocal_goto_save_area
, remap_gimple_op_r
, &wi
, NULL
);
5777 delete id
.debug_map
;
5778 free_dominance_info (CDI_DOMINATORS
);
5779 free_dominance_info (CDI_POST_DOMINATORS
);
5781 fold_marked_statements (0, id
.statements_to_fold
);
5782 delete id
.statements_to_fold
;
5783 fold_cond_expr_cond ();
5784 delete_unreachable_blocks_update_callgraph (&id
);
5785 if (id
.dst_node
->definition
)
5786 cgraph_edge::rebuild_references ();
5787 if (loops_state_satisfies_p (LOOPS_NEED_FIXUP
))
5789 calculate_dominance_info (CDI_DOMINATORS
);
5790 fix_loop_structure (NULL
);
5792 update_ssa (TODO_update_ssa
);
5794 /* After partial cloning we need to rescale frequencies, so they are
5795 within proper range in the cloned function. */
5798 struct cgraph_edge
*e
;
5799 rebuild_frequencies ();
5801 new_version_node
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5802 for (e
= new_version_node
->callees
; e
; e
= e
->next_callee
)
5804 basic_block bb
= gimple_bb (e
->call_stmt
);
5805 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
5807 e
->count
= bb
->count
;
5809 for (e
= new_version_node
->indirect_calls
; e
; e
= e
->next_callee
)
5811 basic_block bb
= gimple_bb (e
->call_stmt
);
5812 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
5814 e
->count
= bb
->count
;
5818 free_dominance_info (CDI_DOMINATORS
);
5819 free_dominance_info (CDI_POST_DOMINATORS
);
5821 gcc_assert (!id
.debug_stmts
.exists ());
5826 /* EXP is CALL_EXPR present in a GENERIC expression tree. Try to integrate
5827 the callee and return the inlined body on success. */
5830 maybe_inline_call_in_expr (tree exp
)
5832 tree fn
= get_callee_fndecl (exp
);
5834 /* We can only try to inline "const" functions. */
5835 if (fn
&& TREE_READONLY (fn
) && DECL_SAVED_TREE (fn
))
5837 call_expr_arg_iterator iter
;
5840 hash_map
<tree
, tree
> decl_map
;
5842 /* Remap the parameters. */
5843 for (param
= DECL_ARGUMENTS (fn
), arg
= first_call_expr_arg (exp
, &iter
);
5845 param
= DECL_CHAIN (param
), arg
= next_call_expr_arg (&iter
))
5846 decl_map
.put (param
, arg
);
5848 memset (&id
, 0, sizeof (id
));
5850 id
.dst_fn
= current_function_decl
;
5851 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
5852 id
.decl_map
= &decl_map
;
5854 id
.copy_decl
= copy_decl_no_change
;
5855 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5856 id
.transform_new_cfg
= false;
5857 id
.transform_return_to_modify
= true;
5858 id
.transform_parameter
= true;
5859 id
.transform_lang_insert_block
= NULL
;
5861 /* Make sure not to unshare trees behind the front-end's back
5862 since front-end specific mechanisms may rely on sharing. */
5863 id
.regimplify
= false;
5864 id
.do_not_unshare
= true;
5866 /* We're not inside any EH region. */
5869 t
= copy_tree_body (&id
);
5871 /* We can only return something suitable for use in a GENERIC
5873 if (TREE_CODE (t
) == MODIFY_EXPR
)
5874 return TREE_OPERAND (t
, 1);
5880 /* Duplicate a type, fields and all. */
5883 build_duplicate_type (tree type
)
5885 struct copy_body_data id
;
5887 memset (&id
, 0, sizeof (id
));
5888 id
.src_fn
= current_function_decl
;
5889 id
.dst_fn
= current_function_decl
;
5891 id
.decl_map
= new hash_map
<tree
, tree
>;
5892 id
.debug_map
= NULL
;
5893 id
.copy_decl
= copy_decl_no_change
;
5895 type
= remap_type_1 (type
, &id
);
5899 delete id
.debug_map
;
5901 TYPE_CANONICAL (type
) = type
;
5906 /* Unshare the entire DECL_SAVED_TREE of FN and return the remapped
5907 parameters and RESULT_DECL in PARMS and RESULT. Used by C++ constexpr
5911 copy_fn (tree fn
, tree
& parms
, tree
& result
)
5915 hash_map
<tree
, tree
> decl_map
;
5920 memset (&id
, 0, sizeof (id
));
5922 id
.dst_fn
= current_function_decl
;
5923 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
5924 id
.decl_map
= &decl_map
;
5926 id
.copy_decl
= copy_decl_no_change
;
5927 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5928 id
.transform_new_cfg
= false;
5929 id
.transform_return_to_modify
= false;
5930 id
.transform_parameter
= true;
5931 id
.transform_lang_insert_block
= NULL
;
5933 /* Make sure not to unshare trees behind the front-end's back
5934 since front-end specific mechanisms may rely on sharing. */
5935 id
.regimplify
= false;
5936 id
.do_not_unshare
= true;
5938 /* We're not inside any EH region. */
5941 /* Remap the parameters and result and return them to the caller. */
5942 for (param
= DECL_ARGUMENTS (fn
);
5944 param
= DECL_CHAIN (param
))
5946 *p
= remap_decl (param
, &id
);
5947 p
= &DECL_CHAIN (*p
);
5950 if (DECL_RESULT (fn
))
5951 result
= remap_decl (DECL_RESULT (fn
), &id
);
5955 return copy_tree_body (&id
);