2 Copyright (C) 2001-2014 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"
78 #include "value-prof.h"
79 #include "tree-pass.h"
84 #include "rtl.h" /* FIXME: For asm_str_count. */
86 /* I'm not real happy about this, but we need to handle gimple and
89 /* Inlining, Cloning, Versioning, Parallelization
91 Inlining: a function body is duplicated, but the PARM_DECLs are
92 remapped into VAR_DECLs, and non-void RETURN_EXPRs become
93 MODIFY_EXPRs that store to a dedicated returned-value variable.
94 The duplicated eh_region info of the copy will later be appended
95 to the info for the caller; the eh_region info in copied throwing
96 statements and RESX statements are adjusted accordingly.
98 Cloning: (only in C++) We have one body for a con/de/structor, and
99 multiple function decls, each with a unique parameter list.
100 Duplicate the body, using the given splay tree; some parameters
101 will become constants (like 0 or 1).
103 Versioning: a function body is duplicated and the result is a new
104 function rather than into blocks of an existing function as with
105 inlining. Some parameters will become constants.
107 Parallelization: a region of a function is duplicated resulting in
108 a new function. Variables may be replaced with complex expressions
109 to enable shared variable semantics.
111 All of these will simultaneously lookup any callgraph edges. If
112 we're going to inline the duplicated function body, and the given
113 function has some cloned callgraph nodes (one for each place this
114 function will be inlined) those callgraph edges will be duplicated.
115 If we're cloning the body, those callgraph edges will be
116 updated to point into the new body. (Note that the original
117 callgraph node and edge list will not be altered.)
119 See the CALL_EXPR handling case in copy_tree_body_r (). */
123 o In order to make inlining-on-trees work, we pessimized
124 function-local static constants. In particular, they are now
125 always output, even when not addressed. Fix this by treating
126 function-local static constants just like global static
127 constants; the back-end already knows not to output them if they
130 o Provide heuristics to clamp inlining of recursive template
134 /* Weights that estimate_num_insns uses to estimate the size of the
137 eni_weights eni_size_weights
;
139 /* Weights that estimate_num_insns uses to estimate the time necessary
140 to execute the produced code. */
142 eni_weights eni_time_weights
;
146 static tree
declare_return_variable (copy_body_data
*, tree
, tree
, basic_block
);
147 static void remap_block (tree
*, copy_body_data
*);
148 static void copy_bind_expr (tree
*, int *, copy_body_data
*);
149 static void declare_inline_vars (tree
, tree
);
150 static void remap_save_expr (tree
*, hash_map
<tree
, tree
> *, int *);
151 static void prepend_lexical_block (tree current_block
, tree new_block
);
152 static tree
copy_decl_to_var (tree
, copy_body_data
*);
153 static tree
copy_result_decl_to_var (tree
, copy_body_data
*);
154 static tree
copy_decl_maybe_to_var (tree
, copy_body_data
*);
155 static gimple
remap_gimple_stmt (gimple
, copy_body_data
*);
156 static bool delete_unreachable_blocks_update_callgraph (copy_body_data
*id
);
158 /* Insert a tree->tree mapping for ID. Despite the name suggests
159 that the trees should be variables, it is used for more than that. */
162 insert_decl_map (copy_body_data
*id
, tree key
, tree value
)
164 id
->decl_map
->put (key
, value
);
166 /* Always insert an identity map as well. If we see this same new
167 node again, we won't want to duplicate it a second time. */
169 id
->decl_map
->put (value
, value
);
172 /* Insert a tree->tree mapping for ID. This is only used for
176 insert_debug_decl_map (copy_body_data
*id
, tree key
, tree value
)
178 if (!gimple_in_ssa_p (id
->src_cfun
))
181 if (!MAY_HAVE_DEBUG_STMTS
)
184 if (!target_for_debug_bind (key
))
187 gcc_assert (TREE_CODE (key
) == PARM_DECL
);
188 gcc_assert (TREE_CODE (value
) == VAR_DECL
);
191 id
->debug_map
= new hash_map
<tree
, tree
>;
193 id
->debug_map
->put (key
, value
);
196 /* If nonzero, we're remapping the contents of inlined debug
197 statements. If negative, an error has occurred, such as a
198 reference to a variable that isn't available in the inlined
200 static int processing_debug_stmt
= 0;
202 /* Construct new SSA name for old NAME. ID is the inline context. */
205 remap_ssa_name (tree name
, copy_body_data
*id
)
210 gcc_assert (TREE_CODE (name
) == SSA_NAME
);
212 n
= id
->decl_map
->get (name
);
214 return unshare_expr (*n
);
216 if (processing_debug_stmt
)
218 if (SSA_NAME_IS_DEFAULT_DEF (name
)
219 && TREE_CODE (SSA_NAME_VAR (name
)) == PARM_DECL
220 && id
->entry_bb
== NULL
221 && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (cfun
)))
223 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
225 gimple_stmt_iterator gsi
;
226 tree val
= SSA_NAME_VAR (name
);
228 n
= id
->decl_map
->get (val
);
231 if (TREE_CODE (val
) != PARM_DECL
)
233 processing_debug_stmt
= -1;
236 def_temp
= gimple_build_debug_source_bind (vexpr
, val
, NULL
);
237 DECL_ARTIFICIAL (vexpr
) = 1;
238 TREE_TYPE (vexpr
) = TREE_TYPE (name
);
239 DECL_MODE (vexpr
) = DECL_MODE (SSA_NAME_VAR (name
));
240 gsi
= gsi_after_labels (single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
241 gsi_insert_before (&gsi
, def_temp
, GSI_SAME_STMT
);
245 processing_debug_stmt
= -1;
249 /* Remap anonymous SSA names or SSA names of anonymous decls. */
250 var
= SSA_NAME_VAR (name
);
252 || (!SSA_NAME_IS_DEFAULT_DEF (name
)
253 && TREE_CODE (var
) == VAR_DECL
254 && !VAR_DECL_IS_VIRTUAL_OPERAND (var
)
255 && DECL_ARTIFICIAL (var
)
256 && DECL_IGNORED_P (var
)
257 && !DECL_NAME (var
)))
259 struct ptr_info_def
*pi
;
260 new_tree
= make_ssa_name (remap_type (TREE_TYPE (name
), id
), NULL
);
261 if (!var
&& SSA_NAME_IDENTIFIER (name
))
262 SET_SSA_NAME_VAR_OR_IDENTIFIER (new_tree
, SSA_NAME_IDENTIFIER (name
));
263 insert_decl_map (id
, name
, new_tree
);
264 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
265 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
266 /* At least IPA points-to info can be directly transferred. */
267 if (id
->src_cfun
->gimple_df
268 && id
->src_cfun
->gimple_df
->ipa_pta
269 && (pi
= SSA_NAME_PTR_INFO (name
))
272 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
278 /* Do not set DEF_STMT yet as statement is not copied yet. We do that
280 new_tree
= remap_decl (var
, id
);
282 /* We might've substituted constant or another SSA_NAME for
285 Replace the SSA name representing RESULT_DECL by variable during
286 inlining: this saves us from need to introduce PHI node in a case
287 return value is just partly initialized. */
288 if ((TREE_CODE (new_tree
) == VAR_DECL
|| TREE_CODE (new_tree
) == PARM_DECL
)
289 && (!SSA_NAME_VAR (name
)
290 || TREE_CODE (SSA_NAME_VAR (name
)) != RESULT_DECL
291 || !id
->transform_return_to_modify
))
293 struct ptr_info_def
*pi
;
294 new_tree
= make_ssa_name (new_tree
, NULL
);
295 insert_decl_map (id
, name
, new_tree
);
296 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
297 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
298 /* At least IPA points-to info can be directly transferred. */
299 if (id
->src_cfun
->gimple_df
300 && id
->src_cfun
->gimple_df
->ipa_pta
301 && (pi
= SSA_NAME_PTR_INFO (name
))
304 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
307 if (SSA_NAME_IS_DEFAULT_DEF (name
))
309 /* By inlining function having uninitialized variable, we might
310 extend the lifetime (variable might get reused). This cause
311 ICE in the case we end up extending lifetime of SSA name across
312 abnormal edge, but also increase register pressure.
314 We simply initialize all uninitialized vars by 0 except
315 for case we are inlining to very first BB. We can avoid
316 this for all BBs that are not inside strongly connected
317 regions of the CFG, but this is expensive to test. */
319 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
)
320 && (!SSA_NAME_VAR (name
)
321 || TREE_CODE (SSA_NAME_VAR (name
)) != PARM_DECL
)
322 && (id
->entry_bb
!= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
),
324 || EDGE_COUNT (id
->entry_bb
->preds
) != 1))
326 gimple_stmt_iterator gsi
= gsi_last_bb (id
->entry_bb
);
328 tree zero
= build_zero_cst (TREE_TYPE (new_tree
));
330 init_stmt
= gimple_build_assign (new_tree
, zero
);
331 gsi_insert_after (&gsi
, init_stmt
, GSI_NEW_STMT
);
332 SSA_NAME_IS_DEFAULT_DEF (new_tree
) = 0;
336 SSA_NAME_DEF_STMT (new_tree
) = gimple_build_nop ();
337 set_ssa_default_def (cfun
, SSA_NAME_VAR (new_tree
), new_tree
);
342 insert_decl_map (id
, name
, new_tree
);
346 /* Remap DECL during the copying of the BLOCK tree for the function. */
349 remap_decl (tree decl
, copy_body_data
*id
)
353 /* We only remap local variables in the current function. */
355 /* See if we have remapped this declaration. */
357 n
= id
->decl_map
->get (decl
);
359 if (!n
&& processing_debug_stmt
)
361 processing_debug_stmt
= -1;
365 /* If we didn't already have an equivalent for this declaration,
369 /* Make a copy of the variable or label. */
370 tree t
= id
->copy_decl (decl
, id
);
372 /* Remember it, so that if we encounter this local entity again
373 we can reuse this copy. Do this early because remap_type may
374 need this decl for TYPE_STUB_DECL. */
375 insert_decl_map (id
, decl
, t
);
380 /* Remap types, if necessary. */
381 TREE_TYPE (t
) = remap_type (TREE_TYPE (t
), id
);
382 if (TREE_CODE (t
) == TYPE_DECL
)
383 DECL_ORIGINAL_TYPE (t
) = remap_type (DECL_ORIGINAL_TYPE (t
), id
);
385 /* Remap sizes as necessary. */
386 walk_tree (&DECL_SIZE (t
), copy_tree_body_r
, id
, NULL
);
387 walk_tree (&DECL_SIZE_UNIT (t
), copy_tree_body_r
, id
, NULL
);
389 /* If fields, do likewise for offset and qualifier. */
390 if (TREE_CODE (t
) == FIELD_DECL
)
392 walk_tree (&DECL_FIELD_OFFSET (t
), copy_tree_body_r
, id
, NULL
);
393 if (TREE_CODE (DECL_CONTEXT (t
)) == QUAL_UNION_TYPE
)
394 walk_tree (&DECL_QUALIFIER (t
), copy_tree_body_r
, id
, NULL
);
400 if (id
->do_not_unshare
)
403 return unshare_expr (*n
);
407 remap_type_1 (tree type
, copy_body_data
*id
)
411 /* We do need a copy. build and register it now. If this is a pointer or
412 reference type, remap the designated type and make a new pointer or
414 if (TREE_CODE (type
) == POINTER_TYPE
)
416 new_tree
= build_pointer_type_for_mode (remap_type (TREE_TYPE (type
), id
),
418 TYPE_REF_CAN_ALIAS_ALL (type
));
419 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
420 new_tree
= build_type_attribute_qual_variant (new_tree
,
421 TYPE_ATTRIBUTES (type
),
423 insert_decl_map (id
, type
, new_tree
);
426 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
428 new_tree
= build_reference_type_for_mode (remap_type (TREE_TYPE (type
), id
),
430 TYPE_REF_CAN_ALIAS_ALL (type
));
431 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
432 new_tree
= build_type_attribute_qual_variant (new_tree
,
433 TYPE_ATTRIBUTES (type
),
435 insert_decl_map (id
, type
, new_tree
);
439 new_tree
= copy_node (type
);
441 insert_decl_map (id
, type
, new_tree
);
443 /* This is a new type, not a copy of an old type. Need to reassociate
444 variants. We can handle everything except the main variant lazily. */
445 t
= TYPE_MAIN_VARIANT (type
);
448 t
= remap_type (t
, id
);
449 TYPE_MAIN_VARIANT (new_tree
) = t
;
450 TYPE_NEXT_VARIANT (new_tree
) = TYPE_NEXT_VARIANT (t
);
451 TYPE_NEXT_VARIANT (t
) = new_tree
;
455 TYPE_MAIN_VARIANT (new_tree
) = new_tree
;
456 TYPE_NEXT_VARIANT (new_tree
) = NULL
;
459 if (TYPE_STUB_DECL (type
))
460 TYPE_STUB_DECL (new_tree
) = remap_decl (TYPE_STUB_DECL (type
), id
);
462 /* Lazily create pointer and reference types. */
463 TYPE_POINTER_TO (new_tree
) = NULL
;
464 TYPE_REFERENCE_TO (new_tree
) = NULL
;
466 /* Copy all types that may contain references to local variables; be sure to
467 preserve sharing in between type and its main variant when possible. */
468 switch (TREE_CODE (new_tree
))
472 case FIXED_POINT_TYPE
:
475 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
477 gcc_checking_assert (TYPE_MIN_VALUE (type
) == TYPE_MIN_VALUE (TYPE_MAIN_VARIANT (type
)));
478 gcc_checking_assert (TYPE_MAX_VALUE (type
) == TYPE_MAX_VALUE (TYPE_MAIN_VARIANT (type
)));
480 TYPE_MIN_VALUE (new_tree
) = TYPE_MIN_VALUE (TYPE_MAIN_VARIANT (new_tree
));
481 TYPE_MAX_VALUE (new_tree
) = TYPE_MAX_VALUE (TYPE_MAIN_VARIANT (new_tree
));
485 t
= TYPE_MIN_VALUE (new_tree
);
486 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
487 walk_tree (&TYPE_MIN_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
489 t
= TYPE_MAX_VALUE (new_tree
);
490 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
491 walk_tree (&TYPE_MAX_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
496 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
497 && TREE_TYPE (type
) == TREE_TYPE (TYPE_MAIN_VARIANT (type
)))
498 TREE_TYPE (new_tree
) = TREE_TYPE (TYPE_MAIN_VARIANT (new_tree
));
500 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
501 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
502 && TYPE_ARG_TYPES (type
) == TYPE_ARG_TYPES (TYPE_MAIN_VARIANT (type
)))
503 TYPE_ARG_TYPES (new_tree
) = TYPE_ARG_TYPES (TYPE_MAIN_VARIANT (new_tree
));
505 walk_tree (&TYPE_ARG_TYPES (new_tree
), copy_tree_body_r
, id
, NULL
);
509 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
510 && TREE_TYPE (type
) == TREE_TYPE (TYPE_MAIN_VARIANT (type
)))
511 TREE_TYPE (new_tree
) = TREE_TYPE (TYPE_MAIN_VARIANT (new_tree
));
513 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
515 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
517 gcc_checking_assert (TYPE_DOMAIN (type
) == TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)));
518 TYPE_DOMAIN (new_tree
) = TYPE_DOMAIN (TYPE_MAIN_VARIANT (new_tree
));
521 TYPE_DOMAIN (new_tree
) = remap_type (TYPE_DOMAIN (new_tree
), id
);
526 case QUAL_UNION_TYPE
:
527 if (TYPE_MAIN_VARIANT (type
) != type
528 && TYPE_FIELDS (type
) == TYPE_FIELDS (TYPE_MAIN_VARIANT (type
)))
529 TYPE_FIELDS (new_tree
) = TYPE_FIELDS (TYPE_MAIN_VARIANT (new_tree
));
534 for (f
= TYPE_FIELDS (new_tree
); f
; f
= DECL_CHAIN (f
))
536 t
= remap_decl (f
, id
);
537 DECL_CONTEXT (t
) = new_tree
;
541 TYPE_FIELDS (new_tree
) = nreverse (nf
);
547 /* Shouldn't have been thought variable sized. */
551 /* All variants of type share the same size, so use the already remaped data. */
552 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
554 gcc_checking_assert (TYPE_SIZE (type
) == TYPE_SIZE (TYPE_MAIN_VARIANT (type
)));
555 gcc_checking_assert (TYPE_SIZE_UNIT (type
) == TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type
)));
557 TYPE_SIZE (new_tree
) = TYPE_SIZE (TYPE_MAIN_VARIANT (new_tree
));
558 TYPE_SIZE_UNIT (new_tree
) = TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (new_tree
));
562 walk_tree (&TYPE_SIZE (new_tree
), copy_tree_body_r
, id
, NULL
);
563 walk_tree (&TYPE_SIZE_UNIT (new_tree
), copy_tree_body_r
, id
, NULL
);
570 remap_type (tree type
, copy_body_data
*id
)
578 /* See if we have remapped this type. */
579 node
= id
->decl_map
->get (type
);
583 /* The type only needs remapping if it's variably modified. */
584 if (! variably_modified_type_p (type
, id
->src_fn
))
586 insert_decl_map (id
, type
, type
);
590 id
->remapping_type_depth
++;
591 tmp
= remap_type_1 (type
, id
);
592 id
->remapping_type_depth
--;
597 /* Decide if DECL can be put into BLOCK_NONLOCAL_VARs. */
600 can_be_nonlocal (tree decl
, copy_body_data
*id
)
602 /* We can not duplicate function decls. */
603 if (TREE_CODE (decl
) == FUNCTION_DECL
)
606 /* Local static vars must be non-local or we get multiple declaration
608 if (TREE_CODE (decl
) == VAR_DECL
609 && !auto_var_in_fn_p (decl
, id
->src_fn
))
616 remap_decls (tree decls
, vec
<tree
, va_gc
> **nonlocalized_list
,
620 tree new_decls
= NULL_TREE
;
622 /* Remap its variables. */
623 for (old_var
= decls
; old_var
; old_var
= DECL_CHAIN (old_var
))
627 if (can_be_nonlocal (old_var
, id
))
629 /* We need to add this variable to the local decls as otherwise
630 nothing else will do so. */
631 if (TREE_CODE (old_var
) == VAR_DECL
632 && ! DECL_EXTERNAL (old_var
))
633 add_local_decl (cfun
, old_var
);
634 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
635 && !DECL_IGNORED_P (old_var
)
636 && nonlocalized_list
)
637 vec_safe_push (*nonlocalized_list
, old_var
);
641 /* Remap the variable. */
642 new_var
= remap_decl (old_var
, id
);
644 /* If we didn't remap this variable, we can't mess with its
645 TREE_CHAIN. If we remapped this variable to the return slot, it's
646 already declared somewhere else, so don't declare it here. */
648 if (new_var
== id
->retvar
)
652 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
653 && !DECL_IGNORED_P (old_var
)
654 && nonlocalized_list
)
655 vec_safe_push (*nonlocalized_list
, old_var
);
659 gcc_assert (DECL_P (new_var
));
660 DECL_CHAIN (new_var
) = new_decls
;
663 /* Also copy value-expressions. */
664 if (TREE_CODE (new_var
) == VAR_DECL
665 && DECL_HAS_VALUE_EXPR_P (new_var
))
667 tree tem
= DECL_VALUE_EXPR (new_var
);
668 bool old_regimplify
= id
->regimplify
;
669 id
->remapping_type_depth
++;
670 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
671 id
->remapping_type_depth
--;
672 id
->regimplify
= old_regimplify
;
673 SET_DECL_VALUE_EXPR (new_var
, tem
);
678 return nreverse (new_decls
);
681 /* Copy the BLOCK to contain remapped versions of the variables
682 therein. And hook the new block into the block-tree. */
685 remap_block (tree
*block
, copy_body_data
*id
)
690 /* Make the new block. */
692 new_block
= make_node (BLOCK
);
693 TREE_USED (new_block
) = TREE_USED (old_block
);
694 BLOCK_ABSTRACT_ORIGIN (new_block
) = old_block
;
695 BLOCK_SOURCE_LOCATION (new_block
) = BLOCK_SOURCE_LOCATION (old_block
);
696 BLOCK_NONLOCALIZED_VARS (new_block
)
697 = vec_safe_copy (BLOCK_NONLOCALIZED_VARS (old_block
));
700 /* Remap its variables. */
701 BLOCK_VARS (new_block
) = remap_decls (BLOCK_VARS (old_block
),
702 &BLOCK_NONLOCALIZED_VARS (new_block
),
705 if (id
->transform_lang_insert_block
)
706 id
->transform_lang_insert_block (new_block
);
708 /* Remember the remapped block. */
709 insert_decl_map (id
, old_block
, new_block
);
712 /* Copy the whole block tree and root it in id->block. */
714 remap_blocks (tree block
, copy_body_data
*id
)
717 tree new_tree
= block
;
722 remap_block (&new_tree
, id
);
723 gcc_assert (new_tree
!= block
);
724 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
725 prepend_lexical_block (new_tree
, remap_blocks (t
, id
));
726 /* Blocks are in arbitrary order, but make things slightly prettier and do
727 not swap order when producing a copy. */
728 BLOCK_SUBBLOCKS (new_tree
) = blocks_nreverse (BLOCK_SUBBLOCKS (new_tree
));
732 /* Remap the block tree rooted at BLOCK to nothing. */
734 remap_blocks_to_null (tree block
, copy_body_data
*id
)
737 insert_decl_map (id
, block
, NULL_TREE
);
738 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
739 remap_blocks_to_null (t
, id
);
743 copy_statement_list (tree
*tp
)
745 tree_stmt_iterator oi
, ni
;
748 new_tree
= alloc_stmt_list ();
749 ni
= tsi_start (new_tree
);
750 oi
= tsi_start (*tp
);
751 TREE_TYPE (new_tree
) = TREE_TYPE (*tp
);
754 for (; !tsi_end_p (oi
); tsi_next (&oi
))
756 tree stmt
= tsi_stmt (oi
);
757 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
758 /* This copy is not redundant; tsi_link_after will smash this
759 STATEMENT_LIST into the end of the one we're building, and we
760 don't want to do that with the original. */
761 copy_statement_list (&stmt
);
762 tsi_link_after (&ni
, stmt
, TSI_CONTINUE_LINKING
);
767 copy_bind_expr (tree
*tp
, int *walk_subtrees
, copy_body_data
*id
)
769 tree block
= BIND_EXPR_BLOCK (*tp
);
770 /* Copy (and replace) the statement. */
771 copy_tree_r (tp
, walk_subtrees
, NULL
);
774 remap_block (&block
, id
);
775 BIND_EXPR_BLOCK (*tp
) = block
;
778 if (BIND_EXPR_VARS (*tp
))
779 /* This will remap a lot of the same decls again, but this should be
781 BIND_EXPR_VARS (*tp
) = remap_decls (BIND_EXPR_VARS (*tp
), NULL
, id
);
785 /* Create a new gimple_seq by remapping all the statements in BODY
786 using the inlining information in ID. */
789 remap_gimple_seq (gimple_seq body
, copy_body_data
*id
)
791 gimple_stmt_iterator si
;
792 gimple_seq new_body
= NULL
;
794 for (si
= gsi_start (body
); !gsi_end_p (si
); gsi_next (&si
))
796 gimple new_stmt
= remap_gimple_stmt (gsi_stmt (si
), id
);
797 gimple_seq_add_stmt (&new_body
, new_stmt
);
804 /* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its
805 block using the mapping information in ID. */
808 copy_gimple_bind (gimple stmt
, copy_body_data
*id
)
811 tree new_block
, new_vars
;
812 gimple_seq body
, new_body
;
814 /* Copy the statement. Note that we purposely don't use copy_stmt
815 here because we need to remap statements as we copy. */
816 body
= gimple_bind_body (stmt
);
817 new_body
= remap_gimple_seq (body
, id
);
819 new_block
= gimple_bind_block (stmt
);
821 remap_block (&new_block
, id
);
823 /* This will remap a lot of the same decls again, but this should be
825 new_vars
= gimple_bind_vars (stmt
);
827 new_vars
= remap_decls (new_vars
, NULL
, id
);
829 new_bind
= gimple_build_bind (new_vars
, new_body
, new_block
);
834 /* Return true if DECL is a parameter or a SSA_NAME for a parameter. */
839 if (TREE_CODE (decl
) == SSA_NAME
)
841 decl
= SSA_NAME_VAR (decl
);
846 return (TREE_CODE (decl
) == PARM_DECL
);
849 /* Remap the GIMPLE operand pointed to by *TP. DATA is really a
850 'struct walk_stmt_info *'. DATA->INFO is a 'copy_body_data *'.
851 WALK_SUBTREES is used to indicate walk_gimple_op whether to keep
852 recursing into the children nodes of *TP. */
855 remap_gimple_op_r (tree
*tp
, int *walk_subtrees
, void *data
)
857 struct walk_stmt_info
*wi_p
= (struct walk_stmt_info
*) data
;
858 copy_body_data
*id
= (copy_body_data
*) wi_p
->info
;
859 tree fn
= id
->src_fn
;
861 if (TREE_CODE (*tp
) == SSA_NAME
)
863 *tp
= remap_ssa_name (*tp
, id
);
867 else if (auto_var_in_fn_p (*tp
, fn
))
869 /* Local variables and labels need to be replaced by equivalent
870 variables. We don't want to copy static variables; there's
871 only one of those, no matter how many times we inline the
872 containing function. Similarly for globals from an outer
876 /* Remap the declaration. */
877 new_decl
= remap_decl (*tp
, id
);
878 gcc_assert (new_decl
);
879 /* Replace this variable with the copy. */
880 STRIP_TYPE_NOPS (new_decl
);
881 /* ??? The C++ frontend uses void * pointer zero to initialize
882 any other type. This confuses the middle-end type verification.
883 As cloned bodies do not go through gimplification again the fixup
884 there doesn't trigger. */
885 if (TREE_CODE (new_decl
) == INTEGER_CST
886 && !useless_type_conversion_p (TREE_TYPE (*tp
), TREE_TYPE (new_decl
)))
887 new_decl
= fold_convert (TREE_TYPE (*tp
), new_decl
);
891 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
893 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
895 else if (TREE_CODE (*tp
) == LABEL_DECL
896 && (!DECL_CONTEXT (*tp
)
897 || decl_function_context (*tp
) == id
->src_fn
))
898 /* These may need to be remapped for EH handling. */
899 *tp
= remap_decl (*tp
, id
);
900 else if (TREE_CODE (*tp
) == FIELD_DECL
)
902 /* If the enclosing record type is variably_modified_type_p, the field
903 has already been remapped. Otherwise, it need not be. */
904 tree
*n
= id
->decl_map
->get (*tp
);
909 else if (TYPE_P (*tp
))
910 /* Types may need remapping as well. */
911 *tp
= remap_type (*tp
, id
);
912 else if (CONSTANT_CLASS_P (*tp
))
914 /* If this is a constant, we have to copy the node iff the type
915 will be remapped. copy_tree_r will not copy a constant. */
916 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
918 if (new_type
== TREE_TYPE (*tp
))
921 else if (TREE_CODE (*tp
) == INTEGER_CST
)
922 *tp
= wide_int_to_tree (new_type
, *tp
);
925 *tp
= copy_node (*tp
);
926 TREE_TYPE (*tp
) = new_type
;
931 /* Otherwise, just copy the node. Note that copy_tree_r already
932 knows not to copy VAR_DECLs, etc., so this is safe. */
934 if (TREE_CODE (*tp
) == MEM_REF
)
936 /* We need to re-canonicalize MEM_REFs from inline substitutions
937 that can happen when a pointer argument is an ADDR_EXPR.
938 Recurse here manually to allow that. */
939 tree ptr
= TREE_OPERAND (*tp
, 0);
940 tree type
= remap_type (TREE_TYPE (*tp
), id
);
942 walk_tree (&ptr
, remap_gimple_op_r
, data
, NULL
);
943 *tp
= fold_build2 (MEM_REF
, type
, ptr
, TREE_OPERAND (*tp
, 1));
944 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
945 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
946 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
947 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
948 remapped a parameter as the property might be valid only
949 for the parameter itself. */
950 if (TREE_THIS_NOTRAP (old
)
951 && (!is_parm (TREE_OPERAND (old
, 0))
952 || (!id
->transform_parameter
&& is_parm (ptr
))))
953 TREE_THIS_NOTRAP (*tp
) = 1;
958 /* Here is the "usual case". Copy this tree node, and then
959 tweak some special cases. */
960 copy_tree_r (tp
, walk_subtrees
, NULL
);
962 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
963 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
965 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
967 /* The copied TARGET_EXPR has never been expanded, even if the
968 original node was expanded already. */
969 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
970 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
972 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
974 /* Variable substitution need not be simple. In particular,
975 the MEM_REF substitution above. Make sure that
976 TREE_CONSTANT and friends are up-to-date. */
977 int invariant
= is_gimple_min_invariant (*tp
);
978 walk_tree (&TREE_OPERAND (*tp
, 0), remap_gimple_op_r
, data
, NULL
);
979 recompute_tree_invariant_for_addr_expr (*tp
);
981 /* If this used to be invariant, but is not any longer,
982 then regimplification is probably needed. */
983 if (invariant
&& !is_gimple_min_invariant (*tp
))
984 id
->regimplify
= true;
990 /* Update the TREE_BLOCK for the cloned expr. */
993 tree new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
994 tree old_block
= TREE_BLOCK (*tp
);
998 n
= id
->decl_map
->get (TREE_BLOCK (*tp
));
1002 TREE_SET_BLOCK (*tp
, new_block
);
1005 /* Keep iterating. */
1010 /* Called from copy_body_id via walk_tree. DATA is really a
1011 `copy_body_data *'. */
1014 copy_tree_body_r (tree
*tp
, int *walk_subtrees
, void *data
)
1016 copy_body_data
*id
= (copy_body_data
*) data
;
1017 tree fn
= id
->src_fn
;
1020 /* Begin by recognizing trees that we'll completely rewrite for the
1021 inlining context. Our output for these trees is completely
1022 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1023 into an edge). Further down, we'll handle trees that get
1024 duplicated and/or tweaked. */
1026 /* When requested, RETURN_EXPRs should be transformed to just the
1027 contained MODIFY_EXPR. The branch semantics of the return will
1028 be handled elsewhere by manipulating the CFG rather than a statement. */
1029 if (TREE_CODE (*tp
) == RETURN_EXPR
&& id
->transform_return_to_modify
)
1031 tree assignment
= TREE_OPERAND (*tp
, 0);
1033 /* If we're returning something, just turn that into an
1034 assignment into the equivalent of the original RESULT_DECL.
1035 If the "assignment" is just the result decl, the result
1036 decl has already been set (e.g. a recent "foo (&result_decl,
1037 ...)"); just toss the entire RETURN_EXPR. */
1038 if (assignment
&& TREE_CODE (assignment
) == MODIFY_EXPR
)
1040 /* Replace the RETURN_EXPR with (a copy of) the
1041 MODIFY_EXPR hanging underneath. */
1042 *tp
= copy_node (assignment
);
1044 else /* Else the RETURN_EXPR returns no value. */
1047 return (tree
) (void *)1;
1050 else if (TREE_CODE (*tp
) == SSA_NAME
)
1052 *tp
= remap_ssa_name (*tp
, id
);
1057 /* Local variables and labels need to be replaced by equivalent
1058 variables. We don't want to copy static variables; there's only
1059 one of those, no matter how many times we inline the containing
1060 function. Similarly for globals from an outer function. */
1061 else if (auto_var_in_fn_p (*tp
, fn
))
1065 /* Remap the declaration. */
1066 new_decl
= remap_decl (*tp
, id
);
1067 gcc_assert (new_decl
);
1068 /* Replace this variable with the copy. */
1069 STRIP_TYPE_NOPS (new_decl
);
1073 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
1074 copy_statement_list (tp
);
1075 else if (TREE_CODE (*tp
) == SAVE_EXPR
1076 || TREE_CODE (*tp
) == TARGET_EXPR
)
1077 remap_save_expr (tp
, id
->decl_map
, walk_subtrees
);
1078 else if (TREE_CODE (*tp
) == LABEL_DECL
1079 && (! DECL_CONTEXT (*tp
)
1080 || decl_function_context (*tp
) == id
->src_fn
))
1081 /* These may need to be remapped for EH handling. */
1082 *tp
= remap_decl (*tp
, id
);
1083 else if (TREE_CODE (*tp
) == BIND_EXPR
)
1084 copy_bind_expr (tp
, walk_subtrees
, id
);
1085 /* Types may need remapping as well. */
1086 else if (TYPE_P (*tp
))
1087 *tp
= remap_type (*tp
, id
);
1089 /* If this is a constant, we have to copy the node iff the type will be
1090 remapped. copy_tree_r will not copy a constant. */
1091 else if (CONSTANT_CLASS_P (*tp
))
1093 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
1095 if (new_type
== TREE_TYPE (*tp
))
1098 else if (TREE_CODE (*tp
) == INTEGER_CST
)
1099 *tp
= wide_int_to_tree (new_type
, *tp
);
1102 *tp
= copy_node (*tp
);
1103 TREE_TYPE (*tp
) = new_type
;
1107 /* Otherwise, just copy the node. Note that copy_tree_r already
1108 knows not to copy VAR_DECLs, etc., so this is safe. */
1111 /* Here we handle trees that are not completely rewritten.
1112 First we detect some inlining-induced bogosities for
1114 if (TREE_CODE (*tp
) == MODIFY_EXPR
1115 && TREE_OPERAND (*tp
, 0) == TREE_OPERAND (*tp
, 1)
1116 && (auto_var_in_fn_p (TREE_OPERAND (*tp
, 0), fn
)))
1118 /* Some assignments VAR = VAR; don't generate any rtl code
1119 and thus don't count as variable modification. Avoid
1120 keeping bogosities like 0 = 0. */
1121 tree decl
= TREE_OPERAND (*tp
, 0), value
;
1124 n
= id
->decl_map
->get (decl
);
1128 STRIP_TYPE_NOPS (value
);
1129 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1131 *tp
= build_empty_stmt (EXPR_LOCATION (*tp
));
1132 return copy_tree_body_r (tp
, walk_subtrees
, data
);
1136 else if (TREE_CODE (*tp
) == INDIRECT_REF
)
1138 /* Get rid of *& from inline substitutions that can happen when a
1139 pointer argument is an ADDR_EXPR. */
1140 tree decl
= TREE_OPERAND (*tp
, 0);
1141 tree
*n
= id
->decl_map
->get (decl
);
1144 /* If we happen to get an ADDR_EXPR in n->value, strip
1145 it manually here as we'll eventually get ADDR_EXPRs
1146 which lie about their types pointed to. In this case
1147 build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
1148 but we absolutely rely on that. As fold_indirect_ref
1149 does other useful transformations, try that first, though. */
1150 tree type
= TREE_TYPE (*tp
);
1151 tree ptr
= id
->do_not_unshare
? *n
: unshare_expr (*n
);
1153 *tp
= gimple_fold_indirect_ref (ptr
);
1156 if (TREE_CODE (ptr
) == ADDR_EXPR
)
1159 = fold_indirect_ref_1 (EXPR_LOCATION (ptr
), type
, ptr
);
1160 /* ??? We should either assert here or build
1161 a VIEW_CONVERT_EXPR instead of blindly leaking
1162 incompatible types to our IL. */
1164 *tp
= TREE_OPERAND (ptr
, 0);
1168 *tp
= build1 (INDIRECT_REF
, type
, ptr
);
1169 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1170 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1171 TREE_READONLY (*tp
) = TREE_READONLY (old
);
1172 /* We cannot propagate the TREE_THIS_NOTRAP flag if we
1173 have remapped a parameter as the property might be
1174 valid only for the parameter itself. */
1175 if (TREE_THIS_NOTRAP (old
)
1176 && (!is_parm (TREE_OPERAND (old
, 0))
1177 || (!id
->transform_parameter
&& is_parm (ptr
))))
1178 TREE_THIS_NOTRAP (*tp
) = 1;
1185 else if (TREE_CODE (*tp
) == MEM_REF
)
1187 /* We need to re-canonicalize MEM_REFs from inline substitutions
1188 that can happen when a pointer argument is an ADDR_EXPR.
1189 Recurse here manually to allow that. */
1190 tree ptr
= TREE_OPERAND (*tp
, 0);
1191 tree type
= remap_type (TREE_TYPE (*tp
), id
);
1193 walk_tree (&ptr
, copy_tree_body_r
, data
, NULL
);
1194 *tp
= fold_build2 (MEM_REF
, type
, ptr
, TREE_OPERAND (*tp
, 1));
1195 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1196 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1197 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
1198 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
1199 remapped a parameter as the property might be valid only
1200 for the parameter itself. */
1201 if (TREE_THIS_NOTRAP (old
)
1202 && (!is_parm (TREE_OPERAND (old
, 0))
1203 || (!id
->transform_parameter
&& is_parm (ptr
))))
1204 TREE_THIS_NOTRAP (*tp
) = 1;
1209 /* Here is the "usual case". Copy this tree node, and then
1210 tweak some special cases. */
1211 copy_tree_r (tp
, walk_subtrees
, NULL
);
1213 /* If EXPR has block defined, map it to newly constructed block.
1214 When inlining we want EXPRs without block appear in the block
1215 of function call if we are not remapping a type. */
1218 new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
1219 if (TREE_BLOCK (*tp
))
1222 n
= id
->decl_map
->get (TREE_BLOCK (*tp
));
1226 TREE_SET_BLOCK (*tp
, new_block
);
1229 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
1230 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
1232 /* The copied TARGET_EXPR has never been expanded, even if the
1233 original node was expanded already. */
1234 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
1236 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
1237 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
1240 /* Variable substitution need not be simple. In particular, the
1241 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
1242 and friends are up-to-date. */
1243 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
1245 int invariant
= is_gimple_min_invariant (*tp
);
1246 walk_tree (&TREE_OPERAND (*tp
, 0), copy_tree_body_r
, id
, NULL
);
1248 /* Handle the case where we substituted an INDIRECT_REF
1249 into the operand of the ADDR_EXPR. */
1250 if (TREE_CODE (TREE_OPERAND (*tp
, 0)) == INDIRECT_REF
)
1251 *tp
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0);
1253 recompute_tree_invariant_for_addr_expr (*tp
);
1255 /* If this used to be invariant, but is not any longer,
1256 then regimplification is probably needed. */
1257 if (invariant
&& !is_gimple_min_invariant (*tp
))
1258 id
->regimplify
= true;
1264 /* Keep iterating. */
1268 /* Helper for remap_gimple_stmt. Given an EH region number for the
1269 source function, map that to the duplicate EH region number in
1270 the destination function. */
1273 remap_eh_region_nr (int old_nr
, copy_body_data
*id
)
1275 eh_region old_r
, new_r
;
1277 old_r
= get_eh_region_from_number_fn (id
->src_cfun
, old_nr
);
1278 new_r
= static_cast<eh_region
> (*id
->eh_map
->get (old_r
));
1280 return new_r
->index
;
1283 /* Similar, but operate on INTEGER_CSTs. */
1286 remap_eh_region_tree_nr (tree old_t_nr
, copy_body_data
*id
)
1290 old_nr
= tree_to_shwi (old_t_nr
);
1291 new_nr
= remap_eh_region_nr (old_nr
, id
);
1293 return build_int_cst (integer_type_node
, new_nr
);
1296 /* Helper for copy_bb. Remap statement STMT using the inlining
1297 information in ID. Return the new statement copy. */
1300 remap_gimple_stmt (gimple stmt
, copy_body_data
*id
)
1303 struct walk_stmt_info wi
;
1304 bool skip_first
= false;
1306 /* Begin by recognizing trees that we'll completely rewrite for the
1307 inlining context. Our output for these trees is completely
1308 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1309 into an edge). Further down, we'll handle trees that get
1310 duplicated and/or tweaked. */
1312 /* When requested, GIMPLE_RETURNs should be transformed to just the
1313 contained GIMPLE_ASSIGN. The branch semantics of the return will
1314 be handled elsewhere by manipulating the CFG rather than the
1316 if (gimple_code (stmt
) == GIMPLE_RETURN
&& id
->transform_return_to_modify
)
1318 tree retval
= gimple_return_retval (stmt
);
1320 /* If we're returning something, just turn that into an
1321 assignment into the equivalent of the original RESULT_DECL.
1322 If RETVAL is just the result decl, the result decl has
1323 already been set (e.g. a recent "foo (&result_decl, ...)");
1324 just toss the entire GIMPLE_RETURN. */
1326 && (TREE_CODE (retval
) != RESULT_DECL
1327 && (TREE_CODE (retval
) != SSA_NAME
1328 || ! SSA_NAME_VAR (retval
)
1329 || TREE_CODE (SSA_NAME_VAR (retval
)) != RESULT_DECL
)))
1331 copy
= gimple_build_assign (id
->do_not_unshare
1332 ? id
->retvar
: unshare_expr (id
->retvar
),
1334 /* id->retvar is already substituted. Skip it on later remapping. */
1338 return gimple_build_nop ();
1340 else if (gimple_has_substatements (stmt
))
1344 /* When cloning bodies from the C++ front end, we will be handed bodies
1345 in High GIMPLE form. Handle here all the High GIMPLE statements that
1346 have embedded statements. */
1347 switch (gimple_code (stmt
))
1350 copy
= copy_gimple_bind (stmt
, id
);
1354 s1
= remap_gimple_seq (gimple_catch_handler (stmt
), id
);
1355 copy
= gimple_build_catch (gimple_catch_types (stmt
), s1
);
1358 case GIMPLE_EH_FILTER
:
1359 s1
= remap_gimple_seq (gimple_eh_filter_failure (stmt
), id
);
1360 copy
= gimple_build_eh_filter (gimple_eh_filter_types (stmt
), s1
);
1364 s1
= remap_gimple_seq (gimple_try_eval (stmt
), id
);
1365 s2
= remap_gimple_seq (gimple_try_cleanup (stmt
), id
);
1366 copy
= gimple_build_try (s1
, s2
, gimple_try_kind (stmt
));
1369 case GIMPLE_WITH_CLEANUP_EXPR
:
1370 s1
= remap_gimple_seq (gimple_wce_cleanup (stmt
), id
);
1371 copy
= gimple_build_wce (s1
);
1374 case GIMPLE_OMP_PARALLEL
:
1375 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1376 copy
= gimple_build_omp_parallel
1378 gimple_omp_parallel_clauses (stmt
),
1379 gimple_omp_parallel_child_fn (stmt
),
1380 gimple_omp_parallel_data_arg (stmt
));
1383 case GIMPLE_OMP_TASK
:
1384 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1385 copy
= gimple_build_omp_task
1387 gimple_omp_task_clauses (stmt
),
1388 gimple_omp_task_child_fn (stmt
),
1389 gimple_omp_task_data_arg (stmt
),
1390 gimple_omp_task_copy_fn (stmt
),
1391 gimple_omp_task_arg_size (stmt
),
1392 gimple_omp_task_arg_align (stmt
));
1395 case GIMPLE_OMP_FOR
:
1396 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1397 s2
= remap_gimple_seq (gimple_omp_for_pre_body (stmt
), id
);
1398 copy
= gimple_build_omp_for (s1
, gimple_omp_for_kind (stmt
),
1399 gimple_omp_for_clauses (stmt
),
1400 gimple_omp_for_collapse (stmt
), s2
);
1403 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1405 gimple_omp_for_set_index (copy
, i
,
1406 gimple_omp_for_index (stmt
, i
));
1407 gimple_omp_for_set_initial (copy
, i
,
1408 gimple_omp_for_initial (stmt
, i
));
1409 gimple_omp_for_set_final (copy
, i
,
1410 gimple_omp_for_final (stmt
, i
));
1411 gimple_omp_for_set_incr (copy
, i
,
1412 gimple_omp_for_incr (stmt
, i
));
1413 gimple_omp_for_set_cond (copy
, i
,
1414 gimple_omp_for_cond (stmt
, i
));
1419 case GIMPLE_OMP_MASTER
:
1420 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1421 copy
= gimple_build_omp_master (s1
);
1424 case GIMPLE_OMP_TASKGROUP
:
1425 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1426 copy
= gimple_build_omp_taskgroup (s1
);
1429 case GIMPLE_OMP_ORDERED
:
1430 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1431 copy
= gimple_build_omp_ordered (s1
);
1434 case GIMPLE_OMP_SECTION
:
1435 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1436 copy
= gimple_build_omp_section (s1
);
1439 case GIMPLE_OMP_SECTIONS
:
1440 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1441 copy
= gimple_build_omp_sections
1442 (s1
, gimple_omp_sections_clauses (stmt
));
1445 case GIMPLE_OMP_SINGLE
:
1446 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1447 copy
= gimple_build_omp_single
1448 (s1
, gimple_omp_single_clauses (stmt
));
1451 case GIMPLE_OMP_TARGET
:
1452 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1453 copy
= gimple_build_omp_target
1454 (s1
, gimple_omp_target_kind (stmt
),
1455 gimple_omp_target_clauses (stmt
));
1458 case GIMPLE_OMP_TEAMS
:
1459 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1460 copy
= gimple_build_omp_teams
1461 (s1
, gimple_omp_teams_clauses (stmt
));
1464 case GIMPLE_OMP_CRITICAL
:
1465 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1467 = gimple_build_omp_critical (s1
, gimple_omp_critical_name (stmt
));
1470 case GIMPLE_TRANSACTION
:
1471 s1
= remap_gimple_seq (gimple_transaction_body (stmt
), id
);
1472 copy
= gimple_build_transaction (s1
, gimple_transaction_label (stmt
));
1473 gimple_transaction_set_subcode (copy
, gimple_transaction_subcode (stmt
));
1482 if (gimple_assign_copy_p (stmt
)
1483 && gimple_assign_lhs (stmt
) == gimple_assign_rhs1 (stmt
)
1484 && auto_var_in_fn_p (gimple_assign_lhs (stmt
), id
->src_fn
))
1486 /* Here we handle statements that are not completely rewritten.
1487 First we detect some inlining-induced bogosities for
1490 /* Some assignments VAR = VAR; don't generate any rtl code
1491 and thus don't count as variable modification. Avoid
1492 keeping bogosities like 0 = 0. */
1493 tree decl
= gimple_assign_lhs (stmt
), value
;
1496 n
= id
->decl_map
->get (decl
);
1500 STRIP_TYPE_NOPS (value
);
1501 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1502 return gimple_build_nop ();
1506 /* For *ptr_N ={v} {CLOBBER}, if ptr_N is SSA_NAME defined
1507 in a block that we aren't copying during tree_function_versioning,
1508 just drop the clobber stmt. */
1509 if (id
->blocks_to_copy
&& gimple_clobber_p (stmt
))
1511 tree lhs
= gimple_assign_lhs (stmt
);
1512 if (TREE_CODE (lhs
) == MEM_REF
1513 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == SSA_NAME
)
1515 gimple def_stmt
= SSA_NAME_DEF_STMT (TREE_OPERAND (lhs
, 0));
1516 if (gimple_bb (def_stmt
)
1517 && !bitmap_bit_p (id
->blocks_to_copy
,
1518 gimple_bb (def_stmt
)->index
))
1519 return gimple_build_nop ();
1523 if (gimple_debug_bind_p (stmt
))
1525 copy
= gimple_build_debug_bind (gimple_debug_bind_get_var (stmt
),
1526 gimple_debug_bind_get_value (stmt
),
1528 id
->debug_stmts
.safe_push (copy
);
1531 if (gimple_debug_source_bind_p (stmt
))
1533 copy
= gimple_build_debug_source_bind
1534 (gimple_debug_source_bind_get_var (stmt
),
1535 gimple_debug_source_bind_get_value (stmt
), stmt
);
1536 id
->debug_stmts
.safe_push (copy
);
1540 /* Create a new deep copy of the statement. */
1541 copy
= gimple_copy (stmt
);
1543 /* Clear flags that need revisiting. */
1544 if (is_gimple_call (copy
)
1545 && gimple_call_tail_p (copy
))
1546 gimple_call_set_tail (copy
, false);
1548 /* Remap the region numbers for __builtin_eh_{pointer,filter},
1549 RESX and EH_DISPATCH. */
1551 switch (gimple_code (copy
))
1555 tree r
, fndecl
= gimple_call_fndecl (copy
);
1556 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
1557 switch (DECL_FUNCTION_CODE (fndecl
))
1559 case BUILT_IN_EH_COPY_VALUES
:
1560 r
= gimple_call_arg (copy
, 1);
1561 r
= remap_eh_region_tree_nr (r
, id
);
1562 gimple_call_set_arg (copy
, 1, r
);
1565 case BUILT_IN_EH_POINTER
:
1566 case BUILT_IN_EH_FILTER
:
1567 r
= gimple_call_arg (copy
, 0);
1568 r
= remap_eh_region_tree_nr (r
, id
);
1569 gimple_call_set_arg (copy
, 0, r
);
1576 /* Reset alias info if we didn't apply measures to
1577 keep it valid over inlining by setting DECL_PT_UID. */
1578 if (!id
->src_cfun
->gimple_df
1579 || !id
->src_cfun
->gimple_df
->ipa_pta
)
1580 gimple_call_reset_alias_info (copy
);
1586 int r
= gimple_resx_region (copy
);
1587 r
= remap_eh_region_nr (r
, id
);
1588 gimple_resx_set_region (copy
, r
);
1592 case GIMPLE_EH_DISPATCH
:
1594 int r
= gimple_eh_dispatch_region (copy
);
1595 r
= remap_eh_region_nr (r
, id
);
1596 gimple_eh_dispatch_set_region (copy
, r
);
1605 /* If STMT has a block defined, map it to the newly constructed
1607 if (gimple_block (copy
))
1610 n
= id
->decl_map
->get (gimple_block (copy
));
1612 gimple_set_block (copy
, *n
);
1615 if (gimple_debug_bind_p (copy
) || gimple_debug_source_bind_p (copy
))
1618 /* Remap all the operands in COPY. */
1619 memset (&wi
, 0, sizeof (wi
));
1622 walk_tree (gimple_op_ptr (copy
, 1), remap_gimple_op_r
, &wi
, NULL
);
1624 walk_gimple_op (copy
, remap_gimple_op_r
, &wi
);
1626 /* Clear the copied virtual operands. We are not remapping them here
1627 but are going to recreate them from scratch. */
1628 if (gimple_has_mem_ops (copy
))
1630 gimple_set_vdef (copy
, NULL_TREE
);
1631 gimple_set_vuse (copy
, NULL_TREE
);
1638 /* Copy basic block, scale profile accordingly. Edges will be taken care of
1642 copy_bb (copy_body_data
*id
, basic_block bb
, int frequency_scale
,
1643 gcov_type count_scale
)
1645 gimple_stmt_iterator gsi
, copy_gsi
, seq_gsi
;
1646 basic_block copy_basic_block
;
1651 /* Search for previous copied basic block. */
1654 prev
= prev
->prev_bb
;
1656 /* create_basic_block() will append every new block to
1657 basic_block_info automatically. */
1658 copy_basic_block
= create_basic_block (NULL
, (void *) 0,
1659 (basic_block
) prev
->aux
);
1660 copy_basic_block
->count
= apply_scale (bb
->count
, count_scale
);
1662 /* We are going to rebuild frequencies from scratch. These values
1663 have just small importance to drive canonicalize_loop_headers. */
1664 freq
= apply_scale ((gcov_type
)bb
->frequency
, frequency_scale
);
1666 /* We recompute frequencies after inlining, so this is quite safe. */
1667 if (freq
> BB_FREQ_MAX
)
1669 copy_basic_block
->frequency
= freq
;
1671 copy_gsi
= gsi_start_bb (copy_basic_block
);
1673 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1675 gimple stmt
= gsi_stmt (gsi
);
1676 gimple orig_stmt
= stmt
;
1678 id
->regimplify
= false;
1679 stmt
= remap_gimple_stmt (stmt
, id
);
1680 if (gimple_nop_p (stmt
))
1683 gimple_duplicate_stmt_histograms (cfun
, stmt
, id
->src_cfun
, orig_stmt
);
1686 /* With return slot optimization we can end up with
1687 non-gimple (foo *)&this->m, fix that here. */
1688 if (is_gimple_assign (stmt
)
1689 && gimple_assign_rhs_code (stmt
) == NOP_EXPR
1690 && !is_gimple_val (gimple_assign_rhs1 (stmt
)))
1693 new_rhs
= force_gimple_operand_gsi (&seq_gsi
,
1694 gimple_assign_rhs1 (stmt
),
1696 GSI_CONTINUE_LINKING
);
1697 gimple_assign_set_rhs1 (stmt
, new_rhs
);
1698 id
->regimplify
= false;
1701 gsi_insert_after (&seq_gsi
, stmt
, GSI_NEW_STMT
);
1704 gimple_regimplify_operands (stmt
, &seq_gsi
);
1706 /* If copy_basic_block has been empty at the start of this iteration,
1707 call gsi_start_bb again to get at the newly added statements. */
1708 if (gsi_end_p (copy_gsi
))
1709 copy_gsi
= gsi_start_bb (copy_basic_block
);
1711 gsi_next (©_gsi
);
1713 /* Process the new statement. The call to gimple_regimplify_operands
1714 possibly turned the statement into multiple statements, we
1715 need to process all of them. */
1720 stmt
= gsi_stmt (copy_gsi
);
1721 if (is_gimple_call (stmt
)
1722 && gimple_call_va_arg_pack_p (stmt
)
1725 /* __builtin_va_arg_pack () should be replaced by
1726 all arguments corresponding to ... in the caller. */
1730 size_t nargs
= gimple_call_num_args (id
->gimple_call
);
1733 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1736 /* Create the new array of arguments. */
1737 n
= nargs
+ gimple_call_num_args (stmt
);
1738 argarray
.create (n
);
1739 argarray
.safe_grow_cleared (n
);
1741 /* Copy all the arguments before '...' */
1742 memcpy (argarray
.address (),
1743 gimple_call_arg_ptr (stmt
, 0),
1744 gimple_call_num_args (stmt
) * sizeof (tree
));
1746 /* Append the arguments passed in '...' */
1747 memcpy (argarray
.address () + gimple_call_num_args (stmt
),
1748 gimple_call_arg_ptr (id
->gimple_call
, 0)
1749 + (gimple_call_num_args (id
->gimple_call
) - nargs
),
1750 nargs
* sizeof (tree
));
1752 new_call
= gimple_build_call_vec (gimple_call_fn (stmt
),
1755 argarray
.release ();
1757 /* Copy all GIMPLE_CALL flags, location and block, except
1758 GF_CALL_VA_ARG_PACK. */
1759 gimple_call_copy_flags (new_call
, stmt
);
1760 gimple_call_set_va_arg_pack (new_call
, false);
1761 gimple_set_location (new_call
, gimple_location (stmt
));
1762 gimple_set_block (new_call
, gimple_block (stmt
));
1763 gimple_call_set_lhs (new_call
, gimple_call_lhs (stmt
));
1765 gsi_replace (©_gsi
, new_call
, false);
1768 else if (is_gimple_call (stmt
)
1770 && (decl
= gimple_call_fndecl (stmt
))
1771 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
1772 && DECL_FUNCTION_CODE (decl
) == BUILT_IN_VA_ARG_PACK_LEN
)
1774 /* __builtin_va_arg_pack_len () should be replaced by
1775 the number of anonymous arguments. */
1776 size_t nargs
= gimple_call_num_args (id
->gimple_call
);
1780 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1783 count
= build_int_cst (integer_type_node
, nargs
);
1784 new_stmt
= gimple_build_assign (gimple_call_lhs (stmt
), count
);
1785 gsi_replace (©_gsi
, new_stmt
, false);
1789 /* Statements produced by inlining can be unfolded, especially
1790 when we constant propagated some operands. We can't fold
1791 them right now for two reasons:
1792 1) folding require SSA_NAME_DEF_STMTs to be correct
1793 2) we can't change function calls to builtins.
1794 So we just mark statement for later folding. We mark
1795 all new statements, instead just statements that has changed
1796 by some nontrivial substitution so even statements made
1797 foldable indirectly are updated. If this turns out to be
1798 expensive, copy_body can be told to watch for nontrivial
1800 if (id
->statements_to_fold
)
1801 id
->statements_to_fold
->add (stmt
);
1803 /* We're duplicating a CALL_EXPR. Find any corresponding
1804 callgraph edges and update or duplicate them. */
1805 if (is_gimple_call (stmt
))
1807 struct cgraph_edge
*edge
;
1809 switch (id
->transform_call_graph_edges
)
1811 case CB_CGE_DUPLICATE
:
1812 edge
= id
->src_node
->get_edge (orig_stmt
);
1815 int edge_freq
= edge
->frequency
;
1817 struct cgraph_edge
*old_edge
= edge
;
1818 edge
= edge
->clone (id
->dst_node
, stmt
,
1820 REG_BR_PROB_BASE
, CGRAPH_FREQ_BASE
,
1822 /* We could also just rescale the frequency, but
1823 doing so would introduce roundoff errors and make
1824 verifier unhappy. */
1825 new_freq
= compute_call_stmt_bb_frequency (id
->dst_node
->decl
,
1828 /* Speculative calls consist of two edges - direct and indirect.
1829 Duplicate the whole thing and distribute frequencies accordingly. */
1830 if (edge
->speculative
)
1832 struct cgraph_edge
*direct
, *indirect
;
1833 struct ipa_ref
*ref
;
1835 gcc_assert (!edge
->indirect_unknown_callee
);
1836 old_edge
->speculative_call_info (direct
, indirect
, ref
);
1837 indirect
= indirect
->clone (id
->dst_node
, stmt
,
1839 REG_BR_PROB_BASE
, CGRAPH_FREQ_BASE
,
1841 if (old_edge
->frequency
+ indirect
->frequency
)
1843 edge
->frequency
= MIN (RDIV ((gcov_type
)new_freq
* old_edge
->frequency
,
1844 (old_edge
->frequency
+ indirect
->frequency
)),
1846 indirect
->frequency
= MIN (RDIV ((gcov_type
)new_freq
* indirect
->frequency
,
1847 (old_edge
->frequency
+ indirect
->frequency
)),
1850 id
->dst_node
->clone_reference (ref
, stmt
);
1854 edge
->frequency
= new_freq
;
1856 && profile_status_for_fn (cfun
) != PROFILE_ABSENT
1857 && (edge_freq
> edge
->frequency
+ 10
1858 || edge_freq
< edge
->frequency
- 10))
1860 fprintf (dump_file
, "Edge frequency estimated by "
1861 "cgraph %i diverge from inliner's estimate %i\n",
1865 "Orig bb: %i, orig bb freq %i, new bb freq %i\n",
1868 copy_basic_block
->frequency
);
1874 case CB_CGE_MOVE_CLONES
:
1875 id
->dst_node
->set_call_stmt_including_clones (orig_stmt
,
1877 edge
= id
->dst_node
->get_edge (stmt
);
1881 edge
= id
->dst_node
->get_edge (orig_stmt
);
1883 edge
->set_call_stmt (stmt
);
1890 /* Constant propagation on argument done during inlining
1891 may create new direct call. Produce an edge for it. */
1893 || (edge
->indirect_inlining_edge
1894 && id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
))
1895 && id
->dst_node
->definition
1896 && (fn
= gimple_call_fndecl (stmt
)) != NULL
)
1898 struct cgraph_node
*dest
= cgraph_node::get (fn
);
1900 /* We have missing edge in the callgraph. This can happen
1901 when previous inlining turned an indirect call into a
1902 direct call by constant propagating arguments or we are
1903 producing dead clone (for further cloning). In all
1904 other cases we hit a bug (incorrect node sharing is the
1905 most common reason for missing edges). */
1906 gcc_assert (!dest
->definition
1907 || dest
->address_taken
1908 || !id
->src_node
->definition
1909 || !id
->dst_node
->definition
);
1910 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
)
1911 id
->dst_node
->create_edge_including_clones
1912 (dest
, orig_stmt
, stmt
, bb
->count
,
1913 compute_call_stmt_bb_frequency (id
->dst_node
->decl
,
1915 CIF_ORIGINALLY_INDIRECT_CALL
);
1917 id
->dst_node
->create_edge (dest
, stmt
,
1919 compute_call_stmt_bb_frequency
1920 (id
->dst_node
->decl
,
1921 copy_basic_block
))->inline_failed
1922 = CIF_ORIGINALLY_INDIRECT_CALL
;
1925 fprintf (dump_file
, "Created new direct edge to %s\n",
1930 notice_special_calls (stmt
);
1933 maybe_duplicate_eh_stmt_fn (cfun
, stmt
, id
->src_cfun
, orig_stmt
,
1934 id
->eh_map
, id
->eh_lp_nr
);
1936 if (gimple_in_ssa_p (cfun
) && !is_gimple_debug (stmt
))
1941 FOR_EACH_SSA_TREE_OPERAND (def
, stmt
, i
, SSA_OP_DEF
)
1942 if (TREE_CODE (def
) == SSA_NAME
)
1943 SSA_NAME_DEF_STMT (def
) = stmt
;
1946 gsi_next (©_gsi
);
1948 while (!gsi_end_p (copy_gsi
));
1950 copy_gsi
= gsi_last_bb (copy_basic_block
);
1953 return copy_basic_block
;
1956 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
1957 form is quite easy, since dominator relationship for old basic blocks does
1960 There is however exception where inlining might change dominator relation
1961 across EH edges from basic block within inlined functions destinating
1962 to landing pads in function we inline into.
1964 The function fills in PHI_RESULTs of such PHI nodes if they refer
1965 to gimple regs. Otherwise, the function mark PHI_RESULT of such
1966 PHI nodes for renaming. For non-gimple regs, renaming is safe: the
1967 EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
1968 set, and this means that there will be no overlapping live ranges
1969 for the underlying symbol.
1971 This might change in future if we allow redirecting of EH edges and
1972 we might want to change way build CFG pre-inlining to include
1973 all the possible edges then. */
1975 update_ssa_across_abnormal_edges (basic_block bb
, basic_block ret_bb
,
1976 bool can_throw
, bool nonlocal_goto
)
1981 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1983 || ((basic_block
)e
->dest
->aux
)->index
== ENTRY_BLOCK
)
1986 gimple_stmt_iterator si
;
1989 gcc_assert (e
->flags
& EDGE_EH
);
1992 gcc_assert (!(e
->flags
& EDGE_EH
));
1994 for (si
= gsi_start_phis (e
->dest
); !gsi_end_p (si
); gsi_next (&si
))
1998 phi
= gsi_stmt (si
);
2000 /* For abnormal goto/call edges the receiver can be the
2001 ENTRY_BLOCK. Do not assert this cannot happen. */
2003 gcc_assert ((e
->flags
& EDGE_EH
)
2004 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi
)));
2006 re
= find_edge (ret_bb
, e
->dest
);
2007 gcc_checking_assert (re
);
2008 gcc_assert ((re
->flags
& (EDGE_EH
| EDGE_ABNORMAL
))
2009 == (e
->flags
& (EDGE_EH
| EDGE_ABNORMAL
)));
2011 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, e
),
2012 USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, re
)));
2018 /* Copy edges from BB into its copy constructed earlier, scale profile
2019 accordingly. Edges will be taken care of later. Assume aux
2020 pointers to point to the copies of each BB. Return true if any
2021 debug stmts are left after a statement that must end the basic block. */
2024 copy_edges_for_bb (basic_block bb
, gcov_type count_scale
, basic_block ret_bb
,
2025 basic_block abnormal_goto_dest
)
2027 basic_block new_bb
= (basic_block
) bb
->aux
;
2030 gimple_stmt_iterator si
;
2032 bool need_debug_cleanup
= false;
2034 /* Use the indices from the original blocks to create edges for the
2036 FOR_EACH_EDGE (old_edge
, ei
, bb
->succs
)
2037 if (!(old_edge
->flags
& EDGE_EH
))
2041 flags
= old_edge
->flags
;
2043 /* Return edges do get a FALLTHRU flag when the get inlined. */
2044 if (old_edge
->dest
->index
== EXIT_BLOCK
2045 && !(old_edge
->flags
& (EDGE_TRUE_VALUE
|EDGE_FALSE_VALUE
|EDGE_FAKE
))
2046 && old_edge
->dest
->aux
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
2047 flags
|= EDGE_FALLTHRU
;
2048 new_edge
= make_edge (new_bb
, (basic_block
) old_edge
->dest
->aux
, flags
);
2049 new_edge
->count
= apply_scale (old_edge
->count
, count_scale
);
2050 new_edge
->probability
= old_edge
->probability
;
2053 if (bb
->index
== ENTRY_BLOCK
|| bb
->index
== EXIT_BLOCK
)
2056 for (si
= gsi_start_bb (new_bb
); !gsi_end_p (si
);)
2059 bool can_throw
, nonlocal_goto
;
2061 copy_stmt
= gsi_stmt (si
);
2062 if (!is_gimple_debug (copy_stmt
))
2063 update_stmt (copy_stmt
);
2065 /* Do this before the possible split_block. */
2068 /* If this tree could throw an exception, there are two
2069 cases where we need to add abnormal edge(s): the
2070 tree wasn't in a region and there is a "current
2071 region" in the caller; or the original tree had
2072 EH edges. In both cases split the block after the tree,
2073 and add abnormal edge(s) as needed; we need both
2074 those from the callee and the caller.
2075 We check whether the copy can throw, because the const
2076 propagation can change an INDIRECT_REF which throws
2077 into a COMPONENT_REF which doesn't. If the copy
2078 can throw, the original could also throw. */
2079 can_throw
= stmt_can_throw_internal (copy_stmt
);
2081 = (stmt_can_make_abnormal_goto (copy_stmt
)
2082 && !computed_goto_p (copy_stmt
));
2084 if (can_throw
|| nonlocal_goto
)
2086 if (!gsi_end_p (si
))
2088 while (!gsi_end_p (si
) && is_gimple_debug (gsi_stmt (si
)))
2091 need_debug_cleanup
= true;
2093 if (!gsi_end_p (si
))
2094 /* Note that bb's predecessor edges aren't necessarily
2095 right at this point; split_block doesn't care. */
2097 edge e
= split_block (new_bb
, copy_stmt
);
2100 new_bb
->aux
= e
->src
->aux
;
2101 si
= gsi_start_bb (new_bb
);
2105 if (gimple_code (copy_stmt
) == GIMPLE_EH_DISPATCH
)
2106 make_eh_dispatch_edges (copy_stmt
);
2108 make_eh_edges (copy_stmt
);
2110 /* If the call we inline cannot make abnormal goto do not add
2111 additional abnormal edges but only retain those already present
2112 in the original function body. */
2113 if (abnormal_goto_dest
== NULL
)
2114 nonlocal_goto
= false;
2117 basic_block copy_stmt_bb
= gimple_bb (copy_stmt
);
2119 if (get_abnormal_succ_dispatcher (copy_stmt_bb
))
2120 nonlocal_goto
= false;
2121 /* ABNORMAL_DISPATCHER (1) is for longjmp/setjmp or nonlocal gotos
2122 in OpenMP regions which aren't allowed to be left abnormally.
2123 So, no need to add abnormal edge in that case. */
2124 else if (is_gimple_call (copy_stmt
)
2125 && gimple_call_internal_p (copy_stmt
)
2126 && (gimple_call_internal_fn (copy_stmt
)
2127 == IFN_ABNORMAL_DISPATCHER
)
2128 && gimple_call_arg (copy_stmt
, 0) == boolean_true_node
)
2129 nonlocal_goto
= false;
2131 make_edge (copy_stmt_bb
, abnormal_goto_dest
, EDGE_ABNORMAL
);
2134 if ((can_throw
|| nonlocal_goto
)
2135 && gimple_in_ssa_p (cfun
))
2136 update_ssa_across_abnormal_edges (gimple_bb (copy_stmt
), ret_bb
,
2137 can_throw
, nonlocal_goto
);
2139 return need_debug_cleanup
;
2142 /* Copy the PHIs. All blocks and edges are copied, some blocks
2143 was possibly split and new outgoing EH edges inserted.
2144 BB points to the block of original function and AUX pointers links
2145 the original and newly copied blocks. */
2148 copy_phis_for_bb (basic_block bb
, copy_body_data
*id
)
2150 basic_block
const new_bb
= (basic_block
) bb
->aux
;
2153 gimple_stmt_iterator si
;
2155 bool inserted
= false;
2157 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
2162 phi
= gsi_stmt (si
);
2163 res
= PHI_RESULT (phi
);
2165 if (!virtual_operand_p (res
))
2167 walk_tree (&new_res
, copy_tree_body_r
, id
, NULL
);
2168 new_phi
= create_phi_node (new_res
, new_bb
);
2169 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2171 edge old_edge
= find_edge ((basic_block
) new_edge
->src
->aux
, bb
);
2177 /* When doing partial cloning, we allow PHIs on the entry block
2178 as long as all the arguments are the same. Find any input
2179 edge to see argument to copy. */
2181 FOR_EACH_EDGE (old_edge
, ei2
, bb
->preds
)
2182 if (!old_edge
->src
->aux
)
2185 arg
= PHI_ARG_DEF_FROM_EDGE (phi
, old_edge
);
2187 walk_tree (&new_arg
, copy_tree_body_r
, id
, NULL
);
2188 gcc_assert (new_arg
);
2189 /* With return slot optimization we can end up with
2190 non-gimple (foo *)&this->m, fix that here. */
2191 if (TREE_CODE (new_arg
) != SSA_NAME
2192 && TREE_CODE (new_arg
) != FUNCTION_DECL
2193 && !is_gimple_val (new_arg
))
2195 gimple_seq stmts
= NULL
;
2196 new_arg
= force_gimple_operand (new_arg
, &stmts
, true, NULL
);
2197 gsi_insert_seq_on_edge (new_edge
, stmts
);
2200 locus
= gimple_phi_arg_location_from_edge (phi
, old_edge
);
2201 if (LOCATION_BLOCK (locus
))
2204 n
= id
->decl_map
->get (LOCATION_BLOCK (locus
));
2207 locus
= COMBINE_LOCATION_DATA (line_table
, locus
, *n
);
2209 locus
= LOCATION_LOCUS (locus
);
2212 locus
= LOCATION_LOCUS (locus
);
2214 add_phi_arg (new_phi
, new_arg
, new_edge
, locus
);
2219 /* Commit the delayed edge insertions. */
2221 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2222 gsi_commit_one_edge_insert (new_edge
, NULL
);
2226 /* Wrapper for remap_decl so it can be used as a callback. */
2229 remap_decl_1 (tree decl
, void *data
)
2231 return remap_decl (decl
, (copy_body_data
*) data
);
2234 /* Build struct function and associated datastructures for the new clone
2235 NEW_FNDECL to be build. CALLEE_FNDECL is the original. Function changes
2236 the cfun to the function of new_fndecl (and current_function_decl too). */
2239 initialize_cfun (tree new_fndecl
, tree callee_fndecl
, gcov_type count
)
2241 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2242 gcov_type count_scale
;
2244 if (!DECL_ARGUMENTS (new_fndecl
))
2245 DECL_ARGUMENTS (new_fndecl
) = DECL_ARGUMENTS (callee_fndecl
);
2246 if (!DECL_RESULT (new_fndecl
))
2247 DECL_RESULT (new_fndecl
) = DECL_RESULT (callee_fndecl
);
2249 if (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
)
2251 = GCOV_COMPUTE_SCALE (count
,
2252 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
);
2254 count_scale
= REG_BR_PROB_BASE
;
2256 /* Register specific tree functions. */
2257 gimple_register_cfg_hooks ();
2259 /* Get clean struct function. */
2260 push_struct_function (new_fndecl
);
2262 /* We will rebuild these, so just sanity check that they are empty. */
2263 gcc_assert (VALUE_HISTOGRAMS (cfun
) == NULL
);
2264 gcc_assert (cfun
->local_decls
== NULL
);
2265 gcc_assert (cfun
->cfg
== NULL
);
2266 gcc_assert (cfun
->decl
== new_fndecl
);
2268 /* Copy items we preserve during cloning. */
2269 cfun
->static_chain_decl
= src_cfun
->static_chain_decl
;
2270 cfun
->nonlocal_goto_save_area
= src_cfun
->nonlocal_goto_save_area
;
2271 cfun
->function_end_locus
= src_cfun
->function_end_locus
;
2272 cfun
->curr_properties
= src_cfun
->curr_properties
;
2273 cfun
->last_verified
= src_cfun
->last_verified
;
2274 cfun
->va_list_gpr_size
= src_cfun
->va_list_gpr_size
;
2275 cfun
->va_list_fpr_size
= src_cfun
->va_list_fpr_size
;
2276 cfun
->has_nonlocal_label
= src_cfun
->has_nonlocal_label
;
2277 cfun
->stdarg
= src_cfun
->stdarg
;
2278 cfun
->after_inlining
= src_cfun
->after_inlining
;
2279 cfun
->can_throw_non_call_exceptions
2280 = src_cfun
->can_throw_non_call_exceptions
;
2281 cfun
->can_delete_dead_exceptions
= src_cfun
->can_delete_dead_exceptions
;
2282 cfun
->returns_struct
= src_cfun
->returns_struct
;
2283 cfun
->returns_pcc_struct
= src_cfun
->returns_pcc_struct
;
2285 init_empty_tree_cfg ();
2287 profile_status_for_fn (cfun
) = profile_status_for_fn (src_cfun
);
2288 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
=
2289 (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
* count_scale
/
2291 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
2292 = ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->frequency
;
2293 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
=
2294 (EXIT_BLOCK_PTR_FOR_FN (src_cfun
)->count
* count_scale
/
2296 EXIT_BLOCK_PTR_FOR_FN (cfun
)->frequency
=
2297 EXIT_BLOCK_PTR_FOR_FN (src_cfun
)->frequency
;
2299 init_eh_for_function ();
2301 if (src_cfun
->gimple_df
)
2303 init_tree_ssa (cfun
);
2304 cfun
->gimple_df
->in_ssa_p
= true;
2305 init_ssa_operands (cfun
);
2309 /* Helper function for copy_cfg_body. Move debug stmts from the end
2310 of NEW_BB to the beginning of successor basic blocks when needed. If the
2311 successor has multiple predecessors, reset them, otherwise keep
2315 maybe_move_debug_stmts_to_successors (copy_body_data
*id
, basic_block new_bb
)
2319 gimple_stmt_iterator si
= gsi_last_nondebug_bb (new_bb
);
2322 || gsi_one_before_end_p (si
)
2323 || !(stmt_can_throw_internal (gsi_stmt (si
))
2324 || stmt_can_make_abnormal_goto (gsi_stmt (si
))))
2327 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
2329 gimple_stmt_iterator ssi
= gsi_last_bb (new_bb
);
2330 gimple_stmt_iterator dsi
= gsi_after_labels (e
->dest
);
2331 while (is_gimple_debug (gsi_stmt (ssi
)))
2333 gimple stmt
= gsi_stmt (ssi
), new_stmt
;
2337 /* For the last edge move the debug stmts instead of copying
2339 if (ei_one_before_end_p (ei
))
2343 if (!single_pred_p (e
->dest
) && gimple_debug_bind_p (stmt
))
2344 gimple_debug_bind_reset_value (stmt
);
2345 gsi_remove (&si
, false);
2346 gsi_insert_before (&dsi
, stmt
, GSI_SAME_STMT
);
2350 if (gimple_debug_bind_p (stmt
))
2352 var
= gimple_debug_bind_get_var (stmt
);
2353 if (single_pred_p (e
->dest
))
2355 value
= gimple_debug_bind_get_value (stmt
);
2356 value
= unshare_expr (value
);
2360 new_stmt
= gimple_build_debug_bind (var
, value
, stmt
);
2362 else if (gimple_debug_source_bind_p (stmt
))
2364 var
= gimple_debug_source_bind_get_var (stmt
);
2365 value
= gimple_debug_source_bind_get_value (stmt
);
2366 new_stmt
= gimple_build_debug_source_bind (var
, value
, stmt
);
2370 gsi_insert_before (&dsi
, new_stmt
, GSI_SAME_STMT
);
2371 id
->debug_stmts
.safe_push (new_stmt
);
2377 /* Make a copy of the sub-loops of SRC_PARENT and place them
2378 as siblings of DEST_PARENT. */
2381 copy_loops (copy_body_data
*id
,
2382 struct loop
*dest_parent
, struct loop
*src_parent
)
2384 struct loop
*src_loop
= src_parent
->inner
;
2387 if (!id
->blocks_to_copy
2388 || bitmap_bit_p (id
->blocks_to_copy
, src_loop
->header
->index
))
2390 struct loop
*dest_loop
= alloc_loop ();
2392 /* Assign the new loop its header and latch and associate
2393 those with the new loop. */
2394 dest_loop
->header
= (basic_block
)src_loop
->header
->aux
;
2395 dest_loop
->header
->loop_father
= dest_loop
;
2396 if (src_loop
->latch
!= NULL
)
2398 dest_loop
->latch
= (basic_block
)src_loop
->latch
->aux
;
2399 dest_loop
->latch
->loop_father
= dest_loop
;
2402 /* Copy loop meta-data. */
2403 copy_loop_info (src_loop
, dest_loop
);
2405 /* Finally place it into the loop array and the loop tree. */
2406 place_new_loop (cfun
, dest_loop
);
2407 flow_loop_tree_node_add (dest_parent
, dest_loop
);
2409 dest_loop
->safelen
= src_loop
->safelen
;
2410 dest_loop
->dont_vectorize
= src_loop
->dont_vectorize
;
2411 if (src_loop
->force_vectorize
)
2413 dest_loop
->force_vectorize
= true;
2414 cfun
->has_force_vectorize_loops
= true;
2416 if (src_loop
->simduid
)
2418 dest_loop
->simduid
= remap_decl (src_loop
->simduid
, id
);
2419 cfun
->has_simduid_loops
= true;
2423 copy_loops (id
, dest_loop
, src_loop
);
2425 src_loop
= src_loop
->next
;
2429 /* Call cgraph_redirect_edge_call_stmt_to_callee on all calls in BB */
2432 redirect_all_calls (copy_body_data
* id
, basic_block bb
)
2434 gimple_stmt_iterator si
;
2435 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
2437 if (is_gimple_call (gsi_stmt (si
)))
2439 struct cgraph_edge
*edge
= id
->dst_node
->get_edge (gsi_stmt (si
));
2441 edge
->redirect_call_stmt_to_callee ();
2446 /* Convert estimated frequencies into counts for NODE, scaling COUNT
2447 with each bb's frequency. Used when NODE has a 0-weight entry
2448 but we are about to inline it into a non-zero count call bb.
2449 See the comments for handle_missing_profiles() in predict.c for
2450 when this can happen for COMDATs. */
2453 freqs_to_counts (struct cgraph_node
*node
, gcov_type count
)
2458 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
2460 FOR_ALL_BB_FN(bb
, fn
)
2462 bb
->count
= apply_scale (count
,
2463 GCOV_COMPUTE_SCALE (bb
->frequency
, BB_FREQ_MAX
));
2464 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
2465 e
->count
= apply_probability (e
->src
->count
, e
->probability
);
2469 /* Make a copy of the body of FN so that it can be inserted inline in
2470 another function. Walks FN via CFG, returns new fndecl. */
2473 copy_cfg_body (copy_body_data
* id
, gcov_type count
, int frequency_scale
,
2474 basic_block entry_block_map
, basic_block exit_block_map
,
2475 basic_block new_entry
)
2477 tree callee_fndecl
= id
->src_fn
;
2478 /* Original cfun for the callee, doesn't change. */
2479 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2480 struct function
*cfun_to_copy
;
2482 tree new_fndecl
= NULL
;
2483 bool need_debug_cleanup
= false;
2484 gcov_type count_scale
;
2486 int incoming_frequency
= 0;
2487 gcov_type incoming_count
= 0;
2489 /* This can happen for COMDAT routines that end up with 0 counts
2490 despite being called (see the comments for handle_missing_profiles()
2491 in predict.c as to why). Apply counts to the blocks in the callee
2492 before inlining, using the guessed edge frequencies, so that we don't
2493 end up with a 0-count inline body which can confuse downstream
2494 optimizations such as function splitting. */
2495 if (!ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
&& count
)
2497 /* Apply the larger of the call bb count and the total incoming
2498 call edge count to the callee. */
2499 gcov_type in_count
= 0;
2500 struct cgraph_edge
*in_edge
;
2501 for (in_edge
= id
->src_node
->callers
; in_edge
;
2502 in_edge
= in_edge
->next_caller
)
2503 in_count
+= in_edge
->count
;
2504 freqs_to_counts (id
->src_node
, count
> in_count
? count
: in_count
);
2507 if (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
)
2509 = GCOV_COMPUTE_SCALE (count
,
2510 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
);
2512 count_scale
= REG_BR_PROB_BASE
;
2514 /* Register specific tree functions. */
2515 gimple_register_cfg_hooks ();
2517 /* If we are inlining just region of the function, make sure to connect
2518 new entry to ENTRY_BLOCK_PTR_FOR_FN (cfun). Since new entry can be
2519 part of loop, we must compute frequency and probability of
2520 ENTRY_BLOCK_PTR_FOR_FN (cfun) based on the frequencies and
2521 probabilities of edges incoming from nonduplicated region. */
2527 FOR_EACH_EDGE (e
, ei
, new_entry
->preds
)
2530 incoming_frequency
+= EDGE_FREQUENCY (e
);
2531 incoming_count
+= e
->count
;
2533 incoming_count
= apply_scale (incoming_count
, count_scale
);
2535 = apply_scale ((gcov_type
)incoming_frequency
, frequency_scale
);
2536 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= incoming_count
;
2537 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
= incoming_frequency
;
2540 /* Must have a CFG here at this point. */
2541 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN
2542 (DECL_STRUCT_FUNCTION (callee_fndecl
)));
2544 cfun_to_copy
= id
->src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2546 ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy
)->aux
= entry_block_map
;
2547 EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy
)->aux
= exit_block_map
;
2548 entry_block_map
->aux
= ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy
);
2549 exit_block_map
->aux
= EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy
);
2551 /* Duplicate any exception-handling regions. */
2553 id
->eh_map
= duplicate_eh_regions (cfun_to_copy
, NULL
, id
->eh_lp_nr
,
2556 /* Use aux pointers to map the original blocks to copy. */
2557 FOR_EACH_BB_FN (bb
, cfun_to_copy
)
2558 if (!id
->blocks_to_copy
|| bitmap_bit_p (id
->blocks_to_copy
, bb
->index
))
2560 basic_block new_bb
= copy_bb (id
, bb
, frequency_scale
, count_scale
);
2563 new_bb
->loop_father
= entry_block_map
->loop_father
;
2566 last
= last_basic_block_for_fn (cfun
);
2568 /* Now that we've duplicated the blocks, duplicate their edges. */
2569 basic_block abnormal_goto_dest
= NULL
;
2571 && stmt_can_make_abnormal_goto (id
->gimple_call
))
2573 gimple_stmt_iterator gsi
= gsi_for_stmt (id
->gimple_call
);
2575 bb
= gimple_bb (id
->gimple_call
);
2577 if (gsi_end_p (gsi
))
2578 abnormal_goto_dest
= get_abnormal_succ_dispatcher (bb
);
2580 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2581 if (!id
->blocks_to_copy
2582 || (bb
->index
> 0 && bitmap_bit_p (id
->blocks_to_copy
, bb
->index
)))
2583 need_debug_cleanup
|= copy_edges_for_bb (bb
, count_scale
, exit_block_map
,
2584 abnormal_goto_dest
);
2588 edge e
= make_edge (entry_block_map
, (basic_block
)new_entry
->aux
, EDGE_FALLTHRU
);
2589 e
->probability
= REG_BR_PROB_BASE
;
2590 e
->count
= incoming_count
;
2593 /* Duplicate the loop tree, if available and wanted. */
2594 if (loops_for_fn (src_cfun
) != NULL
2595 && current_loops
!= NULL
)
2597 copy_loops (id
, entry_block_map
->loop_father
,
2598 get_loop (src_cfun
, 0));
2599 /* Defer to cfgcleanup to update loop-father fields of basic-blocks. */
2600 loops_state_set (LOOPS_NEED_FIXUP
);
2603 /* If the loop tree in the source function needed fixup, mark the
2604 destination loop tree for fixup, too. */
2605 if (loops_for_fn (src_cfun
)->state
& LOOPS_NEED_FIXUP
)
2606 loops_state_set (LOOPS_NEED_FIXUP
);
2608 if (gimple_in_ssa_p (cfun
))
2609 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2610 if (!id
->blocks_to_copy
2611 || (bb
->index
> 0 && bitmap_bit_p (id
->blocks_to_copy
, bb
->index
)))
2612 copy_phis_for_bb (bb
, id
);
2614 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2617 if (need_debug_cleanup
2618 && bb
->index
!= ENTRY_BLOCK
2619 && bb
->index
!= EXIT_BLOCK
)
2620 maybe_move_debug_stmts_to_successors (id
, (basic_block
) bb
->aux
);
2621 /* Update call edge destinations. This can not be done before loop
2622 info is updated, because we may split basic blocks. */
2623 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
)
2624 redirect_all_calls (id
, (basic_block
)bb
->aux
);
2625 ((basic_block
)bb
->aux
)->aux
= NULL
;
2629 /* Zero out AUX fields of newly created block during EH edge
2631 for (; last
< last_basic_block_for_fn (cfun
); last
++)
2633 if (need_debug_cleanup
)
2634 maybe_move_debug_stmts_to_successors (id
,
2635 BASIC_BLOCK_FOR_FN (cfun
, last
));
2636 BASIC_BLOCK_FOR_FN (cfun
, last
)->aux
= NULL
;
2637 /* Update call edge destinations. This can not be done before loop
2638 info is updated, because we may split basic blocks. */
2639 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
)
2640 redirect_all_calls (id
, BASIC_BLOCK_FOR_FN (cfun
, last
));
2642 entry_block_map
->aux
= NULL
;
2643 exit_block_map
->aux
= NULL
;
2654 /* Copy the debug STMT using ID. We deal with these statements in a
2655 special way: if any variable in their VALUE expression wasn't
2656 remapped yet, we won't remap it, because that would get decl uids
2657 out of sync, causing codegen differences between -g and -g0. If
2658 this arises, we drop the VALUE expression altogether. */
2661 copy_debug_stmt (gimple stmt
, copy_body_data
*id
)
2664 struct walk_stmt_info wi
;
2666 if (gimple_block (stmt
))
2668 n
= id
->decl_map
->get (gimple_block (stmt
));
2669 gimple_set_block (stmt
, n
? *n
: id
->block
);
2672 /* Remap all the operands in COPY. */
2673 memset (&wi
, 0, sizeof (wi
));
2676 processing_debug_stmt
= 1;
2678 if (gimple_debug_source_bind_p (stmt
))
2679 t
= gimple_debug_source_bind_get_var (stmt
);
2681 t
= gimple_debug_bind_get_var (stmt
);
2683 if (TREE_CODE (t
) == PARM_DECL
&& id
->debug_map
2684 && (n
= id
->debug_map
->get (t
)))
2686 gcc_assert (TREE_CODE (*n
) == VAR_DECL
);
2689 else if (TREE_CODE (t
) == VAR_DECL
2690 && !is_global_var (t
)
2691 && !id
->decl_map
->get (t
))
2692 /* T is a non-localized variable. */;
2694 walk_tree (&t
, remap_gimple_op_r
, &wi
, NULL
);
2696 if (gimple_debug_bind_p (stmt
))
2698 gimple_debug_bind_set_var (stmt
, t
);
2700 if (gimple_debug_bind_has_value_p (stmt
))
2701 walk_tree (gimple_debug_bind_get_value_ptr (stmt
),
2702 remap_gimple_op_r
, &wi
, NULL
);
2704 /* Punt if any decl couldn't be remapped. */
2705 if (processing_debug_stmt
< 0)
2706 gimple_debug_bind_reset_value (stmt
);
2708 else if (gimple_debug_source_bind_p (stmt
))
2710 gimple_debug_source_bind_set_var (stmt
, t
);
2711 walk_tree (gimple_debug_source_bind_get_value_ptr (stmt
),
2712 remap_gimple_op_r
, &wi
, NULL
);
2713 /* When inlining and source bind refers to one of the optimized
2714 away parameters, change the source bind into normal debug bind
2715 referring to the corresponding DEBUG_EXPR_DECL that should have
2716 been bound before the call stmt. */
2717 t
= gimple_debug_source_bind_get_value (stmt
);
2719 && TREE_CODE (t
) == PARM_DECL
2722 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (id
->src_fn
);
2724 if (debug_args
!= NULL
)
2726 for (i
= 0; i
< vec_safe_length (*debug_args
); i
+= 2)
2727 if ((**debug_args
)[i
] == DECL_ORIGIN (t
)
2728 && TREE_CODE ((**debug_args
)[i
+ 1]) == DEBUG_EXPR_DECL
)
2730 t
= (**debug_args
)[i
+ 1];
2731 stmt
->subcode
= GIMPLE_DEBUG_BIND
;
2732 gimple_debug_bind_set_value (stmt
, t
);
2739 processing_debug_stmt
= 0;
2744 /* Process deferred debug stmts. In order to give values better odds
2745 of being successfully remapped, we delay the processing of debug
2746 stmts until all other stmts that might require remapping are
2750 copy_debug_stmts (copy_body_data
*id
)
2755 if (!id
->debug_stmts
.exists ())
2758 FOR_EACH_VEC_ELT (id
->debug_stmts
, i
, stmt
)
2759 copy_debug_stmt (stmt
, id
);
2761 id
->debug_stmts
.release ();
2764 /* Make a copy of the body of SRC_FN so that it can be inserted inline in
2765 another function. */
2768 copy_tree_body (copy_body_data
*id
)
2770 tree fndecl
= id
->src_fn
;
2771 tree body
= DECL_SAVED_TREE (fndecl
);
2773 walk_tree (&body
, copy_tree_body_r
, id
, NULL
);
2778 /* Make a copy of the body of FN so that it can be inserted inline in
2779 another function. */
2782 copy_body (copy_body_data
*id
, gcov_type count
, int frequency_scale
,
2783 basic_block entry_block_map
, basic_block exit_block_map
,
2784 basic_block new_entry
)
2786 tree fndecl
= id
->src_fn
;
2789 /* If this body has a CFG, walk CFG and copy. */
2790 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (fndecl
)));
2791 body
= copy_cfg_body (id
, count
, frequency_scale
, entry_block_map
, exit_block_map
,
2793 copy_debug_stmts (id
);
2798 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
2799 defined in function FN, or of a data member thereof. */
2802 self_inlining_addr_expr (tree value
, tree fn
)
2806 if (TREE_CODE (value
) != ADDR_EXPR
)
2809 var
= get_base_address (TREE_OPERAND (value
, 0));
2811 return var
&& auto_var_in_fn_p (var
, fn
);
2814 /* Append to BB a debug annotation that binds VAR to VALUE, inheriting
2815 lexical block and line number information from base_stmt, if given,
2816 or from the last stmt of the block otherwise. */
2819 insert_init_debug_bind (copy_body_data
*id
,
2820 basic_block bb
, tree var
, tree value
,
2824 gimple_stmt_iterator gsi
;
2827 if (!gimple_in_ssa_p (id
->src_cfun
))
2830 if (!MAY_HAVE_DEBUG_STMTS
)
2833 tracked_var
= target_for_debug_bind (var
);
2839 gsi
= gsi_last_bb (bb
);
2840 if (!base_stmt
&& !gsi_end_p (gsi
))
2841 base_stmt
= gsi_stmt (gsi
);
2844 note
= gimple_build_debug_bind (tracked_var
, value
, base_stmt
);
2848 if (!gsi_end_p (gsi
))
2849 gsi_insert_after (&gsi
, note
, GSI_SAME_STMT
);
2851 gsi_insert_before (&gsi
, note
, GSI_SAME_STMT
);
2858 insert_init_stmt (copy_body_data
*id
, basic_block bb
, gimple init_stmt
)
2860 /* If VAR represents a zero-sized variable, it's possible that the
2861 assignment statement may result in no gimple statements. */
2864 gimple_stmt_iterator si
= gsi_last_bb (bb
);
2866 /* We can end up with init statements that store to a non-register
2867 from a rhs with a conversion. Handle that here by forcing the
2868 rhs into a temporary. gimple_regimplify_operands is not
2869 prepared to do this for us. */
2870 if (!is_gimple_debug (init_stmt
)
2871 && !is_gimple_reg (gimple_assign_lhs (init_stmt
))
2872 && is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (init_stmt
)))
2873 && gimple_assign_rhs_class (init_stmt
) == GIMPLE_UNARY_RHS
)
2875 tree rhs
= build1 (gimple_assign_rhs_code (init_stmt
),
2876 gimple_expr_type (init_stmt
),
2877 gimple_assign_rhs1 (init_stmt
));
2878 rhs
= force_gimple_operand_gsi (&si
, rhs
, true, NULL_TREE
, false,
2880 gimple_assign_set_rhs_code (init_stmt
, TREE_CODE (rhs
));
2881 gimple_assign_set_rhs1 (init_stmt
, rhs
);
2883 gsi_insert_after (&si
, init_stmt
, GSI_NEW_STMT
);
2884 gimple_regimplify_operands (init_stmt
, &si
);
2886 if (!is_gimple_debug (init_stmt
) && MAY_HAVE_DEBUG_STMTS
)
2888 tree def
= gimple_assign_lhs (init_stmt
);
2889 insert_init_debug_bind (id
, bb
, def
, def
, init_stmt
);
2894 /* Initialize parameter P with VALUE. If needed, produce init statement
2895 at the end of BB. When BB is NULL, we return init statement to be
2898 setup_one_parameter (copy_body_data
*id
, tree p
, tree value
, tree fn
,
2899 basic_block bb
, tree
*vars
)
2901 gimple init_stmt
= NULL
;
2904 tree def
= (gimple_in_ssa_p (cfun
)
2905 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
2908 && value
!= error_mark_node
2909 && !useless_type_conversion_p (TREE_TYPE (p
), TREE_TYPE (value
)))
2911 /* If we can match up types by promotion/demotion do so. */
2912 if (fold_convertible_p (TREE_TYPE (p
), value
))
2913 rhs
= fold_convert (TREE_TYPE (p
), value
);
2916 /* ??? For valid programs we should not end up here.
2917 Still if we end up with truly mismatched types here, fall back
2918 to using a VIEW_CONVERT_EXPR or a literal zero to not leak invalid
2919 GIMPLE to the following passes. */
2920 if (!is_gimple_reg_type (TREE_TYPE (value
))
2921 || TYPE_SIZE (TREE_TYPE (p
)) == TYPE_SIZE (TREE_TYPE (value
)))
2922 rhs
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (p
), value
);
2924 rhs
= build_zero_cst (TREE_TYPE (p
));
2928 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
2929 here since the type of this decl must be visible to the calling
2931 var
= copy_decl_to_var (p
, id
);
2933 /* Declare this new variable. */
2934 DECL_CHAIN (var
) = *vars
;
2937 /* Make gimplifier happy about this variable. */
2938 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
2940 /* If the parameter is never assigned to, has no SSA_NAMEs created,
2941 we would not need to create a new variable here at all, if it
2942 weren't for debug info. Still, we can just use the argument
2944 if (TREE_READONLY (p
)
2945 && !TREE_ADDRESSABLE (p
)
2946 && value
&& !TREE_SIDE_EFFECTS (value
)
2949 /* We may produce non-gimple trees by adding NOPs or introduce
2950 invalid sharing when operand is not really constant.
2951 It is not big deal to prohibit constant propagation here as
2952 we will constant propagate in DOM1 pass anyway. */
2953 if (is_gimple_min_invariant (value
)
2954 && useless_type_conversion_p (TREE_TYPE (p
),
2956 /* We have to be very careful about ADDR_EXPR. Make sure
2957 the base variable isn't a local variable of the inlined
2958 function, e.g., when doing recursive inlining, direct or
2959 mutually-recursive or whatever, which is why we don't
2960 just test whether fn == current_function_decl. */
2961 && ! self_inlining_addr_expr (value
, fn
))
2963 insert_decl_map (id
, p
, value
);
2964 insert_debug_decl_map (id
, p
, var
);
2965 return insert_init_debug_bind (id
, bb
, var
, value
, NULL
);
2969 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
2970 that way, when the PARM_DECL is encountered, it will be
2971 automatically replaced by the VAR_DECL. */
2972 insert_decl_map (id
, p
, var
);
2974 /* Even if P was TREE_READONLY, the new VAR should not be.
2975 In the original code, we would have constructed a
2976 temporary, and then the function body would have never
2977 changed the value of P. However, now, we will be
2978 constructing VAR directly. The constructor body may
2979 change its value multiple times as it is being
2980 constructed. Therefore, it must not be TREE_READONLY;
2981 the back-end assumes that TREE_READONLY variable is
2982 assigned to only once. */
2983 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p
)))
2984 TREE_READONLY (var
) = 0;
2986 /* If there is no setup required and we are in SSA, take the easy route
2987 replacing all SSA names representing the function parameter by the
2988 SSA name passed to function.
2990 We need to construct map for the variable anyway as it might be used
2991 in different SSA names when parameter is set in function.
2993 Do replacement at -O0 for const arguments replaced by constant.
2994 This is important for builtin_constant_p and other construct requiring
2995 constant argument to be visible in inlined function body. */
2996 if (gimple_in_ssa_p (cfun
) && rhs
&& def
&& is_gimple_reg (p
)
2998 || (TREE_READONLY (p
)
2999 && is_gimple_min_invariant (rhs
)))
3000 && (TREE_CODE (rhs
) == SSA_NAME
3001 || is_gimple_min_invariant (rhs
))
3002 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
3004 insert_decl_map (id
, def
, rhs
);
3005 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3008 /* If the value of argument is never used, don't care about initializing
3010 if (optimize
&& gimple_in_ssa_p (cfun
) && !def
&& is_gimple_reg (p
))
3012 gcc_assert (!value
|| !TREE_SIDE_EFFECTS (value
));
3013 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3016 /* Initialize this VAR_DECL from the equivalent argument. Convert
3017 the argument to the proper type in case it was promoted. */
3020 if (rhs
== error_mark_node
)
3022 insert_decl_map (id
, p
, var
);
3023 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3026 STRIP_USELESS_TYPE_CONVERSION (rhs
);
3028 /* If we are in SSA form properly remap the default definition
3029 or assign to a dummy SSA name if the parameter is unused and
3030 we are not optimizing. */
3031 if (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
))
3035 def
= remap_ssa_name (def
, id
);
3036 init_stmt
= gimple_build_assign (def
, rhs
);
3037 SSA_NAME_IS_DEFAULT_DEF (def
) = 0;
3038 set_ssa_default_def (cfun
, var
, NULL
);
3042 def
= make_ssa_name (var
, NULL
);
3043 init_stmt
= gimple_build_assign (def
, rhs
);
3047 init_stmt
= gimple_build_assign (var
, rhs
);
3049 if (bb
&& init_stmt
)
3050 insert_init_stmt (id
, bb
, init_stmt
);
3055 /* Generate code to initialize the parameters of the function at the
3056 top of the stack in ID from the GIMPLE_CALL STMT. */
3059 initialize_inlined_parameters (copy_body_data
*id
, gimple stmt
,
3060 tree fn
, basic_block bb
)
3065 tree vars
= NULL_TREE
;
3066 tree static_chain
= gimple_call_chain (stmt
);
3068 /* Figure out what the parameters are. */
3069 parms
= DECL_ARGUMENTS (fn
);
3071 /* Loop through the parameter declarations, replacing each with an
3072 equivalent VAR_DECL, appropriately initialized. */
3073 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
3076 val
= i
< gimple_call_num_args (stmt
) ? gimple_call_arg (stmt
, i
) : NULL
;
3077 setup_one_parameter (id
, p
, val
, fn
, bb
, &vars
);
3079 /* After remapping parameters remap their types. This has to be done
3080 in a second loop over all parameters to appropriately remap
3081 variable sized arrays when the size is specified in a
3082 parameter following the array. */
3083 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
3085 tree
*varp
= id
->decl_map
->get (p
);
3087 && TREE_CODE (*varp
) == VAR_DECL
)
3089 tree def
= (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
)
3090 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
3092 TREE_TYPE (var
) = remap_type (TREE_TYPE (var
), id
);
3093 /* Also remap the default definition if it was remapped
3094 to the default definition of the parameter replacement
3095 by the parameter setup. */
3098 tree
*defp
= id
->decl_map
->get (def
);
3100 && TREE_CODE (*defp
) == SSA_NAME
3101 && SSA_NAME_VAR (*defp
) == var
)
3102 TREE_TYPE (*defp
) = TREE_TYPE (var
);
3107 /* Initialize the static chain. */
3108 p
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
3109 gcc_assert (fn
!= current_function_decl
);
3112 /* No static chain? Seems like a bug in tree-nested.c. */
3113 gcc_assert (static_chain
);
3115 setup_one_parameter (id
, p
, static_chain
, fn
, bb
, &vars
);
3118 declare_inline_vars (id
->block
, vars
);
3122 /* Declare a return variable to replace the RESULT_DECL for the
3123 function we are calling. An appropriate DECL_STMT is returned.
3124 The USE_STMT is filled to contain a use of the declaration to
3125 indicate the return value of the function.
3127 RETURN_SLOT, if non-null is place where to store the result. It
3128 is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null,
3129 was the LHS of the MODIFY_EXPR to which this call is the RHS.
3131 The return value is a (possibly null) value that holds the result
3132 as seen by the caller. */
3135 declare_return_variable (copy_body_data
*id
, tree return_slot
, tree modify_dest
,
3136 basic_block entry_bb
)
3138 tree callee
= id
->src_fn
;
3139 tree result
= DECL_RESULT (callee
);
3140 tree callee_type
= TREE_TYPE (result
);
3144 /* Handle type-mismatches in the function declaration return type
3145 vs. the call expression. */
3147 caller_type
= TREE_TYPE (modify_dest
);
3149 caller_type
= TREE_TYPE (TREE_TYPE (callee
));
3151 /* We don't need to do anything for functions that don't return anything. */
3152 if (VOID_TYPE_P (callee_type
))
3155 /* If there was a return slot, then the return value is the
3156 dereferenced address of that object. */
3159 /* The front end shouldn't have used both return_slot and
3160 a modify expression. */
3161 gcc_assert (!modify_dest
);
3162 if (DECL_BY_REFERENCE (result
))
3164 tree return_slot_addr
= build_fold_addr_expr (return_slot
);
3165 STRIP_USELESS_TYPE_CONVERSION (return_slot_addr
);
3167 /* We are going to construct *&return_slot and we can't do that
3168 for variables believed to be not addressable.
3170 FIXME: This check possibly can match, because values returned
3171 via return slot optimization are not believed to have address
3172 taken by alias analysis. */
3173 gcc_assert (TREE_CODE (return_slot
) != SSA_NAME
);
3174 var
= return_slot_addr
;
3179 gcc_assert (TREE_CODE (var
) != SSA_NAME
);
3180 if (TREE_ADDRESSABLE (result
))
3181 mark_addressable (var
);
3183 if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
3184 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
3185 && !DECL_GIMPLE_REG_P (result
)
3187 DECL_GIMPLE_REG_P (var
) = 0;
3192 /* All types requiring non-trivial constructors should have been handled. */
3193 gcc_assert (!TREE_ADDRESSABLE (callee_type
));
3195 /* Attempt to avoid creating a new temporary variable. */
3197 && TREE_CODE (modify_dest
) != SSA_NAME
)
3199 bool use_it
= false;
3201 /* We can't use MODIFY_DEST if there's type promotion involved. */
3202 if (!useless_type_conversion_p (callee_type
, caller_type
))
3205 /* ??? If we're assigning to a variable sized type, then we must
3206 reuse the destination variable, because we've no good way to
3207 create variable sized temporaries at this point. */
3208 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type
)) != INTEGER_CST
)
3211 /* If the callee cannot possibly modify MODIFY_DEST, then we can
3212 reuse it as the result of the call directly. Don't do this if
3213 it would promote MODIFY_DEST to addressable. */
3214 else if (TREE_ADDRESSABLE (result
))
3218 tree base_m
= get_base_address (modify_dest
);
3220 /* If the base isn't a decl, then it's a pointer, and we don't
3221 know where that's going to go. */
3222 if (!DECL_P (base_m
))
3224 else if (is_global_var (base_m
))
3226 else if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
3227 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
3228 && !DECL_GIMPLE_REG_P (result
)
3229 && DECL_GIMPLE_REG_P (base_m
))
3231 else if (!TREE_ADDRESSABLE (base_m
))
3243 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type
)) == INTEGER_CST
);
3245 var
= copy_result_decl_to_var (result
, id
);
3246 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
3248 /* Do not have the rest of GCC warn about this variable as it should
3249 not be visible to the user. */
3250 TREE_NO_WARNING (var
) = 1;
3252 declare_inline_vars (id
->block
, var
);
3254 /* Build the use expr. If the return type of the function was
3255 promoted, convert it back to the expected type. */
3257 if (!useless_type_conversion_p (caller_type
, TREE_TYPE (var
)))
3259 /* If we can match up types by promotion/demotion do so. */
3260 if (fold_convertible_p (caller_type
, var
))
3261 use
= fold_convert (caller_type
, var
);
3264 /* ??? For valid programs we should not end up here.
3265 Still if we end up with truly mismatched types here, fall back
3266 to using a MEM_REF to not leak invalid GIMPLE to the following
3268 /* Prevent var from being written into SSA form. */
3269 if (TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
3270 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
)
3271 DECL_GIMPLE_REG_P (var
) = false;
3272 else if (is_gimple_reg_type (TREE_TYPE (var
)))
3273 TREE_ADDRESSABLE (var
) = true;
3274 use
= fold_build2 (MEM_REF
, caller_type
,
3275 build_fold_addr_expr (var
),
3276 build_int_cst (ptr_type_node
, 0));
3280 STRIP_USELESS_TYPE_CONVERSION (use
);
3282 if (DECL_BY_REFERENCE (result
))
3284 TREE_ADDRESSABLE (var
) = 1;
3285 var
= build_fold_addr_expr (var
);
3289 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
3290 way, when the RESULT_DECL is encountered, it will be
3291 automatically replaced by the VAR_DECL.
3293 When returning by reference, ensure that RESULT_DECL remaps to
3295 if (DECL_BY_REFERENCE (result
)
3296 && !is_gimple_val (var
))
3298 tree temp
= create_tmp_var (TREE_TYPE (result
), "retvalptr");
3299 insert_decl_map (id
, result
, temp
);
3300 /* When RESULT_DECL is in SSA form, we need to remap and initialize
3301 it's default_def SSA_NAME. */
3302 if (gimple_in_ssa_p (id
->src_cfun
)
3303 && is_gimple_reg (result
))
3305 temp
= make_ssa_name (temp
, NULL
);
3306 insert_decl_map (id
, ssa_default_def (id
->src_cfun
, result
), temp
);
3308 insert_init_stmt (id
, entry_bb
, gimple_build_assign (temp
, var
));
3311 insert_decl_map (id
, result
, var
);
3313 /* Remember this so we can ignore it in remap_decls. */
3319 /* Callback through walk_tree. Determine if a DECL_INITIAL makes reference
3320 to a local label. */
3323 has_label_address_in_static_1 (tree
*nodep
, int *walk_subtrees
, void *fnp
)
3326 tree fn
= (tree
) fnp
;
3328 if (TREE_CODE (node
) == LABEL_DECL
&& DECL_CONTEXT (node
) == fn
)
3337 /* Determine if the function can be copied. If so return NULL. If
3338 not return a string describng the reason for failure. */
3341 copy_forbidden (struct function
*fun
, tree fndecl
)
3343 const char *reason
= fun
->cannot_be_copied_reason
;
3347 /* Only examine the function once. */
3348 if (fun
->cannot_be_copied_set
)
3351 /* We cannot copy a function that receives a non-local goto
3352 because we cannot remap the destination label used in the
3353 function that is performing the non-local goto. */
3354 /* ??? Actually, this should be possible, if we work at it.
3355 No doubt there's just a handful of places that simply
3356 assume it doesn't happen and don't substitute properly. */
3357 if (fun
->has_nonlocal_label
)
3359 reason
= G_("function %q+F can never be copied "
3360 "because it receives a non-local goto");
3364 FOR_EACH_LOCAL_DECL (fun
, ix
, decl
)
3365 if (TREE_CODE (decl
) == VAR_DECL
3366 && TREE_STATIC (decl
)
3367 && !DECL_EXTERNAL (decl
)
3368 && DECL_INITIAL (decl
)
3369 && walk_tree_without_duplicates (&DECL_INITIAL (decl
),
3370 has_label_address_in_static_1
,
3373 reason
= G_("function %q+F can never be copied because it saves "
3374 "address of local label in a static variable");
3379 fun
->cannot_be_copied_reason
= reason
;
3380 fun
->cannot_be_copied_set
= true;
3385 static const char *inline_forbidden_reason
;
3387 /* A callback for walk_gimple_seq to handle statements. Returns non-null
3388 iff a function can not be inlined. Also sets the reason why. */
3391 inline_forbidden_p_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
3392 struct walk_stmt_info
*wip
)
3394 tree fn
= (tree
) wip
->info
;
3396 gimple stmt
= gsi_stmt (*gsi
);
3398 switch (gimple_code (stmt
))
3401 /* Refuse to inline alloca call unless user explicitly forced so as
3402 this may change program's memory overhead drastically when the
3403 function using alloca is called in loop. In GCC present in
3404 SPEC2000 inlining into schedule_block cause it to require 2GB of
3405 RAM instead of 256MB. Don't do so for alloca calls emitted for
3406 VLA objects as those can't cause unbounded growth (they're always
3407 wrapped inside stack_save/stack_restore regions. */
3408 if (gimple_alloca_call_p (stmt
)
3409 && !gimple_call_alloca_for_var_p (stmt
)
3410 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
3412 inline_forbidden_reason
3413 = G_("function %q+F can never be inlined because it uses "
3414 "alloca (override using the always_inline attribute)");
3415 *handled_ops_p
= true;
3419 t
= gimple_call_fndecl (stmt
);
3423 /* We cannot inline functions that call setjmp. */
3424 if (setjmp_call_p (t
))
3426 inline_forbidden_reason
3427 = G_("function %q+F can never be inlined because it uses setjmp");
3428 *handled_ops_p
= true;
3432 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
3433 switch (DECL_FUNCTION_CODE (t
))
3435 /* We cannot inline functions that take a variable number of
3437 case BUILT_IN_VA_START
:
3438 case BUILT_IN_NEXT_ARG
:
3439 case BUILT_IN_VA_END
:
3440 inline_forbidden_reason
3441 = G_("function %q+F can never be inlined because it "
3442 "uses variable argument lists");
3443 *handled_ops_p
= true;
3446 case BUILT_IN_LONGJMP
:
3447 /* We can't inline functions that call __builtin_longjmp at
3448 all. The non-local goto machinery really requires the
3449 destination be in a different function. If we allow the
3450 function calling __builtin_longjmp to be inlined into the
3451 function calling __builtin_setjmp, Things will Go Awry. */
3452 inline_forbidden_reason
3453 = G_("function %q+F can never be inlined because "
3454 "it uses setjmp-longjmp exception handling");
3455 *handled_ops_p
= true;
3458 case BUILT_IN_NONLOCAL_GOTO
:
3460 inline_forbidden_reason
3461 = G_("function %q+F can never be inlined because "
3462 "it uses non-local goto");
3463 *handled_ops_p
= true;
3466 case BUILT_IN_RETURN
:
3467 case BUILT_IN_APPLY_ARGS
:
3468 /* If a __builtin_apply_args caller would be inlined,
3469 it would be saving arguments of the function it has
3470 been inlined into. Similarly __builtin_return would
3471 return from the function the inline has been inlined into. */
3472 inline_forbidden_reason
3473 = G_("function %q+F can never be inlined because "
3474 "it uses __builtin_return or __builtin_apply_args");
3475 *handled_ops_p
= true;
3484 t
= gimple_goto_dest (stmt
);
3486 /* We will not inline a function which uses computed goto. The
3487 addresses of its local labels, which may be tucked into
3488 global storage, are of course not constant across
3489 instantiations, which causes unexpected behavior. */
3490 if (TREE_CODE (t
) != LABEL_DECL
)
3492 inline_forbidden_reason
3493 = G_("function %q+F can never be inlined "
3494 "because it contains a computed goto");
3495 *handled_ops_p
= true;
3504 *handled_ops_p
= false;
3508 /* Return true if FNDECL is a function that cannot be inlined into
3512 inline_forbidden_p (tree fndecl
)
3514 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
3515 struct walk_stmt_info wi
;
3517 bool forbidden_p
= false;
3519 /* First check for shared reasons not to copy the code. */
3520 inline_forbidden_reason
= copy_forbidden (fun
, fndecl
);
3521 if (inline_forbidden_reason
!= NULL
)
3524 /* Next, walk the statements of the function looking for
3525 constraucts we can't handle, or are non-optimal for inlining. */
3526 hash_set
<tree
> visited_nodes
;
3527 memset (&wi
, 0, sizeof (wi
));
3528 wi
.info
= (void *) fndecl
;
3529 wi
.pset
= &visited_nodes
;
3531 FOR_EACH_BB_FN (bb
, fun
)
3534 gimple_seq seq
= bb_seq (bb
);
3535 ret
= walk_gimple_seq (seq
, inline_forbidden_p_stmt
, NULL
, &wi
);
3536 forbidden_p
= (ret
!= NULL
);
3544 /* Return false if the function FNDECL cannot be inlined on account of its
3545 attributes, true otherwise. */
3547 function_attribute_inlinable_p (const_tree fndecl
)
3549 if (targetm
.attribute_table
)
3553 for (a
= DECL_ATTRIBUTES (fndecl
); a
; a
= TREE_CHAIN (a
))
3555 const_tree name
= TREE_PURPOSE (a
);
3558 for (i
= 0; targetm
.attribute_table
[i
].name
!= NULL
; i
++)
3559 if (is_attribute_p (targetm
.attribute_table
[i
].name
, name
))
3560 return targetm
.function_attribute_inlinable_p (fndecl
);
3567 /* Returns nonzero if FN is a function that does not have any
3568 fundamental inline blocking properties. */
3571 tree_inlinable_function_p (tree fn
)
3573 bool inlinable
= true;
3577 /* If we've already decided this function shouldn't be inlined,
3578 there's no need to check again. */
3579 if (DECL_UNINLINABLE (fn
))
3582 /* We only warn for functions declared `inline' by the user. */
3583 do_warning
= (warn_inline
3584 && DECL_DECLARED_INLINE_P (fn
)
3585 && !DECL_NO_INLINE_WARNING_P (fn
)
3586 && !DECL_IN_SYSTEM_HEADER (fn
));
3588 always_inline
= lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
));
3591 && always_inline
== NULL
)
3594 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3595 "is suppressed using -fno-inline", fn
);
3599 else if (!function_attribute_inlinable_p (fn
))
3602 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3603 "uses attributes conflicting with inlining", fn
);
3607 else if (inline_forbidden_p (fn
))
3609 /* See if we should warn about uninlinable functions. Previously,
3610 some of these warnings would be issued while trying to expand
3611 the function inline, but that would cause multiple warnings
3612 about functions that would for example call alloca. But since
3613 this a property of the function, just one warning is enough.
3614 As a bonus we can now give more details about the reason why a
3615 function is not inlinable. */
3617 error (inline_forbidden_reason
, fn
);
3618 else if (do_warning
)
3619 warning (OPT_Winline
, inline_forbidden_reason
, fn
);
3624 /* Squirrel away the result so that we don't have to check again. */
3625 DECL_UNINLINABLE (fn
) = !inlinable
;
3630 /* Estimate the cost of a memory move of type TYPE. Use machine dependent
3631 word size and take possible memcpy call into account and return
3632 cost based on whether optimizing for size or speed according to SPEED_P. */
3635 estimate_move_cost (tree type
, bool ARG_UNUSED (speed_p
))
3639 gcc_assert (!VOID_TYPE_P (type
));
3641 if (TREE_CODE (type
) == VECTOR_TYPE
)
3643 machine_mode inner
= TYPE_MODE (TREE_TYPE (type
));
3645 = targetm
.vectorize
.preferred_simd_mode (inner
);
3646 int simd_mode_size
= GET_MODE_SIZE (simd
);
3647 return ((GET_MODE_SIZE (TYPE_MODE (type
)) + simd_mode_size
- 1)
3651 size
= int_size_in_bytes (type
);
3653 if (size
< 0 || size
> MOVE_MAX_PIECES
* MOVE_RATIO (speed_p
))
3654 /* Cost of a memcpy call, 3 arguments and the call. */
3657 return ((size
+ MOVE_MAX_PIECES
- 1) / MOVE_MAX_PIECES
);
3660 /* Returns cost of operation CODE, according to WEIGHTS */
3663 estimate_operator_cost (enum tree_code code
, eni_weights
*weights
,
3664 tree op1 ATTRIBUTE_UNUSED
, tree op2
)
3668 /* These are "free" conversions, or their presumed cost
3669 is folded into other operations. */
3674 case VIEW_CONVERT_EXPR
:
3677 /* Assign cost of 1 to usual operations.
3678 ??? We may consider mapping RTL costs to this. */
3684 case POINTER_PLUS_EXPR
:
3687 case MULT_HIGHPART_EXPR
:
3690 case ADDR_SPACE_CONVERT_EXPR
:
3691 case FIXED_CONVERT_EXPR
:
3692 case FIX_TRUNC_EXPR
:
3704 case VEC_RSHIFT_EXPR
:
3711 case TRUTH_ANDIF_EXPR
:
3712 case TRUTH_ORIF_EXPR
:
3713 case TRUTH_AND_EXPR
:
3715 case TRUTH_XOR_EXPR
:
3716 case TRUTH_NOT_EXPR
:
3725 case UNORDERED_EXPR
:
3736 case PREDECREMENT_EXPR
:
3737 case PREINCREMENT_EXPR
:
3738 case POSTDECREMENT_EXPR
:
3739 case POSTINCREMENT_EXPR
:
3741 case REALIGN_LOAD_EXPR
:
3743 case REDUC_MAX_EXPR
:
3744 case REDUC_MIN_EXPR
:
3745 case REDUC_PLUS_EXPR
:
3746 case WIDEN_SUM_EXPR
:
3747 case WIDEN_MULT_EXPR
:
3750 case WIDEN_MULT_PLUS_EXPR
:
3751 case WIDEN_MULT_MINUS_EXPR
:
3752 case WIDEN_LSHIFT_EXPR
:
3754 case VEC_WIDEN_MULT_HI_EXPR
:
3755 case VEC_WIDEN_MULT_LO_EXPR
:
3756 case VEC_WIDEN_MULT_EVEN_EXPR
:
3757 case VEC_WIDEN_MULT_ODD_EXPR
:
3758 case VEC_UNPACK_HI_EXPR
:
3759 case VEC_UNPACK_LO_EXPR
:
3760 case VEC_UNPACK_FLOAT_HI_EXPR
:
3761 case VEC_UNPACK_FLOAT_LO_EXPR
:
3762 case VEC_PACK_TRUNC_EXPR
:
3763 case VEC_PACK_SAT_EXPR
:
3764 case VEC_PACK_FIX_TRUNC_EXPR
:
3765 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3766 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3770 /* Few special cases of expensive operations. This is useful
3771 to avoid inlining on functions having too many of these. */
3772 case TRUNC_DIV_EXPR
:
3774 case FLOOR_DIV_EXPR
:
3775 case ROUND_DIV_EXPR
:
3776 case EXACT_DIV_EXPR
:
3777 case TRUNC_MOD_EXPR
:
3779 case FLOOR_MOD_EXPR
:
3780 case ROUND_MOD_EXPR
:
3782 if (TREE_CODE (op2
) != INTEGER_CST
)
3783 return weights
->div_mod_cost
;
3787 /* We expect a copy assignment with no operator. */
3788 gcc_assert (get_gimple_rhs_class (code
) == GIMPLE_SINGLE_RHS
);
3794 /* Estimate number of instructions that will be created by expanding
3795 the statements in the statement sequence STMTS.
3796 WEIGHTS contains weights attributed to various constructs. */
3799 int estimate_num_insns_seq (gimple_seq stmts
, eni_weights
*weights
)
3802 gimple_stmt_iterator gsi
;
3805 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3806 cost
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
3812 /* Estimate number of instructions that will be created by expanding STMT.
3813 WEIGHTS contains weights attributed to various constructs. */
3816 estimate_num_insns (gimple stmt
, eni_weights
*weights
)
3819 enum gimple_code code
= gimple_code (stmt
);
3826 /* Try to estimate the cost of assignments. We have three cases to
3828 1) Simple assignments to registers;
3829 2) Stores to things that must live in memory. This includes
3830 "normal" stores to scalars, but also assignments of large
3831 structures, or constructors of big arrays;
3833 Let us look at the first two cases, assuming we have "a = b + C":
3834 <GIMPLE_ASSIGN <var_decl "a">
3835 <plus_expr <var_decl "b"> <constant C>>
3836 If "a" is a GIMPLE register, the assignment to it is free on almost
3837 any target, because "a" usually ends up in a real register. Hence
3838 the only cost of this expression comes from the PLUS_EXPR, and we
3839 can ignore the GIMPLE_ASSIGN.
3840 If "a" is not a GIMPLE register, the assignment to "a" will most
3841 likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost
3842 of moving something into "a", which we compute using the function
3843 estimate_move_cost. */
3844 if (gimple_clobber_p (stmt
))
3845 return 0; /* ={v} {CLOBBER} stmt expands to nothing. */
3847 lhs
= gimple_assign_lhs (stmt
);
3848 rhs
= gimple_assign_rhs1 (stmt
);
3852 /* Account for the cost of moving to / from memory. */
3853 if (gimple_store_p (stmt
))
3854 cost
+= estimate_move_cost (TREE_TYPE (lhs
), weights
->time_based
);
3855 if (gimple_assign_load_p (stmt
))
3856 cost
+= estimate_move_cost (TREE_TYPE (rhs
), weights
->time_based
);
3858 cost
+= estimate_operator_cost (gimple_assign_rhs_code (stmt
), weights
,
3859 gimple_assign_rhs1 (stmt
),
3860 get_gimple_rhs_class (gimple_assign_rhs_code (stmt
))
3861 == GIMPLE_BINARY_RHS
3862 ? gimple_assign_rhs2 (stmt
) : NULL
);
3866 cost
= 1 + estimate_operator_cost (gimple_cond_code (stmt
), weights
,
3867 gimple_op (stmt
, 0),
3868 gimple_op (stmt
, 1));
3872 /* Take into account cost of the switch + guess 2 conditional jumps for
3875 TODO: once the switch expansion logic is sufficiently separated, we can
3876 do better job on estimating cost of the switch. */
3877 if (weights
->time_based
)
3878 cost
= floor_log2 (gimple_switch_num_labels (stmt
)) * 2;
3880 cost
= gimple_switch_num_labels (stmt
) * 2;
3887 if (gimple_call_internal_p (stmt
))
3889 else if ((decl
= gimple_call_fndecl (stmt
))
3890 && DECL_BUILT_IN (decl
))
3892 /* Do not special case builtins where we see the body.
3893 This just confuse inliner. */
3894 struct cgraph_node
*node
;
3895 if (!(node
= cgraph_node::get (decl
))
3896 || node
->definition
)
3898 /* For buitins that are likely expanded to nothing or
3899 inlined do not account operand costs. */
3900 else if (is_simple_builtin (decl
))
3902 else if (is_inexpensive_builtin (decl
))
3903 return weights
->target_builtin_call_cost
;
3904 else if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
3906 /* We canonicalize x * x to pow (x, 2.0) with -ffast-math, so
3907 specialize the cheap expansion we do here.
3908 ??? This asks for a more general solution. */
3909 switch (DECL_FUNCTION_CODE (decl
))
3914 if (TREE_CODE (gimple_call_arg (stmt
, 1)) == REAL_CST
3915 && REAL_VALUES_EQUAL
3916 (TREE_REAL_CST (gimple_call_arg (stmt
, 1)), dconst2
))
3917 return estimate_operator_cost
3918 (MULT_EXPR
, weights
, gimple_call_arg (stmt
, 0),
3919 gimple_call_arg (stmt
, 0));
3928 cost
= decl
? weights
->call_cost
: weights
->indirect_call_cost
;
3929 if (gimple_call_lhs (stmt
))
3930 cost
+= estimate_move_cost (TREE_TYPE (gimple_call_lhs (stmt
)),
3931 weights
->time_based
);
3932 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
3934 tree arg
= gimple_call_arg (stmt
, i
);
3935 cost
+= estimate_move_cost (TREE_TYPE (arg
),
3936 weights
->time_based
);
3942 return weights
->return_cost
;
3948 case GIMPLE_PREDICT
:
3954 int count
= asm_str_count (gimple_asm_string (stmt
));
3955 /* 1000 means infinity. This avoids overflows later
3956 with very long asm statements. */
3963 /* This is either going to be an external function call with one
3964 argument, or two register copy statements plus a goto. */
3967 case GIMPLE_EH_DISPATCH
:
3968 /* ??? This is going to turn into a switch statement. Ideally
3969 we'd have a look at the eh region and estimate the number of
3974 return estimate_num_insns_seq (gimple_bind_body (stmt
), weights
);
3976 case GIMPLE_EH_FILTER
:
3977 return estimate_num_insns_seq (gimple_eh_filter_failure (stmt
), weights
);
3980 return estimate_num_insns_seq (gimple_catch_handler (stmt
), weights
);
3983 return (estimate_num_insns_seq (gimple_try_eval (stmt
), weights
)
3984 + estimate_num_insns_seq (gimple_try_cleanup (stmt
), weights
));
3986 /* OpenMP directives are generally very expensive. */
3988 case GIMPLE_OMP_RETURN
:
3989 case GIMPLE_OMP_SECTIONS_SWITCH
:
3990 case GIMPLE_OMP_ATOMIC_STORE
:
3991 case GIMPLE_OMP_CONTINUE
:
3992 /* ...except these, which are cheap. */
3995 case GIMPLE_OMP_ATOMIC_LOAD
:
3996 return weights
->omp_cost
;
3998 case GIMPLE_OMP_FOR
:
3999 return (weights
->omp_cost
4000 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
)
4001 + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt
), weights
));
4003 case GIMPLE_OMP_PARALLEL
:
4004 case GIMPLE_OMP_TASK
:
4005 case GIMPLE_OMP_CRITICAL
:
4006 case GIMPLE_OMP_MASTER
:
4007 case GIMPLE_OMP_TASKGROUP
:
4008 case GIMPLE_OMP_ORDERED
:
4009 case GIMPLE_OMP_SECTION
:
4010 case GIMPLE_OMP_SECTIONS
:
4011 case GIMPLE_OMP_SINGLE
:
4012 case GIMPLE_OMP_TARGET
:
4013 case GIMPLE_OMP_TEAMS
:
4014 return (weights
->omp_cost
4015 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
));
4017 case GIMPLE_TRANSACTION
:
4018 return (weights
->tm_cost
4019 + estimate_num_insns_seq (gimple_transaction_body (stmt
),
4029 /* Estimate number of instructions that will be created by expanding
4030 function FNDECL. WEIGHTS contains weights attributed to various
4034 estimate_num_insns_fn (tree fndecl
, eni_weights
*weights
)
4036 struct function
*my_function
= DECL_STRUCT_FUNCTION (fndecl
);
4037 gimple_stmt_iterator bsi
;
4041 gcc_assert (my_function
&& my_function
->cfg
);
4042 FOR_EACH_BB_FN (bb
, my_function
)
4044 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
4045 n
+= estimate_num_insns (gsi_stmt (bsi
), weights
);
4052 /* Initializes weights used by estimate_num_insns. */
4055 init_inline_once (void)
4057 eni_size_weights
.call_cost
= 1;
4058 eni_size_weights
.indirect_call_cost
= 3;
4059 eni_size_weights
.target_builtin_call_cost
= 1;
4060 eni_size_weights
.div_mod_cost
= 1;
4061 eni_size_weights
.omp_cost
= 40;
4062 eni_size_weights
.tm_cost
= 10;
4063 eni_size_weights
.time_based
= false;
4064 eni_size_weights
.return_cost
= 1;
4066 /* Estimating time for call is difficult, since we have no idea what the
4067 called function does. In the current uses of eni_time_weights,
4068 underestimating the cost does less harm than overestimating it, so
4069 we choose a rather small value here. */
4070 eni_time_weights
.call_cost
= 10;
4071 eni_time_weights
.indirect_call_cost
= 15;
4072 eni_time_weights
.target_builtin_call_cost
= 1;
4073 eni_time_weights
.div_mod_cost
= 10;
4074 eni_time_weights
.omp_cost
= 40;
4075 eni_time_weights
.tm_cost
= 40;
4076 eni_time_weights
.time_based
= true;
4077 eni_time_weights
.return_cost
= 2;
4080 /* Estimate the number of instructions in a gimple_seq. */
4083 count_insns_seq (gimple_seq seq
, eni_weights
*weights
)
4085 gimple_stmt_iterator gsi
;
4087 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4088 n
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
4094 /* Install new lexical TREE_BLOCK underneath 'current_block'. */
4097 prepend_lexical_block (tree current_block
, tree new_block
)
4099 BLOCK_CHAIN (new_block
) = BLOCK_SUBBLOCKS (current_block
);
4100 BLOCK_SUBBLOCKS (current_block
) = new_block
;
4101 BLOCK_SUPERCONTEXT (new_block
) = current_block
;
4104 /* Add local variables from CALLEE to CALLER. */
4107 add_local_variables (struct function
*callee
, struct function
*caller
,
4113 FOR_EACH_LOCAL_DECL (callee
, ix
, var
)
4114 if (!can_be_nonlocal (var
, id
))
4116 tree new_var
= remap_decl (var
, id
);
4118 /* Remap debug-expressions. */
4119 if (TREE_CODE (new_var
) == VAR_DECL
4120 && DECL_HAS_DEBUG_EXPR_P (var
)
4123 tree tem
= DECL_DEBUG_EXPR (var
);
4124 bool old_regimplify
= id
->regimplify
;
4125 id
->remapping_type_depth
++;
4126 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
4127 id
->remapping_type_depth
--;
4128 id
->regimplify
= old_regimplify
;
4129 SET_DECL_DEBUG_EXPR (new_var
, tem
);
4130 DECL_HAS_DEBUG_EXPR_P (new_var
) = 1;
4132 add_local_decl (caller
, new_var
);
4136 /* If STMT is a GIMPLE_CALL, replace it with its inline expansion. */
4139 expand_call_inline (basic_block bb
, gimple stmt
, copy_body_data
*id
)
4143 hash_map
<tree
, tree
> *dst
;
4144 hash_map
<tree
, tree
> *st
= NULL
;
4147 location_t saved_location
;
4148 struct cgraph_edge
*cg_edge
;
4149 cgraph_inline_failed_t reason
;
4150 basic_block return_block
;
4152 gimple_stmt_iterator gsi
, stmt_gsi
;
4153 bool successfully_inlined
= FALSE
;
4154 bool purge_dead_abnormal_edges
;
4156 /* Set input_location here so we get the right instantiation context
4157 if we call instantiate_decl from inlinable_function_p. */
4158 /* FIXME: instantiate_decl isn't called by inlinable_function_p. */
4159 saved_location
= input_location
;
4160 input_location
= gimple_location (stmt
);
4162 /* From here on, we're only interested in CALL_EXPRs. */
4163 if (gimple_code (stmt
) != GIMPLE_CALL
)
4166 cg_edge
= id
->dst_node
->get_edge (stmt
);
4167 gcc_checking_assert (cg_edge
);
4168 /* First, see if we can figure out what function is being called.
4169 If we cannot, then there is no hope of inlining the function. */
4170 if (cg_edge
->indirect_unknown_callee
)
4172 fn
= cg_edge
->callee
->decl
;
4173 gcc_checking_assert (fn
);
4175 /* If FN is a declaration of a function in a nested scope that was
4176 globally declared inline, we don't set its DECL_INITIAL.
4177 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
4178 C++ front-end uses it for cdtors to refer to their internal
4179 declarations, that are not real functions. Fortunately those
4180 don't have trees to be saved, so we can tell by checking their
4182 if (!DECL_INITIAL (fn
)
4183 && DECL_ABSTRACT_ORIGIN (fn
)
4184 && gimple_has_body_p (DECL_ABSTRACT_ORIGIN (fn
)))
4185 fn
= DECL_ABSTRACT_ORIGIN (fn
);
4187 /* Don't try to inline functions that are not well-suited to inlining. */
4188 if (cg_edge
->inline_failed
)
4190 reason
= cg_edge
->inline_failed
;
4191 /* If this call was originally indirect, we do not want to emit any
4192 inlining related warnings or sorry messages because there are no
4193 guarantees regarding those. */
4194 if (cg_edge
->indirect_inlining_edge
)
4197 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
))
4198 /* For extern inline functions that get redefined we always
4199 silently ignored always_inline flag. Better behaviour would
4200 be to be able to keep both bodies and use extern inline body
4201 for inlining, but we can't do that because frontends overwrite
4203 && !cg_edge
->callee
->local
.redefined_extern_inline
4204 /* During early inline pass, report only when optimization is
4206 && (symtab
->global_info_ready
4208 || cgraph_inline_failed_type (reason
) == CIF_FINAL_ERROR
)
4209 /* PR 20090218-1_0.c. Body can be provided by another module. */
4210 && (reason
!= CIF_BODY_NOT_AVAILABLE
|| !flag_generate_lto
))
4212 error ("inlining failed in call to always_inline %q+F: %s", fn
,
4213 cgraph_inline_failed_string (reason
));
4214 error ("called from here");
4216 else if (warn_inline
4217 && DECL_DECLARED_INLINE_P (fn
)
4218 && !DECL_NO_INLINE_WARNING_P (fn
)
4219 && !DECL_IN_SYSTEM_HEADER (fn
)
4220 && reason
!= CIF_UNSPECIFIED
4221 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn
))
4222 /* Do not warn about not inlined recursive calls. */
4223 && !cg_edge
->recursive_p ()
4224 /* Avoid warnings during early inline pass. */
4225 && symtab
->global_info_ready
)
4227 warning (OPT_Winline
, "inlining failed in call to %q+F: %s",
4228 fn
, _(cgraph_inline_failed_string (reason
)));
4229 warning (OPT_Winline
, "called from here");
4233 fn
= cg_edge
->callee
->decl
;
4234 cg_edge
->callee
->get_body ();
4236 #ifdef ENABLE_CHECKING
4237 if (cg_edge
->callee
->decl
!= id
->dst_node
->decl
)
4238 cg_edge
->callee
->verify ();
4241 /* We will be inlining this callee. */
4242 id
->eh_lp_nr
= lookup_stmt_eh_lp (stmt
);
4244 /* Update the callers EH personality. */
4245 if (DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->decl
))
4246 DECL_FUNCTION_PERSONALITY (cg_edge
->caller
->decl
)
4247 = DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->decl
);
4249 /* Split the block holding the GIMPLE_CALL. */
4250 e
= split_block (bb
, stmt
);
4252 return_block
= e
->dest
;
4255 /* split_block splits after the statement; work around this by
4256 moving the call into the second block manually. Not pretty,
4257 but seems easier than doing the CFG manipulation by hand
4258 when the GIMPLE_CALL is in the last statement of BB. */
4259 stmt_gsi
= gsi_last_bb (bb
);
4260 gsi_remove (&stmt_gsi
, false);
4262 /* If the GIMPLE_CALL was in the last statement of BB, it may have
4263 been the source of abnormal edges. In this case, schedule
4264 the removal of dead abnormal edges. */
4265 gsi
= gsi_start_bb (return_block
);
4266 if (gsi_end_p (gsi
))
4268 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
4269 purge_dead_abnormal_edges
= true;
4273 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
4274 purge_dead_abnormal_edges
= false;
4277 stmt_gsi
= gsi_start_bb (return_block
);
4279 /* Build a block containing code to initialize the arguments, the
4280 actual inline expansion of the body, and a label for the return
4281 statements within the function to jump to. The type of the
4282 statement expression is the return type of the function call.
4283 ??? If the call does not have an associated block then we will
4284 remap all callee blocks to NULL, effectively dropping most of
4285 its debug information. This should only happen for calls to
4286 artificial decls inserted by the compiler itself. We need to
4287 either link the inlined blocks into the caller block tree or
4288 not refer to them in any way to not break GC for locations. */
4289 if (gimple_block (stmt
))
4291 id
->block
= make_node (BLOCK
);
4292 BLOCK_ABSTRACT_ORIGIN (id
->block
) = fn
;
4293 BLOCK_SOURCE_LOCATION (id
->block
) = LOCATION_LOCUS (input_location
);
4294 prepend_lexical_block (gimple_block (stmt
), id
->block
);
4297 /* Local declarations will be replaced by their equivalents in this
4300 id
->decl_map
= new hash_map
<tree
, tree
>;
4301 dst
= id
->debug_map
;
4302 id
->debug_map
= NULL
;
4304 /* Record the function we are about to inline. */
4306 id
->src_node
= cg_edge
->callee
;
4307 id
->src_cfun
= DECL_STRUCT_FUNCTION (fn
);
4308 id
->gimple_call
= stmt
;
4310 gcc_assert (!id
->src_cfun
->after_inlining
);
4313 if (lookup_attribute ("cold", DECL_ATTRIBUTES (fn
)))
4315 gimple_stmt_iterator si
= gsi_last_bb (bb
);
4316 gsi_insert_after (&si
, gimple_build_predict (PRED_COLD_FUNCTION
,
4320 initialize_inlined_parameters (id
, stmt
, fn
, bb
);
4322 if (DECL_INITIAL (fn
))
4324 if (gimple_block (stmt
))
4328 prepend_lexical_block (id
->block
,
4329 remap_blocks (DECL_INITIAL (fn
), id
));
4330 gcc_checking_assert (BLOCK_SUBBLOCKS (id
->block
)
4331 && (BLOCK_CHAIN (BLOCK_SUBBLOCKS (id
->block
))
4333 /* Move vars for PARM_DECLs from DECL_INITIAL block to id->block,
4334 otherwise for DWARF DW_TAG_formal_parameter will not be children of
4335 DW_TAG_inlined_subroutine, but of a DW_TAG_lexical_block
4336 under it. The parameters can be then evaluated in the debugger,
4337 but don't show in backtraces. */
4338 for (var
= &BLOCK_VARS (BLOCK_SUBBLOCKS (id
->block
)); *var
; )
4339 if (TREE_CODE (DECL_ORIGIN (*var
)) == PARM_DECL
)
4342 *var
= TREE_CHAIN (v
);
4343 TREE_CHAIN (v
) = BLOCK_VARS (id
->block
);
4344 BLOCK_VARS (id
->block
) = v
;
4347 var
= &TREE_CHAIN (*var
);
4350 remap_blocks_to_null (DECL_INITIAL (fn
), id
);
4353 /* Return statements in the function body will be replaced by jumps
4354 to the RET_LABEL. */
4355 gcc_assert (DECL_INITIAL (fn
));
4356 gcc_assert (TREE_CODE (DECL_INITIAL (fn
)) == BLOCK
);
4358 /* Find the LHS to which the result of this call is assigned. */
4360 if (gimple_call_lhs (stmt
))
4362 modify_dest
= gimple_call_lhs (stmt
);
4364 /* The function which we are inlining might not return a value,
4365 in which case we should issue a warning that the function
4366 does not return a value. In that case the optimizers will
4367 see that the variable to which the value is assigned was not
4368 initialized. We do not want to issue a warning about that
4369 uninitialized variable. */
4370 if (DECL_P (modify_dest
))
4371 TREE_NO_WARNING (modify_dest
) = 1;
4373 if (gimple_call_return_slot_opt_p (stmt
))
4375 return_slot
= modify_dest
;
4382 /* If we are inlining a call to the C++ operator new, we don't want
4383 to use type based alias analysis on the return value. Otherwise
4384 we may get confused if the compiler sees that the inlined new
4385 function returns a pointer which was just deleted. See bug
4387 if (DECL_IS_OPERATOR_NEW (fn
))
4393 /* Declare the return variable for the function. */
4394 use_retvar
= declare_return_variable (id
, return_slot
, modify_dest
, bb
);
4396 /* Add local vars in this inlined callee to caller. */
4397 add_local_variables (id
->src_cfun
, cfun
, id
);
4399 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4401 fprintf (dump_file
, "Inlining ");
4402 print_generic_expr (dump_file
, id
->src_fn
, 0);
4403 fprintf (dump_file
, " to ");
4404 print_generic_expr (dump_file
, id
->dst_fn
, 0);
4405 fprintf (dump_file
, " with frequency %i\n", cg_edge
->frequency
);
4408 /* This is it. Duplicate the callee body. Assume callee is
4409 pre-gimplified. Note that we must not alter the caller
4410 function in any way before this point, as this CALL_EXPR may be
4411 a self-referential call; if we're calling ourselves, we need to
4412 duplicate our body before altering anything. */
4413 copy_body (id
, cg_edge
->callee
->count
,
4414 GCOV_COMPUTE_SCALE (cg_edge
->frequency
, CGRAPH_FREQ_BASE
),
4415 bb
, return_block
, NULL
);
4417 /* Reset the escaped solution. */
4418 if (cfun
->gimple_df
)
4419 pt_solution_reset (&cfun
->gimple_df
->escaped
);
4424 delete id
->debug_map
;
4425 id
->debug_map
= dst
;
4427 delete id
->decl_map
;
4430 /* Unlink the calls virtual operands before replacing it. */
4431 unlink_stmt_vdef (stmt
);
4432 if (gimple_vdef (stmt
)
4433 && TREE_CODE (gimple_vdef (stmt
)) == SSA_NAME
)
4434 release_ssa_name (gimple_vdef (stmt
));
4436 /* If the inlined function returns a result that we care about,
4437 substitute the GIMPLE_CALL with an assignment of the return
4438 variable to the LHS of the call. That is, if STMT was
4439 'a = foo (...)', substitute the call with 'a = USE_RETVAR'. */
4440 if (use_retvar
&& gimple_call_lhs (stmt
))
4442 gimple old_stmt
= stmt
;
4443 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), use_retvar
);
4444 gsi_replace (&stmt_gsi
, stmt
, false);
4445 maybe_clean_or_replace_eh_stmt (old_stmt
, stmt
);
4449 /* Handle the case of inlining a function with no return
4450 statement, which causes the return value to become undefined. */
4451 if (gimple_call_lhs (stmt
)
4452 && TREE_CODE (gimple_call_lhs (stmt
)) == SSA_NAME
)
4454 tree name
= gimple_call_lhs (stmt
);
4455 tree var
= SSA_NAME_VAR (name
);
4456 tree def
= ssa_default_def (cfun
, var
);
4460 /* If the variable is used undefined, make this name
4461 undefined via a move. */
4462 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), def
);
4463 gsi_replace (&stmt_gsi
, stmt
, true);
4467 /* Otherwise make this variable undefined. */
4468 gsi_remove (&stmt_gsi
, true);
4469 set_ssa_default_def (cfun
, var
, name
);
4470 SSA_NAME_DEF_STMT (name
) = gimple_build_nop ();
4474 gsi_remove (&stmt_gsi
, true);
4477 if (purge_dead_abnormal_edges
)
4479 gimple_purge_dead_eh_edges (return_block
);
4480 gimple_purge_dead_abnormal_call_edges (return_block
);
4483 /* If the value of the new expression is ignored, that's OK. We
4484 don't warn about this for CALL_EXPRs, so we shouldn't warn about
4485 the equivalent inlined version either. */
4486 if (is_gimple_assign (stmt
))
4488 gcc_assert (gimple_assign_single_p (stmt
)
4489 || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
)));
4490 TREE_USED (gimple_assign_rhs1 (stmt
)) = 1;
4493 /* Output the inlining info for this abstract function, since it has been
4494 inlined. If we don't do this now, we can lose the information about the
4495 variables in the function when the blocks get blown away as soon as we
4496 remove the cgraph node. */
4497 if (gimple_block (stmt
))
4498 (*debug_hooks
->outlining_inline_function
) (cg_edge
->callee
->decl
);
4500 /* Update callgraph if needed. */
4501 cg_edge
->callee
->remove ();
4503 id
->block
= NULL_TREE
;
4504 successfully_inlined
= TRUE
;
4507 input_location
= saved_location
;
4508 return successfully_inlined
;
4511 /* Expand call statements reachable from STMT_P.
4512 We can only have CALL_EXPRs as the "toplevel" tree code or nested
4513 in a MODIFY_EXPR. */
4516 gimple_expand_calls_inline (basic_block bb
, copy_body_data
*id
)
4518 gimple_stmt_iterator gsi
;
4520 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4522 gimple stmt
= gsi_stmt (gsi
);
4524 if (is_gimple_call (stmt
)
4525 && !gimple_call_internal_p (stmt
)
4526 && expand_call_inline (bb
, stmt
, id
))
4534 /* Walk all basic blocks created after FIRST and try to fold every statement
4535 in the STATEMENTS pointer set. */
4538 fold_marked_statements (int first
, hash_set
<gimple
> *statements
)
4540 for (; first
< n_basic_blocks_for_fn (cfun
); first
++)
4541 if (BASIC_BLOCK_FOR_FN (cfun
, first
))
4543 gimple_stmt_iterator gsi
;
4545 for (gsi
= gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, first
));
4548 if (statements
->contains (gsi_stmt (gsi
)))
4550 gimple old_stmt
= gsi_stmt (gsi
);
4551 tree old_decl
= is_gimple_call (old_stmt
) ? gimple_call_fndecl (old_stmt
) : 0;
4553 if (old_decl
&& DECL_BUILT_IN (old_decl
))
4555 /* Folding builtins can create multiple instructions,
4556 we need to look at all of them. */
4557 gimple_stmt_iterator i2
= gsi
;
4559 if (fold_stmt (&gsi
))
4562 /* If a builtin at the end of a bb folded into nothing,
4563 the following loop won't work. */
4564 if (gsi_end_p (gsi
))
4566 cgraph_update_edges_for_call_stmt (old_stmt
,
4571 i2
= gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, first
));
4576 new_stmt
= gsi_stmt (i2
);
4577 update_stmt (new_stmt
);
4578 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4581 if (new_stmt
== gsi_stmt (gsi
))
4583 /* It is okay to check only for the very last
4584 of these statements. If it is a throwing
4585 statement nothing will change. If it isn't
4586 this can remove EH edges. If that weren't
4587 correct then because some intermediate stmts
4588 throw, but not the last one. That would mean
4589 we'd have to split the block, which we can't
4590 here and we'd loose anyway. And as builtins
4591 probably never throw, this all
4593 if (maybe_clean_or_replace_eh_stmt (old_stmt
,
4595 gimple_purge_dead_eh_edges (
4596 BASIC_BLOCK_FOR_FN (cfun
, first
));
4603 else if (fold_stmt (&gsi
))
4605 /* Re-read the statement from GSI as fold_stmt() may
4607 gimple new_stmt
= gsi_stmt (gsi
);
4608 update_stmt (new_stmt
);
4610 if (is_gimple_call (old_stmt
)
4611 || is_gimple_call (new_stmt
))
4612 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4615 if (maybe_clean_or_replace_eh_stmt (old_stmt
, new_stmt
))
4616 gimple_purge_dead_eh_edges (BASIC_BLOCK_FOR_FN (cfun
,
4623 /* Expand calls to inline functions in the body of FN. */
4626 optimize_inline_calls (tree fn
)
4630 int last
= n_basic_blocks_for_fn (cfun
);
4631 bool inlined_p
= false;
4634 memset (&id
, 0, sizeof (id
));
4636 id
.src_node
= id
.dst_node
= cgraph_node::get (fn
);
4637 gcc_assert (id
.dst_node
->definition
);
4639 /* Or any functions that aren't finished yet. */
4640 if (current_function_decl
)
4641 id
.dst_fn
= current_function_decl
;
4643 id
.copy_decl
= copy_decl_maybe_to_var
;
4644 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
4645 id
.transform_new_cfg
= false;
4646 id
.transform_return_to_modify
= true;
4647 id
.transform_parameter
= true;
4648 id
.transform_lang_insert_block
= NULL
;
4649 id
.statements_to_fold
= new hash_set
<gimple
>;
4651 push_gimplify_context ();
4653 /* We make no attempts to keep dominance info up-to-date. */
4654 free_dominance_info (CDI_DOMINATORS
);
4655 free_dominance_info (CDI_POST_DOMINATORS
);
4657 /* Register specific gimple functions. */
4658 gimple_register_cfg_hooks ();
4660 /* Reach the trees by walking over the CFG, and note the
4661 enclosing basic-blocks in the call edges. */
4662 /* We walk the blocks going forward, because inlined function bodies
4663 will split id->current_basic_block, and the new blocks will
4664 follow it; we'll trudge through them, processing their CALL_EXPRs
4666 FOR_EACH_BB_FN (bb
, cfun
)
4667 inlined_p
|= gimple_expand_calls_inline (bb
, &id
);
4669 pop_gimplify_context (NULL
);
4671 #ifdef ENABLE_CHECKING
4673 struct cgraph_edge
*e
;
4675 id
.dst_node
->verify ();
4677 /* Double check that we inlined everything we are supposed to inline. */
4678 for (e
= id
.dst_node
->callees
; e
; e
= e
->next_callee
)
4679 gcc_assert (e
->inline_failed
);
4683 /* Fold queued statements. */
4684 fold_marked_statements (last
, id
.statements_to_fold
);
4685 delete id
.statements_to_fold
;
4687 gcc_assert (!id
.debug_stmts
.exists ());
4689 /* If we didn't inline into the function there is nothing to do. */
4693 /* Renumber the lexical scoping (non-code) blocks consecutively. */
4696 delete_unreachable_blocks_update_callgraph (&id
);
4697 #ifdef ENABLE_CHECKING
4698 id
.dst_node
->verify ();
4701 /* It would be nice to check SSA/CFG/statement consistency here, but it is
4702 not possible yet - the IPA passes might make various functions to not
4703 throw and they don't care to proactively update local EH info. This is
4704 done later in fixup_cfg pass that also execute the verification. */
4705 return (TODO_update_ssa
4707 | (gimple_in_ssa_p (cfun
) ? TODO_remove_unused_locals
: 0)
4708 | (gimple_in_ssa_p (cfun
) ? TODO_update_address_taken
: 0)
4709 | (profile_status_for_fn (cfun
) != PROFILE_ABSENT
4710 ? TODO_rebuild_frequencies
: 0));
4713 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
4716 copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
4718 enum tree_code code
= TREE_CODE (*tp
);
4719 enum tree_code_class cl
= TREE_CODE_CLASS (code
);
4721 /* We make copies of most nodes. */
4722 if (IS_EXPR_CODE_CLASS (cl
)
4723 || code
== TREE_LIST
4725 || code
== TYPE_DECL
4726 || code
== OMP_CLAUSE
)
4728 /* Because the chain gets clobbered when we make a copy, we save it
4730 tree chain
= NULL_TREE
, new_tree
;
4732 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
4733 chain
= TREE_CHAIN (*tp
);
4735 /* Copy the node. */
4736 new_tree
= copy_node (*tp
);
4740 /* Now, restore the chain, if appropriate. That will cause
4741 walk_tree to walk into the chain as well. */
4742 if (code
== PARM_DECL
4743 || code
== TREE_LIST
4744 || code
== OMP_CLAUSE
)
4745 TREE_CHAIN (*tp
) = chain
;
4747 /* For now, we don't update BLOCKs when we make copies. So, we
4748 have to nullify all BIND_EXPRs. */
4749 if (TREE_CODE (*tp
) == BIND_EXPR
)
4750 BIND_EXPR_BLOCK (*tp
) = NULL_TREE
;
4752 else if (code
== CONSTRUCTOR
)
4754 /* CONSTRUCTOR nodes need special handling because
4755 we need to duplicate the vector of elements. */
4758 new_tree
= copy_node (*tp
);
4759 CONSTRUCTOR_ELTS (new_tree
) = vec_safe_copy (CONSTRUCTOR_ELTS (*tp
));
4762 else if (code
== STATEMENT_LIST
)
4763 /* We used to just abort on STATEMENT_LIST, but we can run into them
4764 with statement-expressions (c++/40975). */
4765 copy_statement_list (tp
);
4766 else if (TREE_CODE_CLASS (code
) == tcc_type
)
4768 else if (TREE_CODE_CLASS (code
) == tcc_declaration
)
4770 else if (TREE_CODE_CLASS (code
) == tcc_constant
)
4775 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
4776 information indicating to what new SAVE_EXPR this one should be mapped,
4777 use that one. Otherwise, create a new node and enter it in ST. FN is
4778 the function into which the copy will be placed. */
4781 remap_save_expr (tree
*tp
, hash_map
<tree
, tree
> *st
, int *walk_subtrees
)
4786 /* See if we already encountered this SAVE_EXPR. */
4789 /* If we didn't already remap this SAVE_EXPR, do so now. */
4792 t
= copy_node (*tp
);
4794 /* Remember this SAVE_EXPR. */
4796 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
4801 /* We've already walked into this SAVE_EXPR; don't do it again. */
4806 /* Replace this SAVE_EXPR with the copy. */
4810 /* Called via walk_gimple_seq. If *GSIP points to a GIMPLE_LABEL for a local
4811 label, copies the declaration and enters it in the splay_tree in DATA (which
4812 is really a 'copy_body_data *'. */
4815 mark_local_labels_stmt (gimple_stmt_iterator
*gsip
,
4816 bool *handled_ops_p ATTRIBUTE_UNUSED
,
4817 struct walk_stmt_info
*wi
)
4819 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4820 gimple stmt
= gsi_stmt (*gsip
);
4822 if (gimple_code (stmt
) == GIMPLE_LABEL
)
4824 tree decl
= gimple_label_label (stmt
);
4826 /* Copy the decl and remember the copy. */
4827 insert_decl_map (id
, decl
, id
->copy_decl (decl
, id
));
4834 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
4835 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
4836 remaps all local declarations to appropriate replacements in gimple
4840 replace_locals_op (tree
*tp
, int *walk_subtrees
, void *data
)
4842 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
4843 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4844 hash_map
<tree
, tree
> *st
= id
->decl_map
;
4848 /* Only a local declaration (variable or label). */
4849 if ((TREE_CODE (expr
) == VAR_DECL
4850 && !TREE_STATIC (expr
))
4851 || TREE_CODE (expr
) == LABEL_DECL
)
4853 /* Lookup the declaration. */
4856 /* If it's there, remap it. */
4861 else if (TREE_CODE (expr
) == STATEMENT_LIST
4862 || TREE_CODE (expr
) == BIND_EXPR
4863 || TREE_CODE (expr
) == SAVE_EXPR
)
4865 else if (TREE_CODE (expr
) == TARGET_EXPR
)
4867 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
4868 It's OK for this to happen if it was part of a subtree that
4869 isn't immediately expanded, such as operand 2 of another
4871 if (!TREE_OPERAND (expr
, 1))
4873 TREE_OPERAND (expr
, 1) = TREE_OPERAND (expr
, 3);
4874 TREE_OPERAND (expr
, 3) = NULL_TREE
;
4878 /* Keep iterating. */
4883 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
4884 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
4885 remaps all local declarations to appropriate replacements in gimple
4889 replace_locals_stmt (gimple_stmt_iterator
*gsip
,
4890 bool *handled_ops_p ATTRIBUTE_UNUSED
,
4891 struct walk_stmt_info
*wi
)
4893 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4894 gimple stmt
= gsi_stmt (*gsip
);
4896 if (gimple_code (stmt
) == GIMPLE_BIND
)
4898 tree block
= gimple_bind_block (stmt
);
4902 remap_block (&block
, id
);
4903 gimple_bind_set_block (stmt
, block
);
4906 /* This will remap a lot of the same decls again, but this should be
4908 if (gimple_bind_vars (stmt
))
4909 gimple_bind_set_vars (stmt
, remap_decls (gimple_bind_vars (stmt
),
4913 /* Keep iterating. */
4918 /* Copies everything in SEQ and replaces variables and labels local to
4919 current_function_decl. */
4922 copy_gimple_seq_and_replace_locals (gimple_seq seq
)
4925 struct walk_stmt_info wi
;
4928 /* There's nothing to do for NULL_TREE. */
4933 memset (&id
, 0, sizeof (id
));
4934 id
.src_fn
= current_function_decl
;
4935 id
.dst_fn
= current_function_decl
;
4936 id
.decl_map
= new hash_map
<tree
, tree
>;
4937 id
.debug_map
= NULL
;
4939 id
.copy_decl
= copy_decl_no_change
;
4940 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
4941 id
.transform_new_cfg
= false;
4942 id
.transform_return_to_modify
= false;
4943 id
.transform_parameter
= false;
4944 id
.transform_lang_insert_block
= NULL
;
4946 /* Walk the tree once to find local labels. */
4947 memset (&wi
, 0, sizeof (wi
));
4948 hash_set
<tree
> visited
;
4951 walk_gimple_seq (seq
, mark_local_labels_stmt
, NULL
, &wi
);
4953 copy
= gimple_seq_copy (seq
);
4955 /* Walk the copy, remapping decls. */
4956 memset (&wi
, 0, sizeof (wi
));
4958 walk_gimple_seq (copy
, replace_locals_stmt
, replace_locals_op
, &wi
);
4963 delete id
.debug_map
;
4969 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
4972 debug_find_tree_1 (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
, void *data
)
4981 debug_find_tree (tree top
, tree search
)
4983 return walk_tree_without_duplicates (&top
, debug_find_tree_1
, search
) != 0;
4987 /* Declare the variables created by the inliner. Add all the variables in
4988 VARS to BIND_EXPR. */
4991 declare_inline_vars (tree block
, tree vars
)
4994 for (t
= vars
; t
; t
= DECL_CHAIN (t
))
4996 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
4997 gcc_assert (!TREE_STATIC (t
) && !TREE_ASM_WRITTEN (t
));
4998 add_local_decl (cfun
, t
);
5002 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), vars
);
5005 /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN,
5006 but now it will be in the TO_FN. PARM_TO_VAR means enable PARM_DECL to
5007 VAR_DECL translation. */
5010 copy_decl_for_dup_finish (copy_body_data
*id
, tree decl
, tree copy
)
5012 /* Don't generate debug information for the copy if we wouldn't have
5013 generated it for the copy either. */
5014 DECL_ARTIFICIAL (copy
) = DECL_ARTIFICIAL (decl
);
5015 DECL_IGNORED_P (copy
) = DECL_IGNORED_P (decl
);
5017 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
5018 declaration inspired this copy. */
5019 DECL_ABSTRACT_ORIGIN (copy
) = DECL_ORIGIN (decl
);
5021 /* The new variable/label has no RTL, yet. */
5022 if (CODE_CONTAINS_STRUCT (TREE_CODE (copy
), TS_DECL_WRTL
)
5023 && !TREE_STATIC (copy
) && !DECL_EXTERNAL (copy
))
5024 SET_DECL_RTL (copy
, 0);
5026 /* These args would always appear unused, if not for this. */
5027 TREE_USED (copy
) = 1;
5029 /* Set the context for the new declaration. */
5030 if (!DECL_CONTEXT (decl
))
5031 /* Globals stay global. */
5033 else if (DECL_CONTEXT (decl
) != id
->src_fn
)
5034 /* Things that weren't in the scope of the function we're inlining
5035 from aren't in the scope we're inlining to, either. */
5037 else if (TREE_STATIC (decl
))
5038 /* Function-scoped static variables should stay in the original
5042 /* Ordinary automatic local variables are now in the scope of the
5044 DECL_CONTEXT (copy
) = id
->dst_fn
;
5050 copy_decl_to_var (tree decl
, copy_body_data
*id
)
5054 gcc_assert (TREE_CODE (decl
) == PARM_DECL
5055 || TREE_CODE (decl
) == RESULT_DECL
);
5057 type
= TREE_TYPE (decl
);
5059 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
5060 VAR_DECL
, DECL_NAME (decl
), type
);
5061 if (DECL_PT_UID_SET_P (decl
))
5062 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
5063 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
5064 TREE_READONLY (copy
) = TREE_READONLY (decl
);
5065 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
5066 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
5068 return copy_decl_for_dup_finish (id
, decl
, copy
);
5071 /* Like copy_decl_to_var, but create a return slot object instead of a
5072 pointer variable for return by invisible reference. */
5075 copy_result_decl_to_var (tree decl
, copy_body_data
*id
)
5079 gcc_assert (TREE_CODE (decl
) == PARM_DECL
5080 || TREE_CODE (decl
) == RESULT_DECL
);
5082 type
= TREE_TYPE (decl
);
5083 if (DECL_BY_REFERENCE (decl
))
5084 type
= TREE_TYPE (type
);
5086 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
5087 VAR_DECL
, DECL_NAME (decl
), type
);
5088 if (DECL_PT_UID_SET_P (decl
))
5089 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
5090 TREE_READONLY (copy
) = TREE_READONLY (decl
);
5091 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
5092 if (!DECL_BY_REFERENCE (decl
))
5094 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
5095 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
5098 return copy_decl_for_dup_finish (id
, decl
, copy
);
5102 copy_decl_no_change (tree decl
, copy_body_data
*id
)
5106 copy
= copy_node (decl
);
5108 /* The COPY is not abstract; it will be generated in DST_FN. */
5109 DECL_ABSTRACT_P (copy
) = false;
5110 lang_hooks
.dup_lang_specific_decl (copy
);
5112 /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
5113 been taken; it's for internal bookkeeping in expand_goto_internal. */
5114 if (TREE_CODE (copy
) == LABEL_DECL
)
5116 TREE_ADDRESSABLE (copy
) = 0;
5117 LABEL_DECL_UID (copy
) = -1;
5120 return copy_decl_for_dup_finish (id
, decl
, copy
);
5124 copy_decl_maybe_to_var (tree decl
, copy_body_data
*id
)
5126 if (TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
)
5127 return copy_decl_to_var (decl
, id
);
5129 return copy_decl_no_change (decl
, id
);
5132 /* Return a copy of the function's argument tree. */
5134 copy_arguments_for_versioning (tree orig_parm
, copy_body_data
* id
,
5135 bitmap args_to_skip
, tree
*vars
)
5138 tree new_parm
= NULL
;
5143 for (arg
= orig_parm
; arg
; arg
= DECL_CHAIN (arg
), i
++)
5144 if (!args_to_skip
|| !bitmap_bit_p (args_to_skip
, i
))
5146 tree new_tree
= remap_decl (arg
, id
);
5147 if (TREE_CODE (new_tree
) != PARM_DECL
)
5148 new_tree
= id
->copy_decl (arg
, id
);
5149 lang_hooks
.dup_lang_specific_decl (new_tree
);
5151 parg
= &DECL_CHAIN (new_tree
);
5153 else if (!id
->decl_map
->get (arg
))
5155 /* Make an equivalent VAR_DECL. If the argument was used
5156 as temporary variable later in function, the uses will be
5157 replaced by local variable. */
5158 tree var
= copy_decl_to_var (arg
, id
);
5159 insert_decl_map (id
, arg
, var
);
5160 /* Declare this new variable. */
5161 DECL_CHAIN (var
) = *vars
;
5167 /* Return a copy of the function's static chain. */
5169 copy_static_chain (tree static_chain
, copy_body_data
* id
)
5171 tree
*chain_copy
, *pvar
;
5173 chain_copy
= &static_chain
;
5174 for (pvar
= chain_copy
; *pvar
; pvar
= &DECL_CHAIN (*pvar
))
5176 tree new_tree
= remap_decl (*pvar
, id
);
5177 lang_hooks
.dup_lang_specific_decl (new_tree
);
5178 DECL_CHAIN (new_tree
) = DECL_CHAIN (*pvar
);
5181 return static_chain
;
5184 /* Return true if the function is allowed to be versioned.
5185 This is a guard for the versioning functionality. */
5188 tree_versionable_function_p (tree fndecl
)
5190 return (!lookup_attribute ("noclone", DECL_ATTRIBUTES (fndecl
))
5191 && copy_forbidden (DECL_STRUCT_FUNCTION (fndecl
), fndecl
) == NULL
);
5194 /* Delete all unreachable basic blocks and update callgraph.
5195 Doing so is somewhat nontrivial because we need to update all clones and
5196 remove inline function that become unreachable. */
5199 delete_unreachable_blocks_update_callgraph (copy_body_data
*id
)
5201 bool changed
= false;
5202 basic_block b
, next_bb
;
5204 find_unreachable_blocks ();
5206 /* Delete all unreachable basic blocks. */
5208 for (b
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
; b
5209 != EXIT_BLOCK_PTR_FOR_FN (cfun
); b
= next_bb
)
5211 next_bb
= b
->next_bb
;
5213 if (!(b
->flags
& BB_REACHABLE
))
5215 gimple_stmt_iterator bsi
;
5217 for (bsi
= gsi_start_bb (b
); !gsi_end_p (bsi
); gsi_next (&bsi
))
5219 struct cgraph_edge
*e
;
5220 struct cgraph_node
*node
;
5222 id
->dst_node
->remove_stmt_references (gsi_stmt (bsi
));
5224 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
5225 &&(e
= id
->dst_node
->get_edge (gsi_stmt (bsi
))) != NULL
)
5227 if (!e
->inline_failed
)
5228 e
->callee
->remove_symbol_and_inline_clones (id
->dst_node
);
5232 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
5233 && id
->dst_node
->clones
)
5234 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
5236 node
->remove_stmt_references (gsi_stmt (bsi
));
5237 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
5238 && (e
= node
->get_edge (gsi_stmt (bsi
))) != NULL
)
5240 if (!e
->inline_failed
)
5241 e
->callee
->remove_symbol_and_inline_clones (id
->dst_node
);
5247 node
= node
->clones
;
5248 else if (node
->next_sibling_clone
)
5249 node
= node
->next_sibling_clone
;
5252 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5253 node
= node
->clone_of
;
5254 if (node
!= id
->dst_node
)
5255 node
= node
->next_sibling_clone
;
5259 delete_basic_block (b
);
5267 /* Update clone info after duplication. */
5270 update_clone_info (copy_body_data
* id
)
5272 struct cgraph_node
*node
;
5273 if (!id
->dst_node
->clones
)
5275 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
5277 /* First update replace maps to match the new body. */
5278 if (node
->clone
.tree_map
)
5281 for (i
= 0; i
< vec_safe_length (node
->clone
.tree_map
); i
++)
5283 struct ipa_replace_map
*replace_info
;
5284 replace_info
= (*node
->clone
.tree_map
)[i
];
5285 walk_tree (&replace_info
->old_tree
, copy_tree_body_r
, id
, NULL
);
5286 walk_tree (&replace_info
->new_tree
, copy_tree_body_r
, id
, NULL
);
5290 node
= node
->clones
;
5291 else if (node
->next_sibling_clone
)
5292 node
= node
->next_sibling_clone
;
5295 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5296 node
= node
->clone_of
;
5297 if (node
!= id
->dst_node
)
5298 node
= node
->next_sibling_clone
;
5303 /* Create a copy of a function's tree.
5304 OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
5305 of the original function and the new copied function
5306 respectively. In case we want to replace a DECL
5307 tree with another tree while duplicating the function's
5308 body, TREE_MAP represents the mapping between these
5309 trees. If UPDATE_CLONES is set, the call_stmt fields
5310 of edges of clones of the function will be updated.
5312 If non-NULL ARGS_TO_SKIP determine function parameters to remove
5314 If SKIP_RETURN is true, the new version will return void.
5315 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
5316 If non_NULL NEW_ENTRY determine new entry BB of the clone.
5319 tree_function_versioning (tree old_decl
, tree new_decl
,
5320 vec
<ipa_replace_map
*, va_gc
> *tree_map
,
5321 bool update_clones
, bitmap args_to_skip
,
5322 bool skip_return
, bitmap blocks_to_copy
,
5323 basic_block new_entry
)
5325 struct cgraph_node
*old_version_node
;
5326 struct cgraph_node
*new_version_node
;
5330 struct ipa_replace_map
*replace_info
;
5331 basic_block old_entry_block
, bb
;
5332 auto_vec
<gimple
, 10> init_stmts
;
5333 tree vars
= NULL_TREE
;
5335 gcc_assert (TREE_CODE (old_decl
) == FUNCTION_DECL
5336 && TREE_CODE (new_decl
) == FUNCTION_DECL
);
5337 DECL_POSSIBLY_INLINED (old_decl
) = 1;
5339 old_version_node
= cgraph_node::get (old_decl
);
5340 gcc_checking_assert (old_version_node
);
5341 new_version_node
= cgraph_node::get (new_decl
);
5342 gcc_checking_assert (new_version_node
);
5344 /* Copy over debug args. */
5345 if (DECL_HAS_DEBUG_ARGS_P (old_decl
))
5347 vec
<tree
, va_gc
> **new_debug_args
, **old_debug_args
;
5348 gcc_checking_assert (decl_debug_args_lookup (new_decl
) == NULL
);
5349 DECL_HAS_DEBUG_ARGS_P (new_decl
) = 0;
5350 old_debug_args
= decl_debug_args_lookup (old_decl
);
5353 new_debug_args
= decl_debug_args_insert (new_decl
);
5354 *new_debug_args
= vec_safe_copy (*old_debug_args
);
5358 /* Output the inlining info for this abstract function, since it has been
5359 inlined. If we don't do this now, we can lose the information about the
5360 variables in the function when the blocks get blown away as soon as we
5361 remove the cgraph node. */
5362 (*debug_hooks
->outlining_inline_function
) (old_decl
);
5364 DECL_ARTIFICIAL (new_decl
) = 1;
5365 DECL_ABSTRACT_ORIGIN (new_decl
) = DECL_ORIGIN (old_decl
);
5366 if (DECL_ORIGIN (old_decl
) == old_decl
)
5367 old_version_node
->used_as_abstract_origin
= true;
5368 DECL_FUNCTION_PERSONALITY (new_decl
) = DECL_FUNCTION_PERSONALITY (old_decl
);
5370 /* Prepare the data structures for the tree copy. */
5371 memset (&id
, 0, sizeof (id
));
5373 /* Generate a new name for the new version. */
5374 id
.statements_to_fold
= new hash_set
<gimple
>;
5376 id
.decl_map
= new hash_map
<tree
, tree
>;
5377 id
.debug_map
= NULL
;
5378 id
.src_fn
= old_decl
;
5379 id
.dst_fn
= new_decl
;
5380 id
.src_node
= old_version_node
;
5381 id
.dst_node
= new_version_node
;
5382 id
.src_cfun
= DECL_STRUCT_FUNCTION (old_decl
);
5383 id
.blocks_to_copy
= blocks_to_copy
;
5385 id
.copy_decl
= copy_decl_no_change
;
5386 id
.transform_call_graph_edges
5387 = update_clones
? CB_CGE_MOVE_CLONES
: CB_CGE_MOVE
;
5388 id
.transform_new_cfg
= true;
5389 id
.transform_return_to_modify
= false;
5390 id
.transform_parameter
= false;
5391 id
.transform_lang_insert_block
= NULL
;
5393 old_entry_block
= ENTRY_BLOCK_PTR_FOR_FN
5394 (DECL_STRUCT_FUNCTION (old_decl
));
5395 DECL_RESULT (new_decl
) = DECL_RESULT (old_decl
);
5396 DECL_ARGUMENTS (new_decl
) = DECL_ARGUMENTS (old_decl
);
5397 initialize_cfun (new_decl
, old_decl
,
5398 old_entry_block
->count
);
5399 if (DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
)
5400 DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
->ipa_pta
5401 = id
.src_cfun
->gimple_df
->ipa_pta
;
5403 /* Copy the function's static chain. */
5404 p
= DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
;
5406 DECL_STRUCT_FUNCTION (new_decl
)->static_chain_decl
=
5407 copy_static_chain (DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
,
5410 /* If there's a tree_map, prepare for substitution. */
5412 for (i
= 0; i
< tree_map
->length (); i
++)
5415 replace_info
= (*tree_map
)[i
];
5416 if (replace_info
->replace_p
)
5418 if (!replace_info
->old_tree
)
5420 int i
= replace_info
->parm_num
;
5424 for (parm
= DECL_ARGUMENTS (old_decl
); i
; parm
= DECL_CHAIN (parm
))
5426 replace_info
->old_tree
= parm
;
5427 req_type
= TREE_TYPE (parm
);
5428 if (!useless_type_conversion_p (req_type
, TREE_TYPE (replace_info
->new_tree
)))
5430 if (fold_convertible_p (req_type
, replace_info
->new_tree
))
5431 replace_info
->new_tree
= fold_build1 (NOP_EXPR
, req_type
, replace_info
->new_tree
);
5432 else if (TYPE_SIZE (req_type
) == TYPE_SIZE (TREE_TYPE (replace_info
->new_tree
)))
5433 replace_info
->new_tree
= fold_build1 (VIEW_CONVERT_EXPR
, req_type
, replace_info
->new_tree
);
5438 fprintf (dump_file
, " const ");
5439 print_generic_expr (dump_file
, replace_info
->new_tree
, 0);
5440 fprintf (dump_file
, " can't be converted to param ");
5441 print_generic_expr (dump_file
, parm
, 0);
5442 fprintf (dump_file
, "\n");
5444 replace_info
->old_tree
= NULL
;
5449 gcc_assert (TREE_CODE (replace_info
->old_tree
) == PARM_DECL
);
5450 if (replace_info
->old_tree
)
5452 init
= setup_one_parameter (&id
, replace_info
->old_tree
,
5453 replace_info
->new_tree
, id
.src_fn
,
5457 init_stmts
.safe_push (init
);
5461 /* Copy the function's arguments. */
5462 if (DECL_ARGUMENTS (old_decl
) != NULL_TREE
)
5463 DECL_ARGUMENTS (new_decl
) =
5464 copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl
), &id
,
5465 args_to_skip
, &vars
);
5467 DECL_INITIAL (new_decl
) = remap_blocks (DECL_INITIAL (id
.src_fn
), &id
);
5468 BLOCK_SUPERCONTEXT (DECL_INITIAL (new_decl
)) = new_decl
;
5470 declare_inline_vars (DECL_INITIAL (new_decl
), vars
);
5472 if (!vec_safe_is_empty (DECL_STRUCT_FUNCTION (old_decl
)->local_decls
))
5473 /* Add local vars. */
5474 add_local_variables (DECL_STRUCT_FUNCTION (old_decl
), cfun
, &id
);
5476 if (DECL_RESULT (old_decl
) == NULL_TREE
)
5478 else if (skip_return
&& !VOID_TYPE_P (TREE_TYPE (DECL_RESULT (old_decl
))))
5480 DECL_RESULT (new_decl
)
5481 = build_decl (DECL_SOURCE_LOCATION (DECL_RESULT (old_decl
)),
5482 RESULT_DECL
, NULL_TREE
, void_type_node
);
5483 DECL_CONTEXT (DECL_RESULT (new_decl
)) = new_decl
;
5484 cfun
->returns_struct
= 0;
5485 cfun
->returns_pcc_struct
= 0;
5490 DECL_RESULT (new_decl
) = remap_decl (DECL_RESULT (old_decl
), &id
);
5491 lang_hooks
.dup_lang_specific_decl (DECL_RESULT (new_decl
));
5492 if (gimple_in_ssa_p (id
.src_cfun
)
5493 && DECL_BY_REFERENCE (DECL_RESULT (old_decl
))
5494 && (old_name
= ssa_default_def (id
.src_cfun
, DECL_RESULT (old_decl
))))
5496 tree new_name
= make_ssa_name (DECL_RESULT (new_decl
), NULL
);
5497 insert_decl_map (&id
, old_name
, new_name
);
5498 SSA_NAME_DEF_STMT (new_name
) = gimple_build_nop ();
5499 set_ssa_default_def (cfun
, DECL_RESULT (new_decl
), new_name
);
5503 /* Set up the destination functions loop tree. */
5504 if (loops_for_fn (DECL_STRUCT_FUNCTION (old_decl
)) != NULL
)
5506 cfun
->curr_properties
&= ~PROP_loops
;
5507 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
5508 cfun
->curr_properties
|= PROP_loops
;
5511 /* Copy the Function's body. */
5512 copy_body (&id
, old_entry_block
->count
, REG_BR_PROB_BASE
,
5513 ENTRY_BLOCK_PTR_FOR_FN (cfun
), EXIT_BLOCK_PTR_FOR_FN (cfun
),
5516 /* Renumber the lexical scoping (non-code) blocks consecutively. */
5517 number_blocks (new_decl
);
5519 /* We want to create the BB unconditionally, so that the addition of
5520 debug stmts doesn't affect BB count, which may in the end cause
5521 codegen differences. */
5522 bb
= split_edge (single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
5523 while (init_stmts
.length ())
5524 insert_init_stmt (&id
, bb
, init_stmts
.pop ());
5525 update_clone_info (&id
);
5527 /* Remap the nonlocal_goto_save_area, if any. */
5528 if (cfun
->nonlocal_goto_save_area
)
5530 struct walk_stmt_info wi
;
5532 memset (&wi
, 0, sizeof (wi
));
5534 walk_tree (&cfun
->nonlocal_goto_save_area
, remap_gimple_op_r
, &wi
, NULL
);
5540 delete id
.debug_map
;
5541 free_dominance_info (CDI_DOMINATORS
);
5542 free_dominance_info (CDI_POST_DOMINATORS
);
5544 fold_marked_statements (0, id
.statements_to_fold
);
5545 delete id
.statements_to_fold
;
5546 fold_cond_expr_cond ();
5547 delete_unreachable_blocks_update_callgraph (&id
);
5548 if (id
.dst_node
->definition
)
5549 cgraph_edge::rebuild_references ();
5550 if (loops_state_satisfies_p (LOOPS_NEED_FIXUP
))
5552 calculate_dominance_info (CDI_DOMINATORS
);
5553 fix_loop_structure (NULL
);
5555 update_ssa (TODO_update_ssa
);
5557 /* After partial cloning we need to rescale frequencies, so they are
5558 within proper range in the cloned function. */
5561 struct cgraph_edge
*e
;
5562 rebuild_frequencies ();
5564 new_version_node
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5565 for (e
= new_version_node
->callees
; e
; e
= e
->next_callee
)
5567 basic_block bb
= gimple_bb (e
->call_stmt
);
5568 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
5570 e
->count
= bb
->count
;
5572 for (e
= new_version_node
->indirect_calls
; e
; e
= e
->next_callee
)
5574 basic_block bb
= gimple_bb (e
->call_stmt
);
5575 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
5577 e
->count
= bb
->count
;
5581 free_dominance_info (CDI_DOMINATORS
);
5582 free_dominance_info (CDI_POST_DOMINATORS
);
5584 gcc_assert (!id
.debug_stmts
.exists ());
5589 /* EXP is CALL_EXPR present in a GENERIC expression tree. Try to integrate
5590 the callee and return the inlined body on success. */
5593 maybe_inline_call_in_expr (tree exp
)
5595 tree fn
= get_callee_fndecl (exp
);
5597 /* We can only try to inline "const" functions. */
5598 if (fn
&& TREE_READONLY (fn
) && DECL_SAVED_TREE (fn
))
5600 call_expr_arg_iterator iter
;
5603 hash_map
<tree
, tree
> decl_map
;
5605 /* Remap the parameters. */
5606 for (param
= DECL_ARGUMENTS (fn
), arg
= first_call_expr_arg (exp
, &iter
);
5608 param
= DECL_CHAIN (param
), arg
= next_call_expr_arg (&iter
))
5609 decl_map
.put (param
, arg
);
5611 memset (&id
, 0, sizeof (id
));
5613 id
.dst_fn
= current_function_decl
;
5614 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
5615 id
.decl_map
= &decl_map
;
5617 id
.copy_decl
= copy_decl_no_change
;
5618 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5619 id
.transform_new_cfg
= false;
5620 id
.transform_return_to_modify
= true;
5621 id
.transform_parameter
= true;
5622 id
.transform_lang_insert_block
= NULL
;
5624 /* Make sure not to unshare trees behind the front-end's back
5625 since front-end specific mechanisms may rely on sharing. */
5626 id
.regimplify
= false;
5627 id
.do_not_unshare
= true;
5629 /* We're not inside any EH region. */
5632 t
= copy_tree_body (&id
);
5634 /* We can only return something suitable for use in a GENERIC
5636 if (TREE_CODE (t
) == MODIFY_EXPR
)
5637 return TREE_OPERAND (t
, 1);
5643 /* Duplicate a type, fields and all. */
5646 build_duplicate_type (tree type
)
5648 struct copy_body_data id
;
5650 memset (&id
, 0, sizeof (id
));
5651 id
.src_fn
= current_function_decl
;
5652 id
.dst_fn
= current_function_decl
;
5654 id
.decl_map
= new hash_map
<tree
, tree
>;
5655 id
.debug_map
= NULL
;
5656 id
.copy_decl
= copy_decl_no_change
;
5658 type
= remap_type_1 (type
, &id
);
5662 delete id
.debug_map
;
5664 TYPE_CANONICAL (type
) = type
;