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"
36 #include "basic-block.h"
37 #include "tree-iterator.h"
39 #include "tree-ssa-alias.h"
40 #include "internal-fn.h"
41 #include "gimple-fold.h"
43 #include "gimple-expr.h"
47 #include "gimple-iterator.h"
48 #include "gimplify-me.h"
49 #include "gimple-walk.h"
50 #include "gimple-ssa.h"
52 #include "tree-phinodes.h"
53 #include "ssa-iterators.h"
54 #include "stringpool.h"
55 #include "tree-ssanames.h"
56 #include "tree-into-ssa.h"
61 #include "tree-pretty-print.h"
65 #include "value-prof.h"
66 #include "tree-pass.h"
71 #include "rtl.h" /* FIXME: For asm_str_count. */
73 /* I'm not real happy about this, but we need to handle gimple and
76 /* Inlining, Cloning, Versioning, Parallelization
78 Inlining: a function body is duplicated, but the PARM_DECLs are
79 remapped into VAR_DECLs, and non-void RETURN_EXPRs become
80 MODIFY_EXPRs that store to a dedicated returned-value variable.
81 The duplicated eh_region info of the copy will later be appended
82 to the info for the caller; the eh_region info in copied throwing
83 statements and RESX statements are adjusted accordingly.
85 Cloning: (only in C++) We have one body for a con/de/structor, and
86 multiple function decls, each with a unique parameter list.
87 Duplicate the body, using the given splay tree; some parameters
88 will become constants (like 0 or 1).
90 Versioning: a function body is duplicated and the result is a new
91 function rather than into blocks of an existing function as with
92 inlining. Some parameters will become constants.
94 Parallelization: a region of a function is duplicated resulting in
95 a new function. Variables may be replaced with complex expressions
96 to enable shared variable semantics.
98 All of these will simultaneously lookup any callgraph edges. If
99 we're going to inline the duplicated function body, and the given
100 function has some cloned callgraph nodes (one for each place this
101 function will be inlined) those callgraph edges will be duplicated.
102 If we're cloning the body, those callgraph edges will be
103 updated to point into the new body. (Note that the original
104 callgraph node and edge list will not be altered.)
106 See the CALL_EXPR handling case in copy_tree_body_r (). */
110 o In order to make inlining-on-trees work, we pessimized
111 function-local static constants. In particular, they are now
112 always output, even when not addressed. Fix this by treating
113 function-local static constants just like global static
114 constants; the back-end already knows not to output them if they
117 o Provide heuristics to clamp inlining of recursive template
121 /* Weights that estimate_num_insns uses to estimate the size of the
124 eni_weights eni_size_weights
;
126 /* Weights that estimate_num_insns uses to estimate the time necessary
127 to execute the produced code. */
129 eni_weights eni_time_weights
;
133 static tree
declare_return_variable (copy_body_data
*, tree
, tree
, basic_block
);
134 static void remap_block (tree
*, copy_body_data
*);
135 static void copy_bind_expr (tree
*, int *, copy_body_data
*);
136 static void declare_inline_vars (tree
, tree
);
137 static void remap_save_expr (tree
*, hash_map
<tree
, tree
> *, int *);
138 static void prepend_lexical_block (tree current_block
, tree new_block
);
139 static tree
copy_decl_to_var (tree
, copy_body_data
*);
140 static tree
copy_result_decl_to_var (tree
, copy_body_data
*);
141 static tree
copy_decl_maybe_to_var (tree
, copy_body_data
*);
142 static gimple
remap_gimple_stmt (gimple
, copy_body_data
*);
143 static bool delete_unreachable_blocks_update_callgraph (copy_body_data
*id
);
145 /* Insert a tree->tree mapping for ID. Despite the name suggests
146 that the trees should be variables, it is used for more than that. */
149 insert_decl_map (copy_body_data
*id
, tree key
, tree value
)
151 id
->decl_map
->put (key
, value
);
153 /* Always insert an identity map as well. If we see this same new
154 node again, we won't want to duplicate it a second time. */
156 id
->decl_map
->put (value
, value
);
159 /* Insert a tree->tree mapping for ID. This is only used for
163 insert_debug_decl_map (copy_body_data
*id
, tree key
, tree value
)
165 if (!gimple_in_ssa_p (id
->src_cfun
))
168 if (!MAY_HAVE_DEBUG_STMTS
)
171 if (!target_for_debug_bind (key
))
174 gcc_assert (TREE_CODE (key
) == PARM_DECL
);
175 gcc_assert (TREE_CODE (value
) == VAR_DECL
);
178 id
->debug_map
= new hash_map
<tree
, tree
>;
180 id
->debug_map
->put (key
, value
);
183 /* If nonzero, we're remapping the contents of inlined debug
184 statements. If negative, an error has occurred, such as a
185 reference to a variable that isn't available in the inlined
187 static int processing_debug_stmt
= 0;
189 /* Construct new SSA name for old NAME. ID is the inline context. */
192 remap_ssa_name (tree name
, copy_body_data
*id
)
197 gcc_assert (TREE_CODE (name
) == SSA_NAME
);
199 n
= id
->decl_map
->get (name
);
201 return unshare_expr (*n
);
203 if (processing_debug_stmt
)
205 if (SSA_NAME_IS_DEFAULT_DEF (name
)
206 && TREE_CODE (SSA_NAME_VAR (name
)) == PARM_DECL
207 && id
->entry_bb
== NULL
208 && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (cfun
)))
210 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
212 gimple_stmt_iterator gsi
;
213 tree val
= SSA_NAME_VAR (name
);
215 n
= id
->decl_map
->get (val
);
218 if (TREE_CODE (val
) != PARM_DECL
)
220 processing_debug_stmt
= -1;
223 def_temp
= gimple_build_debug_source_bind (vexpr
, val
, NULL
);
224 DECL_ARTIFICIAL (vexpr
) = 1;
225 TREE_TYPE (vexpr
) = TREE_TYPE (name
);
226 DECL_MODE (vexpr
) = DECL_MODE (SSA_NAME_VAR (name
));
227 gsi
= gsi_after_labels (single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
228 gsi_insert_before (&gsi
, def_temp
, GSI_SAME_STMT
);
232 processing_debug_stmt
= -1;
236 /* Remap anonymous SSA names or SSA names of anonymous decls. */
237 var
= SSA_NAME_VAR (name
);
239 || (!SSA_NAME_IS_DEFAULT_DEF (name
)
240 && TREE_CODE (var
) == VAR_DECL
241 && !VAR_DECL_IS_VIRTUAL_OPERAND (var
)
242 && DECL_ARTIFICIAL (var
)
243 && DECL_IGNORED_P (var
)
244 && !DECL_NAME (var
)))
246 struct ptr_info_def
*pi
;
247 new_tree
= make_ssa_name (remap_type (TREE_TYPE (name
), id
), NULL
);
248 if (!var
&& SSA_NAME_IDENTIFIER (name
))
249 SET_SSA_NAME_VAR_OR_IDENTIFIER (new_tree
, SSA_NAME_IDENTIFIER (name
));
250 insert_decl_map (id
, name
, new_tree
);
251 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
252 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
253 /* At least IPA points-to info can be directly transferred. */
254 if (id
->src_cfun
->gimple_df
255 && id
->src_cfun
->gimple_df
->ipa_pta
256 && (pi
= SSA_NAME_PTR_INFO (name
))
259 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
265 /* Do not set DEF_STMT yet as statement is not copied yet. We do that
267 new_tree
= remap_decl (var
, id
);
269 /* We might've substituted constant or another SSA_NAME for
272 Replace the SSA name representing RESULT_DECL by variable during
273 inlining: this saves us from need to introduce PHI node in a case
274 return value is just partly initialized. */
275 if ((TREE_CODE (new_tree
) == VAR_DECL
|| TREE_CODE (new_tree
) == PARM_DECL
)
276 && (!SSA_NAME_VAR (name
)
277 || TREE_CODE (SSA_NAME_VAR (name
)) != RESULT_DECL
278 || !id
->transform_return_to_modify
))
280 struct ptr_info_def
*pi
;
281 new_tree
= make_ssa_name (new_tree
, NULL
);
282 insert_decl_map (id
, name
, new_tree
);
283 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
284 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
285 /* At least IPA points-to info can be directly transferred. */
286 if (id
->src_cfun
->gimple_df
287 && id
->src_cfun
->gimple_df
->ipa_pta
288 && (pi
= SSA_NAME_PTR_INFO (name
))
291 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
294 if (SSA_NAME_IS_DEFAULT_DEF (name
))
296 /* By inlining function having uninitialized variable, we might
297 extend the lifetime (variable might get reused). This cause
298 ICE in the case we end up extending lifetime of SSA name across
299 abnormal edge, but also increase register pressure.
301 We simply initialize all uninitialized vars by 0 except
302 for case we are inlining to very first BB. We can avoid
303 this for all BBs that are not inside strongly connected
304 regions of the CFG, but this is expensive to test. */
306 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
)
307 && (!SSA_NAME_VAR (name
)
308 || TREE_CODE (SSA_NAME_VAR (name
)) != PARM_DECL
)
309 && (id
->entry_bb
!= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
),
311 || EDGE_COUNT (id
->entry_bb
->preds
) != 1))
313 gimple_stmt_iterator gsi
= gsi_last_bb (id
->entry_bb
);
315 tree zero
= build_zero_cst (TREE_TYPE (new_tree
));
317 init_stmt
= gimple_build_assign (new_tree
, zero
);
318 gsi_insert_after (&gsi
, init_stmt
, GSI_NEW_STMT
);
319 SSA_NAME_IS_DEFAULT_DEF (new_tree
) = 0;
323 SSA_NAME_DEF_STMT (new_tree
) = gimple_build_nop ();
324 set_ssa_default_def (cfun
, SSA_NAME_VAR (new_tree
), new_tree
);
329 insert_decl_map (id
, name
, new_tree
);
333 /* Remap DECL during the copying of the BLOCK tree for the function. */
336 remap_decl (tree decl
, copy_body_data
*id
)
340 /* We only remap local variables in the current function. */
342 /* See if we have remapped this declaration. */
344 n
= id
->decl_map
->get (decl
);
346 if (!n
&& processing_debug_stmt
)
348 processing_debug_stmt
= -1;
352 /* If we didn't already have an equivalent for this declaration,
356 /* Make a copy of the variable or label. */
357 tree t
= id
->copy_decl (decl
, id
);
359 /* Remember it, so that if we encounter this local entity again
360 we can reuse this copy. Do this early because remap_type may
361 need this decl for TYPE_STUB_DECL. */
362 insert_decl_map (id
, decl
, t
);
367 /* Remap types, if necessary. */
368 TREE_TYPE (t
) = remap_type (TREE_TYPE (t
), id
);
369 if (TREE_CODE (t
) == TYPE_DECL
)
370 DECL_ORIGINAL_TYPE (t
) = remap_type (DECL_ORIGINAL_TYPE (t
), id
);
372 /* Remap sizes as necessary. */
373 walk_tree (&DECL_SIZE (t
), copy_tree_body_r
, id
, NULL
);
374 walk_tree (&DECL_SIZE_UNIT (t
), copy_tree_body_r
, id
, NULL
);
376 /* If fields, do likewise for offset and qualifier. */
377 if (TREE_CODE (t
) == FIELD_DECL
)
379 walk_tree (&DECL_FIELD_OFFSET (t
), copy_tree_body_r
, id
, NULL
);
380 if (TREE_CODE (DECL_CONTEXT (t
)) == QUAL_UNION_TYPE
)
381 walk_tree (&DECL_QUALIFIER (t
), copy_tree_body_r
, id
, NULL
);
387 if (id
->do_not_unshare
)
390 return unshare_expr (*n
);
394 remap_type_1 (tree type
, copy_body_data
*id
)
398 /* We do need a copy. build and register it now. If this is a pointer or
399 reference type, remap the designated type and make a new pointer or
401 if (TREE_CODE (type
) == POINTER_TYPE
)
403 new_tree
= build_pointer_type_for_mode (remap_type (TREE_TYPE (type
), id
),
405 TYPE_REF_CAN_ALIAS_ALL (type
));
406 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
407 new_tree
= build_type_attribute_qual_variant (new_tree
,
408 TYPE_ATTRIBUTES (type
),
410 insert_decl_map (id
, type
, new_tree
);
413 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
415 new_tree
= build_reference_type_for_mode (remap_type (TREE_TYPE (type
), id
),
417 TYPE_REF_CAN_ALIAS_ALL (type
));
418 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
419 new_tree
= build_type_attribute_qual_variant (new_tree
,
420 TYPE_ATTRIBUTES (type
),
422 insert_decl_map (id
, type
, new_tree
);
426 new_tree
= copy_node (type
);
428 insert_decl_map (id
, type
, new_tree
);
430 /* This is a new type, not a copy of an old type. Need to reassociate
431 variants. We can handle everything except the main variant lazily. */
432 t
= TYPE_MAIN_VARIANT (type
);
435 t
= remap_type (t
, id
);
436 TYPE_MAIN_VARIANT (new_tree
) = t
;
437 TYPE_NEXT_VARIANT (new_tree
) = TYPE_NEXT_VARIANT (t
);
438 TYPE_NEXT_VARIANT (t
) = new_tree
;
442 TYPE_MAIN_VARIANT (new_tree
) = new_tree
;
443 TYPE_NEXT_VARIANT (new_tree
) = NULL
;
446 if (TYPE_STUB_DECL (type
))
447 TYPE_STUB_DECL (new_tree
) = remap_decl (TYPE_STUB_DECL (type
), id
);
449 /* Lazily create pointer and reference types. */
450 TYPE_POINTER_TO (new_tree
) = NULL
;
451 TYPE_REFERENCE_TO (new_tree
) = NULL
;
453 /* Copy all types that may contain references to local variables; be sure to
454 preserve sharing in between type and its main variant when possible. */
455 switch (TREE_CODE (new_tree
))
459 case FIXED_POINT_TYPE
:
462 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
464 gcc_checking_assert (TYPE_MIN_VALUE (type
) == TYPE_MIN_VALUE (TYPE_MAIN_VARIANT (type
)));
465 gcc_checking_assert (TYPE_MAX_VALUE (type
) == TYPE_MAX_VALUE (TYPE_MAIN_VARIANT (type
)));
467 TYPE_MIN_VALUE (new_tree
) = TYPE_MIN_VALUE (TYPE_MAIN_VARIANT (new_tree
));
468 TYPE_MAX_VALUE (new_tree
) = TYPE_MAX_VALUE (TYPE_MAIN_VARIANT (new_tree
));
472 t
= TYPE_MIN_VALUE (new_tree
);
473 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
474 walk_tree (&TYPE_MIN_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
476 t
= TYPE_MAX_VALUE (new_tree
);
477 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
478 walk_tree (&TYPE_MAX_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
483 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
484 && TREE_TYPE (type
) == TREE_TYPE (TYPE_MAIN_VARIANT (type
)))
485 TREE_TYPE (new_tree
) = TREE_TYPE (TYPE_MAIN_VARIANT (new_tree
));
487 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
488 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
489 && TYPE_ARG_TYPES (type
) == TYPE_ARG_TYPES (TYPE_MAIN_VARIANT (type
)))
490 TYPE_ARG_TYPES (new_tree
) = TYPE_ARG_TYPES (TYPE_MAIN_VARIANT (new_tree
));
492 walk_tree (&TYPE_ARG_TYPES (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 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
502 gcc_checking_assert (TYPE_DOMAIN (type
) == TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)));
503 TYPE_DOMAIN (new_tree
) = TYPE_DOMAIN (TYPE_MAIN_VARIANT (new_tree
));
506 TYPE_DOMAIN (new_tree
) = remap_type (TYPE_DOMAIN (new_tree
), id
);
511 case QUAL_UNION_TYPE
:
512 if (TYPE_MAIN_VARIANT (type
) != type
513 && TYPE_FIELDS (type
) == TYPE_FIELDS (TYPE_MAIN_VARIANT (type
)))
514 TYPE_FIELDS (new_tree
) = TYPE_FIELDS (TYPE_MAIN_VARIANT (new_tree
));
519 for (f
= TYPE_FIELDS (new_tree
); f
; f
= DECL_CHAIN (f
))
521 t
= remap_decl (f
, id
);
522 DECL_CONTEXT (t
) = new_tree
;
526 TYPE_FIELDS (new_tree
) = nreverse (nf
);
532 /* Shouldn't have been thought variable sized. */
536 /* All variants of type share the same size, so use the already remaped data. */
537 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
539 gcc_checking_assert (TYPE_SIZE (type
) == TYPE_SIZE (TYPE_MAIN_VARIANT (type
)));
540 gcc_checking_assert (TYPE_SIZE_UNIT (type
) == TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type
)));
542 TYPE_SIZE (new_tree
) = TYPE_SIZE (TYPE_MAIN_VARIANT (new_tree
));
543 TYPE_SIZE_UNIT (new_tree
) = TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (new_tree
));
547 walk_tree (&TYPE_SIZE (new_tree
), copy_tree_body_r
, id
, NULL
);
548 walk_tree (&TYPE_SIZE_UNIT (new_tree
), copy_tree_body_r
, id
, NULL
);
555 remap_type (tree type
, copy_body_data
*id
)
563 /* See if we have remapped this type. */
564 node
= id
->decl_map
->get (type
);
568 /* The type only needs remapping if it's variably modified. */
569 if (! variably_modified_type_p (type
, id
->src_fn
))
571 insert_decl_map (id
, type
, type
);
575 id
->remapping_type_depth
++;
576 tmp
= remap_type_1 (type
, id
);
577 id
->remapping_type_depth
--;
582 /* Decide if DECL can be put into BLOCK_NONLOCAL_VARs. */
585 can_be_nonlocal (tree decl
, copy_body_data
*id
)
587 /* We can not duplicate function decls. */
588 if (TREE_CODE (decl
) == FUNCTION_DECL
)
591 /* Local static vars must be non-local or we get multiple declaration
593 if (TREE_CODE (decl
) == VAR_DECL
594 && !auto_var_in_fn_p (decl
, id
->src_fn
))
601 remap_decls (tree decls
, vec
<tree
, va_gc
> **nonlocalized_list
,
605 tree new_decls
= NULL_TREE
;
607 /* Remap its variables. */
608 for (old_var
= decls
; old_var
; old_var
= DECL_CHAIN (old_var
))
612 if (can_be_nonlocal (old_var
, id
))
614 /* We need to add this variable to the local decls as otherwise
615 nothing else will do so. */
616 if (TREE_CODE (old_var
) == VAR_DECL
617 && ! DECL_EXTERNAL (old_var
))
618 add_local_decl (cfun
, old_var
);
619 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
620 && !DECL_IGNORED_P (old_var
)
621 && nonlocalized_list
)
622 vec_safe_push (*nonlocalized_list
, old_var
);
626 /* Remap the variable. */
627 new_var
= remap_decl (old_var
, id
);
629 /* If we didn't remap this variable, we can't mess with its
630 TREE_CHAIN. If we remapped this variable to the return slot, it's
631 already declared somewhere else, so don't declare it here. */
633 if (new_var
== id
->retvar
)
637 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
638 && !DECL_IGNORED_P (old_var
)
639 && nonlocalized_list
)
640 vec_safe_push (*nonlocalized_list
, old_var
);
644 gcc_assert (DECL_P (new_var
));
645 DECL_CHAIN (new_var
) = new_decls
;
648 /* Also copy value-expressions. */
649 if (TREE_CODE (new_var
) == VAR_DECL
650 && DECL_HAS_VALUE_EXPR_P (new_var
))
652 tree tem
= DECL_VALUE_EXPR (new_var
);
653 bool old_regimplify
= id
->regimplify
;
654 id
->remapping_type_depth
++;
655 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
656 id
->remapping_type_depth
--;
657 id
->regimplify
= old_regimplify
;
658 SET_DECL_VALUE_EXPR (new_var
, tem
);
663 return nreverse (new_decls
);
666 /* Copy the BLOCK to contain remapped versions of the variables
667 therein. And hook the new block into the block-tree. */
670 remap_block (tree
*block
, copy_body_data
*id
)
675 /* Make the new block. */
677 new_block
= make_node (BLOCK
);
678 TREE_USED (new_block
) = TREE_USED (old_block
);
679 BLOCK_ABSTRACT_ORIGIN (new_block
) = old_block
;
680 BLOCK_SOURCE_LOCATION (new_block
) = BLOCK_SOURCE_LOCATION (old_block
);
681 BLOCK_NONLOCALIZED_VARS (new_block
)
682 = vec_safe_copy (BLOCK_NONLOCALIZED_VARS (old_block
));
685 /* Remap its variables. */
686 BLOCK_VARS (new_block
) = remap_decls (BLOCK_VARS (old_block
),
687 &BLOCK_NONLOCALIZED_VARS (new_block
),
690 if (id
->transform_lang_insert_block
)
691 id
->transform_lang_insert_block (new_block
);
693 /* Remember the remapped block. */
694 insert_decl_map (id
, old_block
, new_block
);
697 /* Copy the whole block tree and root it in id->block. */
699 remap_blocks (tree block
, copy_body_data
*id
)
702 tree new_tree
= block
;
707 remap_block (&new_tree
, id
);
708 gcc_assert (new_tree
!= block
);
709 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
710 prepend_lexical_block (new_tree
, remap_blocks (t
, id
));
711 /* Blocks are in arbitrary order, but make things slightly prettier and do
712 not swap order when producing a copy. */
713 BLOCK_SUBBLOCKS (new_tree
) = blocks_nreverse (BLOCK_SUBBLOCKS (new_tree
));
717 /* Remap the block tree rooted at BLOCK to nothing. */
719 remap_blocks_to_null (tree block
, copy_body_data
*id
)
722 insert_decl_map (id
, block
, NULL_TREE
);
723 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
724 remap_blocks_to_null (t
, id
);
728 copy_statement_list (tree
*tp
)
730 tree_stmt_iterator oi
, ni
;
733 new_tree
= alloc_stmt_list ();
734 ni
= tsi_start (new_tree
);
735 oi
= tsi_start (*tp
);
736 TREE_TYPE (new_tree
) = TREE_TYPE (*tp
);
739 for (; !tsi_end_p (oi
); tsi_next (&oi
))
741 tree stmt
= tsi_stmt (oi
);
742 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
743 /* This copy is not redundant; tsi_link_after will smash this
744 STATEMENT_LIST into the end of the one we're building, and we
745 don't want to do that with the original. */
746 copy_statement_list (&stmt
);
747 tsi_link_after (&ni
, stmt
, TSI_CONTINUE_LINKING
);
752 copy_bind_expr (tree
*tp
, int *walk_subtrees
, copy_body_data
*id
)
754 tree block
= BIND_EXPR_BLOCK (*tp
);
755 /* Copy (and replace) the statement. */
756 copy_tree_r (tp
, walk_subtrees
, NULL
);
759 remap_block (&block
, id
);
760 BIND_EXPR_BLOCK (*tp
) = block
;
763 if (BIND_EXPR_VARS (*tp
))
764 /* This will remap a lot of the same decls again, but this should be
766 BIND_EXPR_VARS (*tp
) = remap_decls (BIND_EXPR_VARS (*tp
), NULL
, id
);
770 /* Create a new gimple_seq by remapping all the statements in BODY
771 using the inlining information in ID. */
774 remap_gimple_seq (gimple_seq body
, copy_body_data
*id
)
776 gimple_stmt_iterator si
;
777 gimple_seq new_body
= NULL
;
779 for (si
= gsi_start (body
); !gsi_end_p (si
); gsi_next (&si
))
781 gimple new_stmt
= remap_gimple_stmt (gsi_stmt (si
), id
);
782 gimple_seq_add_stmt (&new_body
, new_stmt
);
789 /* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its
790 block using the mapping information in ID. */
793 copy_gimple_bind (gimple stmt
, copy_body_data
*id
)
796 tree new_block
, new_vars
;
797 gimple_seq body
, new_body
;
799 /* Copy the statement. Note that we purposely don't use copy_stmt
800 here because we need to remap statements as we copy. */
801 body
= gimple_bind_body (stmt
);
802 new_body
= remap_gimple_seq (body
, id
);
804 new_block
= gimple_bind_block (stmt
);
806 remap_block (&new_block
, id
);
808 /* This will remap a lot of the same decls again, but this should be
810 new_vars
= gimple_bind_vars (stmt
);
812 new_vars
= remap_decls (new_vars
, NULL
, id
);
814 new_bind
= gimple_build_bind (new_vars
, new_body
, new_block
);
819 /* Return true if DECL is a parameter or a SSA_NAME for a parameter. */
824 if (TREE_CODE (decl
) == SSA_NAME
)
826 decl
= SSA_NAME_VAR (decl
);
831 return (TREE_CODE (decl
) == PARM_DECL
);
834 /* Remap the GIMPLE operand pointed to by *TP. DATA is really a
835 'struct walk_stmt_info *'. DATA->INFO is a 'copy_body_data *'.
836 WALK_SUBTREES is used to indicate walk_gimple_op whether to keep
837 recursing into the children nodes of *TP. */
840 remap_gimple_op_r (tree
*tp
, int *walk_subtrees
, void *data
)
842 struct walk_stmt_info
*wi_p
= (struct walk_stmt_info
*) data
;
843 copy_body_data
*id
= (copy_body_data
*) wi_p
->info
;
844 tree fn
= id
->src_fn
;
846 if (TREE_CODE (*tp
) == SSA_NAME
)
848 *tp
= remap_ssa_name (*tp
, id
);
852 else if (auto_var_in_fn_p (*tp
, fn
))
854 /* Local variables and labels need to be replaced by equivalent
855 variables. We don't want to copy static variables; there's
856 only one of those, no matter how many times we inline the
857 containing function. Similarly for globals from an outer
861 /* Remap the declaration. */
862 new_decl
= remap_decl (*tp
, id
);
863 gcc_assert (new_decl
);
864 /* Replace this variable with the copy. */
865 STRIP_TYPE_NOPS (new_decl
);
866 /* ??? The C++ frontend uses void * pointer zero to initialize
867 any other type. This confuses the middle-end type verification.
868 As cloned bodies do not go through gimplification again the fixup
869 there doesn't trigger. */
870 if (TREE_CODE (new_decl
) == INTEGER_CST
871 && !useless_type_conversion_p (TREE_TYPE (*tp
), TREE_TYPE (new_decl
)))
872 new_decl
= fold_convert (TREE_TYPE (*tp
), new_decl
);
876 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
878 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
880 else if (TREE_CODE (*tp
) == LABEL_DECL
881 && (!DECL_CONTEXT (*tp
)
882 || decl_function_context (*tp
) == id
->src_fn
))
883 /* These may need to be remapped for EH handling. */
884 *tp
= remap_decl (*tp
, id
);
885 else if (TREE_CODE (*tp
) == FIELD_DECL
)
887 /* If the enclosing record type is variably_modified_type_p, the field
888 has already been remapped. Otherwise, it need not be. */
889 tree
*n
= id
->decl_map
->get (*tp
);
894 else if (TYPE_P (*tp
))
895 /* Types may need remapping as well. */
896 *tp
= remap_type (*tp
, id
);
897 else if (CONSTANT_CLASS_P (*tp
))
899 /* If this is a constant, we have to copy the node iff the type
900 will be remapped. copy_tree_r will not copy a constant. */
901 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
903 if (new_type
== TREE_TYPE (*tp
))
906 else if (TREE_CODE (*tp
) == INTEGER_CST
)
907 *tp
= wide_int_to_tree (new_type
, *tp
);
910 *tp
= copy_node (*tp
);
911 TREE_TYPE (*tp
) = new_type
;
916 /* Otherwise, just copy the node. Note that copy_tree_r already
917 knows not to copy VAR_DECLs, etc., so this is safe. */
919 if (TREE_CODE (*tp
) == MEM_REF
)
921 /* We need to re-canonicalize MEM_REFs from inline substitutions
922 that can happen when a pointer argument is an ADDR_EXPR.
923 Recurse here manually to allow that. */
924 tree ptr
= TREE_OPERAND (*tp
, 0);
925 tree type
= remap_type (TREE_TYPE (*tp
), id
);
927 walk_tree (&ptr
, remap_gimple_op_r
, data
, NULL
);
928 *tp
= fold_build2 (MEM_REF
, type
, ptr
, TREE_OPERAND (*tp
, 1));
929 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
930 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
931 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
932 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
933 remapped a parameter as the property might be valid only
934 for the parameter itself. */
935 if (TREE_THIS_NOTRAP (old
)
936 && (!is_parm (TREE_OPERAND (old
, 0))
937 || (!id
->transform_parameter
&& is_parm (ptr
))))
938 TREE_THIS_NOTRAP (*tp
) = 1;
943 /* Here is the "usual case". Copy this tree node, and then
944 tweak some special cases. */
945 copy_tree_r (tp
, walk_subtrees
, NULL
);
947 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
948 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
950 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
952 /* The copied TARGET_EXPR has never been expanded, even if the
953 original node was expanded already. */
954 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
955 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
957 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
959 /* Variable substitution need not be simple. In particular,
960 the MEM_REF substitution above. Make sure that
961 TREE_CONSTANT and friends are up-to-date. */
962 int invariant
= is_gimple_min_invariant (*tp
);
963 walk_tree (&TREE_OPERAND (*tp
, 0), remap_gimple_op_r
, data
, NULL
);
964 recompute_tree_invariant_for_addr_expr (*tp
);
966 /* If this used to be invariant, but is not any longer,
967 then regimplification is probably needed. */
968 if (invariant
&& !is_gimple_min_invariant (*tp
))
969 id
->regimplify
= true;
975 /* Update the TREE_BLOCK for the cloned expr. */
978 tree new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
979 tree old_block
= TREE_BLOCK (*tp
);
983 n
= id
->decl_map
->get (TREE_BLOCK (*tp
));
987 TREE_SET_BLOCK (*tp
, new_block
);
990 /* Keep iterating. */
995 /* Called from copy_body_id via walk_tree. DATA is really a
996 `copy_body_data *'. */
999 copy_tree_body_r (tree
*tp
, int *walk_subtrees
, void *data
)
1001 copy_body_data
*id
= (copy_body_data
*) data
;
1002 tree fn
= id
->src_fn
;
1005 /* Begin by recognizing trees that we'll completely rewrite for the
1006 inlining context. Our output for these trees is completely
1007 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1008 into an edge). Further down, we'll handle trees that get
1009 duplicated and/or tweaked. */
1011 /* When requested, RETURN_EXPRs should be transformed to just the
1012 contained MODIFY_EXPR. The branch semantics of the return will
1013 be handled elsewhere by manipulating the CFG rather than a statement. */
1014 if (TREE_CODE (*tp
) == RETURN_EXPR
&& id
->transform_return_to_modify
)
1016 tree assignment
= TREE_OPERAND (*tp
, 0);
1018 /* If we're returning something, just turn that into an
1019 assignment into the equivalent of the original RESULT_DECL.
1020 If the "assignment" is just the result decl, the result
1021 decl has already been set (e.g. a recent "foo (&result_decl,
1022 ...)"); just toss the entire RETURN_EXPR. */
1023 if (assignment
&& TREE_CODE (assignment
) == MODIFY_EXPR
)
1025 /* Replace the RETURN_EXPR with (a copy of) the
1026 MODIFY_EXPR hanging underneath. */
1027 *tp
= copy_node (assignment
);
1029 else /* Else the RETURN_EXPR returns no value. */
1032 return (tree
) (void *)1;
1035 else if (TREE_CODE (*tp
) == SSA_NAME
)
1037 *tp
= remap_ssa_name (*tp
, id
);
1042 /* Local variables and labels need to be replaced by equivalent
1043 variables. We don't want to copy static variables; there's only
1044 one of those, no matter how many times we inline the containing
1045 function. Similarly for globals from an outer function. */
1046 else if (auto_var_in_fn_p (*tp
, fn
))
1050 /* Remap the declaration. */
1051 new_decl
= remap_decl (*tp
, id
);
1052 gcc_assert (new_decl
);
1053 /* Replace this variable with the copy. */
1054 STRIP_TYPE_NOPS (new_decl
);
1058 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
1059 copy_statement_list (tp
);
1060 else if (TREE_CODE (*tp
) == SAVE_EXPR
1061 || TREE_CODE (*tp
) == TARGET_EXPR
)
1062 remap_save_expr (tp
, id
->decl_map
, walk_subtrees
);
1063 else if (TREE_CODE (*tp
) == LABEL_DECL
1064 && (! DECL_CONTEXT (*tp
)
1065 || decl_function_context (*tp
) == id
->src_fn
))
1066 /* These may need to be remapped for EH handling. */
1067 *tp
= remap_decl (*tp
, id
);
1068 else if (TREE_CODE (*tp
) == BIND_EXPR
)
1069 copy_bind_expr (tp
, walk_subtrees
, id
);
1070 /* Types may need remapping as well. */
1071 else if (TYPE_P (*tp
))
1072 *tp
= remap_type (*tp
, id
);
1074 /* If this is a constant, we have to copy the node iff the type will be
1075 remapped. copy_tree_r will not copy a constant. */
1076 else if (CONSTANT_CLASS_P (*tp
))
1078 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
1080 if (new_type
== TREE_TYPE (*tp
))
1083 else if (TREE_CODE (*tp
) == INTEGER_CST
)
1084 *tp
= wide_int_to_tree (new_type
, *tp
);
1087 *tp
= copy_node (*tp
);
1088 TREE_TYPE (*tp
) = new_type
;
1092 /* Otherwise, just copy the node. Note that copy_tree_r already
1093 knows not to copy VAR_DECLs, etc., so this is safe. */
1096 /* Here we handle trees that are not completely rewritten.
1097 First we detect some inlining-induced bogosities for
1099 if (TREE_CODE (*tp
) == MODIFY_EXPR
1100 && TREE_OPERAND (*tp
, 0) == TREE_OPERAND (*tp
, 1)
1101 && (auto_var_in_fn_p (TREE_OPERAND (*tp
, 0), fn
)))
1103 /* Some assignments VAR = VAR; don't generate any rtl code
1104 and thus don't count as variable modification. Avoid
1105 keeping bogosities like 0 = 0. */
1106 tree decl
= TREE_OPERAND (*tp
, 0), value
;
1109 n
= id
->decl_map
->get (decl
);
1113 STRIP_TYPE_NOPS (value
);
1114 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1116 *tp
= build_empty_stmt (EXPR_LOCATION (*tp
));
1117 return copy_tree_body_r (tp
, walk_subtrees
, data
);
1121 else if (TREE_CODE (*tp
) == INDIRECT_REF
)
1123 /* Get rid of *& from inline substitutions that can happen when a
1124 pointer argument is an ADDR_EXPR. */
1125 tree decl
= TREE_OPERAND (*tp
, 0);
1126 tree
*n
= id
->decl_map
->get (decl
);
1129 /* If we happen to get an ADDR_EXPR in n->value, strip
1130 it manually here as we'll eventually get ADDR_EXPRs
1131 which lie about their types pointed to. In this case
1132 build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
1133 but we absolutely rely on that. As fold_indirect_ref
1134 does other useful transformations, try that first, though. */
1135 tree type
= TREE_TYPE (*tp
);
1136 tree ptr
= id
->do_not_unshare
? *n
: unshare_expr (*n
);
1138 *tp
= gimple_fold_indirect_ref (ptr
);
1141 if (TREE_CODE (ptr
) == ADDR_EXPR
)
1144 = fold_indirect_ref_1 (EXPR_LOCATION (ptr
), type
, ptr
);
1145 /* ??? We should either assert here or build
1146 a VIEW_CONVERT_EXPR instead of blindly leaking
1147 incompatible types to our IL. */
1149 *tp
= TREE_OPERAND (ptr
, 0);
1153 *tp
= build1 (INDIRECT_REF
, type
, ptr
);
1154 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1155 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1156 TREE_READONLY (*tp
) = TREE_READONLY (old
);
1157 /* We cannot propagate the TREE_THIS_NOTRAP flag if we
1158 have remapped a parameter as the property might be
1159 valid only for the parameter itself. */
1160 if (TREE_THIS_NOTRAP (old
)
1161 && (!is_parm (TREE_OPERAND (old
, 0))
1162 || (!id
->transform_parameter
&& is_parm (ptr
))))
1163 TREE_THIS_NOTRAP (*tp
) = 1;
1170 else if (TREE_CODE (*tp
) == MEM_REF
)
1172 /* We need to re-canonicalize MEM_REFs from inline substitutions
1173 that can happen when a pointer argument is an ADDR_EXPR.
1174 Recurse here manually to allow that. */
1175 tree ptr
= TREE_OPERAND (*tp
, 0);
1176 tree type
= remap_type (TREE_TYPE (*tp
), id
);
1178 walk_tree (&ptr
, copy_tree_body_r
, data
, NULL
);
1179 *tp
= fold_build2 (MEM_REF
, type
, ptr
, TREE_OPERAND (*tp
, 1));
1180 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1181 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1182 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
1183 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
1184 remapped a parameter as the property might be valid only
1185 for the parameter itself. */
1186 if (TREE_THIS_NOTRAP (old
)
1187 && (!is_parm (TREE_OPERAND (old
, 0))
1188 || (!id
->transform_parameter
&& is_parm (ptr
))))
1189 TREE_THIS_NOTRAP (*tp
) = 1;
1194 /* Here is the "usual case". Copy this tree node, and then
1195 tweak some special cases. */
1196 copy_tree_r (tp
, walk_subtrees
, NULL
);
1198 /* If EXPR has block defined, map it to newly constructed block.
1199 When inlining we want EXPRs without block appear in the block
1200 of function call if we are not remapping a type. */
1203 new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
1204 if (TREE_BLOCK (*tp
))
1207 n
= id
->decl_map
->get (TREE_BLOCK (*tp
));
1211 TREE_SET_BLOCK (*tp
, new_block
);
1214 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
1215 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
1217 /* The copied TARGET_EXPR has never been expanded, even if the
1218 original node was expanded already. */
1219 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
1221 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
1222 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
1225 /* Variable substitution need not be simple. In particular, the
1226 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
1227 and friends are up-to-date. */
1228 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
1230 int invariant
= is_gimple_min_invariant (*tp
);
1231 walk_tree (&TREE_OPERAND (*tp
, 0), copy_tree_body_r
, id
, NULL
);
1233 /* Handle the case where we substituted an INDIRECT_REF
1234 into the operand of the ADDR_EXPR. */
1235 if (TREE_CODE (TREE_OPERAND (*tp
, 0)) == INDIRECT_REF
)
1236 *tp
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0);
1238 recompute_tree_invariant_for_addr_expr (*tp
);
1240 /* If this used to be invariant, but is not any longer,
1241 then regimplification is probably needed. */
1242 if (invariant
&& !is_gimple_min_invariant (*tp
))
1243 id
->regimplify
= true;
1249 /* Keep iterating. */
1253 /* Helper for remap_gimple_stmt. Given an EH region number for the
1254 source function, map that to the duplicate EH region number in
1255 the destination function. */
1258 remap_eh_region_nr (int old_nr
, copy_body_data
*id
)
1260 eh_region old_r
, new_r
;
1262 old_r
= get_eh_region_from_number_fn (id
->src_cfun
, old_nr
);
1263 new_r
= static_cast<eh_region
> (*id
->eh_map
->get (old_r
));
1265 return new_r
->index
;
1268 /* Similar, but operate on INTEGER_CSTs. */
1271 remap_eh_region_tree_nr (tree old_t_nr
, copy_body_data
*id
)
1275 old_nr
= tree_to_shwi (old_t_nr
);
1276 new_nr
= remap_eh_region_nr (old_nr
, id
);
1278 return build_int_cst (integer_type_node
, new_nr
);
1281 /* Helper for copy_bb. Remap statement STMT using the inlining
1282 information in ID. Return the new statement copy. */
1285 remap_gimple_stmt (gimple stmt
, copy_body_data
*id
)
1288 struct walk_stmt_info wi
;
1289 bool skip_first
= false;
1291 /* Begin by recognizing trees that we'll completely rewrite for the
1292 inlining context. Our output for these trees is completely
1293 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1294 into an edge). Further down, we'll handle trees that get
1295 duplicated and/or tweaked. */
1297 /* When requested, GIMPLE_RETURNs should be transformed to just the
1298 contained GIMPLE_ASSIGN. The branch semantics of the return will
1299 be handled elsewhere by manipulating the CFG rather than the
1301 if (gimple_code (stmt
) == GIMPLE_RETURN
&& id
->transform_return_to_modify
)
1303 tree retval
= gimple_return_retval (stmt
);
1305 /* If we're returning something, just turn that into an
1306 assignment into the equivalent of the original RESULT_DECL.
1307 If RETVAL is just the result decl, the result decl has
1308 already been set (e.g. a recent "foo (&result_decl, ...)");
1309 just toss the entire GIMPLE_RETURN. */
1311 && (TREE_CODE (retval
) != RESULT_DECL
1312 && (TREE_CODE (retval
) != SSA_NAME
1313 || ! SSA_NAME_VAR (retval
)
1314 || TREE_CODE (SSA_NAME_VAR (retval
)) != RESULT_DECL
)))
1316 copy
= gimple_build_assign (id
->do_not_unshare
1317 ? id
->retvar
: unshare_expr (id
->retvar
),
1319 /* id->retvar is already substituted. Skip it on later remapping. */
1323 return gimple_build_nop ();
1325 else if (gimple_has_substatements (stmt
))
1329 /* When cloning bodies from the C++ front end, we will be handed bodies
1330 in High GIMPLE form. Handle here all the High GIMPLE statements that
1331 have embedded statements. */
1332 switch (gimple_code (stmt
))
1335 copy
= copy_gimple_bind (stmt
, id
);
1339 s1
= remap_gimple_seq (gimple_catch_handler (stmt
), id
);
1340 copy
= gimple_build_catch (gimple_catch_types (stmt
), s1
);
1343 case GIMPLE_EH_FILTER
:
1344 s1
= remap_gimple_seq (gimple_eh_filter_failure (stmt
), id
);
1345 copy
= gimple_build_eh_filter (gimple_eh_filter_types (stmt
), s1
);
1349 s1
= remap_gimple_seq (gimple_try_eval (stmt
), id
);
1350 s2
= remap_gimple_seq (gimple_try_cleanup (stmt
), id
);
1351 copy
= gimple_build_try (s1
, s2
, gimple_try_kind (stmt
));
1354 case GIMPLE_WITH_CLEANUP_EXPR
:
1355 s1
= remap_gimple_seq (gimple_wce_cleanup (stmt
), id
);
1356 copy
= gimple_build_wce (s1
);
1359 case GIMPLE_OMP_PARALLEL
:
1360 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1361 copy
= gimple_build_omp_parallel
1363 gimple_omp_parallel_clauses (stmt
),
1364 gimple_omp_parallel_child_fn (stmt
),
1365 gimple_omp_parallel_data_arg (stmt
));
1368 case GIMPLE_OMP_TASK
:
1369 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1370 copy
= gimple_build_omp_task
1372 gimple_omp_task_clauses (stmt
),
1373 gimple_omp_task_child_fn (stmt
),
1374 gimple_omp_task_data_arg (stmt
),
1375 gimple_omp_task_copy_fn (stmt
),
1376 gimple_omp_task_arg_size (stmt
),
1377 gimple_omp_task_arg_align (stmt
));
1380 case GIMPLE_OMP_FOR
:
1381 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1382 s2
= remap_gimple_seq (gimple_omp_for_pre_body (stmt
), id
);
1383 copy
= gimple_build_omp_for (s1
, gimple_omp_for_kind (stmt
),
1384 gimple_omp_for_clauses (stmt
),
1385 gimple_omp_for_collapse (stmt
), s2
);
1388 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1390 gimple_omp_for_set_index (copy
, i
,
1391 gimple_omp_for_index (stmt
, i
));
1392 gimple_omp_for_set_initial (copy
, i
,
1393 gimple_omp_for_initial (stmt
, i
));
1394 gimple_omp_for_set_final (copy
, i
,
1395 gimple_omp_for_final (stmt
, i
));
1396 gimple_omp_for_set_incr (copy
, i
,
1397 gimple_omp_for_incr (stmt
, i
));
1398 gimple_omp_for_set_cond (copy
, i
,
1399 gimple_omp_for_cond (stmt
, i
));
1404 case GIMPLE_OMP_MASTER
:
1405 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1406 copy
= gimple_build_omp_master (s1
);
1409 case GIMPLE_OMP_TASKGROUP
:
1410 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1411 copy
= gimple_build_omp_taskgroup (s1
);
1414 case GIMPLE_OMP_ORDERED
:
1415 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1416 copy
= gimple_build_omp_ordered (s1
);
1419 case GIMPLE_OMP_SECTION
:
1420 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1421 copy
= gimple_build_omp_section (s1
);
1424 case GIMPLE_OMP_SECTIONS
:
1425 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1426 copy
= gimple_build_omp_sections
1427 (s1
, gimple_omp_sections_clauses (stmt
));
1430 case GIMPLE_OMP_SINGLE
:
1431 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1432 copy
= gimple_build_omp_single
1433 (s1
, gimple_omp_single_clauses (stmt
));
1436 case GIMPLE_OMP_TARGET
:
1437 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1438 copy
= gimple_build_omp_target
1439 (s1
, gimple_omp_target_kind (stmt
),
1440 gimple_omp_target_clauses (stmt
));
1443 case GIMPLE_OMP_TEAMS
:
1444 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1445 copy
= gimple_build_omp_teams
1446 (s1
, gimple_omp_teams_clauses (stmt
));
1449 case GIMPLE_OMP_CRITICAL
:
1450 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1452 = gimple_build_omp_critical (s1
, gimple_omp_critical_name (stmt
));
1455 case GIMPLE_TRANSACTION
:
1456 s1
= remap_gimple_seq (gimple_transaction_body (stmt
), id
);
1457 copy
= gimple_build_transaction (s1
, gimple_transaction_label (stmt
));
1458 gimple_transaction_set_subcode (copy
, gimple_transaction_subcode (stmt
));
1467 if (gimple_assign_copy_p (stmt
)
1468 && gimple_assign_lhs (stmt
) == gimple_assign_rhs1 (stmt
)
1469 && auto_var_in_fn_p (gimple_assign_lhs (stmt
), id
->src_fn
))
1471 /* Here we handle statements that are not completely rewritten.
1472 First we detect some inlining-induced bogosities for
1475 /* Some assignments VAR = VAR; don't generate any rtl code
1476 and thus don't count as variable modification. Avoid
1477 keeping bogosities like 0 = 0. */
1478 tree decl
= gimple_assign_lhs (stmt
), value
;
1481 n
= id
->decl_map
->get (decl
);
1485 STRIP_TYPE_NOPS (value
);
1486 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1487 return gimple_build_nop ();
1491 /* For *ptr_N ={v} {CLOBBER}, if ptr_N is SSA_NAME defined
1492 in a block that we aren't copying during tree_function_versioning,
1493 just drop the clobber stmt. */
1494 if (id
->blocks_to_copy
&& gimple_clobber_p (stmt
))
1496 tree lhs
= gimple_assign_lhs (stmt
);
1497 if (TREE_CODE (lhs
) == MEM_REF
1498 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == SSA_NAME
)
1500 gimple def_stmt
= SSA_NAME_DEF_STMT (TREE_OPERAND (lhs
, 0));
1501 if (gimple_bb (def_stmt
)
1502 && !bitmap_bit_p (id
->blocks_to_copy
,
1503 gimple_bb (def_stmt
)->index
))
1504 return gimple_build_nop ();
1508 if (gimple_debug_bind_p (stmt
))
1510 copy
= gimple_build_debug_bind (gimple_debug_bind_get_var (stmt
),
1511 gimple_debug_bind_get_value (stmt
),
1513 id
->debug_stmts
.safe_push (copy
);
1516 if (gimple_debug_source_bind_p (stmt
))
1518 copy
= gimple_build_debug_source_bind
1519 (gimple_debug_source_bind_get_var (stmt
),
1520 gimple_debug_source_bind_get_value (stmt
), stmt
);
1521 id
->debug_stmts
.safe_push (copy
);
1525 /* Create a new deep copy of the statement. */
1526 copy
= gimple_copy (stmt
);
1528 /* Clear flags that need revisiting. */
1529 if (is_gimple_call (copy
)
1530 && gimple_call_tail_p (copy
))
1531 gimple_call_set_tail (copy
, false);
1533 /* Remap the region numbers for __builtin_eh_{pointer,filter},
1534 RESX and EH_DISPATCH. */
1536 switch (gimple_code (copy
))
1540 tree r
, fndecl
= gimple_call_fndecl (copy
);
1541 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
1542 switch (DECL_FUNCTION_CODE (fndecl
))
1544 case BUILT_IN_EH_COPY_VALUES
:
1545 r
= gimple_call_arg (copy
, 1);
1546 r
= remap_eh_region_tree_nr (r
, id
);
1547 gimple_call_set_arg (copy
, 1, r
);
1550 case BUILT_IN_EH_POINTER
:
1551 case BUILT_IN_EH_FILTER
:
1552 r
= gimple_call_arg (copy
, 0);
1553 r
= remap_eh_region_tree_nr (r
, id
);
1554 gimple_call_set_arg (copy
, 0, r
);
1561 /* Reset alias info if we didn't apply measures to
1562 keep it valid over inlining by setting DECL_PT_UID. */
1563 if (!id
->src_cfun
->gimple_df
1564 || !id
->src_cfun
->gimple_df
->ipa_pta
)
1565 gimple_call_reset_alias_info (copy
);
1571 int r
= gimple_resx_region (copy
);
1572 r
= remap_eh_region_nr (r
, id
);
1573 gimple_resx_set_region (copy
, r
);
1577 case GIMPLE_EH_DISPATCH
:
1579 int r
= gimple_eh_dispatch_region (copy
);
1580 r
= remap_eh_region_nr (r
, id
);
1581 gimple_eh_dispatch_set_region (copy
, r
);
1590 /* If STMT has a block defined, map it to the newly constructed
1592 if (gimple_block (copy
))
1595 n
= id
->decl_map
->get (gimple_block (copy
));
1597 gimple_set_block (copy
, *n
);
1600 if (gimple_debug_bind_p (copy
) || gimple_debug_source_bind_p (copy
))
1603 /* Remap all the operands in COPY. */
1604 memset (&wi
, 0, sizeof (wi
));
1607 walk_tree (gimple_op_ptr (copy
, 1), remap_gimple_op_r
, &wi
, NULL
);
1609 walk_gimple_op (copy
, remap_gimple_op_r
, &wi
);
1611 /* Clear the copied virtual operands. We are not remapping them here
1612 but are going to recreate them from scratch. */
1613 if (gimple_has_mem_ops (copy
))
1615 gimple_set_vdef (copy
, NULL_TREE
);
1616 gimple_set_vuse (copy
, NULL_TREE
);
1623 /* Copy basic block, scale profile accordingly. Edges will be taken care of
1627 copy_bb (copy_body_data
*id
, basic_block bb
, int frequency_scale
,
1628 gcov_type count_scale
)
1630 gimple_stmt_iterator gsi
, copy_gsi
, seq_gsi
;
1631 basic_block copy_basic_block
;
1636 /* Search for previous copied basic block. */
1639 prev
= prev
->prev_bb
;
1641 /* create_basic_block() will append every new block to
1642 basic_block_info automatically. */
1643 copy_basic_block
= create_basic_block (NULL
, (void *) 0,
1644 (basic_block
) prev
->aux
);
1645 copy_basic_block
->count
= apply_scale (bb
->count
, count_scale
);
1647 /* We are going to rebuild frequencies from scratch. These values
1648 have just small importance to drive canonicalize_loop_headers. */
1649 freq
= apply_scale ((gcov_type
)bb
->frequency
, frequency_scale
);
1651 /* We recompute frequencies after inlining, so this is quite safe. */
1652 if (freq
> BB_FREQ_MAX
)
1654 copy_basic_block
->frequency
= freq
;
1656 copy_gsi
= gsi_start_bb (copy_basic_block
);
1658 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1660 gimple stmt
= gsi_stmt (gsi
);
1661 gimple orig_stmt
= stmt
;
1663 id
->regimplify
= false;
1664 stmt
= remap_gimple_stmt (stmt
, id
);
1665 if (gimple_nop_p (stmt
))
1668 gimple_duplicate_stmt_histograms (cfun
, stmt
, id
->src_cfun
, orig_stmt
);
1671 /* With return slot optimization we can end up with
1672 non-gimple (foo *)&this->m, fix that here. */
1673 if (is_gimple_assign (stmt
)
1674 && gimple_assign_rhs_code (stmt
) == NOP_EXPR
1675 && !is_gimple_val (gimple_assign_rhs1 (stmt
)))
1678 new_rhs
= force_gimple_operand_gsi (&seq_gsi
,
1679 gimple_assign_rhs1 (stmt
),
1681 GSI_CONTINUE_LINKING
);
1682 gimple_assign_set_rhs1 (stmt
, new_rhs
);
1683 id
->regimplify
= false;
1686 gsi_insert_after (&seq_gsi
, stmt
, GSI_NEW_STMT
);
1689 gimple_regimplify_operands (stmt
, &seq_gsi
);
1691 /* If copy_basic_block has been empty at the start of this iteration,
1692 call gsi_start_bb again to get at the newly added statements. */
1693 if (gsi_end_p (copy_gsi
))
1694 copy_gsi
= gsi_start_bb (copy_basic_block
);
1696 gsi_next (©_gsi
);
1698 /* Process the new statement. The call to gimple_regimplify_operands
1699 possibly turned the statement into multiple statements, we
1700 need to process all of them. */
1705 stmt
= gsi_stmt (copy_gsi
);
1706 if (is_gimple_call (stmt
)
1707 && gimple_call_va_arg_pack_p (stmt
)
1710 /* __builtin_va_arg_pack () should be replaced by
1711 all arguments corresponding to ... in the caller. */
1715 size_t nargs
= gimple_call_num_args (id
->gimple_call
);
1718 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1721 /* Create the new array of arguments. */
1722 n
= nargs
+ gimple_call_num_args (stmt
);
1723 argarray
.create (n
);
1724 argarray
.safe_grow_cleared (n
);
1726 /* Copy all the arguments before '...' */
1727 memcpy (argarray
.address (),
1728 gimple_call_arg_ptr (stmt
, 0),
1729 gimple_call_num_args (stmt
) * sizeof (tree
));
1731 /* Append the arguments passed in '...' */
1732 memcpy (argarray
.address () + gimple_call_num_args (stmt
),
1733 gimple_call_arg_ptr (id
->gimple_call
, 0)
1734 + (gimple_call_num_args (id
->gimple_call
) - nargs
),
1735 nargs
* sizeof (tree
));
1737 new_call
= gimple_build_call_vec (gimple_call_fn (stmt
),
1740 argarray
.release ();
1742 /* Copy all GIMPLE_CALL flags, location and block, except
1743 GF_CALL_VA_ARG_PACK. */
1744 gimple_call_copy_flags (new_call
, stmt
);
1745 gimple_call_set_va_arg_pack (new_call
, false);
1746 gimple_set_location (new_call
, gimple_location (stmt
));
1747 gimple_set_block (new_call
, gimple_block (stmt
));
1748 gimple_call_set_lhs (new_call
, gimple_call_lhs (stmt
));
1750 gsi_replace (©_gsi
, new_call
, false);
1753 else if (is_gimple_call (stmt
)
1755 && (decl
= gimple_call_fndecl (stmt
))
1756 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
1757 && DECL_FUNCTION_CODE (decl
) == BUILT_IN_VA_ARG_PACK_LEN
)
1759 /* __builtin_va_arg_pack_len () should be replaced by
1760 the number of anonymous arguments. */
1761 size_t nargs
= gimple_call_num_args (id
->gimple_call
);
1765 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1768 count
= build_int_cst (integer_type_node
, nargs
);
1769 new_stmt
= gimple_build_assign (gimple_call_lhs (stmt
), count
);
1770 gsi_replace (©_gsi
, new_stmt
, false);
1774 /* Statements produced by inlining can be unfolded, especially
1775 when we constant propagated some operands. We can't fold
1776 them right now for two reasons:
1777 1) folding require SSA_NAME_DEF_STMTs to be correct
1778 2) we can't change function calls to builtins.
1779 So we just mark statement for later folding. We mark
1780 all new statements, instead just statements that has changed
1781 by some nontrivial substitution so even statements made
1782 foldable indirectly are updated. If this turns out to be
1783 expensive, copy_body can be told to watch for nontrivial
1785 if (id
->statements_to_fold
)
1786 id
->statements_to_fold
->add (stmt
);
1788 /* We're duplicating a CALL_EXPR. Find any corresponding
1789 callgraph edges and update or duplicate them. */
1790 if (is_gimple_call (stmt
))
1792 struct cgraph_edge
*edge
;
1794 switch (id
->transform_call_graph_edges
)
1796 case CB_CGE_DUPLICATE
:
1797 edge
= id
->src_node
->get_edge (orig_stmt
);
1800 int edge_freq
= edge
->frequency
;
1802 struct cgraph_edge
*old_edge
= edge
;
1803 edge
= edge
->clone (id
->dst_node
, stmt
,
1805 REG_BR_PROB_BASE
, CGRAPH_FREQ_BASE
,
1807 /* We could also just rescale the frequency, but
1808 doing so would introduce roundoff errors and make
1809 verifier unhappy. */
1810 new_freq
= compute_call_stmt_bb_frequency (id
->dst_node
->decl
,
1813 /* Speculative calls consist of two edges - direct and indirect.
1814 Duplicate the whole thing and distribute frequencies accordingly. */
1815 if (edge
->speculative
)
1817 struct cgraph_edge
*direct
, *indirect
;
1818 struct ipa_ref
*ref
;
1820 gcc_assert (!edge
->indirect_unknown_callee
);
1821 old_edge
->speculative_call_info (direct
, indirect
, ref
);
1822 indirect
= indirect
->clone (id
->dst_node
, stmt
,
1824 REG_BR_PROB_BASE
, CGRAPH_FREQ_BASE
,
1826 if (old_edge
->frequency
+ indirect
->frequency
)
1828 edge
->frequency
= MIN (RDIV ((gcov_type
)new_freq
* old_edge
->frequency
,
1829 (old_edge
->frequency
+ indirect
->frequency
)),
1831 indirect
->frequency
= MIN (RDIV ((gcov_type
)new_freq
* indirect
->frequency
,
1832 (old_edge
->frequency
+ indirect
->frequency
)),
1835 id
->dst_node
->clone_reference (ref
, stmt
);
1839 edge
->frequency
= new_freq
;
1841 && profile_status_for_fn (cfun
) != PROFILE_ABSENT
1842 && (edge_freq
> edge
->frequency
+ 10
1843 || edge_freq
< edge
->frequency
- 10))
1845 fprintf (dump_file
, "Edge frequency estimated by "
1846 "cgraph %i diverge from inliner's estimate %i\n",
1850 "Orig bb: %i, orig bb freq %i, new bb freq %i\n",
1853 copy_basic_block
->frequency
);
1859 case CB_CGE_MOVE_CLONES
:
1860 id
->dst_node
->set_call_stmt_including_clones (orig_stmt
,
1862 edge
= id
->dst_node
->get_edge (stmt
);
1866 edge
= id
->dst_node
->get_edge (orig_stmt
);
1868 edge
->set_call_stmt (stmt
);
1875 /* Constant propagation on argument done during inlining
1876 may create new direct call. Produce an edge for it. */
1878 || (edge
->indirect_inlining_edge
1879 && id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
))
1880 && id
->dst_node
->definition
1881 && (fn
= gimple_call_fndecl (stmt
)) != NULL
)
1883 struct cgraph_node
*dest
= cgraph_node::get (fn
);
1885 /* We have missing edge in the callgraph. This can happen
1886 when previous inlining turned an indirect call into a
1887 direct call by constant propagating arguments or we are
1888 producing dead clone (for further cloning). In all
1889 other cases we hit a bug (incorrect node sharing is the
1890 most common reason for missing edges). */
1891 gcc_assert (!dest
->definition
1892 || dest
->address_taken
1893 || !id
->src_node
->definition
1894 || !id
->dst_node
->definition
);
1895 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
)
1896 id
->dst_node
->create_edge_including_clones
1897 (dest
, orig_stmt
, stmt
, bb
->count
,
1898 compute_call_stmt_bb_frequency (id
->dst_node
->decl
,
1900 CIF_ORIGINALLY_INDIRECT_CALL
);
1902 id
->dst_node
->create_edge (dest
, stmt
,
1904 compute_call_stmt_bb_frequency
1905 (id
->dst_node
->decl
,
1906 copy_basic_block
))->inline_failed
1907 = CIF_ORIGINALLY_INDIRECT_CALL
;
1910 fprintf (dump_file
, "Created new direct edge to %s\n",
1915 notice_special_calls (stmt
);
1918 maybe_duplicate_eh_stmt_fn (cfun
, stmt
, id
->src_cfun
, orig_stmt
,
1919 id
->eh_map
, id
->eh_lp_nr
);
1921 if (gimple_in_ssa_p (cfun
) && !is_gimple_debug (stmt
))
1926 FOR_EACH_SSA_TREE_OPERAND (def
, stmt
, i
, SSA_OP_DEF
)
1927 if (TREE_CODE (def
) == SSA_NAME
)
1928 SSA_NAME_DEF_STMT (def
) = stmt
;
1931 gsi_next (©_gsi
);
1933 while (!gsi_end_p (copy_gsi
));
1935 copy_gsi
= gsi_last_bb (copy_basic_block
);
1938 return copy_basic_block
;
1941 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
1942 form is quite easy, since dominator relationship for old basic blocks does
1945 There is however exception where inlining might change dominator relation
1946 across EH edges from basic block within inlined functions destinating
1947 to landing pads in function we inline into.
1949 The function fills in PHI_RESULTs of such PHI nodes if they refer
1950 to gimple regs. Otherwise, the function mark PHI_RESULT of such
1951 PHI nodes for renaming. For non-gimple regs, renaming is safe: the
1952 EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
1953 set, and this means that there will be no overlapping live ranges
1954 for the underlying symbol.
1956 This might change in future if we allow redirecting of EH edges and
1957 we might want to change way build CFG pre-inlining to include
1958 all the possible edges then. */
1960 update_ssa_across_abnormal_edges (basic_block bb
, basic_block ret_bb
,
1961 bool can_throw
, bool nonlocal_goto
)
1966 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1968 || ((basic_block
)e
->dest
->aux
)->index
== ENTRY_BLOCK
)
1971 gimple_stmt_iterator si
;
1974 gcc_assert (e
->flags
& EDGE_EH
);
1977 gcc_assert (!(e
->flags
& EDGE_EH
));
1979 for (si
= gsi_start_phis (e
->dest
); !gsi_end_p (si
); gsi_next (&si
))
1983 phi
= gsi_stmt (si
);
1985 /* For abnormal goto/call edges the receiver can be the
1986 ENTRY_BLOCK. Do not assert this cannot happen. */
1988 gcc_assert ((e
->flags
& EDGE_EH
)
1989 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi
)));
1991 re
= find_edge (ret_bb
, e
->dest
);
1992 gcc_checking_assert (re
);
1993 gcc_assert ((re
->flags
& (EDGE_EH
| EDGE_ABNORMAL
))
1994 == (e
->flags
& (EDGE_EH
| EDGE_ABNORMAL
)));
1996 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, e
),
1997 USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, re
)));
2003 /* Copy edges from BB into its copy constructed earlier, scale profile
2004 accordingly. Edges will be taken care of later. Assume aux
2005 pointers to point to the copies of each BB. Return true if any
2006 debug stmts are left after a statement that must end the basic block. */
2009 copy_edges_for_bb (basic_block bb
, gcov_type count_scale
, basic_block ret_bb
,
2010 basic_block abnormal_goto_dest
)
2012 basic_block new_bb
= (basic_block
) bb
->aux
;
2015 gimple_stmt_iterator si
;
2017 bool need_debug_cleanup
= false;
2019 /* Use the indices from the original blocks to create edges for the
2021 FOR_EACH_EDGE (old_edge
, ei
, bb
->succs
)
2022 if (!(old_edge
->flags
& EDGE_EH
))
2026 flags
= old_edge
->flags
;
2028 /* Return edges do get a FALLTHRU flag when the get inlined. */
2029 if (old_edge
->dest
->index
== EXIT_BLOCK
2030 && !(old_edge
->flags
& (EDGE_TRUE_VALUE
|EDGE_FALSE_VALUE
|EDGE_FAKE
))
2031 && old_edge
->dest
->aux
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
2032 flags
|= EDGE_FALLTHRU
;
2033 new_edge
= make_edge (new_bb
, (basic_block
) old_edge
->dest
->aux
, flags
);
2034 new_edge
->count
= apply_scale (old_edge
->count
, count_scale
);
2035 new_edge
->probability
= old_edge
->probability
;
2038 if (bb
->index
== ENTRY_BLOCK
|| bb
->index
== EXIT_BLOCK
)
2041 for (si
= gsi_start_bb (new_bb
); !gsi_end_p (si
);)
2044 bool can_throw
, nonlocal_goto
;
2046 copy_stmt
= gsi_stmt (si
);
2047 if (!is_gimple_debug (copy_stmt
))
2048 update_stmt (copy_stmt
);
2050 /* Do this before the possible split_block. */
2053 /* If this tree could throw an exception, there are two
2054 cases where we need to add abnormal edge(s): the
2055 tree wasn't in a region and there is a "current
2056 region" in the caller; or the original tree had
2057 EH edges. In both cases split the block after the tree,
2058 and add abnormal edge(s) as needed; we need both
2059 those from the callee and the caller.
2060 We check whether the copy can throw, because the const
2061 propagation can change an INDIRECT_REF which throws
2062 into a COMPONENT_REF which doesn't. If the copy
2063 can throw, the original could also throw. */
2064 can_throw
= stmt_can_throw_internal (copy_stmt
);
2066 = (stmt_can_make_abnormal_goto (copy_stmt
)
2067 && !computed_goto_p (copy_stmt
));
2069 if (can_throw
|| nonlocal_goto
)
2071 if (!gsi_end_p (si
))
2073 while (!gsi_end_p (si
) && is_gimple_debug (gsi_stmt (si
)))
2076 need_debug_cleanup
= true;
2078 if (!gsi_end_p (si
))
2079 /* Note that bb's predecessor edges aren't necessarily
2080 right at this point; split_block doesn't care. */
2082 edge e
= split_block (new_bb
, copy_stmt
);
2085 new_bb
->aux
= e
->src
->aux
;
2086 si
= gsi_start_bb (new_bb
);
2090 if (gimple_code (copy_stmt
) == GIMPLE_EH_DISPATCH
)
2091 make_eh_dispatch_edges (copy_stmt
);
2093 make_eh_edges (copy_stmt
);
2095 /* If the call we inline cannot make abnormal goto do not add
2096 additional abnormal edges but only retain those already present
2097 in the original function body. */
2098 if (abnormal_goto_dest
== NULL
)
2099 nonlocal_goto
= false;
2102 basic_block copy_stmt_bb
= gimple_bb (copy_stmt
);
2104 if (get_abnormal_succ_dispatcher (copy_stmt_bb
))
2105 nonlocal_goto
= false;
2106 /* ABNORMAL_DISPATCHER (1) is for longjmp/setjmp or nonlocal gotos
2107 in OpenMP regions which aren't allowed to be left abnormally.
2108 So, no need to add abnormal edge in that case. */
2109 else if (is_gimple_call (copy_stmt
)
2110 && gimple_call_internal_p (copy_stmt
)
2111 && (gimple_call_internal_fn (copy_stmt
)
2112 == IFN_ABNORMAL_DISPATCHER
)
2113 && gimple_call_arg (copy_stmt
, 0) == boolean_true_node
)
2114 nonlocal_goto
= false;
2116 make_edge (copy_stmt_bb
, abnormal_goto_dest
, EDGE_ABNORMAL
);
2119 if ((can_throw
|| nonlocal_goto
)
2120 && gimple_in_ssa_p (cfun
))
2121 update_ssa_across_abnormal_edges (gimple_bb (copy_stmt
), ret_bb
,
2122 can_throw
, nonlocal_goto
);
2124 return need_debug_cleanup
;
2127 /* Copy the PHIs. All blocks and edges are copied, some blocks
2128 was possibly split and new outgoing EH edges inserted.
2129 BB points to the block of original function and AUX pointers links
2130 the original and newly copied blocks. */
2133 copy_phis_for_bb (basic_block bb
, copy_body_data
*id
)
2135 basic_block
const new_bb
= (basic_block
) bb
->aux
;
2138 gimple_stmt_iterator si
;
2140 bool inserted
= false;
2142 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
2147 phi
= gsi_stmt (si
);
2148 res
= PHI_RESULT (phi
);
2150 if (!virtual_operand_p (res
))
2152 walk_tree (&new_res
, copy_tree_body_r
, id
, NULL
);
2153 new_phi
= create_phi_node (new_res
, new_bb
);
2154 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2156 edge old_edge
= find_edge ((basic_block
) new_edge
->src
->aux
, bb
);
2162 /* When doing partial cloning, we allow PHIs on the entry block
2163 as long as all the arguments are the same. Find any input
2164 edge to see argument to copy. */
2166 FOR_EACH_EDGE (old_edge
, ei2
, bb
->preds
)
2167 if (!old_edge
->src
->aux
)
2170 arg
= PHI_ARG_DEF_FROM_EDGE (phi
, old_edge
);
2172 walk_tree (&new_arg
, copy_tree_body_r
, id
, NULL
);
2173 gcc_assert (new_arg
);
2174 /* With return slot optimization we can end up with
2175 non-gimple (foo *)&this->m, fix that here. */
2176 if (TREE_CODE (new_arg
) != SSA_NAME
2177 && TREE_CODE (new_arg
) != FUNCTION_DECL
2178 && !is_gimple_val (new_arg
))
2180 gimple_seq stmts
= NULL
;
2181 new_arg
= force_gimple_operand (new_arg
, &stmts
, true, NULL
);
2182 gsi_insert_seq_on_edge (new_edge
, stmts
);
2185 locus
= gimple_phi_arg_location_from_edge (phi
, old_edge
);
2186 if (LOCATION_BLOCK (locus
))
2189 n
= id
->decl_map
->get (LOCATION_BLOCK (locus
));
2192 locus
= COMBINE_LOCATION_DATA (line_table
, locus
, *n
);
2194 locus
= LOCATION_LOCUS (locus
);
2197 locus
= LOCATION_LOCUS (locus
);
2199 add_phi_arg (new_phi
, new_arg
, new_edge
, locus
);
2204 /* Commit the delayed edge insertions. */
2206 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2207 gsi_commit_one_edge_insert (new_edge
, NULL
);
2211 /* Wrapper for remap_decl so it can be used as a callback. */
2214 remap_decl_1 (tree decl
, void *data
)
2216 return remap_decl (decl
, (copy_body_data
*) data
);
2219 /* Build struct function and associated datastructures for the new clone
2220 NEW_FNDECL to be build. CALLEE_FNDECL is the original. Function changes
2221 the cfun to the function of new_fndecl (and current_function_decl too). */
2224 initialize_cfun (tree new_fndecl
, tree callee_fndecl
, gcov_type count
)
2226 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2227 gcov_type count_scale
;
2229 if (!DECL_ARGUMENTS (new_fndecl
))
2230 DECL_ARGUMENTS (new_fndecl
) = DECL_ARGUMENTS (callee_fndecl
);
2231 if (!DECL_RESULT (new_fndecl
))
2232 DECL_RESULT (new_fndecl
) = DECL_RESULT (callee_fndecl
);
2234 if (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
)
2236 = GCOV_COMPUTE_SCALE (count
,
2237 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
);
2239 count_scale
= REG_BR_PROB_BASE
;
2241 /* Register specific tree functions. */
2242 gimple_register_cfg_hooks ();
2244 /* Get clean struct function. */
2245 push_struct_function (new_fndecl
);
2247 /* We will rebuild these, so just sanity check that they are empty. */
2248 gcc_assert (VALUE_HISTOGRAMS (cfun
) == NULL
);
2249 gcc_assert (cfun
->local_decls
== NULL
);
2250 gcc_assert (cfun
->cfg
== NULL
);
2251 gcc_assert (cfun
->decl
== new_fndecl
);
2253 /* Copy items we preserve during cloning. */
2254 cfun
->static_chain_decl
= src_cfun
->static_chain_decl
;
2255 cfun
->nonlocal_goto_save_area
= src_cfun
->nonlocal_goto_save_area
;
2256 cfun
->function_end_locus
= src_cfun
->function_end_locus
;
2257 cfun
->curr_properties
= src_cfun
->curr_properties
;
2258 cfun
->last_verified
= src_cfun
->last_verified
;
2259 cfun
->va_list_gpr_size
= src_cfun
->va_list_gpr_size
;
2260 cfun
->va_list_fpr_size
= src_cfun
->va_list_fpr_size
;
2261 cfun
->has_nonlocal_label
= src_cfun
->has_nonlocal_label
;
2262 cfun
->stdarg
= src_cfun
->stdarg
;
2263 cfun
->after_inlining
= src_cfun
->after_inlining
;
2264 cfun
->can_throw_non_call_exceptions
2265 = src_cfun
->can_throw_non_call_exceptions
;
2266 cfun
->can_delete_dead_exceptions
= src_cfun
->can_delete_dead_exceptions
;
2267 cfun
->returns_struct
= src_cfun
->returns_struct
;
2268 cfun
->returns_pcc_struct
= src_cfun
->returns_pcc_struct
;
2270 init_empty_tree_cfg ();
2272 profile_status_for_fn (cfun
) = profile_status_for_fn (src_cfun
);
2273 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
=
2274 (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
* count_scale
/
2276 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
2277 = ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->frequency
;
2278 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
=
2279 (EXIT_BLOCK_PTR_FOR_FN (src_cfun
)->count
* count_scale
/
2281 EXIT_BLOCK_PTR_FOR_FN (cfun
)->frequency
=
2282 EXIT_BLOCK_PTR_FOR_FN (src_cfun
)->frequency
;
2284 init_eh_for_function ();
2286 if (src_cfun
->gimple_df
)
2288 init_tree_ssa (cfun
);
2289 cfun
->gimple_df
->in_ssa_p
= true;
2290 init_ssa_operands (cfun
);
2294 /* Helper function for copy_cfg_body. Move debug stmts from the end
2295 of NEW_BB to the beginning of successor basic blocks when needed. If the
2296 successor has multiple predecessors, reset them, otherwise keep
2300 maybe_move_debug_stmts_to_successors (copy_body_data
*id
, basic_block new_bb
)
2304 gimple_stmt_iterator si
= gsi_last_nondebug_bb (new_bb
);
2307 || gsi_one_before_end_p (si
)
2308 || !(stmt_can_throw_internal (gsi_stmt (si
))
2309 || stmt_can_make_abnormal_goto (gsi_stmt (si
))))
2312 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
2314 gimple_stmt_iterator ssi
= gsi_last_bb (new_bb
);
2315 gimple_stmt_iterator dsi
= gsi_after_labels (e
->dest
);
2316 while (is_gimple_debug (gsi_stmt (ssi
)))
2318 gimple stmt
= gsi_stmt (ssi
), new_stmt
;
2322 /* For the last edge move the debug stmts instead of copying
2324 if (ei_one_before_end_p (ei
))
2328 if (!single_pred_p (e
->dest
) && gimple_debug_bind_p (stmt
))
2329 gimple_debug_bind_reset_value (stmt
);
2330 gsi_remove (&si
, false);
2331 gsi_insert_before (&dsi
, stmt
, GSI_SAME_STMT
);
2335 if (gimple_debug_bind_p (stmt
))
2337 var
= gimple_debug_bind_get_var (stmt
);
2338 if (single_pred_p (e
->dest
))
2340 value
= gimple_debug_bind_get_value (stmt
);
2341 value
= unshare_expr (value
);
2345 new_stmt
= gimple_build_debug_bind (var
, value
, stmt
);
2347 else if (gimple_debug_source_bind_p (stmt
))
2349 var
= gimple_debug_source_bind_get_var (stmt
);
2350 value
= gimple_debug_source_bind_get_value (stmt
);
2351 new_stmt
= gimple_build_debug_source_bind (var
, value
, stmt
);
2355 gsi_insert_before (&dsi
, new_stmt
, GSI_SAME_STMT
);
2356 id
->debug_stmts
.safe_push (new_stmt
);
2362 /* Make a copy of the sub-loops of SRC_PARENT and place them
2363 as siblings of DEST_PARENT. */
2366 copy_loops (copy_body_data
*id
,
2367 struct loop
*dest_parent
, struct loop
*src_parent
)
2369 struct loop
*src_loop
= src_parent
->inner
;
2372 if (!id
->blocks_to_copy
2373 || bitmap_bit_p (id
->blocks_to_copy
, src_loop
->header
->index
))
2375 struct loop
*dest_loop
= alloc_loop ();
2377 /* Assign the new loop its header and latch and associate
2378 those with the new loop. */
2379 dest_loop
->header
= (basic_block
)src_loop
->header
->aux
;
2380 dest_loop
->header
->loop_father
= dest_loop
;
2381 if (src_loop
->latch
!= NULL
)
2383 dest_loop
->latch
= (basic_block
)src_loop
->latch
->aux
;
2384 dest_loop
->latch
->loop_father
= dest_loop
;
2387 /* Copy loop meta-data. */
2388 copy_loop_info (src_loop
, dest_loop
);
2390 /* Finally place it into the loop array and the loop tree. */
2391 place_new_loop (cfun
, dest_loop
);
2392 flow_loop_tree_node_add (dest_parent
, dest_loop
);
2394 dest_loop
->safelen
= src_loop
->safelen
;
2395 dest_loop
->dont_vectorize
= src_loop
->dont_vectorize
;
2396 if (src_loop
->force_vectorize
)
2398 dest_loop
->force_vectorize
= true;
2399 cfun
->has_force_vectorize_loops
= true;
2401 if (src_loop
->simduid
)
2403 dest_loop
->simduid
= remap_decl (src_loop
->simduid
, id
);
2404 cfun
->has_simduid_loops
= true;
2408 copy_loops (id
, dest_loop
, src_loop
);
2410 src_loop
= src_loop
->next
;
2414 /* Call cgraph_redirect_edge_call_stmt_to_callee on all calls in BB */
2417 redirect_all_calls (copy_body_data
* id
, basic_block bb
)
2419 gimple_stmt_iterator si
;
2420 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
2422 if (is_gimple_call (gsi_stmt (si
)))
2424 struct cgraph_edge
*edge
= id
->dst_node
->get_edge (gsi_stmt (si
));
2426 edge
->redirect_call_stmt_to_callee ();
2431 /* Convert estimated frequencies into counts for NODE, scaling COUNT
2432 with each bb's frequency. Used when NODE has a 0-weight entry
2433 but we are about to inline it into a non-zero count call bb.
2434 See the comments for handle_missing_profiles() in predict.c for
2435 when this can happen for COMDATs. */
2438 freqs_to_counts (struct cgraph_node
*node
, gcov_type count
)
2443 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
2445 FOR_ALL_BB_FN(bb
, fn
)
2447 bb
->count
= apply_scale (count
,
2448 GCOV_COMPUTE_SCALE (bb
->frequency
, BB_FREQ_MAX
));
2449 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
2450 e
->count
= apply_probability (e
->src
->count
, e
->probability
);
2454 /* Make a copy of the body of FN so that it can be inserted inline in
2455 another function. Walks FN via CFG, returns new fndecl. */
2458 copy_cfg_body (copy_body_data
* id
, gcov_type count
, int frequency_scale
,
2459 basic_block entry_block_map
, basic_block exit_block_map
,
2460 basic_block new_entry
)
2462 tree callee_fndecl
= id
->src_fn
;
2463 /* Original cfun for the callee, doesn't change. */
2464 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2465 struct function
*cfun_to_copy
;
2467 tree new_fndecl
= NULL
;
2468 bool need_debug_cleanup
= false;
2469 gcov_type count_scale
;
2471 int incoming_frequency
= 0;
2472 gcov_type incoming_count
= 0;
2474 /* This can happen for COMDAT routines that end up with 0 counts
2475 despite being called (see the comments for handle_missing_profiles()
2476 in predict.c as to why). Apply counts to the blocks in the callee
2477 before inlining, using the guessed edge frequencies, so that we don't
2478 end up with a 0-count inline body which can confuse downstream
2479 optimizations such as function splitting. */
2480 if (!ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
&& count
)
2482 /* Apply the larger of the call bb count and the total incoming
2483 call edge count to the callee. */
2484 gcov_type in_count
= 0;
2485 struct cgraph_edge
*in_edge
;
2486 for (in_edge
= id
->src_node
->callers
; in_edge
;
2487 in_edge
= in_edge
->next_caller
)
2488 in_count
+= in_edge
->count
;
2489 freqs_to_counts (id
->src_node
, count
> in_count
? count
: in_count
);
2492 if (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
)
2494 = GCOV_COMPUTE_SCALE (count
,
2495 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
);
2497 count_scale
= REG_BR_PROB_BASE
;
2499 /* Register specific tree functions. */
2500 gimple_register_cfg_hooks ();
2502 /* If we are inlining just region of the function, make sure to connect
2503 new entry to ENTRY_BLOCK_PTR_FOR_FN (cfun). Since new entry can be
2504 part of loop, we must compute frequency and probability of
2505 ENTRY_BLOCK_PTR_FOR_FN (cfun) based on the frequencies and
2506 probabilities of edges incoming from nonduplicated region. */
2512 FOR_EACH_EDGE (e
, ei
, new_entry
->preds
)
2515 incoming_frequency
+= EDGE_FREQUENCY (e
);
2516 incoming_count
+= e
->count
;
2518 incoming_count
= apply_scale (incoming_count
, count_scale
);
2520 = apply_scale ((gcov_type
)incoming_frequency
, frequency_scale
);
2521 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= incoming_count
;
2522 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
= incoming_frequency
;
2525 /* Must have a CFG here at this point. */
2526 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN
2527 (DECL_STRUCT_FUNCTION (callee_fndecl
)));
2529 cfun_to_copy
= id
->src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2531 ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy
)->aux
= entry_block_map
;
2532 EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy
)->aux
= exit_block_map
;
2533 entry_block_map
->aux
= ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy
);
2534 exit_block_map
->aux
= EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy
);
2536 /* Duplicate any exception-handling regions. */
2538 id
->eh_map
= duplicate_eh_regions (cfun_to_copy
, NULL
, id
->eh_lp_nr
,
2541 /* Use aux pointers to map the original blocks to copy. */
2542 FOR_EACH_BB_FN (bb
, cfun_to_copy
)
2543 if (!id
->blocks_to_copy
|| bitmap_bit_p (id
->blocks_to_copy
, bb
->index
))
2545 basic_block new_bb
= copy_bb (id
, bb
, frequency_scale
, count_scale
);
2548 new_bb
->loop_father
= entry_block_map
->loop_father
;
2551 last
= last_basic_block_for_fn (cfun
);
2553 /* Now that we've duplicated the blocks, duplicate their edges. */
2554 basic_block abnormal_goto_dest
= NULL
;
2556 && stmt_can_make_abnormal_goto (id
->gimple_call
))
2558 gimple_stmt_iterator gsi
= gsi_for_stmt (id
->gimple_call
);
2560 bb
= gimple_bb (id
->gimple_call
);
2562 if (gsi_end_p (gsi
))
2563 abnormal_goto_dest
= get_abnormal_succ_dispatcher (bb
);
2565 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2566 if (!id
->blocks_to_copy
2567 || (bb
->index
> 0 && bitmap_bit_p (id
->blocks_to_copy
, bb
->index
)))
2568 need_debug_cleanup
|= copy_edges_for_bb (bb
, count_scale
, exit_block_map
,
2569 abnormal_goto_dest
);
2573 edge e
= make_edge (entry_block_map
, (basic_block
)new_entry
->aux
, EDGE_FALLTHRU
);
2574 e
->probability
= REG_BR_PROB_BASE
;
2575 e
->count
= incoming_count
;
2578 /* Duplicate the loop tree, if available and wanted. */
2579 if (loops_for_fn (src_cfun
) != NULL
2580 && current_loops
!= NULL
)
2582 copy_loops (id
, entry_block_map
->loop_father
,
2583 get_loop (src_cfun
, 0));
2584 /* Defer to cfgcleanup to update loop-father fields of basic-blocks. */
2585 loops_state_set (LOOPS_NEED_FIXUP
);
2588 /* If the loop tree in the source function needed fixup, mark the
2589 destination loop tree for fixup, too. */
2590 if (loops_for_fn (src_cfun
)->state
& LOOPS_NEED_FIXUP
)
2591 loops_state_set (LOOPS_NEED_FIXUP
);
2593 if (gimple_in_ssa_p (cfun
))
2594 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2595 if (!id
->blocks_to_copy
2596 || (bb
->index
> 0 && bitmap_bit_p (id
->blocks_to_copy
, bb
->index
)))
2597 copy_phis_for_bb (bb
, id
);
2599 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2602 if (need_debug_cleanup
2603 && bb
->index
!= ENTRY_BLOCK
2604 && bb
->index
!= EXIT_BLOCK
)
2605 maybe_move_debug_stmts_to_successors (id
, (basic_block
) bb
->aux
);
2606 /* Update call edge destinations. This can not be done before loop
2607 info is updated, because we may split basic blocks. */
2608 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
)
2609 redirect_all_calls (id
, (basic_block
)bb
->aux
);
2610 ((basic_block
)bb
->aux
)->aux
= NULL
;
2614 /* Zero out AUX fields of newly created block during EH edge
2616 for (; last
< last_basic_block_for_fn (cfun
); last
++)
2618 if (need_debug_cleanup
)
2619 maybe_move_debug_stmts_to_successors (id
,
2620 BASIC_BLOCK_FOR_FN (cfun
, last
));
2621 BASIC_BLOCK_FOR_FN (cfun
, last
)->aux
= NULL
;
2622 /* Update call edge destinations. This can not be done before loop
2623 info is updated, because we may split basic blocks. */
2624 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
)
2625 redirect_all_calls (id
, BASIC_BLOCK_FOR_FN (cfun
, last
));
2627 entry_block_map
->aux
= NULL
;
2628 exit_block_map
->aux
= NULL
;
2639 /* Copy the debug STMT using ID. We deal with these statements in a
2640 special way: if any variable in their VALUE expression wasn't
2641 remapped yet, we won't remap it, because that would get decl uids
2642 out of sync, causing codegen differences between -g and -g0. If
2643 this arises, we drop the VALUE expression altogether. */
2646 copy_debug_stmt (gimple stmt
, copy_body_data
*id
)
2649 struct walk_stmt_info wi
;
2651 if (gimple_block (stmt
))
2653 n
= id
->decl_map
->get (gimple_block (stmt
));
2654 gimple_set_block (stmt
, n
? *n
: id
->block
);
2657 /* Remap all the operands in COPY. */
2658 memset (&wi
, 0, sizeof (wi
));
2661 processing_debug_stmt
= 1;
2663 if (gimple_debug_source_bind_p (stmt
))
2664 t
= gimple_debug_source_bind_get_var (stmt
);
2666 t
= gimple_debug_bind_get_var (stmt
);
2668 if (TREE_CODE (t
) == PARM_DECL
&& id
->debug_map
2669 && (n
= id
->debug_map
->get (t
)))
2671 gcc_assert (TREE_CODE (*n
) == VAR_DECL
);
2674 else if (TREE_CODE (t
) == VAR_DECL
2675 && !is_global_var (t
)
2676 && !id
->decl_map
->get (t
))
2677 /* T is a non-localized variable. */;
2679 walk_tree (&t
, remap_gimple_op_r
, &wi
, NULL
);
2681 if (gimple_debug_bind_p (stmt
))
2683 gimple_debug_bind_set_var (stmt
, t
);
2685 if (gimple_debug_bind_has_value_p (stmt
))
2686 walk_tree (gimple_debug_bind_get_value_ptr (stmt
),
2687 remap_gimple_op_r
, &wi
, NULL
);
2689 /* Punt if any decl couldn't be remapped. */
2690 if (processing_debug_stmt
< 0)
2691 gimple_debug_bind_reset_value (stmt
);
2693 else if (gimple_debug_source_bind_p (stmt
))
2695 gimple_debug_source_bind_set_var (stmt
, t
);
2696 walk_tree (gimple_debug_source_bind_get_value_ptr (stmt
),
2697 remap_gimple_op_r
, &wi
, NULL
);
2698 /* When inlining and source bind refers to one of the optimized
2699 away parameters, change the source bind into normal debug bind
2700 referring to the corresponding DEBUG_EXPR_DECL that should have
2701 been bound before the call stmt. */
2702 t
= gimple_debug_source_bind_get_value (stmt
);
2704 && TREE_CODE (t
) == PARM_DECL
2707 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (id
->src_fn
);
2709 if (debug_args
!= NULL
)
2711 for (i
= 0; i
< vec_safe_length (*debug_args
); i
+= 2)
2712 if ((**debug_args
)[i
] == DECL_ORIGIN (t
)
2713 && TREE_CODE ((**debug_args
)[i
+ 1]) == DEBUG_EXPR_DECL
)
2715 t
= (**debug_args
)[i
+ 1];
2716 stmt
->subcode
= GIMPLE_DEBUG_BIND
;
2717 gimple_debug_bind_set_value (stmt
, t
);
2724 processing_debug_stmt
= 0;
2729 /* Process deferred debug stmts. In order to give values better odds
2730 of being successfully remapped, we delay the processing of debug
2731 stmts until all other stmts that might require remapping are
2735 copy_debug_stmts (copy_body_data
*id
)
2740 if (!id
->debug_stmts
.exists ())
2743 FOR_EACH_VEC_ELT (id
->debug_stmts
, i
, stmt
)
2744 copy_debug_stmt (stmt
, id
);
2746 id
->debug_stmts
.release ();
2749 /* Make a copy of the body of SRC_FN so that it can be inserted inline in
2750 another function. */
2753 copy_tree_body (copy_body_data
*id
)
2755 tree fndecl
= id
->src_fn
;
2756 tree body
= DECL_SAVED_TREE (fndecl
);
2758 walk_tree (&body
, copy_tree_body_r
, id
, NULL
);
2763 /* Make a copy of the body of FN so that it can be inserted inline in
2764 another function. */
2767 copy_body (copy_body_data
*id
, gcov_type count
, int frequency_scale
,
2768 basic_block entry_block_map
, basic_block exit_block_map
,
2769 basic_block new_entry
)
2771 tree fndecl
= id
->src_fn
;
2774 /* If this body has a CFG, walk CFG and copy. */
2775 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (fndecl
)));
2776 body
= copy_cfg_body (id
, count
, frequency_scale
, entry_block_map
, exit_block_map
,
2778 copy_debug_stmts (id
);
2783 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
2784 defined in function FN, or of a data member thereof. */
2787 self_inlining_addr_expr (tree value
, tree fn
)
2791 if (TREE_CODE (value
) != ADDR_EXPR
)
2794 var
= get_base_address (TREE_OPERAND (value
, 0));
2796 return var
&& auto_var_in_fn_p (var
, fn
);
2799 /* Append to BB a debug annotation that binds VAR to VALUE, inheriting
2800 lexical block and line number information from base_stmt, if given,
2801 or from the last stmt of the block otherwise. */
2804 insert_init_debug_bind (copy_body_data
*id
,
2805 basic_block bb
, tree var
, tree value
,
2809 gimple_stmt_iterator gsi
;
2812 if (!gimple_in_ssa_p (id
->src_cfun
))
2815 if (!MAY_HAVE_DEBUG_STMTS
)
2818 tracked_var
= target_for_debug_bind (var
);
2824 gsi
= gsi_last_bb (bb
);
2825 if (!base_stmt
&& !gsi_end_p (gsi
))
2826 base_stmt
= gsi_stmt (gsi
);
2829 note
= gimple_build_debug_bind (tracked_var
, value
, base_stmt
);
2833 if (!gsi_end_p (gsi
))
2834 gsi_insert_after (&gsi
, note
, GSI_SAME_STMT
);
2836 gsi_insert_before (&gsi
, note
, GSI_SAME_STMT
);
2843 insert_init_stmt (copy_body_data
*id
, basic_block bb
, gimple init_stmt
)
2845 /* If VAR represents a zero-sized variable, it's possible that the
2846 assignment statement may result in no gimple statements. */
2849 gimple_stmt_iterator si
= gsi_last_bb (bb
);
2851 /* We can end up with init statements that store to a non-register
2852 from a rhs with a conversion. Handle that here by forcing the
2853 rhs into a temporary. gimple_regimplify_operands is not
2854 prepared to do this for us. */
2855 if (!is_gimple_debug (init_stmt
)
2856 && !is_gimple_reg (gimple_assign_lhs (init_stmt
))
2857 && is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (init_stmt
)))
2858 && gimple_assign_rhs_class (init_stmt
) == GIMPLE_UNARY_RHS
)
2860 tree rhs
= build1 (gimple_assign_rhs_code (init_stmt
),
2861 gimple_expr_type (init_stmt
),
2862 gimple_assign_rhs1 (init_stmt
));
2863 rhs
= force_gimple_operand_gsi (&si
, rhs
, true, NULL_TREE
, false,
2865 gimple_assign_set_rhs_code (init_stmt
, TREE_CODE (rhs
));
2866 gimple_assign_set_rhs1 (init_stmt
, rhs
);
2868 gsi_insert_after (&si
, init_stmt
, GSI_NEW_STMT
);
2869 gimple_regimplify_operands (init_stmt
, &si
);
2871 if (!is_gimple_debug (init_stmt
) && MAY_HAVE_DEBUG_STMTS
)
2873 tree def
= gimple_assign_lhs (init_stmt
);
2874 insert_init_debug_bind (id
, bb
, def
, def
, init_stmt
);
2879 /* Initialize parameter P with VALUE. If needed, produce init statement
2880 at the end of BB. When BB is NULL, we return init statement to be
2883 setup_one_parameter (copy_body_data
*id
, tree p
, tree value
, tree fn
,
2884 basic_block bb
, tree
*vars
)
2886 gimple init_stmt
= NULL
;
2889 tree def
= (gimple_in_ssa_p (cfun
)
2890 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
2893 && value
!= error_mark_node
2894 && !useless_type_conversion_p (TREE_TYPE (p
), TREE_TYPE (value
)))
2896 /* If we can match up types by promotion/demotion do so. */
2897 if (fold_convertible_p (TREE_TYPE (p
), value
))
2898 rhs
= fold_convert (TREE_TYPE (p
), value
);
2901 /* ??? For valid programs we should not end up here.
2902 Still if we end up with truly mismatched types here, fall back
2903 to using a VIEW_CONVERT_EXPR or a literal zero to not leak invalid
2904 GIMPLE to the following passes. */
2905 if (!is_gimple_reg_type (TREE_TYPE (value
))
2906 || TYPE_SIZE (TREE_TYPE (p
)) == TYPE_SIZE (TREE_TYPE (value
)))
2907 rhs
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (p
), value
);
2909 rhs
= build_zero_cst (TREE_TYPE (p
));
2913 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
2914 here since the type of this decl must be visible to the calling
2916 var
= copy_decl_to_var (p
, id
);
2918 /* Declare this new variable. */
2919 DECL_CHAIN (var
) = *vars
;
2922 /* Make gimplifier happy about this variable. */
2923 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
2925 /* If the parameter is never assigned to, has no SSA_NAMEs created,
2926 we would not need to create a new variable here at all, if it
2927 weren't for debug info. Still, we can just use the argument
2929 if (TREE_READONLY (p
)
2930 && !TREE_ADDRESSABLE (p
)
2931 && value
&& !TREE_SIDE_EFFECTS (value
)
2934 /* We may produce non-gimple trees by adding NOPs or introduce
2935 invalid sharing when operand is not really constant.
2936 It is not big deal to prohibit constant propagation here as
2937 we will constant propagate in DOM1 pass anyway. */
2938 if (is_gimple_min_invariant (value
)
2939 && useless_type_conversion_p (TREE_TYPE (p
),
2941 /* We have to be very careful about ADDR_EXPR. Make sure
2942 the base variable isn't a local variable of the inlined
2943 function, e.g., when doing recursive inlining, direct or
2944 mutually-recursive or whatever, which is why we don't
2945 just test whether fn == current_function_decl. */
2946 && ! self_inlining_addr_expr (value
, fn
))
2948 insert_decl_map (id
, p
, value
);
2949 insert_debug_decl_map (id
, p
, var
);
2950 return insert_init_debug_bind (id
, bb
, var
, value
, NULL
);
2954 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
2955 that way, when the PARM_DECL is encountered, it will be
2956 automatically replaced by the VAR_DECL. */
2957 insert_decl_map (id
, p
, var
);
2959 /* Even if P was TREE_READONLY, the new VAR should not be.
2960 In the original code, we would have constructed a
2961 temporary, and then the function body would have never
2962 changed the value of P. However, now, we will be
2963 constructing VAR directly. The constructor body may
2964 change its value multiple times as it is being
2965 constructed. Therefore, it must not be TREE_READONLY;
2966 the back-end assumes that TREE_READONLY variable is
2967 assigned to only once. */
2968 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p
)))
2969 TREE_READONLY (var
) = 0;
2971 /* If there is no setup required and we are in SSA, take the easy route
2972 replacing all SSA names representing the function parameter by the
2973 SSA name passed to function.
2975 We need to construct map for the variable anyway as it might be used
2976 in different SSA names when parameter is set in function.
2978 Do replacement at -O0 for const arguments replaced by constant.
2979 This is important for builtin_constant_p and other construct requiring
2980 constant argument to be visible in inlined function body. */
2981 if (gimple_in_ssa_p (cfun
) && rhs
&& def
&& is_gimple_reg (p
)
2983 || (TREE_READONLY (p
)
2984 && is_gimple_min_invariant (rhs
)))
2985 && (TREE_CODE (rhs
) == SSA_NAME
2986 || is_gimple_min_invariant (rhs
))
2987 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
2989 insert_decl_map (id
, def
, rhs
);
2990 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
2993 /* If the value of argument is never used, don't care about initializing
2995 if (optimize
&& gimple_in_ssa_p (cfun
) && !def
&& is_gimple_reg (p
))
2997 gcc_assert (!value
|| !TREE_SIDE_EFFECTS (value
));
2998 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3001 /* Initialize this VAR_DECL from the equivalent argument. Convert
3002 the argument to the proper type in case it was promoted. */
3005 if (rhs
== error_mark_node
)
3007 insert_decl_map (id
, p
, var
);
3008 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3011 STRIP_USELESS_TYPE_CONVERSION (rhs
);
3013 /* If we are in SSA form properly remap the default definition
3014 or assign to a dummy SSA name if the parameter is unused and
3015 we are not optimizing. */
3016 if (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
))
3020 def
= remap_ssa_name (def
, id
);
3021 init_stmt
= gimple_build_assign (def
, rhs
);
3022 SSA_NAME_IS_DEFAULT_DEF (def
) = 0;
3023 set_ssa_default_def (cfun
, var
, NULL
);
3027 def
= make_ssa_name (var
, NULL
);
3028 init_stmt
= gimple_build_assign (def
, rhs
);
3032 init_stmt
= gimple_build_assign (var
, rhs
);
3034 if (bb
&& init_stmt
)
3035 insert_init_stmt (id
, bb
, init_stmt
);
3040 /* Generate code to initialize the parameters of the function at the
3041 top of the stack in ID from the GIMPLE_CALL STMT. */
3044 initialize_inlined_parameters (copy_body_data
*id
, gimple stmt
,
3045 tree fn
, basic_block bb
)
3050 tree vars
= NULL_TREE
;
3051 tree static_chain
= gimple_call_chain (stmt
);
3053 /* Figure out what the parameters are. */
3054 parms
= DECL_ARGUMENTS (fn
);
3056 /* Loop through the parameter declarations, replacing each with an
3057 equivalent VAR_DECL, appropriately initialized. */
3058 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
3061 val
= i
< gimple_call_num_args (stmt
) ? gimple_call_arg (stmt
, i
) : NULL
;
3062 setup_one_parameter (id
, p
, val
, fn
, bb
, &vars
);
3064 /* After remapping parameters remap their types. This has to be done
3065 in a second loop over all parameters to appropriately remap
3066 variable sized arrays when the size is specified in a
3067 parameter following the array. */
3068 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
3070 tree
*varp
= id
->decl_map
->get (p
);
3072 && TREE_CODE (*varp
) == VAR_DECL
)
3074 tree def
= (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
)
3075 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
3077 TREE_TYPE (var
) = remap_type (TREE_TYPE (var
), id
);
3078 /* Also remap the default definition if it was remapped
3079 to the default definition of the parameter replacement
3080 by the parameter setup. */
3083 tree
*defp
= id
->decl_map
->get (def
);
3085 && TREE_CODE (*defp
) == SSA_NAME
3086 && SSA_NAME_VAR (*defp
) == var
)
3087 TREE_TYPE (*defp
) = TREE_TYPE (var
);
3092 /* Initialize the static chain. */
3093 p
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
3094 gcc_assert (fn
!= current_function_decl
);
3097 /* No static chain? Seems like a bug in tree-nested.c. */
3098 gcc_assert (static_chain
);
3100 setup_one_parameter (id
, p
, static_chain
, fn
, bb
, &vars
);
3103 declare_inline_vars (id
->block
, vars
);
3107 /* Declare a return variable to replace the RESULT_DECL for the
3108 function we are calling. An appropriate DECL_STMT is returned.
3109 The USE_STMT is filled to contain a use of the declaration to
3110 indicate the return value of the function.
3112 RETURN_SLOT, if non-null is place where to store the result. It
3113 is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null,
3114 was the LHS of the MODIFY_EXPR to which this call is the RHS.
3116 The return value is a (possibly null) value that holds the result
3117 as seen by the caller. */
3120 declare_return_variable (copy_body_data
*id
, tree return_slot
, tree modify_dest
,
3121 basic_block entry_bb
)
3123 tree callee
= id
->src_fn
;
3124 tree result
= DECL_RESULT (callee
);
3125 tree callee_type
= TREE_TYPE (result
);
3129 /* Handle type-mismatches in the function declaration return type
3130 vs. the call expression. */
3132 caller_type
= TREE_TYPE (modify_dest
);
3134 caller_type
= TREE_TYPE (TREE_TYPE (callee
));
3136 /* We don't need to do anything for functions that don't return anything. */
3137 if (VOID_TYPE_P (callee_type
))
3140 /* If there was a return slot, then the return value is the
3141 dereferenced address of that object. */
3144 /* The front end shouldn't have used both return_slot and
3145 a modify expression. */
3146 gcc_assert (!modify_dest
);
3147 if (DECL_BY_REFERENCE (result
))
3149 tree return_slot_addr
= build_fold_addr_expr (return_slot
);
3150 STRIP_USELESS_TYPE_CONVERSION (return_slot_addr
);
3152 /* We are going to construct *&return_slot and we can't do that
3153 for variables believed to be not addressable.
3155 FIXME: This check possibly can match, because values returned
3156 via return slot optimization are not believed to have address
3157 taken by alias analysis. */
3158 gcc_assert (TREE_CODE (return_slot
) != SSA_NAME
);
3159 var
= return_slot_addr
;
3164 gcc_assert (TREE_CODE (var
) != SSA_NAME
);
3165 if (TREE_ADDRESSABLE (result
))
3166 mark_addressable (var
);
3168 if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
3169 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
3170 && !DECL_GIMPLE_REG_P (result
)
3172 DECL_GIMPLE_REG_P (var
) = 0;
3177 /* All types requiring non-trivial constructors should have been handled. */
3178 gcc_assert (!TREE_ADDRESSABLE (callee_type
));
3180 /* Attempt to avoid creating a new temporary variable. */
3182 && TREE_CODE (modify_dest
) != SSA_NAME
)
3184 bool use_it
= false;
3186 /* We can't use MODIFY_DEST if there's type promotion involved. */
3187 if (!useless_type_conversion_p (callee_type
, caller_type
))
3190 /* ??? If we're assigning to a variable sized type, then we must
3191 reuse the destination variable, because we've no good way to
3192 create variable sized temporaries at this point. */
3193 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type
)) != INTEGER_CST
)
3196 /* If the callee cannot possibly modify MODIFY_DEST, then we can
3197 reuse it as the result of the call directly. Don't do this if
3198 it would promote MODIFY_DEST to addressable. */
3199 else if (TREE_ADDRESSABLE (result
))
3203 tree base_m
= get_base_address (modify_dest
);
3205 /* If the base isn't a decl, then it's a pointer, and we don't
3206 know where that's going to go. */
3207 if (!DECL_P (base_m
))
3209 else if (is_global_var (base_m
))
3211 else if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
3212 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
3213 && !DECL_GIMPLE_REG_P (result
)
3214 && DECL_GIMPLE_REG_P (base_m
))
3216 else if (!TREE_ADDRESSABLE (base_m
))
3228 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type
)) == INTEGER_CST
);
3230 var
= copy_result_decl_to_var (result
, id
);
3231 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
3233 /* Do not have the rest of GCC warn about this variable as it should
3234 not be visible to the user. */
3235 TREE_NO_WARNING (var
) = 1;
3237 declare_inline_vars (id
->block
, var
);
3239 /* Build the use expr. If the return type of the function was
3240 promoted, convert it back to the expected type. */
3242 if (!useless_type_conversion_p (caller_type
, TREE_TYPE (var
)))
3244 /* If we can match up types by promotion/demotion do so. */
3245 if (fold_convertible_p (caller_type
, var
))
3246 use
= fold_convert (caller_type
, var
);
3249 /* ??? For valid programs we should not end up here.
3250 Still if we end up with truly mismatched types here, fall back
3251 to using a MEM_REF to not leak invalid GIMPLE to the following
3253 /* Prevent var from being written into SSA form. */
3254 if (TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
3255 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
)
3256 DECL_GIMPLE_REG_P (var
) = false;
3257 else if (is_gimple_reg_type (TREE_TYPE (var
)))
3258 TREE_ADDRESSABLE (var
) = true;
3259 use
= fold_build2 (MEM_REF
, caller_type
,
3260 build_fold_addr_expr (var
),
3261 build_int_cst (ptr_type_node
, 0));
3265 STRIP_USELESS_TYPE_CONVERSION (use
);
3267 if (DECL_BY_REFERENCE (result
))
3269 TREE_ADDRESSABLE (var
) = 1;
3270 var
= build_fold_addr_expr (var
);
3274 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
3275 way, when the RESULT_DECL is encountered, it will be
3276 automatically replaced by the VAR_DECL.
3278 When returning by reference, ensure that RESULT_DECL remaps to
3280 if (DECL_BY_REFERENCE (result
)
3281 && !is_gimple_val (var
))
3283 tree temp
= create_tmp_var (TREE_TYPE (result
), "retvalptr");
3284 insert_decl_map (id
, result
, temp
);
3285 /* When RESULT_DECL is in SSA form, we need to remap and initialize
3286 it's default_def SSA_NAME. */
3287 if (gimple_in_ssa_p (id
->src_cfun
)
3288 && is_gimple_reg (result
))
3290 temp
= make_ssa_name (temp
, NULL
);
3291 insert_decl_map (id
, ssa_default_def (id
->src_cfun
, result
), temp
);
3293 insert_init_stmt (id
, entry_bb
, gimple_build_assign (temp
, var
));
3296 insert_decl_map (id
, result
, var
);
3298 /* Remember this so we can ignore it in remap_decls. */
3304 /* Callback through walk_tree. Determine if a DECL_INITIAL makes reference
3305 to a local label. */
3308 has_label_address_in_static_1 (tree
*nodep
, int *walk_subtrees
, void *fnp
)
3311 tree fn
= (tree
) fnp
;
3313 if (TREE_CODE (node
) == LABEL_DECL
&& DECL_CONTEXT (node
) == fn
)
3322 /* Determine if the function can be copied. If so return NULL. If
3323 not return a string describng the reason for failure. */
3326 copy_forbidden (struct function
*fun
, tree fndecl
)
3328 const char *reason
= fun
->cannot_be_copied_reason
;
3332 /* Only examine the function once. */
3333 if (fun
->cannot_be_copied_set
)
3336 /* We cannot copy a function that receives a non-local goto
3337 because we cannot remap the destination label used in the
3338 function that is performing the non-local goto. */
3339 /* ??? Actually, this should be possible, if we work at it.
3340 No doubt there's just a handful of places that simply
3341 assume it doesn't happen and don't substitute properly. */
3342 if (fun
->has_nonlocal_label
)
3344 reason
= G_("function %q+F can never be copied "
3345 "because it receives a non-local goto");
3349 FOR_EACH_LOCAL_DECL (fun
, ix
, decl
)
3350 if (TREE_CODE (decl
) == VAR_DECL
3351 && TREE_STATIC (decl
)
3352 && !DECL_EXTERNAL (decl
)
3353 && DECL_INITIAL (decl
)
3354 && walk_tree_without_duplicates (&DECL_INITIAL (decl
),
3355 has_label_address_in_static_1
,
3358 reason
= G_("function %q+F can never be copied because it saves "
3359 "address of local label in a static variable");
3364 fun
->cannot_be_copied_reason
= reason
;
3365 fun
->cannot_be_copied_set
= true;
3370 static const char *inline_forbidden_reason
;
3372 /* A callback for walk_gimple_seq to handle statements. Returns non-null
3373 iff a function can not be inlined. Also sets the reason why. */
3376 inline_forbidden_p_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
3377 struct walk_stmt_info
*wip
)
3379 tree fn
= (tree
) wip
->info
;
3381 gimple stmt
= gsi_stmt (*gsi
);
3383 switch (gimple_code (stmt
))
3386 /* Refuse to inline alloca call unless user explicitly forced so as
3387 this may change program's memory overhead drastically when the
3388 function using alloca is called in loop. In GCC present in
3389 SPEC2000 inlining into schedule_block cause it to require 2GB of
3390 RAM instead of 256MB. Don't do so for alloca calls emitted for
3391 VLA objects as those can't cause unbounded growth (they're always
3392 wrapped inside stack_save/stack_restore regions. */
3393 if (gimple_alloca_call_p (stmt
)
3394 && !gimple_call_alloca_for_var_p (stmt
)
3395 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
3397 inline_forbidden_reason
3398 = G_("function %q+F can never be inlined because it uses "
3399 "alloca (override using the always_inline attribute)");
3400 *handled_ops_p
= true;
3404 t
= gimple_call_fndecl (stmt
);
3408 /* We cannot inline functions that call setjmp. */
3409 if (setjmp_call_p (t
))
3411 inline_forbidden_reason
3412 = G_("function %q+F can never be inlined because it uses setjmp");
3413 *handled_ops_p
= true;
3417 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
3418 switch (DECL_FUNCTION_CODE (t
))
3420 /* We cannot inline functions that take a variable number of
3422 case BUILT_IN_VA_START
:
3423 case BUILT_IN_NEXT_ARG
:
3424 case BUILT_IN_VA_END
:
3425 inline_forbidden_reason
3426 = G_("function %q+F can never be inlined because it "
3427 "uses variable argument lists");
3428 *handled_ops_p
= true;
3431 case BUILT_IN_LONGJMP
:
3432 /* We can't inline functions that call __builtin_longjmp at
3433 all. The non-local goto machinery really requires the
3434 destination be in a different function. If we allow the
3435 function calling __builtin_longjmp to be inlined into the
3436 function calling __builtin_setjmp, Things will Go Awry. */
3437 inline_forbidden_reason
3438 = G_("function %q+F can never be inlined because "
3439 "it uses setjmp-longjmp exception handling");
3440 *handled_ops_p
= true;
3443 case BUILT_IN_NONLOCAL_GOTO
:
3445 inline_forbidden_reason
3446 = G_("function %q+F can never be inlined because "
3447 "it uses non-local goto");
3448 *handled_ops_p
= true;
3451 case BUILT_IN_RETURN
:
3452 case BUILT_IN_APPLY_ARGS
:
3453 /* If a __builtin_apply_args caller would be inlined,
3454 it would be saving arguments of the function it has
3455 been inlined into. Similarly __builtin_return would
3456 return from the function the inline has been inlined into. */
3457 inline_forbidden_reason
3458 = G_("function %q+F can never be inlined because "
3459 "it uses __builtin_return or __builtin_apply_args");
3460 *handled_ops_p
= true;
3469 t
= gimple_goto_dest (stmt
);
3471 /* We will not inline a function which uses computed goto. The
3472 addresses of its local labels, which may be tucked into
3473 global storage, are of course not constant across
3474 instantiations, which causes unexpected behavior. */
3475 if (TREE_CODE (t
) != LABEL_DECL
)
3477 inline_forbidden_reason
3478 = G_("function %q+F can never be inlined "
3479 "because it contains a computed goto");
3480 *handled_ops_p
= true;
3489 *handled_ops_p
= false;
3493 /* Return true if FNDECL is a function that cannot be inlined into
3497 inline_forbidden_p (tree fndecl
)
3499 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
3500 struct walk_stmt_info wi
;
3502 bool forbidden_p
= false;
3504 /* First check for shared reasons not to copy the code. */
3505 inline_forbidden_reason
= copy_forbidden (fun
, fndecl
);
3506 if (inline_forbidden_reason
!= NULL
)
3509 /* Next, walk the statements of the function looking for
3510 constraucts we can't handle, or are non-optimal for inlining. */
3511 hash_set
<tree
> visited_nodes
;
3512 memset (&wi
, 0, sizeof (wi
));
3513 wi
.info
= (void *) fndecl
;
3514 wi
.pset
= &visited_nodes
;
3516 FOR_EACH_BB_FN (bb
, fun
)
3519 gimple_seq seq
= bb_seq (bb
);
3520 ret
= walk_gimple_seq (seq
, inline_forbidden_p_stmt
, NULL
, &wi
);
3521 forbidden_p
= (ret
!= NULL
);
3529 /* Return false if the function FNDECL cannot be inlined on account of its
3530 attributes, true otherwise. */
3532 function_attribute_inlinable_p (const_tree fndecl
)
3534 if (targetm
.attribute_table
)
3538 for (a
= DECL_ATTRIBUTES (fndecl
); a
; a
= TREE_CHAIN (a
))
3540 const_tree name
= TREE_PURPOSE (a
);
3543 for (i
= 0; targetm
.attribute_table
[i
].name
!= NULL
; i
++)
3544 if (is_attribute_p (targetm
.attribute_table
[i
].name
, name
))
3545 return targetm
.function_attribute_inlinable_p (fndecl
);
3552 /* Returns nonzero if FN is a function that does not have any
3553 fundamental inline blocking properties. */
3556 tree_inlinable_function_p (tree fn
)
3558 bool inlinable
= true;
3562 /* If we've already decided this function shouldn't be inlined,
3563 there's no need to check again. */
3564 if (DECL_UNINLINABLE (fn
))
3567 /* We only warn for functions declared `inline' by the user. */
3568 do_warning
= (warn_inline
3569 && DECL_DECLARED_INLINE_P (fn
)
3570 && !DECL_NO_INLINE_WARNING_P (fn
)
3571 && !DECL_IN_SYSTEM_HEADER (fn
));
3573 always_inline
= lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
));
3576 && always_inline
== NULL
)
3579 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3580 "is suppressed using -fno-inline", fn
);
3584 else if (!function_attribute_inlinable_p (fn
))
3587 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3588 "uses attributes conflicting with inlining", fn
);
3592 else if (inline_forbidden_p (fn
))
3594 /* See if we should warn about uninlinable functions. Previously,
3595 some of these warnings would be issued while trying to expand
3596 the function inline, but that would cause multiple warnings
3597 about functions that would for example call alloca. But since
3598 this a property of the function, just one warning is enough.
3599 As a bonus we can now give more details about the reason why a
3600 function is not inlinable. */
3602 error (inline_forbidden_reason
, fn
);
3603 else if (do_warning
)
3604 warning (OPT_Winline
, inline_forbidden_reason
, fn
);
3609 /* Squirrel away the result so that we don't have to check again. */
3610 DECL_UNINLINABLE (fn
) = !inlinable
;
3615 /* Estimate the cost of a memory move of type TYPE. Use machine dependent
3616 word size and take possible memcpy call into account and return
3617 cost based on whether optimizing for size or speed according to SPEED_P. */
3620 estimate_move_cost (tree type
, bool ARG_UNUSED (speed_p
))
3624 gcc_assert (!VOID_TYPE_P (type
));
3626 if (TREE_CODE (type
) == VECTOR_TYPE
)
3628 enum machine_mode inner
= TYPE_MODE (TREE_TYPE (type
));
3629 enum machine_mode simd
3630 = targetm
.vectorize
.preferred_simd_mode (inner
);
3631 int simd_mode_size
= GET_MODE_SIZE (simd
);
3632 return ((GET_MODE_SIZE (TYPE_MODE (type
)) + simd_mode_size
- 1)
3636 size
= int_size_in_bytes (type
);
3638 if (size
< 0 || size
> MOVE_MAX_PIECES
* MOVE_RATIO (speed_p
))
3639 /* Cost of a memcpy call, 3 arguments and the call. */
3642 return ((size
+ MOVE_MAX_PIECES
- 1) / MOVE_MAX_PIECES
);
3645 /* Returns cost of operation CODE, according to WEIGHTS */
3648 estimate_operator_cost (enum tree_code code
, eni_weights
*weights
,
3649 tree op1 ATTRIBUTE_UNUSED
, tree op2
)
3653 /* These are "free" conversions, or their presumed cost
3654 is folded into other operations. */
3659 case VIEW_CONVERT_EXPR
:
3662 /* Assign cost of 1 to usual operations.
3663 ??? We may consider mapping RTL costs to this. */
3669 case POINTER_PLUS_EXPR
:
3672 case MULT_HIGHPART_EXPR
:
3675 case ADDR_SPACE_CONVERT_EXPR
:
3676 case FIXED_CONVERT_EXPR
:
3677 case FIX_TRUNC_EXPR
:
3689 case VEC_LSHIFT_EXPR
:
3690 case VEC_RSHIFT_EXPR
:
3697 case TRUTH_ANDIF_EXPR
:
3698 case TRUTH_ORIF_EXPR
:
3699 case TRUTH_AND_EXPR
:
3701 case TRUTH_XOR_EXPR
:
3702 case TRUTH_NOT_EXPR
:
3711 case UNORDERED_EXPR
:
3722 case PREDECREMENT_EXPR
:
3723 case PREINCREMENT_EXPR
:
3724 case POSTDECREMENT_EXPR
:
3725 case POSTINCREMENT_EXPR
:
3727 case REALIGN_LOAD_EXPR
:
3729 case REDUC_MAX_EXPR
:
3730 case REDUC_MIN_EXPR
:
3731 case REDUC_PLUS_EXPR
:
3732 case WIDEN_SUM_EXPR
:
3733 case WIDEN_MULT_EXPR
:
3736 case WIDEN_MULT_PLUS_EXPR
:
3737 case WIDEN_MULT_MINUS_EXPR
:
3738 case WIDEN_LSHIFT_EXPR
:
3740 case VEC_WIDEN_MULT_HI_EXPR
:
3741 case VEC_WIDEN_MULT_LO_EXPR
:
3742 case VEC_WIDEN_MULT_EVEN_EXPR
:
3743 case VEC_WIDEN_MULT_ODD_EXPR
:
3744 case VEC_UNPACK_HI_EXPR
:
3745 case VEC_UNPACK_LO_EXPR
:
3746 case VEC_UNPACK_FLOAT_HI_EXPR
:
3747 case VEC_UNPACK_FLOAT_LO_EXPR
:
3748 case VEC_PACK_TRUNC_EXPR
:
3749 case VEC_PACK_SAT_EXPR
:
3750 case VEC_PACK_FIX_TRUNC_EXPR
:
3751 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3752 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3756 /* Few special cases of expensive operations. This is useful
3757 to avoid inlining on functions having too many of these. */
3758 case TRUNC_DIV_EXPR
:
3760 case FLOOR_DIV_EXPR
:
3761 case ROUND_DIV_EXPR
:
3762 case EXACT_DIV_EXPR
:
3763 case TRUNC_MOD_EXPR
:
3765 case FLOOR_MOD_EXPR
:
3766 case ROUND_MOD_EXPR
:
3768 if (TREE_CODE (op2
) != INTEGER_CST
)
3769 return weights
->div_mod_cost
;
3773 /* We expect a copy assignment with no operator. */
3774 gcc_assert (get_gimple_rhs_class (code
) == GIMPLE_SINGLE_RHS
);
3780 /* Estimate number of instructions that will be created by expanding
3781 the statements in the statement sequence STMTS.
3782 WEIGHTS contains weights attributed to various constructs. */
3785 int estimate_num_insns_seq (gimple_seq stmts
, eni_weights
*weights
)
3788 gimple_stmt_iterator gsi
;
3791 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3792 cost
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
3798 /* Estimate number of instructions that will be created by expanding STMT.
3799 WEIGHTS contains weights attributed to various constructs. */
3802 estimate_num_insns (gimple stmt
, eni_weights
*weights
)
3805 enum gimple_code code
= gimple_code (stmt
);
3812 /* Try to estimate the cost of assignments. We have three cases to
3814 1) Simple assignments to registers;
3815 2) Stores to things that must live in memory. This includes
3816 "normal" stores to scalars, but also assignments of large
3817 structures, or constructors of big arrays;
3819 Let us look at the first two cases, assuming we have "a = b + C":
3820 <GIMPLE_ASSIGN <var_decl "a">
3821 <plus_expr <var_decl "b"> <constant C>>
3822 If "a" is a GIMPLE register, the assignment to it is free on almost
3823 any target, because "a" usually ends up in a real register. Hence
3824 the only cost of this expression comes from the PLUS_EXPR, and we
3825 can ignore the GIMPLE_ASSIGN.
3826 If "a" is not a GIMPLE register, the assignment to "a" will most
3827 likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost
3828 of moving something into "a", which we compute using the function
3829 estimate_move_cost. */
3830 if (gimple_clobber_p (stmt
))
3831 return 0; /* ={v} {CLOBBER} stmt expands to nothing. */
3833 lhs
= gimple_assign_lhs (stmt
);
3834 rhs
= gimple_assign_rhs1 (stmt
);
3838 /* Account for the cost of moving to / from memory. */
3839 if (gimple_store_p (stmt
))
3840 cost
+= estimate_move_cost (TREE_TYPE (lhs
), weights
->time_based
);
3841 if (gimple_assign_load_p (stmt
))
3842 cost
+= estimate_move_cost (TREE_TYPE (rhs
), weights
->time_based
);
3844 cost
+= estimate_operator_cost (gimple_assign_rhs_code (stmt
), weights
,
3845 gimple_assign_rhs1 (stmt
),
3846 get_gimple_rhs_class (gimple_assign_rhs_code (stmt
))
3847 == GIMPLE_BINARY_RHS
3848 ? gimple_assign_rhs2 (stmt
) : NULL
);
3852 cost
= 1 + estimate_operator_cost (gimple_cond_code (stmt
), weights
,
3853 gimple_op (stmt
, 0),
3854 gimple_op (stmt
, 1));
3858 /* Take into account cost of the switch + guess 2 conditional jumps for
3861 TODO: once the switch expansion logic is sufficiently separated, we can
3862 do better job on estimating cost of the switch. */
3863 if (weights
->time_based
)
3864 cost
= floor_log2 (gimple_switch_num_labels (stmt
)) * 2;
3866 cost
= gimple_switch_num_labels (stmt
) * 2;
3873 if (gimple_call_internal_p (stmt
))
3875 else if ((decl
= gimple_call_fndecl (stmt
))
3876 && DECL_BUILT_IN (decl
))
3878 /* Do not special case builtins where we see the body.
3879 This just confuse inliner. */
3880 struct cgraph_node
*node
;
3881 if (!(node
= cgraph_node::get (decl
))
3882 || node
->definition
)
3884 /* For buitins that are likely expanded to nothing or
3885 inlined do not account operand costs. */
3886 else if (is_simple_builtin (decl
))
3888 else if (is_inexpensive_builtin (decl
))
3889 return weights
->target_builtin_call_cost
;
3890 else if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
3892 /* We canonicalize x * x to pow (x, 2.0) with -ffast-math, so
3893 specialize the cheap expansion we do here.
3894 ??? This asks for a more general solution. */
3895 switch (DECL_FUNCTION_CODE (decl
))
3900 if (TREE_CODE (gimple_call_arg (stmt
, 1)) == REAL_CST
3901 && REAL_VALUES_EQUAL
3902 (TREE_REAL_CST (gimple_call_arg (stmt
, 1)), dconst2
))
3903 return estimate_operator_cost
3904 (MULT_EXPR
, weights
, gimple_call_arg (stmt
, 0),
3905 gimple_call_arg (stmt
, 0));
3914 cost
= decl
? weights
->call_cost
: weights
->indirect_call_cost
;
3915 if (gimple_call_lhs (stmt
))
3916 cost
+= estimate_move_cost (TREE_TYPE (gimple_call_lhs (stmt
)),
3917 weights
->time_based
);
3918 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
3920 tree arg
= gimple_call_arg (stmt
, i
);
3921 cost
+= estimate_move_cost (TREE_TYPE (arg
),
3922 weights
->time_based
);
3928 return weights
->return_cost
;
3934 case GIMPLE_PREDICT
:
3940 int count
= asm_str_count (gimple_asm_string (stmt
));
3941 /* 1000 means infinity. This avoids overflows later
3942 with very long asm statements. */
3949 /* This is either going to be an external function call with one
3950 argument, or two register copy statements plus a goto. */
3953 case GIMPLE_EH_DISPATCH
:
3954 /* ??? This is going to turn into a switch statement. Ideally
3955 we'd have a look at the eh region and estimate the number of
3960 return estimate_num_insns_seq (gimple_bind_body (stmt
), weights
);
3962 case GIMPLE_EH_FILTER
:
3963 return estimate_num_insns_seq (gimple_eh_filter_failure (stmt
), weights
);
3966 return estimate_num_insns_seq (gimple_catch_handler (stmt
), weights
);
3969 return (estimate_num_insns_seq (gimple_try_eval (stmt
), weights
)
3970 + estimate_num_insns_seq (gimple_try_cleanup (stmt
), weights
));
3972 /* OpenMP directives are generally very expensive. */
3974 case GIMPLE_OMP_RETURN
:
3975 case GIMPLE_OMP_SECTIONS_SWITCH
:
3976 case GIMPLE_OMP_ATOMIC_STORE
:
3977 case GIMPLE_OMP_CONTINUE
:
3978 /* ...except these, which are cheap. */
3981 case GIMPLE_OMP_ATOMIC_LOAD
:
3982 return weights
->omp_cost
;
3984 case GIMPLE_OMP_FOR
:
3985 return (weights
->omp_cost
3986 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
)
3987 + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt
), weights
));
3989 case GIMPLE_OMP_PARALLEL
:
3990 case GIMPLE_OMP_TASK
:
3991 case GIMPLE_OMP_CRITICAL
:
3992 case GIMPLE_OMP_MASTER
:
3993 case GIMPLE_OMP_TASKGROUP
:
3994 case GIMPLE_OMP_ORDERED
:
3995 case GIMPLE_OMP_SECTION
:
3996 case GIMPLE_OMP_SECTIONS
:
3997 case GIMPLE_OMP_SINGLE
:
3998 case GIMPLE_OMP_TARGET
:
3999 case GIMPLE_OMP_TEAMS
:
4000 return (weights
->omp_cost
4001 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
));
4003 case GIMPLE_TRANSACTION
:
4004 return (weights
->tm_cost
4005 + estimate_num_insns_seq (gimple_transaction_body (stmt
),
4015 /* Estimate number of instructions that will be created by expanding
4016 function FNDECL. WEIGHTS contains weights attributed to various
4020 estimate_num_insns_fn (tree fndecl
, eni_weights
*weights
)
4022 struct function
*my_function
= DECL_STRUCT_FUNCTION (fndecl
);
4023 gimple_stmt_iterator bsi
;
4027 gcc_assert (my_function
&& my_function
->cfg
);
4028 FOR_EACH_BB_FN (bb
, my_function
)
4030 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
4031 n
+= estimate_num_insns (gsi_stmt (bsi
), weights
);
4038 /* Initializes weights used by estimate_num_insns. */
4041 init_inline_once (void)
4043 eni_size_weights
.call_cost
= 1;
4044 eni_size_weights
.indirect_call_cost
= 3;
4045 eni_size_weights
.target_builtin_call_cost
= 1;
4046 eni_size_weights
.div_mod_cost
= 1;
4047 eni_size_weights
.omp_cost
= 40;
4048 eni_size_weights
.tm_cost
= 10;
4049 eni_size_weights
.time_based
= false;
4050 eni_size_weights
.return_cost
= 1;
4052 /* Estimating time for call is difficult, since we have no idea what the
4053 called function does. In the current uses of eni_time_weights,
4054 underestimating the cost does less harm than overestimating it, so
4055 we choose a rather small value here. */
4056 eni_time_weights
.call_cost
= 10;
4057 eni_time_weights
.indirect_call_cost
= 15;
4058 eni_time_weights
.target_builtin_call_cost
= 1;
4059 eni_time_weights
.div_mod_cost
= 10;
4060 eni_time_weights
.omp_cost
= 40;
4061 eni_time_weights
.tm_cost
= 40;
4062 eni_time_weights
.time_based
= true;
4063 eni_time_weights
.return_cost
= 2;
4066 /* Estimate the number of instructions in a gimple_seq. */
4069 count_insns_seq (gimple_seq seq
, eni_weights
*weights
)
4071 gimple_stmt_iterator gsi
;
4073 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4074 n
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
4080 /* Install new lexical TREE_BLOCK underneath 'current_block'. */
4083 prepend_lexical_block (tree current_block
, tree new_block
)
4085 BLOCK_CHAIN (new_block
) = BLOCK_SUBBLOCKS (current_block
);
4086 BLOCK_SUBBLOCKS (current_block
) = new_block
;
4087 BLOCK_SUPERCONTEXT (new_block
) = current_block
;
4090 /* Add local variables from CALLEE to CALLER. */
4093 add_local_variables (struct function
*callee
, struct function
*caller
,
4099 FOR_EACH_LOCAL_DECL (callee
, ix
, var
)
4100 if (!can_be_nonlocal (var
, id
))
4102 tree new_var
= remap_decl (var
, id
);
4104 /* Remap debug-expressions. */
4105 if (TREE_CODE (new_var
) == VAR_DECL
4106 && DECL_HAS_DEBUG_EXPR_P (var
)
4109 tree tem
= DECL_DEBUG_EXPR (var
);
4110 bool old_regimplify
= id
->regimplify
;
4111 id
->remapping_type_depth
++;
4112 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
4113 id
->remapping_type_depth
--;
4114 id
->regimplify
= old_regimplify
;
4115 SET_DECL_DEBUG_EXPR (new_var
, tem
);
4116 DECL_HAS_DEBUG_EXPR_P (new_var
) = 1;
4118 add_local_decl (caller
, new_var
);
4122 /* If STMT is a GIMPLE_CALL, replace it with its inline expansion. */
4125 expand_call_inline (basic_block bb
, gimple stmt
, copy_body_data
*id
)
4129 hash_map
<tree
, tree
> *dst
;
4130 hash_map
<tree
, tree
> *st
= NULL
;
4133 location_t saved_location
;
4134 struct cgraph_edge
*cg_edge
;
4135 cgraph_inline_failed_t reason
;
4136 basic_block return_block
;
4138 gimple_stmt_iterator gsi
, stmt_gsi
;
4139 bool successfully_inlined
= FALSE
;
4140 bool purge_dead_abnormal_edges
;
4142 /* Set input_location here so we get the right instantiation context
4143 if we call instantiate_decl from inlinable_function_p. */
4144 /* FIXME: instantiate_decl isn't called by inlinable_function_p. */
4145 saved_location
= input_location
;
4146 input_location
= gimple_location (stmt
);
4148 /* From here on, we're only interested in CALL_EXPRs. */
4149 if (gimple_code (stmt
) != GIMPLE_CALL
)
4152 cg_edge
= id
->dst_node
->get_edge (stmt
);
4153 gcc_checking_assert (cg_edge
);
4154 /* First, see if we can figure out what function is being called.
4155 If we cannot, then there is no hope of inlining the function. */
4156 if (cg_edge
->indirect_unknown_callee
)
4158 fn
= cg_edge
->callee
->decl
;
4159 gcc_checking_assert (fn
);
4161 /* If FN is a declaration of a function in a nested scope that was
4162 globally declared inline, we don't set its DECL_INITIAL.
4163 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
4164 C++ front-end uses it for cdtors to refer to their internal
4165 declarations, that are not real functions. Fortunately those
4166 don't have trees to be saved, so we can tell by checking their
4168 if (!DECL_INITIAL (fn
)
4169 && DECL_ABSTRACT_ORIGIN (fn
)
4170 && gimple_has_body_p (DECL_ABSTRACT_ORIGIN (fn
)))
4171 fn
= DECL_ABSTRACT_ORIGIN (fn
);
4173 /* Don't try to inline functions that are not well-suited to inlining. */
4174 if (cg_edge
->inline_failed
)
4176 reason
= cg_edge
->inline_failed
;
4177 /* If this call was originally indirect, we do not want to emit any
4178 inlining related warnings or sorry messages because there are no
4179 guarantees regarding those. */
4180 if (cg_edge
->indirect_inlining_edge
)
4183 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
))
4184 /* For extern inline functions that get redefined we always
4185 silently ignored always_inline flag. Better behaviour would
4186 be to be able to keep both bodies and use extern inline body
4187 for inlining, but we can't do that because frontends overwrite
4189 && !cg_edge
->callee
->local
.redefined_extern_inline
4190 /* During early inline pass, report only when optimization is
4192 && (symtab
->global_info_ready
4194 || cgraph_inline_failed_type (reason
) == CIF_FINAL_ERROR
)
4195 /* PR 20090218-1_0.c. Body can be provided by another module. */
4196 && (reason
!= CIF_BODY_NOT_AVAILABLE
|| !flag_generate_lto
))
4198 error ("inlining failed in call to always_inline %q+F: %s", fn
,
4199 cgraph_inline_failed_string (reason
));
4200 error ("called from here");
4202 else if (warn_inline
4203 && DECL_DECLARED_INLINE_P (fn
)
4204 && !DECL_NO_INLINE_WARNING_P (fn
)
4205 && !DECL_IN_SYSTEM_HEADER (fn
)
4206 && reason
!= CIF_UNSPECIFIED
4207 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn
))
4208 /* Do not warn about not inlined recursive calls. */
4209 && !cg_edge
->recursive_p ()
4210 /* Avoid warnings during early inline pass. */
4211 && symtab
->global_info_ready
)
4213 warning (OPT_Winline
, "inlining failed in call to %q+F: %s",
4214 fn
, _(cgraph_inline_failed_string (reason
)));
4215 warning (OPT_Winline
, "called from here");
4219 fn
= cg_edge
->callee
->decl
;
4220 cg_edge
->callee
->get_body ();
4222 #ifdef ENABLE_CHECKING
4223 if (cg_edge
->callee
->decl
!= id
->dst_node
->decl
)
4224 cg_edge
->callee
->verify ();
4227 /* We will be inlining this callee. */
4228 id
->eh_lp_nr
= lookup_stmt_eh_lp (stmt
);
4230 /* Update the callers EH personality. */
4231 if (DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->decl
))
4232 DECL_FUNCTION_PERSONALITY (cg_edge
->caller
->decl
)
4233 = DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->decl
);
4235 /* Split the block holding the GIMPLE_CALL. */
4236 e
= split_block (bb
, stmt
);
4238 return_block
= e
->dest
;
4241 /* split_block splits after the statement; work around this by
4242 moving the call into the second block manually. Not pretty,
4243 but seems easier than doing the CFG manipulation by hand
4244 when the GIMPLE_CALL is in the last statement of BB. */
4245 stmt_gsi
= gsi_last_bb (bb
);
4246 gsi_remove (&stmt_gsi
, false);
4248 /* If the GIMPLE_CALL was in the last statement of BB, it may have
4249 been the source of abnormal edges. In this case, schedule
4250 the removal of dead abnormal edges. */
4251 gsi
= gsi_start_bb (return_block
);
4252 if (gsi_end_p (gsi
))
4254 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
4255 purge_dead_abnormal_edges
= true;
4259 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
4260 purge_dead_abnormal_edges
= false;
4263 stmt_gsi
= gsi_start_bb (return_block
);
4265 /* Build a block containing code to initialize the arguments, the
4266 actual inline expansion of the body, and a label for the return
4267 statements within the function to jump to. The type of the
4268 statement expression is the return type of the function call.
4269 ??? If the call does not have an associated block then we will
4270 remap all callee blocks to NULL, effectively dropping most of
4271 its debug information. This should only happen for calls to
4272 artificial decls inserted by the compiler itself. We need to
4273 either link the inlined blocks into the caller block tree or
4274 not refer to them in any way to not break GC for locations. */
4275 if (gimple_block (stmt
))
4277 id
->block
= make_node (BLOCK
);
4278 BLOCK_ABSTRACT_ORIGIN (id
->block
) = fn
;
4279 BLOCK_SOURCE_LOCATION (id
->block
) = LOCATION_LOCUS (input_location
);
4280 prepend_lexical_block (gimple_block (stmt
), id
->block
);
4283 /* Local declarations will be replaced by their equivalents in this
4286 id
->decl_map
= new hash_map
<tree
, tree
>;
4287 dst
= id
->debug_map
;
4288 id
->debug_map
= NULL
;
4290 /* Record the function we are about to inline. */
4292 id
->src_node
= cg_edge
->callee
;
4293 id
->src_cfun
= DECL_STRUCT_FUNCTION (fn
);
4294 id
->gimple_call
= stmt
;
4296 gcc_assert (!id
->src_cfun
->after_inlining
);
4299 if (lookup_attribute ("cold", DECL_ATTRIBUTES (fn
)))
4301 gimple_stmt_iterator si
= gsi_last_bb (bb
);
4302 gsi_insert_after (&si
, gimple_build_predict (PRED_COLD_FUNCTION
,
4306 initialize_inlined_parameters (id
, stmt
, fn
, bb
);
4308 if (DECL_INITIAL (fn
))
4310 if (gimple_block (stmt
))
4314 prepend_lexical_block (id
->block
,
4315 remap_blocks (DECL_INITIAL (fn
), id
));
4316 gcc_checking_assert (BLOCK_SUBBLOCKS (id
->block
)
4317 && (BLOCK_CHAIN (BLOCK_SUBBLOCKS (id
->block
))
4319 /* Move vars for PARM_DECLs from DECL_INITIAL block to id->block,
4320 otherwise for DWARF DW_TAG_formal_parameter will not be children of
4321 DW_TAG_inlined_subroutine, but of a DW_TAG_lexical_block
4322 under it. The parameters can be then evaluated in the debugger,
4323 but don't show in backtraces. */
4324 for (var
= &BLOCK_VARS (BLOCK_SUBBLOCKS (id
->block
)); *var
; )
4325 if (TREE_CODE (DECL_ORIGIN (*var
)) == PARM_DECL
)
4328 *var
= TREE_CHAIN (v
);
4329 TREE_CHAIN (v
) = BLOCK_VARS (id
->block
);
4330 BLOCK_VARS (id
->block
) = v
;
4333 var
= &TREE_CHAIN (*var
);
4336 remap_blocks_to_null (DECL_INITIAL (fn
), id
);
4339 /* Return statements in the function body will be replaced by jumps
4340 to the RET_LABEL. */
4341 gcc_assert (DECL_INITIAL (fn
));
4342 gcc_assert (TREE_CODE (DECL_INITIAL (fn
)) == BLOCK
);
4344 /* Find the LHS to which the result of this call is assigned. */
4346 if (gimple_call_lhs (stmt
))
4348 modify_dest
= gimple_call_lhs (stmt
);
4350 /* The function which we are inlining might not return a value,
4351 in which case we should issue a warning that the function
4352 does not return a value. In that case the optimizers will
4353 see that the variable to which the value is assigned was not
4354 initialized. We do not want to issue a warning about that
4355 uninitialized variable. */
4356 if (DECL_P (modify_dest
))
4357 TREE_NO_WARNING (modify_dest
) = 1;
4359 if (gimple_call_return_slot_opt_p (stmt
))
4361 return_slot
= modify_dest
;
4368 /* If we are inlining a call to the C++ operator new, we don't want
4369 to use type based alias analysis on the return value. Otherwise
4370 we may get confused if the compiler sees that the inlined new
4371 function returns a pointer which was just deleted. See bug
4373 if (DECL_IS_OPERATOR_NEW (fn
))
4379 /* Declare the return variable for the function. */
4380 use_retvar
= declare_return_variable (id
, return_slot
, modify_dest
, bb
);
4382 /* Add local vars in this inlined callee to caller. */
4383 add_local_variables (id
->src_cfun
, cfun
, id
);
4385 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4387 fprintf (dump_file
, "Inlining ");
4388 print_generic_expr (dump_file
, id
->src_fn
, 0);
4389 fprintf (dump_file
, " to ");
4390 print_generic_expr (dump_file
, id
->dst_fn
, 0);
4391 fprintf (dump_file
, " with frequency %i\n", cg_edge
->frequency
);
4394 /* This is it. Duplicate the callee body. Assume callee is
4395 pre-gimplified. Note that we must not alter the caller
4396 function in any way before this point, as this CALL_EXPR may be
4397 a self-referential call; if we're calling ourselves, we need to
4398 duplicate our body before altering anything. */
4399 copy_body (id
, cg_edge
->callee
->count
,
4400 GCOV_COMPUTE_SCALE (cg_edge
->frequency
, CGRAPH_FREQ_BASE
),
4401 bb
, return_block
, NULL
);
4403 /* Reset the escaped solution. */
4404 if (cfun
->gimple_df
)
4405 pt_solution_reset (&cfun
->gimple_df
->escaped
);
4410 delete id
->debug_map
;
4411 id
->debug_map
= dst
;
4413 delete id
->decl_map
;
4416 /* Unlink the calls virtual operands before replacing it. */
4417 unlink_stmt_vdef (stmt
);
4418 if (gimple_vdef (stmt
)
4419 && TREE_CODE (gimple_vdef (stmt
)) == SSA_NAME
)
4420 release_ssa_name (gimple_vdef (stmt
));
4422 /* If the inlined function returns a result that we care about,
4423 substitute the GIMPLE_CALL with an assignment of the return
4424 variable to the LHS of the call. That is, if STMT was
4425 'a = foo (...)', substitute the call with 'a = USE_RETVAR'. */
4426 if (use_retvar
&& gimple_call_lhs (stmt
))
4428 gimple old_stmt
= stmt
;
4429 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), use_retvar
);
4430 gsi_replace (&stmt_gsi
, stmt
, false);
4431 maybe_clean_or_replace_eh_stmt (old_stmt
, stmt
);
4435 /* Handle the case of inlining a function with no return
4436 statement, which causes the return value to become undefined. */
4437 if (gimple_call_lhs (stmt
)
4438 && TREE_CODE (gimple_call_lhs (stmt
)) == SSA_NAME
)
4440 tree name
= gimple_call_lhs (stmt
);
4441 tree var
= SSA_NAME_VAR (name
);
4442 tree def
= ssa_default_def (cfun
, var
);
4446 /* If the variable is used undefined, make this name
4447 undefined via a move. */
4448 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), def
);
4449 gsi_replace (&stmt_gsi
, stmt
, true);
4453 /* Otherwise make this variable undefined. */
4454 gsi_remove (&stmt_gsi
, true);
4455 set_ssa_default_def (cfun
, var
, name
);
4456 SSA_NAME_DEF_STMT (name
) = gimple_build_nop ();
4460 gsi_remove (&stmt_gsi
, true);
4463 if (purge_dead_abnormal_edges
)
4465 gimple_purge_dead_eh_edges (return_block
);
4466 gimple_purge_dead_abnormal_call_edges (return_block
);
4469 /* If the value of the new expression is ignored, that's OK. We
4470 don't warn about this for CALL_EXPRs, so we shouldn't warn about
4471 the equivalent inlined version either. */
4472 if (is_gimple_assign (stmt
))
4474 gcc_assert (gimple_assign_single_p (stmt
)
4475 || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
)));
4476 TREE_USED (gimple_assign_rhs1 (stmt
)) = 1;
4479 /* Output the inlining info for this abstract function, since it has been
4480 inlined. If we don't do this now, we can lose the information about the
4481 variables in the function when the blocks get blown away as soon as we
4482 remove the cgraph node. */
4483 if (gimple_block (stmt
))
4484 (*debug_hooks
->outlining_inline_function
) (cg_edge
->callee
->decl
);
4486 /* Update callgraph if needed. */
4487 cg_edge
->callee
->remove ();
4489 id
->block
= NULL_TREE
;
4490 successfully_inlined
= TRUE
;
4493 input_location
= saved_location
;
4494 return successfully_inlined
;
4497 /* Expand call statements reachable from STMT_P.
4498 We can only have CALL_EXPRs as the "toplevel" tree code or nested
4499 in a MODIFY_EXPR. */
4502 gimple_expand_calls_inline (basic_block bb
, copy_body_data
*id
)
4504 gimple_stmt_iterator gsi
;
4506 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4508 gimple stmt
= gsi_stmt (gsi
);
4510 if (is_gimple_call (stmt
)
4511 && !gimple_call_internal_p (stmt
)
4512 && expand_call_inline (bb
, stmt
, id
))
4520 /* Walk all basic blocks created after FIRST and try to fold every statement
4521 in the STATEMENTS pointer set. */
4524 fold_marked_statements (int first
, hash_set
<gimple
> *statements
)
4526 for (; first
< n_basic_blocks_for_fn (cfun
); first
++)
4527 if (BASIC_BLOCK_FOR_FN (cfun
, first
))
4529 gimple_stmt_iterator gsi
;
4531 for (gsi
= gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, first
));
4534 if (statements
->contains (gsi_stmt (gsi
)))
4536 gimple old_stmt
= gsi_stmt (gsi
);
4537 tree old_decl
= is_gimple_call (old_stmt
) ? gimple_call_fndecl (old_stmt
) : 0;
4539 if (old_decl
&& DECL_BUILT_IN (old_decl
))
4541 /* Folding builtins can create multiple instructions,
4542 we need to look at all of them. */
4543 gimple_stmt_iterator i2
= gsi
;
4545 if (fold_stmt (&gsi
))
4548 /* If a builtin at the end of a bb folded into nothing,
4549 the following loop won't work. */
4550 if (gsi_end_p (gsi
))
4552 cgraph_update_edges_for_call_stmt (old_stmt
,
4557 i2
= gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, first
));
4562 new_stmt
= gsi_stmt (i2
);
4563 update_stmt (new_stmt
);
4564 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4567 if (new_stmt
== gsi_stmt (gsi
))
4569 /* It is okay to check only for the very last
4570 of these statements. If it is a throwing
4571 statement nothing will change. If it isn't
4572 this can remove EH edges. If that weren't
4573 correct then because some intermediate stmts
4574 throw, but not the last one. That would mean
4575 we'd have to split the block, which we can't
4576 here and we'd loose anyway. And as builtins
4577 probably never throw, this all
4579 if (maybe_clean_or_replace_eh_stmt (old_stmt
,
4581 gimple_purge_dead_eh_edges (
4582 BASIC_BLOCK_FOR_FN (cfun
, first
));
4589 else if (fold_stmt (&gsi
))
4591 /* Re-read the statement from GSI as fold_stmt() may
4593 gimple new_stmt
= gsi_stmt (gsi
);
4594 update_stmt (new_stmt
);
4596 if (is_gimple_call (old_stmt
)
4597 || is_gimple_call (new_stmt
))
4598 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4601 if (maybe_clean_or_replace_eh_stmt (old_stmt
, new_stmt
))
4602 gimple_purge_dead_eh_edges (BASIC_BLOCK_FOR_FN (cfun
,
4609 /* Expand calls to inline functions in the body of FN. */
4612 optimize_inline_calls (tree fn
)
4616 int last
= n_basic_blocks_for_fn (cfun
);
4617 bool inlined_p
= false;
4620 memset (&id
, 0, sizeof (id
));
4622 id
.src_node
= id
.dst_node
= cgraph_node::get (fn
);
4623 gcc_assert (id
.dst_node
->definition
);
4625 /* Or any functions that aren't finished yet. */
4626 if (current_function_decl
)
4627 id
.dst_fn
= current_function_decl
;
4629 id
.copy_decl
= copy_decl_maybe_to_var
;
4630 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
4631 id
.transform_new_cfg
= false;
4632 id
.transform_return_to_modify
= true;
4633 id
.transform_parameter
= true;
4634 id
.transform_lang_insert_block
= NULL
;
4635 id
.statements_to_fold
= new hash_set
<gimple
>;
4637 push_gimplify_context ();
4639 /* We make no attempts to keep dominance info up-to-date. */
4640 free_dominance_info (CDI_DOMINATORS
);
4641 free_dominance_info (CDI_POST_DOMINATORS
);
4643 /* Register specific gimple functions. */
4644 gimple_register_cfg_hooks ();
4646 /* Reach the trees by walking over the CFG, and note the
4647 enclosing basic-blocks in the call edges. */
4648 /* We walk the blocks going forward, because inlined function bodies
4649 will split id->current_basic_block, and the new blocks will
4650 follow it; we'll trudge through them, processing their CALL_EXPRs
4652 FOR_EACH_BB_FN (bb
, cfun
)
4653 inlined_p
|= gimple_expand_calls_inline (bb
, &id
);
4655 pop_gimplify_context (NULL
);
4657 #ifdef ENABLE_CHECKING
4659 struct cgraph_edge
*e
;
4661 id
.dst_node
->verify ();
4663 /* Double check that we inlined everything we are supposed to inline. */
4664 for (e
= id
.dst_node
->callees
; e
; e
= e
->next_callee
)
4665 gcc_assert (e
->inline_failed
);
4669 /* Fold queued statements. */
4670 fold_marked_statements (last
, id
.statements_to_fold
);
4671 delete id
.statements_to_fold
;
4673 gcc_assert (!id
.debug_stmts
.exists ());
4675 /* If we didn't inline into the function there is nothing to do. */
4679 /* Renumber the lexical scoping (non-code) blocks consecutively. */
4682 delete_unreachable_blocks_update_callgraph (&id
);
4683 #ifdef ENABLE_CHECKING
4684 id
.dst_node
->verify ();
4687 /* It would be nice to check SSA/CFG/statement consistency here, but it is
4688 not possible yet - the IPA passes might make various functions to not
4689 throw and they don't care to proactively update local EH info. This is
4690 done later in fixup_cfg pass that also execute the verification. */
4691 return (TODO_update_ssa
4693 | (gimple_in_ssa_p (cfun
) ? TODO_remove_unused_locals
: 0)
4694 | (gimple_in_ssa_p (cfun
) ? TODO_update_address_taken
: 0)
4695 | (profile_status_for_fn (cfun
) != PROFILE_ABSENT
4696 ? TODO_rebuild_frequencies
: 0));
4699 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
4702 copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
4704 enum tree_code code
= TREE_CODE (*tp
);
4705 enum tree_code_class cl
= TREE_CODE_CLASS (code
);
4707 /* We make copies of most nodes. */
4708 if (IS_EXPR_CODE_CLASS (cl
)
4709 || code
== TREE_LIST
4711 || code
== TYPE_DECL
4712 || code
== OMP_CLAUSE
)
4714 /* Because the chain gets clobbered when we make a copy, we save it
4716 tree chain
= NULL_TREE
, new_tree
;
4718 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
4719 chain
= TREE_CHAIN (*tp
);
4721 /* Copy the node. */
4722 new_tree
= copy_node (*tp
);
4726 /* Now, restore the chain, if appropriate. That will cause
4727 walk_tree to walk into the chain as well. */
4728 if (code
== PARM_DECL
4729 || code
== TREE_LIST
4730 || code
== OMP_CLAUSE
)
4731 TREE_CHAIN (*tp
) = chain
;
4733 /* For now, we don't update BLOCKs when we make copies. So, we
4734 have to nullify all BIND_EXPRs. */
4735 if (TREE_CODE (*tp
) == BIND_EXPR
)
4736 BIND_EXPR_BLOCK (*tp
) = NULL_TREE
;
4738 else if (code
== CONSTRUCTOR
)
4740 /* CONSTRUCTOR nodes need special handling because
4741 we need to duplicate the vector of elements. */
4744 new_tree
= copy_node (*tp
);
4745 CONSTRUCTOR_ELTS (new_tree
) = vec_safe_copy (CONSTRUCTOR_ELTS (*tp
));
4748 else if (code
== STATEMENT_LIST
)
4749 /* We used to just abort on STATEMENT_LIST, but we can run into them
4750 with statement-expressions (c++/40975). */
4751 copy_statement_list (tp
);
4752 else if (TREE_CODE_CLASS (code
) == tcc_type
)
4754 else if (TREE_CODE_CLASS (code
) == tcc_declaration
)
4756 else if (TREE_CODE_CLASS (code
) == tcc_constant
)
4761 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
4762 information indicating to what new SAVE_EXPR this one should be mapped,
4763 use that one. Otherwise, create a new node and enter it in ST. FN is
4764 the function into which the copy will be placed. */
4767 remap_save_expr (tree
*tp
, hash_map
<tree
, tree
> *st
, int *walk_subtrees
)
4772 /* See if we already encountered this SAVE_EXPR. */
4775 /* If we didn't already remap this SAVE_EXPR, do so now. */
4778 t
= copy_node (*tp
);
4780 /* Remember this SAVE_EXPR. */
4782 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
4787 /* We've already walked into this SAVE_EXPR; don't do it again. */
4792 /* Replace this SAVE_EXPR with the copy. */
4796 /* Called via walk_gimple_seq. If *GSIP points to a GIMPLE_LABEL for a local
4797 label, copies the declaration and enters it in the splay_tree in DATA (which
4798 is really a 'copy_body_data *'. */
4801 mark_local_labels_stmt (gimple_stmt_iterator
*gsip
,
4802 bool *handled_ops_p ATTRIBUTE_UNUSED
,
4803 struct walk_stmt_info
*wi
)
4805 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4806 gimple stmt
= gsi_stmt (*gsip
);
4808 if (gimple_code (stmt
) == GIMPLE_LABEL
)
4810 tree decl
= gimple_label_label (stmt
);
4812 /* Copy the decl and remember the copy. */
4813 insert_decl_map (id
, decl
, id
->copy_decl (decl
, id
));
4820 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
4821 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
4822 remaps all local declarations to appropriate replacements in gimple
4826 replace_locals_op (tree
*tp
, int *walk_subtrees
, void *data
)
4828 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
4829 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4830 hash_map
<tree
, tree
> *st
= id
->decl_map
;
4834 /* Only a local declaration (variable or label). */
4835 if ((TREE_CODE (expr
) == VAR_DECL
4836 && !TREE_STATIC (expr
))
4837 || TREE_CODE (expr
) == LABEL_DECL
)
4839 /* Lookup the declaration. */
4842 /* If it's there, remap it. */
4847 else if (TREE_CODE (expr
) == STATEMENT_LIST
4848 || TREE_CODE (expr
) == BIND_EXPR
4849 || TREE_CODE (expr
) == SAVE_EXPR
)
4851 else if (TREE_CODE (expr
) == TARGET_EXPR
)
4853 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
4854 It's OK for this to happen if it was part of a subtree that
4855 isn't immediately expanded, such as operand 2 of another
4857 if (!TREE_OPERAND (expr
, 1))
4859 TREE_OPERAND (expr
, 1) = TREE_OPERAND (expr
, 3);
4860 TREE_OPERAND (expr
, 3) = NULL_TREE
;
4864 /* Keep iterating. */
4869 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
4870 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
4871 remaps all local declarations to appropriate replacements in gimple
4875 replace_locals_stmt (gimple_stmt_iterator
*gsip
,
4876 bool *handled_ops_p ATTRIBUTE_UNUSED
,
4877 struct walk_stmt_info
*wi
)
4879 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4880 gimple stmt
= gsi_stmt (*gsip
);
4882 if (gimple_code (stmt
) == GIMPLE_BIND
)
4884 tree block
= gimple_bind_block (stmt
);
4888 remap_block (&block
, id
);
4889 gimple_bind_set_block (stmt
, block
);
4892 /* This will remap a lot of the same decls again, but this should be
4894 if (gimple_bind_vars (stmt
))
4895 gimple_bind_set_vars (stmt
, remap_decls (gimple_bind_vars (stmt
),
4899 /* Keep iterating. */
4904 /* Copies everything in SEQ and replaces variables and labels local to
4905 current_function_decl. */
4908 copy_gimple_seq_and_replace_locals (gimple_seq seq
)
4911 struct walk_stmt_info wi
;
4914 /* There's nothing to do for NULL_TREE. */
4919 memset (&id
, 0, sizeof (id
));
4920 id
.src_fn
= current_function_decl
;
4921 id
.dst_fn
= current_function_decl
;
4922 id
.decl_map
= new hash_map
<tree
, tree
>;
4923 id
.debug_map
= NULL
;
4925 id
.copy_decl
= copy_decl_no_change
;
4926 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
4927 id
.transform_new_cfg
= false;
4928 id
.transform_return_to_modify
= false;
4929 id
.transform_parameter
= false;
4930 id
.transform_lang_insert_block
= NULL
;
4932 /* Walk the tree once to find local labels. */
4933 memset (&wi
, 0, sizeof (wi
));
4934 hash_set
<tree
> visited
;
4937 walk_gimple_seq (seq
, mark_local_labels_stmt
, NULL
, &wi
);
4939 copy
= gimple_seq_copy (seq
);
4941 /* Walk the copy, remapping decls. */
4942 memset (&wi
, 0, sizeof (wi
));
4944 walk_gimple_seq (copy
, replace_locals_stmt
, replace_locals_op
, &wi
);
4949 delete id
.debug_map
;
4955 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
4958 debug_find_tree_1 (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
, void *data
)
4967 debug_find_tree (tree top
, tree search
)
4969 return walk_tree_without_duplicates (&top
, debug_find_tree_1
, search
) != 0;
4973 /* Declare the variables created by the inliner. Add all the variables in
4974 VARS to BIND_EXPR. */
4977 declare_inline_vars (tree block
, tree vars
)
4980 for (t
= vars
; t
; t
= DECL_CHAIN (t
))
4982 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
4983 gcc_assert (!TREE_STATIC (t
) && !TREE_ASM_WRITTEN (t
));
4984 add_local_decl (cfun
, t
);
4988 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), vars
);
4991 /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN,
4992 but now it will be in the TO_FN. PARM_TO_VAR means enable PARM_DECL to
4993 VAR_DECL translation. */
4996 copy_decl_for_dup_finish (copy_body_data
*id
, tree decl
, tree copy
)
4998 /* Don't generate debug information for the copy if we wouldn't have
4999 generated it for the copy either. */
5000 DECL_ARTIFICIAL (copy
) = DECL_ARTIFICIAL (decl
);
5001 DECL_IGNORED_P (copy
) = DECL_IGNORED_P (decl
);
5003 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
5004 declaration inspired this copy. */
5005 DECL_ABSTRACT_ORIGIN (copy
) = DECL_ORIGIN (decl
);
5007 /* The new variable/label has no RTL, yet. */
5008 if (CODE_CONTAINS_STRUCT (TREE_CODE (copy
), TS_DECL_WRTL
)
5009 && !TREE_STATIC (copy
) && !DECL_EXTERNAL (copy
))
5010 SET_DECL_RTL (copy
, 0);
5012 /* These args would always appear unused, if not for this. */
5013 TREE_USED (copy
) = 1;
5015 /* Set the context for the new declaration. */
5016 if (!DECL_CONTEXT (decl
))
5017 /* Globals stay global. */
5019 else if (DECL_CONTEXT (decl
) != id
->src_fn
)
5020 /* Things that weren't in the scope of the function we're inlining
5021 from aren't in the scope we're inlining to, either. */
5023 else if (TREE_STATIC (decl
))
5024 /* Function-scoped static variables should stay in the original
5028 /* Ordinary automatic local variables are now in the scope of the
5030 DECL_CONTEXT (copy
) = id
->dst_fn
;
5036 copy_decl_to_var (tree decl
, copy_body_data
*id
)
5040 gcc_assert (TREE_CODE (decl
) == PARM_DECL
5041 || TREE_CODE (decl
) == RESULT_DECL
);
5043 type
= TREE_TYPE (decl
);
5045 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
5046 VAR_DECL
, DECL_NAME (decl
), type
);
5047 if (DECL_PT_UID_SET_P (decl
))
5048 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
5049 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
5050 TREE_READONLY (copy
) = TREE_READONLY (decl
);
5051 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
5052 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
5054 return copy_decl_for_dup_finish (id
, decl
, copy
);
5057 /* Like copy_decl_to_var, but create a return slot object instead of a
5058 pointer variable for return by invisible reference. */
5061 copy_result_decl_to_var (tree decl
, copy_body_data
*id
)
5065 gcc_assert (TREE_CODE (decl
) == PARM_DECL
5066 || TREE_CODE (decl
) == RESULT_DECL
);
5068 type
= TREE_TYPE (decl
);
5069 if (DECL_BY_REFERENCE (decl
))
5070 type
= TREE_TYPE (type
);
5072 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
5073 VAR_DECL
, DECL_NAME (decl
), type
);
5074 if (DECL_PT_UID_SET_P (decl
))
5075 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
5076 TREE_READONLY (copy
) = TREE_READONLY (decl
);
5077 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
5078 if (!DECL_BY_REFERENCE (decl
))
5080 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
5081 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
5084 return copy_decl_for_dup_finish (id
, decl
, copy
);
5088 copy_decl_no_change (tree decl
, copy_body_data
*id
)
5092 copy
= copy_node (decl
);
5094 /* The COPY is not abstract; it will be generated in DST_FN. */
5095 DECL_ABSTRACT_P (copy
) = false;
5096 lang_hooks
.dup_lang_specific_decl (copy
);
5098 /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
5099 been taken; it's for internal bookkeeping in expand_goto_internal. */
5100 if (TREE_CODE (copy
) == LABEL_DECL
)
5102 TREE_ADDRESSABLE (copy
) = 0;
5103 LABEL_DECL_UID (copy
) = -1;
5106 return copy_decl_for_dup_finish (id
, decl
, copy
);
5110 copy_decl_maybe_to_var (tree decl
, copy_body_data
*id
)
5112 if (TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
)
5113 return copy_decl_to_var (decl
, id
);
5115 return copy_decl_no_change (decl
, id
);
5118 /* Return a copy of the function's argument tree. */
5120 copy_arguments_for_versioning (tree orig_parm
, copy_body_data
* id
,
5121 bitmap args_to_skip
, tree
*vars
)
5124 tree new_parm
= NULL
;
5129 for (arg
= orig_parm
; arg
; arg
= DECL_CHAIN (arg
), i
++)
5130 if (!args_to_skip
|| !bitmap_bit_p (args_to_skip
, i
))
5132 tree new_tree
= remap_decl (arg
, id
);
5133 if (TREE_CODE (new_tree
) != PARM_DECL
)
5134 new_tree
= id
->copy_decl (arg
, id
);
5135 lang_hooks
.dup_lang_specific_decl (new_tree
);
5137 parg
= &DECL_CHAIN (new_tree
);
5139 else if (!id
->decl_map
->get (arg
))
5141 /* Make an equivalent VAR_DECL. If the argument was used
5142 as temporary variable later in function, the uses will be
5143 replaced by local variable. */
5144 tree var
= copy_decl_to_var (arg
, id
);
5145 insert_decl_map (id
, arg
, var
);
5146 /* Declare this new variable. */
5147 DECL_CHAIN (var
) = *vars
;
5153 /* Return a copy of the function's static chain. */
5155 copy_static_chain (tree static_chain
, copy_body_data
* id
)
5157 tree
*chain_copy
, *pvar
;
5159 chain_copy
= &static_chain
;
5160 for (pvar
= chain_copy
; *pvar
; pvar
= &DECL_CHAIN (*pvar
))
5162 tree new_tree
= remap_decl (*pvar
, id
);
5163 lang_hooks
.dup_lang_specific_decl (new_tree
);
5164 DECL_CHAIN (new_tree
) = DECL_CHAIN (*pvar
);
5167 return static_chain
;
5170 /* Return true if the function is allowed to be versioned.
5171 This is a guard for the versioning functionality. */
5174 tree_versionable_function_p (tree fndecl
)
5176 return (!lookup_attribute ("noclone", DECL_ATTRIBUTES (fndecl
))
5177 && copy_forbidden (DECL_STRUCT_FUNCTION (fndecl
), fndecl
) == NULL
);
5180 /* Delete all unreachable basic blocks and update callgraph.
5181 Doing so is somewhat nontrivial because we need to update all clones and
5182 remove inline function that become unreachable. */
5185 delete_unreachable_blocks_update_callgraph (copy_body_data
*id
)
5187 bool changed
= false;
5188 basic_block b
, next_bb
;
5190 find_unreachable_blocks ();
5192 /* Delete all unreachable basic blocks. */
5194 for (b
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
; b
5195 != EXIT_BLOCK_PTR_FOR_FN (cfun
); b
= next_bb
)
5197 next_bb
= b
->next_bb
;
5199 if (!(b
->flags
& BB_REACHABLE
))
5201 gimple_stmt_iterator bsi
;
5203 for (bsi
= gsi_start_bb (b
); !gsi_end_p (bsi
); gsi_next (&bsi
))
5205 struct cgraph_edge
*e
;
5206 struct cgraph_node
*node
;
5208 id
->dst_node
->remove_stmt_references (gsi_stmt (bsi
));
5210 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
5211 &&(e
= id
->dst_node
->get_edge (gsi_stmt (bsi
))) != NULL
)
5213 if (!e
->inline_failed
)
5214 e
->callee
->remove_symbol_and_inline_clones (id
->dst_node
);
5218 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
5219 && id
->dst_node
->clones
)
5220 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
5222 node
->remove_stmt_references (gsi_stmt (bsi
));
5223 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
5224 && (e
= node
->get_edge (gsi_stmt (bsi
))) != NULL
)
5226 if (!e
->inline_failed
)
5227 e
->callee
->remove_symbol_and_inline_clones (id
->dst_node
);
5233 node
= node
->clones
;
5234 else if (node
->next_sibling_clone
)
5235 node
= node
->next_sibling_clone
;
5238 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5239 node
= node
->clone_of
;
5240 if (node
!= id
->dst_node
)
5241 node
= node
->next_sibling_clone
;
5245 delete_basic_block (b
);
5253 /* Update clone info after duplication. */
5256 update_clone_info (copy_body_data
* id
)
5258 struct cgraph_node
*node
;
5259 if (!id
->dst_node
->clones
)
5261 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
5263 /* First update replace maps to match the new body. */
5264 if (node
->clone
.tree_map
)
5267 for (i
= 0; i
< vec_safe_length (node
->clone
.tree_map
); i
++)
5269 struct ipa_replace_map
*replace_info
;
5270 replace_info
= (*node
->clone
.tree_map
)[i
];
5271 walk_tree (&replace_info
->old_tree
, copy_tree_body_r
, id
, NULL
);
5272 walk_tree (&replace_info
->new_tree
, copy_tree_body_r
, id
, NULL
);
5276 node
= node
->clones
;
5277 else if (node
->next_sibling_clone
)
5278 node
= node
->next_sibling_clone
;
5281 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5282 node
= node
->clone_of
;
5283 if (node
!= id
->dst_node
)
5284 node
= node
->next_sibling_clone
;
5289 /* Create a copy of a function's tree.
5290 OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
5291 of the original function and the new copied function
5292 respectively. In case we want to replace a DECL
5293 tree with another tree while duplicating the function's
5294 body, TREE_MAP represents the mapping between these
5295 trees. If UPDATE_CLONES is set, the call_stmt fields
5296 of edges of clones of the function will be updated.
5298 If non-NULL ARGS_TO_SKIP determine function parameters to remove
5300 If SKIP_RETURN is true, the new version will return void.
5301 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
5302 If non_NULL NEW_ENTRY determine new entry BB of the clone.
5305 tree_function_versioning (tree old_decl
, tree new_decl
,
5306 vec
<ipa_replace_map
*, va_gc
> *tree_map
,
5307 bool update_clones
, bitmap args_to_skip
,
5308 bool skip_return
, bitmap blocks_to_copy
,
5309 basic_block new_entry
)
5311 struct cgraph_node
*old_version_node
;
5312 struct cgraph_node
*new_version_node
;
5316 struct ipa_replace_map
*replace_info
;
5317 basic_block old_entry_block
, bb
;
5318 auto_vec
<gimple
, 10> init_stmts
;
5319 tree vars
= NULL_TREE
;
5321 gcc_assert (TREE_CODE (old_decl
) == FUNCTION_DECL
5322 && TREE_CODE (new_decl
) == FUNCTION_DECL
);
5323 DECL_POSSIBLY_INLINED (old_decl
) = 1;
5325 old_version_node
= cgraph_node::get (old_decl
);
5326 gcc_checking_assert (old_version_node
);
5327 new_version_node
= cgraph_node::get (new_decl
);
5328 gcc_checking_assert (new_version_node
);
5330 /* Copy over debug args. */
5331 if (DECL_HAS_DEBUG_ARGS_P (old_decl
))
5333 vec
<tree
, va_gc
> **new_debug_args
, **old_debug_args
;
5334 gcc_checking_assert (decl_debug_args_lookup (new_decl
) == NULL
);
5335 DECL_HAS_DEBUG_ARGS_P (new_decl
) = 0;
5336 old_debug_args
= decl_debug_args_lookup (old_decl
);
5339 new_debug_args
= decl_debug_args_insert (new_decl
);
5340 *new_debug_args
= vec_safe_copy (*old_debug_args
);
5344 /* Output the inlining info for this abstract function, since it has been
5345 inlined. If we don't do this now, we can lose the information about the
5346 variables in the function when the blocks get blown away as soon as we
5347 remove the cgraph node. */
5348 (*debug_hooks
->outlining_inline_function
) (old_decl
);
5350 DECL_ARTIFICIAL (new_decl
) = 1;
5351 DECL_ABSTRACT_ORIGIN (new_decl
) = DECL_ORIGIN (old_decl
);
5352 if (DECL_ORIGIN (old_decl
) == old_decl
)
5353 old_version_node
->used_as_abstract_origin
= true;
5354 DECL_FUNCTION_PERSONALITY (new_decl
) = DECL_FUNCTION_PERSONALITY (old_decl
);
5356 /* Prepare the data structures for the tree copy. */
5357 memset (&id
, 0, sizeof (id
));
5359 /* Generate a new name for the new version. */
5360 id
.statements_to_fold
= new hash_set
<gimple
>;
5362 id
.decl_map
= new hash_map
<tree
, tree
>;
5363 id
.debug_map
= NULL
;
5364 id
.src_fn
= old_decl
;
5365 id
.dst_fn
= new_decl
;
5366 id
.src_node
= old_version_node
;
5367 id
.dst_node
= new_version_node
;
5368 id
.src_cfun
= DECL_STRUCT_FUNCTION (old_decl
);
5369 id
.blocks_to_copy
= blocks_to_copy
;
5371 id
.copy_decl
= copy_decl_no_change
;
5372 id
.transform_call_graph_edges
5373 = update_clones
? CB_CGE_MOVE_CLONES
: CB_CGE_MOVE
;
5374 id
.transform_new_cfg
= true;
5375 id
.transform_return_to_modify
= false;
5376 id
.transform_parameter
= false;
5377 id
.transform_lang_insert_block
= NULL
;
5379 old_entry_block
= ENTRY_BLOCK_PTR_FOR_FN
5380 (DECL_STRUCT_FUNCTION (old_decl
));
5381 DECL_RESULT (new_decl
) = DECL_RESULT (old_decl
);
5382 DECL_ARGUMENTS (new_decl
) = DECL_ARGUMENTS (old_decl
);
5383 initialize_cfun (new_decl
, old_decl
,
5384 old_entry_block
->count
);
5385 if (DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
)
5386 DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
->ipa_pta
5387 = id
.src_cfun
->gimple_df
->ipa_pta
;
5389 /* Copy the function's static chain. */
5390 p
= DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
;
5392 DECL_STRUCT_FUNCTION (new_decl
)->static_chain_decl
=
5393 copy_static_chain (DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
,
5396 /* If there's a tree_map, prepare for substitution. */
5398 for (i
= 0; i
< tree_map
->length (); i
++)
5401 replace_info
= (*tree_map
)[i
];
5402 if (replace_info
->replace_p
)
5404 if (!replace_info
->old_tree
)
5406 int i
= replace_info
->parm_num
;
5410 for (parm
= DECL_ARGUMENTS (old_decl
); i
; parm
= DECL_CHAIN (parm
))
5412 replace_info
->old_tree
= parm
;
5413 req_type
= TREE_TYPE (parm
);
5414 if (!useless_type_conversion_p (req_type
, TREE_TYPE (replace_info
->new_tree
)))
5416 if (fold_convertible_p (req_type
, replace_info
->new_tree
))
5417 replace_info
->new_tree
= fold_build1 (NOP_EXPR
, req_type
, replace_info
->new_tree
);
5418 else if (TYPE_SIZE (req_type
) == TYPE_SIZE (TREE_TYPE (replace_info
->new_tree
)))
5419 replace_info
->new_tree
= fold_build1 (VIEW_CONVERT_EXPR
, req_type
, replace_info
->new_tree
);
5424 fprintf (dump_file
, " const ");
5425 print_generic_expr (dump_file
, replace_info
->new_tree
, 0);
5426 fprintf (dump_file
, " can't be converted to param ");
5427 print_generic_expr (dump_file
, parm
, 0);
5428 fprintf (dump_file
, "\n");
5430 replace_info
->old_tree
= NULL
;
5435 gcc_assert (TREE_CODE (replace_info
->old_tree
) == PARM_DECL
);
5436 if (replace_info
->old_tree
)
5438 init
= setup_one_parameter (&id
, replace_info
->old_tree
,
5439 replace_info
->new_tree
, id
.src_fn
,
5443 init_stmts
.safe_push (init
);
5447 /* Copy the function's arguments. */
5448 if (DECL_ARGUMENTS (old_decl
) != NULL_TREE
)
5449 DECL_ARGUMENTS (new_decl
) =
5450 copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl
), &id
,
5451 args_to_skip
, &vars
);
5453 DECL_INITIAL (new_decl
) = remap_blocks (DECL_INITIAL (id
.src_fn
), &id
);
5454 BLOCK_SUPERCONTEXT (DECL_INITIAL (new_decl
)) = new_decl
;
5456 declare_inline_vars (DECL_INITIAL (new_decl
), vars
);
5458 if (!vec_safe_is_empty (DECL_STRUCT_FUNCTION (old_decl
)->local_decls
))
5459 /* Add local vars. */
5460 add_local_variables (DECL_STRUCT_FUNCTION (old_decl
), cfun
, &id
);
5462 if (DECL_RESULT (old_decl
) == NULL_TREE
)
5464 else if (skip_return
&& !VOID_TYPE_P (TREE_TYPE (DECL_RESULT (old_decl
))))
5466 DECL_RESULT (new_decl
)
5467 = build_decl (DECL_SOURCE_LOCATION (DECL_RESULT (old_decl
)),
5468 RESULT_DECL
, NULL_TREE
, void_type_node
);
5469 DECL_CONTEXT (DECL_RESULT (new_decl
)) = new_decl
;
5470 cfun
->returns_struct
= 0;
5471 cfun
->returns_pcc_struct
= 0;
5476 DECL_RESULT (new_decl
) = remap_decl (DECL_RESULT (old_decl
), &id
);
5477 lang_hooks
.dup_lang_specific_decl (DECL_RESULT (new_decl
));
5478 if (gimple_in_ssa_p (id
.src_cfun
)
5479 && DECL_BY_REFERENCE (DECL_RESULT (old_decl
))
5480 && (old_name
= ssa_default_def (id
.src_cfun
, DECL_RESULT (old_decl
))))
5482 tree new_name
= make_ssa_name (DECL_RESULT (new_decl
), NULL
);
5483 insert_decl_map (&id
, old_name
, new_name
);
5484 SSA_NAME_DEF_STMT (new_name
) = gimple_build_nop ();
5485 set_ssa_default_def (cfun
, DECL_RESULT (new_decl
), new_name
);
5489 /* Set up the destination functions loop tree. */
5490 if (loops_for_fn (DECL_STRUCT_FUNCTION (old_decl
)) != NULL
)
5492 cfun
->curr_properties
&= ~PROP_loops
;
5493 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
5494 cfun
->curr_properties
|= PROP_loops
;
5497 /* Copy the Function's body. */
5498 copy_body (&id
, old_entry_block
->count
, REG_BR_PROB_BASE
,
5499 ENTRY_BLOCK_PTR_FOR_FN (cfun
), EXIT_BLOCK_PTR_FOR_FN (cfun
),
5502 /* Renumber the lexical scoping (non-code) blocks consecutively. */
5503 number_blocks (new_decl
);
5505 /* We want to create the BB unconditionally, so that the addition of
5506 debug stmts doesn't affect BB count, which may in the end cause
5507 codegen differences. */
5508 bb
= split_edge (single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
5509 while (init_stmts
.length ())
5510 insert_init_stmt (&id
, bb
, init_stmts
.pop ());
5511 update_clone_info (&id
);
5513 /* Remap the nonlocal_goto_save_area, if any. */
5514 if (cfun
->nonlocal_goto_save_area
)
5516 struct walk_stmt_info wi
;
5518 memset (&wi
, 0, sizeof (wi
));
5520 walk_tree (&cfun
->nonlocal_goto_save_area
, remap_gimple_op_r
, &wi
, NULL
);
5526 delete id
.debug_map
;
5527 free_dominance_info (CDI_DOMINATORS
);
5528 free_dominance_info (CDI_POST_DOMINATORS
);
5530 fold_marked_statements (0, id
.statements_to_fold
);
5531 delete id
.statements_to_fold
;
5532 fold_cond_expr_cond ();
5533 delete_unreachable_blocks_update_callgraph (&id
);
5534 if (id
.dst_node
->definition
)
5535 cgraph_edge::rebuild_references ();
5536 if (loops_state_satisfies_p (LOOPS_NEED_FIXUP
))
5538 calculate_dominance_info (CDI_DOMINATORS
);
5539 fix_loop_structure (NULL
);
5541 update_ssa (TODO_update_ssa
);
5543 /* After partial cloning we need to rescale frequencies, so they are
5544 within proper range in the cloned function. */
5547 struct cgraph_edge
*e
;
5548 rebuild_frequencies ();
5550 new_version_node
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5551 for (e
= new_version_node
->callees
; e
; e
= e
->next_callee
)
5553 basic_block bb
= gimple_bb (e
->call_stmt
);
5554 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
5556 e
->count
= bb
->count
;
5558 for (e
= new_version_node
->indirect_calls
; e
; e
= e
->next_callee
)
5560 basic_block bb
= gimple_bb (e
->call_stmt
);
5561 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
5563 e
->count
= bb
->count
;
5567 free_dominance_info (CDI_DOMINATORS
);
5568 free_dominance_info (CDI_POST_DOMINATORS
);
5570 gcc_assert (!id
.debug_stmts
.exists ());
5575 /* EXP is CALL_EXPR present in a GENERIC expression tree. Try to integrate
5576 the callee and return the inlined body on success. */
5579 maybe_inline_call_in_expr (tree exp
)
5581 tree fn
= get_callee_fndecl (exp
);
5583 /* We can only try to inline "const" functions. */
5584 if (fn
&& TREE_READONLY (fn
) && DECL_SAVED_TREE (fn
))
5586 call_expr_arg_iterator iter
;
5589 hash_map
<tree
, tree
> decl_map
;
5591 /* Remap the parameters. */
5592 for (param
= DECL_ARGUMENTS (fn
), arg
= first_call_expr_arg (exp
, &iter
);
5594 param
= DECL_CHAIN (param
), arg
= next_call_expr_arg (&iter
))
5595 decl_map
.put (param
, arg
);
5597 memset (&id
, 0, sizeof (id
));
5599 id
.dst_fn
= current_function_decl
;
5600 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
5601 id
.decl_map
= &decl_map
;
5603 id
.copy_decl
= copy_decl_no_change
;
5604 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5605 id
.transform_new_cfg
= false;
5606 id
.transform_return_to_modify
= true;
5607 id
.transform_parameter
= true;
5608 id
.transform_lang_insert_block
= NULL
;
5610 /* Make sure not to unshare trees behind the front-end's back
5611 since front-end specific mechanisms may rely on sharing. */
5612 id
.regimplify
= false;
5613 id
.do_not_unshare
= true;
5615 /* We're not inside any EH region. */
5618 t
= copy_tree_body (&id
);
5620 /* We can only return something suitable for use in a GENERIC
5622 if (TREE_CODE (t
) == MODIFY_EXPR
)
5623 return TREE_OPERAND (t
, 1);
5629 /* Duplicate a type, fields and all. */
5632 build_duplicate_type (tree type
)
5634 struct copy_body_data id
;
5636 memset (&id
, 0, sizeof (id
));
5637 id
.src_fn
= current_function_decl
;
5638 id
.dst_fn
= current_function_decl
;
5640 id
.decl_map
= new hash_map
<tree
, tree
>;
5641 id
.debug_map
= NULL
;
5642 id
.copy_decl
= copy_decl_no_change
;
5644 type
= remap_type_1 (type
, &id
);
5648 delete id
.debug_map
;
5650 TYPE_CANONICAL (type
) = type
;