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 "pointer-set.h"
40 #include "tree-ssa-alias.h"
41 #include "internal-fn.h"
42 #include "gimple-fold.h"
44 #include "gimple-expr.h"
48 #include "gimple-iterator.h"
49 #include "gimplify-me.h"
50 #include "gimple-walk.h"
51 #include "gimple-ssa.h"
53 #include "tree-phinodes.h"
54 #include "ssa-iterators.h"
55 #include "stringpool.h"
56 #include "tree-ssanames.h"
57 #include "tree-into-ssa.h"
62 #include "tree-pretty-print.h"
66 #include "value-prof.h"
67 #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
*, void *, 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 *pointer_map_insert (id
->decl_map
, 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 *pointer_map_insert (id
->decl_map
, 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
= pointer_map_create ();
180 *pointer_map_insert (id
->debug_map
, 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
= (tree
*) pointer_map_contains (id
->decl_map
, 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
= (tree
*) pointer_map_contains (id
->decl_map
, 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
= (tree
*) pointer_map_contains (id
->decl_map
, 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 switch (TREE_CODE (new_tree
))
457 case FIXED_POINT_TYPE
:
460 t
= TYPE_MIN_VALUE (new_tree
);
461 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
462 walk_tree (&TYPE_MIN_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
464 t
= TYPE_MAX_VALUE (new_tree
);
465 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
466 walk_tree (&TYPE_MAX_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
470 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
471 walk_tree (&TYPE_ARG_TYPES (new_tree
), copy_tree_body_r
, id
, NULL
);
475 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
476 TYPE_DOMAIN (new_tree
) = remap_type (TYPE_DOMAIN (new_tree
), id
);
481 case QUAL_UNION_TYPE
:
485 for (f
= TYPE_FIELDS (new_tree
); f
; f
= DECL_CHAIN (f
))
487 t
= remap_decl (f
, id
);
488 DECL_CONTEXT (t
) = new_tree
;
492 TYPE_FIELDS (new_tree
) = nreverse (nf
);
498 /* Shouldn't have been thought variable sized. */
502 walk_tree (&TYPE_SIZE (new_tree
), copy_tree_body_r
, id
, NULL
);
503 walk_tree (&TYPE_SIZE_UNIT (new_tree
), copy_tree_body_r
, id
, NULL
);
509 remap_type (tree type
, copy_body_data
*id
)
517 /* See if we have remapped this type. */
518 node
= (tree
*) pointer_map_contains (id
->decl_map
, type
);
522 /* The type only needs remapping if it's variably modified. */
523 if (! variably_modified_type_p (type
, id
->src_fn
))
525 insert_decl_map (id
, type
, type
);
529 id
->remapping_type_depth
++;
530 tmp
= remap_type_1 (type
, id
);
531 id
->remapping_type_depth
--;
536 /* Decide if DECL can be put into BLOCK_NONLOCAL_VARs. */
539 can_be_nonlocal (tree decl
, copy_body_data
*id
)
541 /* We can not duplicate function decls. */
542 if (TREE_CODE (decl
) == FUNCTION_DECL
)
545 /* Local static vars must be non-local or we get multiple declaration
547 if (TREE_CODE (decl
) == VAR_DECL
548 && !auto_var_in_fn_p (decl
, id
->src_fn
))
555 remap_decls (tree decls
, vec
<tree
, va_gc
> **nonlocalized_list
,
559 tree new_decls
= NULL_TREE
;
561 /* Remap its variables. */
562 for (old_var
= decls
; old_var
; old_var
= DECL_CHAIN (old_var
))
566 if (can_be_nonlocal (old_var
, id
))
568 /* We need to add this variable to the local decls as otherwise
569 nothing else will do so. */
570 if (TREE_CODE (old_var
) == VAR_DECL
571 && ! DECL_EXTERNAL (old_var
))
572 add_local_decl (cfun
, old_var
);
573 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
574 && !DECL_IGNORED_P (old_var
)
575 && nonlocalized_list
)
576 vec_safe_push (*nonlocalized_list
, old_var
);
580 /* Remap the variable. */
581 new_var
= remap_decl (old_var
, id
);
583 /* If we didn't remap this variable, we can't mess with its
584 TREE_CHAIN. If we remapped this variable to the return slot, it's
585 already declared somewhere else, so don't declare it here. */
587 if (new_var
== id
->retvar
)
591 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
592 && !DECL_IGNORED_P (old_var
)
593 && nonlocalized_list
)
594 vec_safe_push (*nonlocalized_list
, old_var
);
598 gcc_assert (DECL_P (new_var
));
599 DECL_CHAIN (new_var
) = new_decls
;
602 /* Also copy value-expressions. */
603 if (TREE_CODE (new_var
) == VAR_DECL
604 && DECL_HAS_VALUE_EXPR_P (new_var
))
606 tree tem
= DECL_VALUE_EXPR (new_var
);
607 bool old_regimplify
= id
->regimplify
;
608 id
->remapping_type_depth
++;
609 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
610 id
->remapping_type_depth
--;
611 id
->regimplify
= old_regimplify
;
612 SET_DECL_VALUE_EXPR (new_var
, tem
);
617 return nreverse (new_decls
);
620 /* Copy the BLOCK to contain remapped versions of the variables
621 therein. And hook the new block into the block-tree. */
624 remap_block (tree
*block
, copy_body_data
*id
)
629 /* Make the new block. */
631 new_block
= make_node (BLOCK
);
632 TREE_USED (new_block
) = TREE_USED (old_block
);
633 BLOCK_ABSTRACT_ORIGIN (new_block
) = old_block
;
634 BLOCK_SOURCE_LOCATION (new_block
) = BLOCK_SOURCE_LOCATION (old_block
);
635 BLOCK_NONLOCALIZED_VARS (new_block
)
636 = vec_safe_copy (BLOCK_NONLOCALIZED_VARS (old_block
));
639 /* Remap its variables. */
640 BLOCK_VARS (new_block
) = remap_decls (BLOCK_VARS (old_block
),
641 &BLOCK_NONLOCALIZED_VARS (new_block
),
644 if (id
->transform_lang_insert_block
)
645 id
->transform_lang_insert_block (new_block
);
647 /* Remember the remapped block. */
648 insert_decl_map (id
, old_block
, new_block
);
651 /* Copy the whole block tree and root it in id->block. */
653 remap_blocks (tree block
, copy_body_data
*id
)
656 tree new_tree
= block
;
661 remap_block (&new_tree
, id
);
662 gcc_assert (new_tree
!= block
);
663 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
664 prepend_lexical_block (new_tree
, remap_blocks (t
, id
));
665 /* Blocks are in arbitrary order, but make things slightly prettier and do
666 not swap order when producing a copy. */
667 BLOCK_SUBBLOCKS (new_tree
) = blocks_nreverse (BLOCK_SUBBLOCKS (new_tree
));
671 /* Remap the block tree rooted at BLOCK to nothing. */
673 remap_blocks_to_null (tree block
, copy_body_data
*id
)
676 insert_decl_map (id
, block
, NULL_TREE
);
677 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
678 remap_blocks_to_null (t
, id
);
682 copy_statement_list (tree
*tp
)
684 tree_stmt_iterator oi
, ni
;
687 new_tree
= alloc_stmt_list ();
688 ni
= tsi_start (new_tree
);
689 oi
= tsi_start (*tp
);
690 TREE_TYPE (new_tree
) = TREE_TYPE (*tp
);
693 for (; !tsi_end_p (oi
); tsi_next (&oi
))
695 tree stmt
= tsi_stmt (oi
);
696 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
697 /* This copy is not redundant; tsi_link_after will smash this
698 STATEMENT_LIST into the end of the one we're building, and we
699 don't want to do that with the original. */
700 copy_statement_list (&stmt
);
701 tsi_link_after (&ni
, stmt
, TSI_CONTINUE_LINKING
);
706 copy_bind_expr (tree
*tp
, int *walk_subtrees
, copy_body_data
*id
)
708 tree block
= BIND_EXPR_BLOCK (*tp
);
709 /* Copy (and replace) the statement. */
710 copy_tree_r (tp
, walk_subtrees
, NULL
);
713 remap_block (&block
, id
);
714 BIND_EXPR_BLOCK (*tp
) = block
;
717 if (BIND_EXPR_VARS (*tp
))
718 /* This will remap a lot of the same decls again, but this should be
720 BIND_EXPR_VARS (*tp
) = remap_decls (BIND_EXPR_VARS (*tp
), NULL
, id
);
724 /* Create a new gimple_seq by remapping all the statements in BODY
725 using the inlining information in ID. */
728 remap_gimple_seq (gimple_seq body
, copy_body_data
*id
)
730 gimple_stmt_iterator si
;
731 gimple_seq new_body
= NULL
;
733 for (si
= gsi_start (body
); !gsi_end_p (si
); gsi_next (&si
))
735 gimple new_stmt
= remap_gimple_stmt (gsi_stmt (si
), id
);
736 gimple_seq_add_stmt (&new_body
, new_stmt
);
743 /* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its
744 block using the mapping information in ID. */
747 copy_gimple_bind (gimple stmt
, copy_body_data
*id
)
750 tree new_block
, new_vars
;
751 gimple_seq body
, new_body
;
753 /* Copy the statement. Note that we purposely don't use copy_stmt
754 here because we need to remap statements as we copy. */
755 body
= gimple_bind_body (stmt
);
756 new_body
= remap_gimple_seq (body
, id
);
758 new_block
= gimple_bind_block (stmt
);
760 remap_block (&new_block
, id
);
762 /* This will remap a lot of the same decls again, but this should be
764 new_vars
= gimple_bind_vars (stmt
);
766 new_vars
= remap_decls (new_vars
, NULL
, id
);
768 new_bind
= gimple_build_bind (new_vars
, new_body
, new_block
);
773 /* Return true if DECL is a parameter or a SSA_NAME for a parameter. */
778 if (TREE_CODE (decl
) == SSA_NAME
)
780 decl
= SSA_NAME_VAR (decl
);
785 return (TREE_CODE (decl
) == PARM_DECL
);
788 /* Remap the GIMPLE operand pointed to by *TP. DATA is really a
789 'struct walk_stmt_info *'. DATA->INFO is a 'copy_body_data *'.
790 WALK_SUBTREES is used to indicate walk_gimple_op whether to keep
791 recursing into the children nodes of *TP. */
794 remap_gimple_op_r (tree
*tp
, int *walk_subtrees
, void *data
)
796 struct walk_stmt_info
*wi_p
= (struct walk_stmt_info
*) data
;
797 copy_body_data
*id
= (copy_body_data
*) wi_p
->info
;
798 tree fn
= id
->src_fn
;
800 if (TREE_CODE (*tp
) == SSA_NAME
)
802 *tp
= remap_ssa_name (*tp
, id
);
806 else if (auto_var_in_fn_p (*tp
, fn
))
808 /* Local variables and labels need to be replaced by equivalent
809 variables. We don't want to copy static variables; there's
810 only one of those, no matter how many times we inline the
811 containing function. Similarly for globals from an outer
815 /* Remap the declaration. */
816 new_decl
= remap_decl (*tp
, id
);
817 gcc_assert (new_decl
);
818 /* Replace this variable with the copy. */
819 STRIP_TYPE_NOPS (new_decl
);
820 /* ??? The C++ frontend uses void * pointer zero to initialize
821 any other type. This confuses the middle-end type verification.
822 As cloned bodies do not go through gimplification again the fixup
823 there doesn't trigger. */
824 if (TREE_CODE (new_decl
) == INTEGER_CST
825 && !useless_type_conversion_p (TREE_TYPE (*tp
), TREE_TYPE (new_decl
)))
826 new_decl
= fold_convert (TREE_TYPE (*tp
), new_decl
);
830 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
832 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
834 else if (TREE_CODE (*tp
) == LABEL_DECL
835 && (!DECL_CONTEXT (*tp
)
836 || decl_function_context (*tp
) == id
->src_fn
))
837 /* These may need to be remapped for EH handling. */
838 *tp
= remap_decl (*tp
, id
);
839 else if (TREE_CODE (*tp
) == FIELD_DECL
)
841 /* If the enclosing record type is variably_modified_type_p, the field
842 has already been remapped. Otherwise, it need not be. */
843 tree
*n
= (tree
*) pointer_map_contains (id
->decl_map
, *tp
);
848 else if (TYPE_P (*tp
))
849 /* Types may need remapping as well. */
850 *tp
= remap_type (*tp
, id
);
851 else if (CONSTANT_CLASS_P (*tp
))
853 /* If this is a constant, we have to copy the node iff the type
854 will be remapped. copy_tree_r will not copy a constant. */
855 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
857 if (new_type
== TREE_TYPE (*tp
))
860 else if (TREE_CODE (*tp
) == INTEGER_CST
)
861 *tp
= wide_int_to_tree (new_type
, *tp
);
864 *tp
= copy_node (*tp
);
865 TREE_TYPE (*tp
) = new_type
;
870 /* Otherwise, just copy the node. Note that copy_tree_r already
871 knows not to copy VAR_DECLs, etc., so this is safe. */
873 if (TREE_CODE (*tp
) == MEM_REF
)
875 /* We need to re-canonicalize MEM_REFs from inline substitutions
876 that can happen when a pointer argument is an ADDR_EXPR.
877 Recurse here manually to allow that. */
878 tree ptr
= TREE_OPERAND (*tp
, 0);
879 tree type
= remap_type (TREE_TYPE (*tp
), id
);
881 walk_tree (&ptr
, remap_gimple_op_r
, data
, NULL
);
882 *tp
= fold_build2 (MEM_REF
, type
, ptr
, TREE_OPERAND (*tp
, 1));
883 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
884 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
885 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
886 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
887 remapped a parameter as the property might be valid only
888 for the parameter itself. */
889 if (TREE_THIS_NOTRAP (old
)
890 && (!is_parm (TREE_OPERAND (old
, 0))
891 || (!id
->transform_parameter
&& is_parm (ptr
))))
892 TREE_THIS_NOTRAP (*tp
) = 1;
897 /* Here is the "usual case". Copy this tree node, and then
898 tweak some special cases. */
899 copy_tree_r (tp
, walk_subtrees
, NULL
);
901 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
902 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
904 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
906 /* The copied TARGET_EXPR has never been expanded, even if the
907 original node was expanded already. */
908 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
909 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
911 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
913 /* Variable substitution need not be simple. In particular,
914 the MEM_REF substitution above. Make sure that
915 TREE_CONSTANT and friends are up-to-date. */
916 int invariant
= is_gimple_min_invariant (*tp
);
917 walk_tree (&TREE_OPERAND (*tp
, 0), remap_gimple_op_r
, data
, NULL
);
918 recompute_tree_invariant_for_addr_expr (*tp
);
920 /* If this used to be invariant, but is not any longer,
921 then regimplification is probably needed. */
922 if (invariant
&& !is_gimple_min_invariant (*tp
))
923 id
->regimplify
= true;
929 /* Update the TREE_BLOCK for the cloned expr. */
932 tree new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
933 tree old_block
= TREE_BLOCK (*tp
);
937 n
= (tree
*) pointer_map_contains (id
->decl_map
,
942 TREE_SET_BLOCK (*tp
, new_block
);
945 /* Keep iterating. */
950 /* Called from copy_body_id via walk_tree. DATA is really a
951 `copy_body_data *'. */
954 copy_tree_body_r (tree
*tp
, int *walk_subtrees
, void *data
)
956 copy_body_data
*id
= (copy_body_data
*) data
;
957 tree fn
= id
->src_fn
;
960 /* Begin by recognizing trees that we'll completely rewrite for the
961 inlining context. Our output for these trees is completely
962 different from out input (e.g. RETURN_EXPR is deleted, and morphs
963 into an edge). Further down, we'll handle trees that get
964 duplicated and/or tweaked. */
966 /* When requested, RETURN_EXPRs should be transformed to just the
967 contained MODIFY_EXPR. The branch semantics of the return will
968 be handled elsewhere by manipulating the CFG rather than a statement. */
969 if (TREE_CODE (*tp
) == RETURN_EXPR
&& id
->transform_return_to_modify
)
971 tree assignment
= TREE_OPERAND (*tp
, 0);
973 /* If we're returning something, just turn that into an
974 assignment into the equivalent of the original RESULT_DECL.
975 If the "assignment" is just the result decl, the result
976 decl has already been set (e.g. a recent "foo (&result_decl,
977 ...)"); just toss the entire RETURN_EXPR. */
978 if (assignment
&& TREE_CODE (assignment
) == MODIFY_EXPR
)
980 /* Replace the RETURN_EXPR with (a copy of) the
981 MODIFY_EXPR hanging underneath. */
982 *tp
= copy_node (assignment
);
984 else /* Else the RETURN_EXPR returns no value. */
987 return (tree
) (void *)1;
990 else if (TREE_CODE (*tp
) == SSA_NAME
)
992 *tp
= remap_ssa_name (*tp
, id
);
997 /* Local variables and labels need to be replaced by equivalent
998 variables. We don't want to copy static variables; there's only
999 one of those, no matter how many times we inline the containing
1000 function. Similarly for globals from an outer function. */
1001 else if (auto_var_in_fn_p (*tp
, fn
))
1005 /* Remap the declaration. */
1006 new_decl
= remap_decl (*tp
, id
);
1007 gcc_assert (new_decl
);
1008 /* Replace this variable with the copy. */
1009 STRIP_TYPE_NOPS (new_decl
);
1013 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
1014 copy_statement_list (tp
);
1015 else if (TREE_CODE (*tp
) == SAVE_EXPR
1016 || TREE_CODE (*tp
) == TARGET_EXPR
)
1017 remap_save_expr (tp
, id
->decl_map
, walk_subtrees
);
1018 else if (TREE_CODE (*tp
) == LABEL_DECL
1019 && (! DECL_CONTEXT (*tp
)
1020 || decl_function_context (*tp
) == id
->src_fn
))
1021 /* These may need to be remapped for EH handling. */
1022 *tp
= remap_decl (*tp
, id
);
1023 else if (TREE_CODE (*tp
) == BIND_EXPR
)
1024 copy_bind_expr (tp
, walk_subtrees
, id
);
1025 /* Types may need remapping as well. */
1026 else if (TYPE_P (*tp
))
1027 *tp
= remap_type (*tp
, id
);
1029 /* If this is a constant, we have to copy the node iff the type will be
1030 remapped. copy_tree_r will not copy a constant. */
1031 else if (CONSTANT_CLASS_P (*tp
))
1033 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
1035 if (new_type
== TREE_TYPE (*tp
))
1038 else if (TREE_CODE (*tp
) == INTEGER_CST
)
1039 *tp
= wide_int_to_tree (new_type
, *tp
);
1042 *tp
= copy_node (*tp
);
1043 TREE_TYPE (*tp
) = new_type
;
1047 /* Otherwise, just copy the node. Note that copy_tree_r already
1048 knows not to copy VAR_DECLs, etc., so this is safe. */
1051 /* Here we handle trees that are not completely rewritten.
1052 First we detect some inlining-induced bogosities for
1054 if (TREE_CODE (*tp
) == MODIFY_EXPR
1055 && TREE_OPERAND (*tp
, 0) == TREE_OPERAND (*tp
, 1)
1056 && (auto_var_in_fn_p (TREE_OPERAND (*tp
, 0), fn
)))
1058 /* Some assignments VAR = VAR; don't generate any rtl code
1059 and thus don't count as variable modification. Avoid
1060 keeping bogosities like 0 = 0. */
1061 tree decl
= TREE_OPERAND (*tp
, 0), value
;
1064 n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
1068 STRIP_TYPE_NOPS (value
);
1069 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1071 *tp
= build_empty_stmt (EXPR_LOCATION (*tp
));
1072 return copy_tree_body_r (tp
, walk_subtrees
, data
);
1076 else if (TREE_CODE (*tp
) == INDIRECT_REF
)
1078 /* Get rid of *& from inline substitutions that can happen when a
1079 pointer argument is an ADDR_EXPR. */
1080 tree decl
= TREE_OPERAND (*tp
, 0);
1081 tree
*n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
1084 /* If we happen to get an ADDR_EXPR in n->value, strip
1085 it manually here as we'll eventually get ADDR_EXPRs
1086 which lie about their types pointed to. In this case
1087 build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
1088 but we absolutely rely on that. As fold_indirect_ref
1089 does other useful transformations, try that first, though. */
1090 tree type
= TREE_TYPE (*tp
);
1091 tree ptr
= id
->do_not_unshare
? *n
: unshare_expr (*n
);
1093 *tp
= gimple_fold_indirect_ref (ptr
);
1096 if (TREE_CODE (ptr
) == ADDR_EXPR
)
1099 = fold_indirect_ref_1 (EXPR_LOCATION (ptr
), type
, ptr
);
1100 /* ??? We should either assert here or build
1101 a VIEW_CONVERT_EXPR instead of blindly leaking
1102 incompatible types to our IL. */
1104 *tp
= TREE_OPERAND (ptr
, 0);
1108 *tp
= build1 (INDIRECT_REF
, type
, ptr
);
1109 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1110 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1111 TREE_READONLY (*tp
) = TREE_READONLY (old
);
1112 /* We cannot propagate the TREE_THIS_NOTRAP flag if we
1113 have remapped a parameter as the property might be
1114 valid only for the parameter itself. */
1115 if (TREE_THIS_NOTRAP (old
)
1116 && (!is_parm (TREE_OPERAND (old
, 0))
1117 || (!id
->transform_parameter
&& is_parm (ptr
))))
1118 TREE_THIS_NOTRAP (*tp
) = 1;
1125 else if (TREE_CODE (*tp
) == MEM_REF
)
1127 /* We need to re-canonicalize MEM_REFs from inline substitutions
1128 that can happen when a pointer argument is an ADDR_EXPR.
1129 Recurse here manually to allow that. */
1130 tree ptr
= TREE_OPERAND (*tp
, 0);
1131 tree type
= remap_type (TREE_TYPE (*tp
), id
);
1133 walk_tree (&ptr
, copy_tree_body_r
, data
, NULL
);
1134 *tp
= fold_build2 (MEM_REF
, type
, ptr
, TREE_OPERAND (*tp
, 1));
1135 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1136 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1137 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
1138 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
1139 remapped a parameter as the property might be valid only
1140 for the parameter itself. */
1141 if (TREE_THIS_NOTRAP (old
)
1142 && (!is_parm (TREE_OPERAND (old
, 0))
1143 || (!id
->transform_parameter
&& is_parm (ptr
))))
1144 TREE_THIS_NOTRAP (*tp
) = 1;
1149 /* Here is the "usual case". Copy this tree node, and then
1150 tweak some special cases. */
1151 copy_tree_r (tp
, walk_subtrees
, NULL
);
1153 /* If EXPR has block defined, map it to newly constructed block.
1154 When inlining we want EXPRs without block appear in the block
1155 of function call if we are not remapping a type. */
1158 new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
1159 if (TREE_BLOCK (*tp
))
1162 n
= (tree
*) pointer_map_contains (id
->decl_map
,
1167 TREE_SET_BLOCK (*tp
, new_block
);
1170 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
1171 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
1173 /* The copied TARGET_EXPR has never been expanded, even if the
1174 original node was expanded already. */
1175 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
1177 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
1178 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
1181 /* Variable substitution need not be simple. In particular, the
1182 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
1183 and friends are up-to-date. */
1184 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
1186 int invariant
= is_gimple_min_invariant (*tp
);
1187 walk_tree (&TREE_OPERAND (*tp
, 0), copy_tree_body_r
, id
, NULL
);
1189 /* Handle the case where we substituted an INDIRECT_REF
1190 into the operand of the ADDR_EXPR. */
1191 if (TREE_CODE (TREE_OPERAND (*tp
, 0)) == INDIRECT_REF
)
1192 *tp
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0);
1194 recompute_tree_invariant_for_addr_expr (*tp
);
1196 /* If this used to be invariant, but is not any longer,
1197 then regimplification is probably needed. */
1198 if (invariant
&& !is_gimple_min_invariant (*tp
))
1199 id
->regimplify
= true;
1205 /* Keep iterating. */
1209 /* Helper for remap_gimple_stmt. Given an EH region number for the
1210 source function, map that to the duplicate EH region number in
1211 the destination function. */
1214 remap_eh_region_nr (int old_nr
, copy_body_data
*id
)
1216 eh_region old_r
, new_r
;
1219 old_r
= get_eh_region_from_number_fn (id
->src_cfun
, old_nr
);
1220 slot
= pointer_map_contains (id
->eh_map
, old_r
);
1221 new_r
= (eh_region
) *slot
;
1223 return new_r
->index
;
1226 /* Similar, but operate on INTEGER_CSTs. */
1229 remap_eh_region_tree_nr (tree old_t_nr
, copy_body_data
*id
)
1233 old_nr
= tree_to_shwi (old_t_nr
);
1234 new_nr
= remap_eh_region_nr (old_nr
, id
);
1236 return build_int_cst (integer_type_node
, new_nr
);
1239 /* Helper for copy_bb. Remap statement STMT using the inlining
1240 information in ID. Return the new statement copy. */
1243 remap_gimple_stmt (gimple stmt
, copy_body_data
*id
)
1246 struct walk_stmt_info wi
;
1247 bool skip_first
= false;
1249 /* Begin by recognizing trees that we'll completely rewrite for the
1250 inlining context. Our output for these trees is completely
1251 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1252 into an edge). Further down, we'll handle trees that get
1253 duplicated and/or tweaked. */
1255 /* When requested, GIMPLE_RETURNs should be transformed to just the
1256 contained GIMPLE_ASSIGN. The branch semantics of the return will
1257 be handled elsewhere by manipulating the CFG rather than the
1259 if (gimple_code (stmt
) == GIMPLE_RETURN
&& id
->transform_return_to_modify
)
1261 tree retval
= gimple_return_retval (stmt
);
1263 /* If we're returning something, just turn that into an
1264 assignment into the equivalent of the original RESULT_DECL.
1265 If RETVAL is just the result decl, the result decl has
1266 already been set (e.g. a recent "foo (&result_decl, ...)");
1267 just toss the entire GIMPLE_RETURN. */
1269 && (TREE_CODE (retval
) != RESULT_DECL
1270 && (TREE_CODE (retval
) != SSA_NAME
1271 || ! SSA_NAME_VAR (retval
)
1272 || TREE_CODE (SSA_NAME_VAR (retval
)) != RESULT_DECL
)))
1274 copy
= gimple_build_assign (id
->do_not_unshare
1275 ? id
->retvar
: unshare_expr (id
->retvar
),
1277 /* id->retvar is already substituted. Skip it on later remapping. */
1281 return gimple_build_nop ();
1283 else if (gimple_has_substatements (stmt
))
1287 /* When cloning bodies from the C++ front end, we will be handed bodies
1288 in High GIMPLE form. Handle here all the High GIMPLE statements that
1289 have embedded statements. */
1290 switch (gimple_code (stmt
))
1293 copy
= copy_gimple_bind (stmt
, id
);
1297 s1
= remap_gimple_seq (gimple_catch_handler (stmt
), id
);
1298 copy
= gimple_build_catch (gimple_catch_types (stmt
), s1
);
1301 case GIMPLE_EH_FILTER
:
1302 s1
= remap_gimple_seq (gimple_eh_filter_failure (stmt
), id
);
1303 copy
= gimple_build_eh_filter (gimple_eh_filter_types (stmt
), s1
);
1307 s1
= remap_gimple_seq (gimple_try_eval (stmt
), id
);
1308 s2
= remap_gimple_seq (gimple_try_cleanup (stmt
), id
);
1309 copy
= gimple_build_try (s1
, s2
, gimple_try_kind (stmt
));
1312 case GIMPLE_WITH_CLEANUP_EXPR
:
1313 s1
= remap_gimple_seq (gimple_wce_cleanup (stmt
), id
);
1314 copy
= gimple_build_wce (s1
);
1317 case GIMPLE_OMP_PARALLEL
:
1318 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1319 copy
= gimple_build_omp_parallel
1321 gimple_omp_parallel_clauses (stmt
),
1322 gimple_omp_parallel_child_fn (stmt
),
1323 gimple_omp_parallel_data_arg (stmt
));
1326 case GIMPLE_OMP_TASK
:
1327 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1328 copy
= gimple_build_omp_task
1330 gimple_omp_task_clauses (stmt
),
1331 gimple_omp_task_child_fn (stmt
),
1332 gimple_omp_task_data_arg (stmt
),
1333 gimple_omp_task_copy_fn (stmt
),
1334 gimple_omp_task_arg_size (stmt
),
1335 gimple_omp_task_arg_align (stmt
));
1338 case GIMPLE_OMP_FOR
:
1339 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1340 s2
= remap_gimple_seq (gimple_omp_for_pre_body (stmt
), id
);
1341 copy
= gimple_build_omp_for (s1
, gimple_omp_for_kind (stmt
),
1342 gimple_omp_for_clauses (stmt
),
1343 gimple_omp_for_collapse (stmt
), s2
);
1346 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1348 gimple_omp_for_set_index (copy
, i
,
1349 gimple_omp_for_index (stmt
, i
));
1350 gimple_omp_for_set_initial (copy
, i
,
1351 gimple_omp_for_initial (stmt
, i
));
1352 gimple_omp_for_set_final (copy
, i
,
1353 gimple_omp_for_final (stmt
, i
));
1354 gimple_omp_for_set_incr (copy
, i
,
1355 gimple_omp_for_incr (stmt
, i
));
1356 gimple_omp_for_set_cond (copy
, i
,
1357 gimple_omp_for_cond (stmt
, i
));
1362 case GIMPLE_OMP_MASTER
:
1363 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1364 copy
= gimple_build_omp_master (s1
);
1367 case GIMPLE_OMP_TASKGROUP
:
1368 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1369 copy
= gimple_build_omp_taskgroup (s1
);
1372 case GIMPLE_OMP_ORDERED
:
1373 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1374 copy
= gimple_build_omp_ordered (s1
);
1377 case GIMPLE_OMP_SECTION
:
1378 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1379 copy
= gimple_build_omp_section (s1
);
1382 case GIMPLE_OMP_SECTIONS
:
1383 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1384 copy
= gimple_build_omp_sections
1385 (s1
, gimple_omp_sections_clauses (stmt
));
1388 case GIMPLE_OMP_SINGLE
:
1389 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1390 copy
= gimple_build_omp_single
1391 (s1
, gimple_omp_single_clauses (stmt
));
1394 case GIMPLE_OMP_TARGET
:
1395 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1396 copy
= gimple_build_omp_target
1397 (s1
, gimple_omp_target_kind (stmt
),
1398 gimple_omp_target_clauses (stmt
));
1401 case GIMPLE_OMP_TEAMS
:
1402 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1403 copy
= gimple_build_omp_teams
1404 (s1
, gimple_omp_teams_clauses (stmt
));
1407 case GIMPLE_OMP_CRITICAL
:
1408 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1410 = gimple_build_omp_critical (s1
, gimple_omp_critical_name (stmt
));
1413 case GIMPLE_TRANSACTION
:
1414 s1
= remap_gimple_seq (gimple_transaction_body (stmt
), id
);
1415 copy
= gimple_build_transaction (s1
, gimple_transaction_label (stmt
));
1416 gimple_transaction_set_subcode (copy
, gimple_transaction_subcode (stmt
));
1425 if (gimple_assign_copy_p (stmt
)
1426 && gimple_assign_lhs (stmt
) == gimple_assign_rhs1 (stmt
)
1427 && auto_var_in_fn_p (gimple_assign_lhs (stmt
), id
->src_fn
))
1429 /* Here we handle statements that are not completely rewritten.
1430 First we detect some inlining-induced bogosities for
1433 /* Some assignments VAR = VAR; don't generate any rtl code
1434 and thus don't count as variable modification. Avoid
1435 keeping bogosities like 0 = 0. */
1436 tree decl
= gimple_assign_lhs (stmt
), value
;
1439 n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
1443 STRIP_TYPE_NOPS (value
);
1444 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1445 return gimple_build_nop ();
1449 /* For *ptr_N ={v} {CLOBBER}, if ptr_N is SSA_NAME defined
1450 in a block that we aren't copying during tree_function_versioning,
1451 just drop the clobber stmt. */
1452 if (id
->blocks_to_copy
&& gimple_clobber_p (stmt
))
1454 tree lhs
= gimple_assign_lhs (stmt
);
1455 if (TREE_CODE (lhs
) == MEM_REF
1456 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == SSA_NAME
)
1458 gimple def_stmt
= SSA_NAME_DEF_STMT (TREE_OPERAND (lhs
, 0));
1459 if (gimple_bb (def_stmt
)
1460 && !bitmap_bit_p (id
->blocks_to_copy
,
1461 gimple_bb (def_stmt
)->index
))
1462 return gimple_build_nop ();
1466 if (gimple_debug_bind_p (stmt
))
1468 copy
= gimple_build_debug_bind (gimple_debug_bind_get_var (stmt
),
1469 gimple_debug_bind_get_value (stmt
),
1471 id
->debug_stmts
.safe_push (copy
);
1474 if (gimple_debug_source_bind_p (stmt
))
1476 copy
= gimple_build_debug_source_bind
1477 (gimple_debug_source_bind_get_var (stmt
),
1478 gimple_debug_source_bind_get_value (stmt
), stmt
);
1479 id
->debug_stmts
.safe_push (copy
);
1483 /* Create a new deep copy of the statement. */
1484 copy
= gimple_copy (stmt
);
1486 /* Clear flags that need revisiting. */
1487 if (is_gimple_call (copy
)
1488 && gimple_call_tail_p (copy
))
1489 gimple_call_set_tail (copy
, false);
1491 /* Remap the region numbers for __builtin_eh_{pointer,filter},
1492 RESX and EH_DISPATCH. */
1494 switch (gimple_code (copy
))
1498 tree r
, fndecl
= gimple_call_fndecl (copy
);
1499 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
1500 switch (DECL_FUNCTION_CODE (fndecl
))
1502 case BUILT_IN_EH_COPY_VALUES
:
1503 r
= gimple_call_arg (copy
, 1);
1504 r
= remap_eh_region_tree_nr (r
, id
);
1505 gimple_call_set_arg (copy
, 1, r
);
1508 case BUILT_IN_EH_POINTER
:
1509 case BUILT_IN_EH_FILTER
:
1510 r
= gimple_call_arg (copy
, 0);
1511 r
= remap_eh_region_tree_nr (r
, id
);
1512 gimple_call_set_arg (copy
, 0, r
);
1519 /* Reset alias info if we didn't apply measures to
1520 keep it valid over inlining by setting DECL_PT_UID. */
1521 if (!id
->src_cfun
->gimple_df
1522 || !id
->src_cfun
->gimple_df
->ipa_pta
)
1523 gimple_call_reset_alias_info (copy
);
1529 int r
= gimple_resx_region (copy
);
1530 r
= remap_eh_region_nr (r
, id
);
1531 gimple_resx_set_region (copy
, r
);
1535 case GIMPLE_EH_DISPATCH
:
1537 int r
= gimple_eh_dispatch_region (copy
);
1538 r
= remap_eh_region_nr (r
, id
);
1539 gimple_eh_dispatch_set_region (copy
, r
);
1548 /* If STMT has a block defined, map it to the newly constructed
1550 if (gimple_block (copy
))
1553 n
= (tree
*) pointer_map_contains (id
->decl_map
, gimple_block (copy
));
1555 gimple_set_block (copy
, *n
);
1558 if (gimple_debug_bind_p (copy
) || gimple_debug_source_bind_p (copy
))
1561 /* Remap all the operands in COPY. */
1562 memset (&wi
, 0, sizeof (wi
));
1565 walk_tree (gimple_op_ptr (copy
, 1), remap_gimple_op_r
, &wi
, NULL
);
1567 walk_gimple_op (copy
, remap_gimple_op_r
, &wi
);
1569 /* Clear the copied virtual operands. We are not remapping them here
1570 but are going to recreate them from scratch. */
1571 if (gimple_has_mem_ops (copy
))
1573 gimple_set_vdef (copy
, NULL_TREE
);
1574 gimple_set_vuse (copy
, NULL_TREE
);
1581 /* Copy basic block, scale profile accordingly. Edges will be taken care of
1585 copy_bb (copy_body_data
*id
, basic_block bb
, int frequency_scale
,
1586 gcov_type count_scale
)
1588 gimple_stmt_iterator gsi
, copy_gsi
, seq_gsi
;
1589 basic_block copy_basic_block
;
1594 /* Search for previous copied basic block. */
1597 prev
= prev
->prev_bb
;
1599 /* create_basic_block() will append every new block to
1600 basic_block_info automatically. */
1601 copy_basic_block
= create_basic_block (NULL
, (void *) 0,
1602 (basic_block
) prev
->aux
);
1603 copy_basic_block
->count
= apply_scale (bb
->count
, count_scale
);
1605 /* We are going to rebuild frequencies from scratch. These values
1606 have just small importance to drive canonicalize_loop_headers. */
1607 freq
= apply_scale ((gcov_type
)bb
->frequency
, frequency_scale
);
1609 /* We recompute frequencies after inlining, so this is quite safe. */
1610 if (freq
> BB_FREQ_MAX
)
1612 copy_basic_block
->frequency
= freq
;
1614 copy_gsi
= gsi_start_bb (copy_basic_block
);
1616 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1618 gimple stmt
= gsi_stmt (gsi
);
1619 gimple orig_stmt
= stmt
;
1621 id
->regimplify
= false;
1622 stmt
= remap_gimple_stmt (stmt
, id
);
1623 if (gimple_nop_p (stmt
))
1626 gimple_duplicate_stmt_histograms (cfun
, stmt
, id
->src_cfun
, orig_stmt
);
1629 /* With return slot optimization we can end up with
1630 non-gimple (foo *)&this->m, fix that here. */
1631 if (is_gimple_assign (stmt
)
1632 && gimple_assign_rhs_code (stmt
) == NOP_EXPR
1633 && !is_gimple_val (gimple_assign_rhs1 (stmt
)))
1636 new_rhs
= force_gimple_operand_gsi (&seq_gsi
,
1637 gimple_assign_rhs1 (stmt
),
1639 GSI_CONTINUE_LINKING
);
1640 gimple_assign_set_rhs1 (stmt
, new_rhs
);
1641 id
->regimplify
= false;
1644 gsi_insert_after (&seq_gsi
, stmt
, GSI_NEW_STMT
);
1647 gimple_regimplify_operands (stmt
, &seq_gsi
);
1649 /* If copy_basic_block has been empty at the start of this iteration,
1650 call gsi_start_bb again to get at the newly added statements. */
1651 if (gsi_end_p (copy_gsi
))
1652 copy_gsi
= gsi_start_bb (copy_basic_block
);
1654 gsi_next (©_gsi
);
1656 /* Process the new statement. The call to gimple_regimplify_operands
1657 possibly turned the statement into multiple statements, we
1658 need to process all of them. */
1663 stmt
= gsi_stmt (copy_gsi
);
1664 if (is_gimple_call (stmt
)
1665 && gimple_call_va_arg_pack_p (stmt
)
1668 /* __builtin_va_arg_pack () should be replaced by
1669 all arguments corresponding to ... in the caller. */
1673 size_t nargs
= gimple_call_num_args (id
->gimple_call
);
1676 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1679 /* Create the new array of arguments. */
1680 n
= nargs
+ gimple_call_num_args (stmt
);
1681 argarray
.create (n
);
1682 argarray
.safe_grow_cleared (n
);
1684 /* Copy all the arguments before '...' */
1685 memcpy (argarray
.address (),
1686 gimple_call_arg_ptr (stmt
, 0),
1687 gimple_call_num_args (stmt
) * sizeof (tree
));
1689 /* Append the arguments passed in '...' */
1690 memcpy (argarray
.address () + gimple_call_num_args (stmt
),
1691 gimple_call_arg_ptr (id
->gimple_call
, 0)
1692 + (gimple_call_num_args (id
->gimple_call
) - nargs
),
1693 nargs
* sizeof (tree
));
1695 new_call
= gimple_build_call_vec (gimple_call_fn (stmt
),
1698 argarray
.release ();
1700 /* Copy all GIMPLE_CALL flags, location and block, except
1701 GF_CALL_VA_ARG_PACK. */
1702 gimple_call_copy_flags (new_call
, stmt
);
1703 gimple_call_set_va_arg_pack (new_call
, false);
1704 gimple_set_location (new_call
, gimple_location (stmt
));
1705 gimple_set_block (new_call
, gimple_block (stmt
));
1706 gimple_call_set_lhs (new_call
, gimple_call_lhs (stmt
));
1708 gsi_replace (©_gsi
, new_call
, false);
1711 else if (is_gimple_call (stmt
)
1713 && (decl
= gimple_call_fndecl (stmt
))
1714 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
1715 && DECL_FUNCTION_CODE (decl
) == BUILT_IN_VA_ARG_PACK_LEN
)
1717 /* __builtin_va_arg_pack_len () should be replaced by
1718 the number of anonymous arguments. */
1719 size_t nargs
= gimple_call_num_args (id
->gimple_call
);
1723 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1726 count
= build_int_cst (integer_type_node
, nargs
);
1727 new_stmt
= gimple_build_assign (gimple_call_lhs (stmt
), count
);
1728 gsi_replace (©_gsi
, new_stmt
, false);
1732 /* Statements produced by inlining can be unfolded, especially
1733 when we constant propagated some operands. We can't fold
1734 them right now for two reasons:
1735 1) folding require SSA_NAME_DEF_STMTs to be correct
1736 2) we can't change function calls to builtins.
1737 So we just mark statement for later folding. We mark
1738 all new statements, instead just statements that has changed
1739 by some nontrivial substitution so even statements made
1740 foldable indirectly are updated. If this turns out to be
1741 expensive, copy_body can be told to watch for nontrivial
1743 if (id
->statements_to_fold
)
1744 pointer_set_insert (id
->statements_to_fold
, stmt
);
1746 /* We're duplicating a CALL_EXPR. Find any corresponding
1747 callgraph edges and update or duplicate them. */
1748 if (is_gimple_call (stmt
))
1750 struct cgraph_edge
*edge
;
1752 switch (id
->transform_call_graph_edges
)
1754 case CB_CGE_DUPLICATE
:
1755 edge
= cgraph_edge (id
->src_node
, orig_stmt
);
1758 int edge_freq
= edge
->frequency
;
1760 struct cgraph_edge
*old_edge
= edge
;
1761 edge
= cgraph_clone_edge (edge
, id
->dst_node
, stmt
,
1763 REG_BR_PROB_BASE
, CGRAPH_FREQ_BASE
,
1765 /* We could also just rescale the frequency, but
1766 doing so would introduce roundoff errors and make
1767 verifier unhappy. */
1768 new_freq
= compute_call_stmt_bb_frequency (id
->dst_node
->decl
,
1771 /* Speculative calls consist of two edges - direct and indirect.
1772 Duplicate the whole thing and distribute frequencies accordingly. */
1773 if (edge
->speculative
)
1775 struct cgraph_edge
*direct
, *indirect
;
1776 struct ipa_ref
*ref
;
1778 gcc_assert (!edge
->indirect_unknown_callee
);
1779 cgraph_speculative_call_info (old_edge
, direct
, indirect
, ref
);
1780 indirect
= cgraph_clone_edge (indirect
, id
->dst_node
, stmt
,
1782 REG_BR_PROB_BASE
, CGRAPH_FREQ_BASE
,
1784 if (old_edge
->frequency
+ indirect
->frequency
)
1786 edge
->frequency
= MIN (RDIV ((gcov_type
)new_freq
* old_edge
->frequency
,
1787 (old_edge
->frequency
+ indirect
->frequency
)),
1789 indirect
->frequency
= MIN (RDIV ((gcov_type
)new_freq
* indirect
->frequency
,
1790 (old_edge
->frequency
+ indirect
->frequency
)),
1793 ipa_clone_ref (ref
, id
->dst_node
, stmt
);
1797 edge
->frequency
= new_freq
;
1799 && profile_status_for_fn (cfun
) != PROFILE_ABSENT
1800 && (edge_freq
> edge
->frequency
+ 10
1801 || edge_freq
< edge
->frequency
- 10))
1803 fprintf (dump_file
, "Edge frequency estimated by "
1804 "cgraph %i diverge from inliner's estimate %i\n",
1808 "Orig bb: %i, orig bb freq %i, new bb freq %i\n",
1811 copy_basic_block
->frequency
);
1817 case CB_CGE_MOVE_CLONES
:
1818 cgraph_set_call_stmt_including_clones (id
->dst_node
,
1820 edge
= cgraph_edge (id
->dst_node
, stmt
);
1824 edge
= cgraph_edge (id
->dst_node
, orig_stmt
);
1826 cgraph_set_call_stmt (edge
, stmt
);
1833 /* Constant propagation on argument done during inlining
1834 may create new direct call. Produce an edge for it. */
1836 || (edge
->indirect_inlining_edge
1837 && id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
))
1838 && id
->dst_node
->definition
1839 && (fn
= gimple_call_fndecl (stmt
)) != NULL
)
1841 struct cgraph_node
*dest
= cgraph_get_node (fn
);
1843 /* We have missing edge in the callgraph. This can happen
1844 when previous inlining turned an indirect call into a
1845 direct call by constant propagating arguments or we are
1846 producing dead clone (for further cloning). In all
1847 other cases we hit a bug (incorrect node sharing is the
1848 most common reason for missing edges). */
1849 gcc_assert (!dest
->definition
1850 || dest
->address_taken
1851 || !id
->src_node
->definition
1852 || !id
->dst_node
->definition
);
1853 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
)
1854 cgraph_create_edge_including_clones
1855 (id
->dst_node
, dest
, orig_stmt
, stmt
, bb
->count
,
1856 compute_call_stmt_bb_frequency (id
->dst_node
->decl
,
1858 CIF_ORIGINALLY_INDIRECT_CALL
);
1860 cgraph_create_edge (id
->dst_node
, dest
, stmt
,
1862 compute_call_stmt_bb_frequency
1863 (id
->dst_node
->decl
,
1864 copy_basic_block
))->inline_failed
1865 = CIF_ORIGINALLY_INDIRECT_CALL
;
1868 fprintf (dump_file
, "Created new direct edge to %s\n",
1873 notice_special_calls (stmt
);
1876 maybe_duplicate_eh_stmt_fn (cfun
, stmt
, id
->src_cfun
, orig_stmt
,
1877 id
->eh_map
, id
->eh_lp_nr
);
1879 if (gimple_in_ssa_p (cfun
) && !is_gimple_debug (stmt
))
1884 FOR_EACH_SSA_TREE_OPERAND (def
, stmt
, i
, SSA_OP_DEF
)
1885 if (TREE_CODE (def
) == SSA_NAME
)
1886 SSA_NAME_DEF_STMT (def
) = stmt
;
1889 gsi_next (©_gsi
);
1891 while (!gsi_end_p (copy_gsi
));
1893 copy_gsi
= gsi_last_bb (copy_basic_block
);
1896 return copy_basic_block
;
1899 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
1900 form is quite easy, since dominator relationship for old basic blocks does
1903 There is however exception where inlining might change dominator relation
1904 across EH edges from basic block within inlined functions destinating
1905 to landing pads in function we inline into.
1907 The function fills in PHI_RESULTs of such PHI nodes if they refer
1908 to gimple regs. Otherwise, the function mark PHI_RESULT of such
1909 PHI nodes for renaming. For non-gimple regs, renaming is safe: the
1910 EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
1911 set, and this means that there will be no overlapping live ranges
1912 for the underlying symbol.
1914 This might change in future if we allow redirecting of EH edges and
1915 we might want to change way build CFG pre-inlining to include
1916 all the possible edges then. */
1918 update_ssa_across_abnormal_edges (basic_block bb
, basic_block ret_bb
,
1919 bool can_throw
, bool nonlocal_goto
)
1924 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1926 || ((basic_block
)e
->dest
->aux
)->index
== ENTRY_BLOCK
)
1929 gimple_stmt_iterator si
;
1932 gcc_assert (e
->flags
& EDGE_EH
);
1935 gcc_assert (!(e
->flags
& EDGE_EH
));
1937 for (si
= gsi_start_phis (e
->dest
); !gsi_end_p (si
); gsi_next (&si
))
1941 phi
= gsi_stmt (si
);
1943 /* For abnormal goto/call edges the receiver can be the
1944 ENTRY_BLOCK. Do not assert this cannot happen. */
1946 gcc_assert ((e
->flags
& EDGE_EH
)
1947 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi
)));
1949 re
= find_edge (ret_bb
, e
->dest
);
1950 gcc_checking_assert (re
);
1951 gcc_assert ((re
->flags
& (EDGE_EH
| EDGE_ABNORMAL
))
1952 == (e
->flags
& (EDGE_EH
| EDGE_ABNORMAL
)));
1954 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, e
),
1955 USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, re
)));
1961 /* Copy edges from BB into its copy constructed earlier, scale profile
1962 accordingly. Edges will be taken care of later. Assume aux
1963 pointers to point to the copies of each BB. Return true if any
1964 debug stmts are left after a statement that must end the basic block. */
1967 copy_edges_for_bb (basic_block bb
, gcov_type count_scale
, basic_block ret_bb
,
1968 basic_block abnormal_goto_dest
)
1970 basic_block new_bb
= (basic_block
) bb
->aux
;
1973 gimple_stmt_iterator si
;
1975 bool need_debug_cleanup
= false;
1977 /* Use the indices from the original blocks to create edges for the
1979 FOR_EACH_EDGE (old_edge
, ei
, bb
->succs
)
1980 if (!(old_edge
->flags
& EDGE_EH
))
1984 flags
= old_edge
->flags
;
1986 /* Return edges do get a FALLTHRU flag when the get inlined. */
1987 if (old_edge
->dest
->index
== EXIT_BLOCK
1988 && !(old_edge
->flags
& (EDGE_TRUE_VALUE
|EDGE_FALSE_VALUE
|EDGE_FAKE
))
1989 && old_edge
->dest
->aux
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
1990 flags
|= EDGE_FALLTHRU
;
1991 new_edge
= make_edge (new_bb
, (basic_block
) old_edge
->dest
->aux
, flags
);
1992 new_edge
->count
= apply_scale (old_edge
->count
, count_scale
);
1993 new_edge
->probability
= old_edge
->probability
;
1996 if (bb
->index
== ENTRY_BLOCK
|| bb
->index
== EXIT_BLOCK
)
1999 for (si
= gsi_start_bb (new_bb
); !gsi_end_p (si
);)
2002 bool can_throw
, nonlocal_goto
;
2004 copy_stmt
= gsi_stmt (si
);
2005 if (!is_gimple_debug (copy_stmt
))
2006 update_stmt (copy_stmt
);
2008 /* Do this before the possible split_block. */
2011 /* If this tree could throw an exception, there are two
2012 cases where we need to add abnormal edge(s): the
2013 tree wasn't in a region and there is a "current
2014 region" in the caller; or the original tree had
2015 EH edges. In both cases split the block after the tree,
2016 and add abnormal edge(s) as needed; we need both
2017 those from the callee and the caller.
2018 We check whether the copy can throw, because the const
2019 propagation can change an INDIRECT_REF which throws
2020 into a COMPONENT_REF which doesn't. If the copy
2021 can throw, the original could also throw. */
2022 can_throw
= stmt_can_throw_internal (copy_stmt
);
2024 = (stmt_can_make_abnormal_goto (copy_stmt
)
2025 && !computed_goto_p (copy_stmt
));
2027 if (can_throw
|| nonlocal_goto
)
2029 if (!gsi_end_p (si
))
2031 while (!gsi_end_p (si
) && is_gimple_debug (gsi_stmt (si
)))
2034 need_debug_cleanup
= true;
2036 if (!gsi_end_p (si
))
2037 /* Note that bb's predecessor edges aren't necessarily
2038 right at this point; split_block doesn't care. */
2040 edge e
= split_block (new_bb
, copy_stmt
);
2043 new_bb
->aux
= e
->src
->aux
;
2044 si
= gsi_start_bb (new_bb
);
2048 if (gimple_code (copy_stmt
) == GIMPLE_EH_DISPATCH
)
2049 make_eh_dispatch_edges (copy_stmt
);
2051 make_eh_edges (copy_stmt
);
2053 /* If the call we inline cannot make abnormal goto do not add
2054 additional abnormal edges but only retain those already present
2055 in the original function body. */
2056 if (abnormal_goto_dest
== NULL
)
2057 nonlocal_goto
= false;
2060 basic_block copy_stmt_bb
= gimple_bb (copy_stmt
);
2062 if (get_abnormal_succ_dispatcher (copy_stmt_bb
))
2063 nonlocal_goto
= false;
2064 /* ABNORMAL_DISPATCHER (1) is for longjmp/setjmp or nonlocal gotos
2065 in OpenMP regions which aren't allowed to be left abnormally.
2066 So, no need to add abnormal edge in that case. */
2067 else if (is_gimple_call (copy_stmt
)
2068 && gimple_call_internal_p (copy_stmt
)
2069 && (gimple_call_internal_fn (copy_stmt
)
2070 == IFN_ABNORMAL_DISPATCHER
)
2071 && gimple_call_arg (copy_stmt
, 0) == boolean_true_node
)
2072 nonlocal_goto
= false;
2074 make_edge (copy_stmt_bb
, abnormal_goto_dest
, EDGE_ABNORMAL
);
2077 if ((can_throw
|| nonlocal_goto
)
2078 && gimple_in_ssa_p (cfun
))
2079 update_ssa_across_abnormal_edges (gimple_bb (copy_stmt
), ret_bb
,
2080 can_throw
, nonlocal_goto
);
2082 return need_debug_cleanup
;
2085 /* Copy the PHIs. All blocks and edges are copied, some blocks
2086 was possibly split and new outgoing EH edges inserted.
2087 BB points to the block of original function and AUX pointers links
2088 the original and newly copied blocks. */
2091 copy_phis_for_bb (basic_block bb
, copy_body_data
*id
)
2093 basic_block
const new_bb
= (basic_block
) bb
->aux
;
2096 gimple_stmt_iterator si
;
2098 bool inserted
= false;
2100 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
2105 phi
= gsi_stmt (si
);
2106 res
= PHI_RESULT (phi
);
2108 if (!virtual_operand_p (res
))
2110 walk_tree (&new_res
, copy_tree_body_r
, id
, NULL
);
2111 new_phi
= create_phi_node (new_res
, new_bb
);
2112 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2114 edge old_edge
= find_edge ((basic_block
) new_edge
->src
->aux
, bb
);
2120 /* When doing partial cloning, we allow PHIs on the entry block
2121 as long as all the arguments are the same. Find any input
2122 edge to see argument to copy. */
2124 FOR_EACH_EDGE (old_edge
, ei2
, bb
->preds
)
2125 if (!old_edge
->src
->aux
)
2128 arg
= PHI_ARG_DEF_FROM_EDGE (phi
, old_edge
);
2130 walk_tree (&new_arg
, copy_tree_body_r
, id
, NULL
);
2131 gcc_assert (new_arg
);
2132 /* With return slot optimization we can end up with
2133 non-gimple (foo *)&this->m, fix that here. */
2134 if (TREE_CODE (new_arg
) != SSA_NAME
2135 && TREE_CODE (new_arg
) != FUNCTION_DECL
2136 && !is_gimple_val (new_arg
))
2138 gimple_seq stmts
= NULL
;
2139 new_arg
= force_gimple_operand (new_arg
, &stmts
, true, NULL
);
2140 gsi_insert_seq_on_edge (new_edge
, stmts
);
2143 locus
= gimple_phi_arg_location_from_edge (phi
, old_edge
);
2144 if (LOCATION_BLOCK (locus
))
2147 n
= (tree
*) pointer_map_contains (id
->decl_map
,
2148 LOCATION_BLOCK (locus
));
2151 locus
= COMBINE_LOCATION_DATA (line_table
, locus
, *n
);
2153 locus
= LOCATION_LOCUS (locus
);
2156 locus
= LOCATION_LOCUS (locus
);
2158 add_phi_arg (new_phi
, new_arg
, new_edge
, locus
);
2163 /* Commit the delayed edge insertions. */
2165 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2166 gsi_commit_one_edge_insert (new_edge
, NULL
);
2170 /* Wrapper for remap_decl so it can be used as a callback. */
2173 remap_decl_1 (tree decl
, void *data
)
2175 return remap_decl (decl
, (copy_body_data
*) data
);
2178 /* Build struct function and associated datastructures for the new clone
2179 NEW_FNDECL to be build. CALLEE_FNDECL is the original. Function changes
2180 the cfun to the function of new_fndecl (and current_function_decl too). */
2183 initialize_cfun (tree new_fndecl
, tree callee_fndecl
, gcov_type count
)
2185 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2186 gcov_type count_scale
;
2188 if (!DECL_ARGUMENTS (new_fndecl
))
2189 DECL_ARGUMENTS (new_fndecl
) = DECL_ARGUMENTS (callee_fndecl
);
2190 if (!DECL_RESULT (new_fndecl
))
2191 DECL_RESULT (new_fndecl
) = DECL_RESULT (callee_fndecl
);
2193 if (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
)
2195 = GCOV_COMPUTE_SCALE (count
,
2196 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
);
2198 count_scale
= REG_BR_PROB_BASE
;
2200 /* Register specific tree functions. */
2201 gimple_register_cfg_hooks ();
2203 /* Get clean struct function. */
2204 push_struct_function (new_fndecl
);
2206 /* We will rebuild these, so just sanity check that they are empty. */
2207 gcc_assert (VALUE_HISTOGRAMS (cfun
) == NULL
);
2208 gcc_assert (cfun
->local_decls
== NULL
);
2209 gcc_assert (cfun
->cfg
== NULL
);
2210 gcc_assert (cfun
->decl
== new_fndecl
);
2212 /* Copy items we preserve during cloning. */
2213 cfun
->static_chain_decl
= src_cfun
->static_chain_decl
;
2214 cfun
->nonlocal_goto_save_area
= src_cfun
->nonlocal_goto_save_area
;
2215 cfun
->function_end_locus
= src_cfun
->function_end_locus
;
2216 cfun
->curr_properties
= src_cfun
->curr_properties
;
2217 cfun
->last_verified
= src_cfun
->last_verified
;
2218 cfun
->va_list_gpr_size
= src_cfun
->va_list_gpr_size
;
2219 cfun
->va_list_fpr_size
= src_cfun
->va_list_fpr_size
;
2220 cfun
->has_nonlocal_label
= src_cfun
->has_nonlocal_label
;
2221 cfun
->stdarg
= src_cfun
->stdarg
;
2222 cfun
->after_inlining
= src_cfun
->after_inlining
;
2223 cfun
->can_throw_non_call_exceptions
2224 = src_cfun
->can_throw_non_call_exceptions
;
2225 cfun
->can_delete_dead_exceptions
= src_cfun
->can_delete_dead_exceptions
;
2226 cfun
->returns_struct
= src_cfun
->returns_struct
;
2227 cfun
->returns_pcc_struct
= src_cfun
->returns_pcc_struct
;
2229 init_empty_tree_cfg ();
2231 profile_status_for_fn (cfun
) = profile_status_for_fn (src_cfun
);
2232 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
=
2233 (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
* count_scale
/
2235 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
2236 = ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->frequency
;
2237 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
=
2238 (EXIT_BLOCK_PTR_FOR_FN (src_cfun
)->count
* count_scale
/
2240 EXIT_BLOCK_PTR_FOR_FN (cfun
)->frequency
=
2241 EXIT_BLOCK_PTR_FOR_FN (src_cfun
)->frequency
;
2243 init_eh_for_function ();
2245 if (src_cfun
->gimple_df
)
2247 init_tree_ssa (cfun
);
2248 cfun
->gimple_df
->in_ssa_p
= true;
2249 init_ssa_operands (cfun
);
2253 /* Helper function for copy_cfg_body. Move debug stmts from the end
2254 of NEW_BB to the beginning of successor basic blocks when needed. If the
2255 successor has multiple predecessors, reset them, otherwise keep
2259 maybe_move_debug_stmts_to_successors (copy_body_data
*id
, basic_block new_bb
)
2263 gimple_stmt_iterator si
= gsi_last_nondebug_bb (new_bb
);
2266 || gsi_one_before_end_p (si
)
2267 || !(stmt_can_throw_internal (gsi_stmt (si
))
2268 || stmt_can_make_abnormal_goto (gsi_stmt (si
))))
2271 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
2273 gimple_stmt_iterator ssi
= gsi_last_bb (new_bb
);
2274 gimple_stmt_iterator dsi
= gsi_after_labels (e
->dest
);
2275 while (is_gimple_debug (gsi_stmt (ssi
)))
2277 gimple stmt
= gsi_stmt (ssi
), new_stmt
;
2281 /* For the last edge move the debug stmts instead of copying
2283 if (ei_one_before_end_p (ei
))
2287 if (!single_pred_p (e
->dest
) && gimple_debug_bind_p (stmt
))
2288 gimple_debug_bind_reset_value (stmt
);
2289 gsi_remove (&si
, false);
2290 gsi_insert_before (&dsi
, stmt
, GSI_SAME_STMT
);
2294 if (gimple_debug_bind_p (stmt
))
2296 var
= gimple_debug_bind_get_var (stmt
);
2297 if (single_pred_p (e
->dest
))
2299 value
= gimple_debug_bind_get_value (stmt
);
2300 value
= unshare_expr (value
);
2304 new_stmt
= gimple_build_debug_bind (var
, value
, stmt
);
2306 else if (gimple_debug_source_bind_p (stmt
))
2308 var
= gimple_debug_source_bind_get_var (stmt
);
2309 value
= gimple_debug_source_bind_get_value (stmt
);
2310 new_stmt
= gimple_build_debug_source_bind (var
, value
, stmt
);
2314 gsi_insert_before (&dsi
, new_stmt
, GSI_SAME_STMT
);
2315 id
->debug_stmts
.safe_push (new_stmt
);
2321 /* Make a copy of the sub-loops of SRC_PARENT and place them
2322 as siblings of DEST_PARENT. */
2325 copy_loops (copy_body_data
*id
,
2326 struct loop
*dest_parent
, struct loop
*src_parent
)
2328 struct loop
*src_loop
= src_parent
->inner
;
2331 if (!id
->blocks_to_copy
2332 || bitmap_bit_p (id
->blocks_to_copy
, src_loop
->header
->index
))
2334 struct loop
*dest_loop
= alloc_loop ();
2336 /* Assign the new loop its header and latch and associate
2337 those with the new loop. */
2338 if (src_loop
->header
!= NULL
)
2340 dest_loop
->header
= (basic_block
)src_loop
->header
->aux
;
2341 dest_loop
->header
->loop_father
= dest_loop
;
2343 if (src_loop
->latch
!= NULL
)
2345 dest_loop
->latch
= (basic_block
)src_loop
->latch
->aux
;
2346 dest_loop
->latch
->loop_father
= dest_loop
;
2349 /* Copy loop meta-data. */
2350 copy_loop_info (src_loop
, dest_loop
);
2352 /* Finally place it into the loop array and the loop tree. */
2353 place_new_loop (cfun
, dest_loop
);
2354 flow_loop_tree_node_add (dest_parent
, dest_loop
);
2356 dest_loop
->safelen
= src_loop
->safelen
;
2357 dest_loop
->dont_vectorize
= src_loop
->dont_vectorize
;
2358 if (src_loop
->force_vectorize
)
2360 dest_loop
->force_vectorize
= true;
2361 cfun
->has_force_vectorize_loops
= true;
2363 if (src_loop
->simduid
)
2365 dest_loop
->simduid
= remap_decl (src_loop
->simduid
, id
);
2366 cfun
->has_simduid_loops
= true;
2370 copy_loops (id
, dest_loop
, src_loop
);
2372 src_loop
= src_loop
->next
;
2376 /* Call cgraph_redirect_edge_call_stmt_to_callee on all calls in BB */
2379 redirect_all_calls (copy_body_data
* id
, basic_block bb
)
2381 gimple_stmt_iterator si
;
2382 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
2384 if (is_gimple_call (gsi_stmt (si
)))
2386 struct cgraph_edge
*edge
= cgraph_edge (id
->dst_node
, gsi_stmt (si
));
2388 cgraph_redirect_edge_call_stmt_to_callee (edge
);
2393 /* Convert estimated frequencies into counts for NODE, scaling COUNT
2394 with each bb's frequency. Used when NODE has a 0-weight entry
2395 but we are about to inline it into a non-zero count call bb.
2396 See the comments for handle_missing_profiles() in predict.c for
2397 when this can happen for COMDATs. */
2400 freqs_to_counts (struct cgraph_node
*node
, gcov_type count
)
2405 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
2407 FOR_ALL_BB_FN(bb
, fn
)
2409 bb
->count
= apply_scale (count
,
2410 GCOV_COMPUTE_SCALE (bb
->frequency
, BB_FREQ_MAX
));
2411 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
2412 e
->count
= apply_probability (e
->src
->count
, e
->probability
);
2416 /* Make a copy of the body of FN so that it can be inserted inline in
2417 another function. Walks FN via CFG, returns new fndecl. */
2420 copy_cfg_body (copy_body_data
* id
, gcov_type count
, int frequency_scale
,
2421 basic_block entry_block_map
, basic_block exit_block_map
,
2422 basic_block new_entry
)
2424 tree callee_fndecl
= id
->src_fn
;
2425 /* Original cfun for the callee, doesn't change. */
2426 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2427 struct function
*cfun_to_copy
;
2429 tree new_fndecl
= NULL
;
2430 bool need_debug_cleanup
= false;
2431 gcov_type count_scale
;
2433 int incoming_frequency
= 0;
2434 gcov_type incoming_count
= 0;
2436 /* This can happen for COMDAT routines that end up with 0 counts
2437 despite being called (see the comments for handle_missing_profiles()
2438 in predict.c as to why). Apply counts to the blocks in the callee
2439 before inlining, using the guessed edge frequencies, so that we don't
2440 end up with a 0-count inline body which can confuse downstream
2441 optimizations such as function splitting. */
2442 if (!ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
&& count
)
2444 /* Apply the larger of the call bb count and the total incoming
2445 call edge count to the callee. */
2446 gcov_type in_count
= 0;
2447 struct cgraph_edge
*in_edge
;
2448 for (in_edge
= id
->src_node
->callers
; in_edge
;
2449 in_edge
= in_edge
->next_caller
)
2450 in_count
+= in_edge
->count
;
2451 freqs_to_counts (id
->src_node
, count
> in_count
? count
: in_count
);
2454 if (ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
)
2456 = GCOV_COMPUTE_SCALE (count
,
2457 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
);
2459 count_scale
= REG_BR_PROB_BASE
;
2461 /* Register specific tree functions. */
2462 gimple_register_cfg_hooks ();
2464 /* If we are inlining just region of the function, make sure to connect
2465 new entry to ENTRY_BLOCK_PTR_FOR_FN (cfun). Since new entry can be
2466 part of loop, we must compute frequency and probability of
2467 ENTRY_BLOCK_PTR_FOR_FN (cfun) based on the frequencies and
2468 probabilities of edges incoming from nonduplicated region. */
2474 FOR_EACH_EDGE (e
, ei
, new_entry
->preds
)
2477 incoming_frequency
+= EDGE_FREQUENCY (e
);
2478 incoming_count
+= e
->count
;
2480 incoming_count
= apply_scale (incoming_count
, count_scale
);
2482 = apply_scale ((gcov_type
)incoming_frequency
, frequency_scale
);
2483 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= incoming_count
;
2484 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
= incoming_frequency
;
2487 /* Must have a CFG here at this point. */
2488 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN
2489 (DECL_STRUCT_FUNCTION (callee_fndecl
)));
2491 cfun_to_copy
= id
->src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2493 ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy
)->aux
= entry_block_map
;
2494 EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy
)->aux
= exit_block_map
;
2495 entry_block_map
->aux
= ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy
);
2496 exit_block_map
->aux
= EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy
);
2498 /* Duplicate any exception-handling regions. */
2500 id
->eh_map
= duplicate_eh_regions (cfun_to_copy
, NULL
, id
->eh_lp_nr
,
2503 /* Use aux pointers to map the original blocks to copy. */
2504 FOR_EACH_BB_FN (bb
, cfun_to_copy
)
2505 if (!id
->blocks_to_copy
|| bitmap_bit_p (id
->blocks_to_copy
, bb
->index
))
2507 basic_block new_bb
= copy_bb (id
, bb
, frequency_scale
, count_scale
);
2510 new_bb
->loop_father
= entry_block_map
->loop_father
;
2513 last
= last_basic_block_for_fn (cfun
);
2515 /* Now that we've duplicated the blocks, duplicate their edges. */
2516 basic_block abnormal_goto_dest
= NULL
;
2518 && stmt_can_make_abnormal_goto (id
->gimple_call
))
2520 gimple_stmt_iterator gsi
= gsi_for_stmt (id
->gimple_call
);
2522 bb
= gimple_bb (id
->gimple_call
);
2524 if (gsi_end_p (gsi
))
2525 abnormal_goto_dest
= get_abnormal_succ_dispatcher (bb
);
2527 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2528 if (!id
->blocks_to_copy
2529 || (bb
->index
> 0 && bitmap_bit_p (id
->blocks_to_copy
, bb
->index
)))
2530 need_debug_cleanup
|= copy_edges_for_bb (bb
, count_scale
, exit_block_map
,
2531 abnormal_goto_dest
);
2535 edge e
= make_edge (entry_block_map
, (basic_block
)new_entry
->aux
, EDGE_FALLTHRU
);
2536 e
->probability
= REG_BR_PROB_BASE
;
2537 e
->count
= incoming_count
;
2540 /* Duplicate the loop tree, if available and wanted. */
2541 if (loops_for_fn (src_cfun
) != NULL
2542 && current_loops
!= NULL
)
2544 copy_loops (id
, entry_block_map
->loop_father
,
2545 get_loop (src_cfun
, 0));
2546 /* Defer to cfgcleanup to update loop-father fields of basic-blocks. */
2547 loops_state_set (LOOPS_NEED_FIXUP
);
2550 /* If the loop tree in the source function needed fixup, mark the
2551 destination loop tree for fixup, too. */
2552 if (loops_for_fn (src_cfun
)->state
& LOOPS_NEED_FIXUP
)
2553 loops_state_set (LOOPS_NEED_FIXUP
);
2555 if (gimple_in_ssa_p (cfun
))
2556 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2557 if (!id
->blocks_to_copy
2558 || (bb
->index
> 0 && bitmap_bit_p (id
->blocks_to_copy
, bb
->index
)))
2559 copy_phis_for_bb (bb
, id
);
2561 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2564 if (need_debug_cleanup
2565 && bb
->index
!= ENTRY_BLOCK
2566 && bb
->index
!= EXIT_BLOCK
)
2567 maybe_move_debug_stmts_to_successors (id
, (basic_block
) bb
->aux
);
2568 /* Update call edge destinations. This can not be done before loop
2569 info is updated, because we may split basic blocks. */
2570 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
)
2571 redirect_all_calls (id
, (basic_block
)bb
->aux
);
2572 ((basic_block
)bb
->aux
)->aux
= NULL
;
2576 /* Zero out AUX fields of newly created block during EH edge
2578 for (; last
< last_basic_block_for_fn (cfun
); last
++)
2580 if (need_debug_cleanup
)
2581 maybe_move_debug_stmts_to_successors (id
,
2582 BASIC_BLOCK_FOR_FN (cfun
, last
));
2583 BASIC_BLOCK_FOR_FN (cfun
, last
)->aux
= NULL
;
2584 /* Update call edge destinations. This can not be done before loop
2585 info is updated, because we may split basic blocks. */
2586 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
)
2587 redirect_all_calls (id
, BASIC_BLOCK_FOR_FN (cfun
, last
));
2589 entry_block_map
->aux
= NULL
;
2590 exit_block_map
->aux
= NULL
;
2594 pointer_map_destroy (id
->eh_map
);
2601 /* Copy the debug STMT using ID. We deal with these statements in a
2602 special way: if any variable in their VALUE expression wasn't
2603 remapped yet, we won't remap it, because that would get decl uids
2604 out of sync, causing codegen differences between -g and -g0. If
2605 this arises, we drop the VALUE expression altogether. */
2608 copy_debug_stmt (gimple stmt
, copy_body_data
*id
)
2611 struct walk_stmt_info wi
;
2613 if (gimple_block (stmt
))
2615 n
= (tree
*) pointer_map_contains (id
->decl_map
, gimple_block (stmt
));
2616 gimple_set_block (stmt
, n
? *n
: id
->block
);
2619 /* Remap all the operands in COPY. */
2620 memset (&wi
, 0, sizeof (wi
));
2623 processing_debug_stmt
= 1;
2625 if (gimple_debug_source_bind_p (stmt
))
2626 t
= gimple_debug_source_bind_get_var (stmt
);
2628 t
= gimple_debug_bind_get_var (stmt
);
2630 if (TREE_CODE (t
) == PARM_DECL
&& id
->debug_map
2631 && (n
= (tree
*) pointer_map_contains (id
->debug_map
, t
)))
2633 gcc_assert (TREE_CODE (*n
) == VAR_DECL
);
2636 else if (TREE_CODE (t
) == VAR_DECL
2637 && !is_global_var (t
)
2638 && !pointer_map_contains (id
->decl_map
, t
))
2639 /* T is a non-localized variable. */;
2641 walk_tree (&t
, remap_gimple_op_r
, &wi
, NULL
);
2643 if (gimple_debug_bind_p (stmt
))
2645 gimple_debug_bind_set_var (stmt
, t
);
2647 if (gimple_debug_bind_has_value_p (stmt
))
2648 walk_tree (gimple_debug_bind_get_value_ptr (stmt
),
2649 remap_gimple_op_r
, &wi
, NULL
);
2651 /* Punt if any decl couldn't be remapped. */
2652 if (processing_debug_stmt
< 0)
2653 gimple_debug_bind_reset_value (stmt
);
2655 else if (gimple_debug_source_bind_p (stmt
))
2657 gimple_debug_source_bind_set_var (stmt
, t
);
2658 walk_tree (gimple_debug_source_bind_get_value_ptr (stmt
),
2659 remap_gimple_op_r
, &wi
, NULL
);
2660 /* When inlining and source bind refers to one of the optimized
2661 away parameters, change the source bind into normal debug bind
2662 referring to the corresponding DEBUG_EXPR_DECL that should have
2663 been bound before the call stmt. */
2664 t
= gimple_debug_source_bind_get_value (stmt
);
2666 && TREE_CODE (t
) == PARM_DECL
2669 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (id
->src_fn
);
2671 if (debug_args
!= NULL
)
2673 for (i
= 0; i
< vec_safe_length (*debug_args
); i
+= 2)
2674 if ((**debug_args
)[i
] == DECL_ORIGIN (t
)
2675 && TREE_CODE ((**debug_args
)[i
+ 1]) == DEBUG_EXPR_DECL
)
2677 t
= (**debug_args
)[i
+ 1];
2678 stmt
->subcode
= GIMPLE_DEBUG_BIND
;
2679 gimple_debug_bind_set_value (stmt
, t
);
2686 processing_debug_stmt
= 0;
2691 /* Process deferred debug stmts. In order to give values better odds
2692 of being successfully remapped, we delay the processing of debug
2693 stmts until all other stmts that might require remapping are
2697 copy_debug_stmts (copy_body_data
*id
)
2702 if (!id
->debug_stmts
.exists ())
2705 FOR_EACH_VEC_ELT (id
->debug_stmts
, i
, stmt
)
2706 copy_debug_stmt (stmt
, id
);
2708 id
->debug_stmts
.release ();
2711 /* Make a copy of the body of SRC_FN so that it can be inserted inline in
2712 another function. */
2715 copy_tree_body (copy_body_data
*id
)
2717 tree fndecl
= id
->src_fn
;
2718 tree body
= DECL_SAVED_TREE (fndecl
);
2720 walk_tree (&body
, copy_tree_body_r
, id
, NULL
);
2725 /* Make a copy of the body of FN so that it can be inserted inline in
2726 another function. */
2729 copy_body (copy_body_data
*id
, gcov_type count
, int frequency_scale
,
2730 basic_block entry_block_map
, basic_block exit_block_map
,
2731 basic_block new_entry
)
2733 tree fndecl
= id
->src_fn
;
2736 /* If this body has a CFG, walk CFG and copy. */
2737 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (fndecl
)));
2738 body
= copy_cfg_body (id
, count
, frequency_scale
, entry_block_map
, exit_block_map
,
2740 copy_debug_stmts (id
);
2745 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
2746 defined in function FN, or of a data member thereof. */
2749 self_inlining_addr_expr (tree value
, tree fn
)
2753 if (TREE_CODE (value
) != ADDR_EXPR
)
2756 var
= get_base_address (TREE_OPERAND (value
, 0));
2758 return var
&& auto_var_in_fn_p (var
, fn
);
2761 /* Append to BB a debug annotation that binds VAR to VALUE, inheriting
2762 lexical block and line number information from base_stmt, if given,
2763 or from the last stmt of the block otherwise. */
2766 insert_init_debug_bind (copy_body_data
*id
,
2767 basic_block bb
, tree var
, tree value
,
2771 gimple_stmt_iterator gsi
;
2774 if (!gimple_in_ssa_p (id
->src_cfun
))
2777 if (!MAY_HAVE_DEBUG_STMTS
)
2780 tracked_var
= target_for_debug_bind (var
);
2786 gsi
= gsi_last_bb (bb
);
2787 if (!base_stmt
&& !gsi_end_p (gsi
))
2788 base_stmt
= gsi_stmt (gsi
);
2791 note
= gimple_build_debug_bind (tracked_var
, value
, base_stmt
);
2795 if (!gsi_end_p (gsi
))
2796 gsi_insert_after (&gsi
, note
, GSI_SAME_STMT
);
2798 gsi_insert_before (&gsi
, note
, GSI_SAME_STMT
);
2805 insert_init_stmt (copy_body_data
*id
, basic_block bb
, gimple init_stmt
)
2807 /* If VAR represents a zero-sized variable, it's possible that the
2808 assignment statement may result in no gimple statements. */
2811 gimple_stmt_iterator si
= gsi_last_bb (bb
);
2813 /* We can end up with init statements that store to a non-register
2814 from a rhs with a conversion. Handle that here by forcing the
2815 rhs into a temporary. gimple_regimplify_operands is not
2816 prepared to do this for us. */
2817 if (!is_gimple_debug (init_stmt
)
2818 && !is_gimple_reg (gimple_assign_lhs (init_stmt
))
2819 && is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (init_stmt
)))
2820 && gimple_assign_rhs_class (init_stmt
) == GIMPLE_UNARY_RHS
)
2822 tree rhs
= build1 (gimple_assign_rhs_code (init_stmt
),
2823 gimple_expr_type (init_stmt
),
2824 gimple_assign_rhs1 (init_stmt
));
2825 rhs
= force_gimple_operand_gsi (&si
, rhs
, true, NULL_TREE
, false,
2827 gimple_assign_set_rhs_code (init_stmt
, TREE_CODE (rhs
));
2828 gimple_assign_set_rhs1 (init_stmt
, rhs
);
2830 gsi_insert_after (&si
, init_stmt
, GSI_NEW_STMT
);
2831 gimple_regimplify_operands (init_stmt
, &si
);
2833 if (!is_gimple_debug (init_stmt
) && MAY_HAVE_DEBUG_STMTS
)
2835 tree def
= gimple_assign_lhs (init_stmt
);
2836 insert_init_debug_bind (id
, bb
, def
, def
, init_stmt
);
2841 /* Initialize parameter P with VALUE. If needed, produce init statement
2842 at the end of BB. When BB is NULL, we return init statement to be
2845 setup_one_parameter (copy_body_data
*id
, tree p
, tree value
, tree fn
,
2846 basic_block bb
, tree
*vars
)
2848 gimple init_stmt
= NULL
;
2851 tree def
= (gimple_in_ssa_p (cfun
)
2852 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
2855 && value
!= error_mark_node
2856 && !useless_type_conversion_p (TREE_TYPE (p
), TREE_TYPE (value
)))
2858 /* If we can match up types by promotion/demotion do so. */
2859 if (fold_convertible_p (TREE_TYPE (p
), value
))
2860 rhs
= fold_convert (TREE_TYPE (p
), value
);
2863 /* ??? For valid programs we should not end up here.
2864 Still if we end up with truly mismatched types here, fall back
2865 to using a VIEW_CONVERT_EXPR or a literal zero to not leak invalid
2866 GIMPLE to the following passes. */
2867 if (!is_gimple_reg_type (TREE_TYPE (value
))
2868 || TYPE_SIZE (TREE_TYPE (p
)) == TYPE_SIZE (TREE_TYPE (value
)))
2869 rhs
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (p
), value
);
2871 rhs
= build_zero_cst (TREE_TYPE (p
));
2875 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
2876 here since the type of this decl must be visible to the calling
2878 var
= copy_decl_to_var (p
, id
);
2880 /* Declare this new variable. */
2881 DECL_CHAIN (var
) = *vars
;
2884 /* Make gimplifier happy about this variable. */
2885 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
2887 /* If the parameter is never assigned to, has no SSA_NAMEs created,
2888 we would not need to create a new variable here at all, if it
2889 weren't for debug info. Still, we can just use the argument
2891 if (TREE_READONLY (p
)
2892 && !TREE_ADDRESSABLE (p
)
2893 && value
&& !TREE_SIDE_EFFECTS (value
)
2896 /* We may produce non-gimple trees by adding NOPs or introduce
2897 invalid sharing when operand is not really constant.
2898 It is not big deal to prohibit constant propagation here as
2899 we will constant propagate in DOM1 pass anyway. */
2900 if (is_gimple_min_invariant (value
)
2901 && useless_type_conversion_p (TREE_TYPE (p
),
2903 /* We have to be very careful about ADDR_EXPR. Make sure
2904 the base variable isn't a local variable of the inlined
2905 function, e.g., when doing recursive inlining, direct or
2906 mutually-recursive or whatever, which is why we don't
2907 just test whether fn == current_function_decl. */
2908 && ! self_inlining_addr_expr (value
, fn
))
2910 insert_decl_map (id
, p
, value
);
2911 insert_debug_decl_map (id
, p
, var
);
2912 return insert_init_debug_bind (id
, bb
, var
, value
, NULL
);
2916 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
2917 that way, when the PARM_DECL is encountered, it will be
2918 automatically replaced by the VAR_DECL. */
2919 insert_decl_map (id
, p
, var
);
2921 /* Even if P was TREE_READONLY, the new VAR should not be.
2922 In the original code, we would have constructed a
2923 temporary, and then the function body would have never
2924 changed the value of P. However, now, we will be
2925 constructing VAR directly. The constructor body may
2926 change its value multiple times as it is being
2927 constructed. Therefore, it must not be TREE_READONLY;
2928 the back-end assumes that TREE_READONLY variable is
2929 assigned to only once. */
2930 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p
)))
2931 TREE_READONLY (var
) = 0;
2933 /* If there is no setup required and we are in SSA, take the easy route
2934 replacing all SSA names representing the function parameter by the
2935 SSA name passed to function.
2937 We need to construct map for the variable anyway as it might be used
2938 in different SSA names when parameter is set in function.
2940 Do replacement at -O0 for const arguments replaced by constant.
2941 This is important for builtin_constant_p and other construct requiring
2942 constant argument to be visible in inlined function body. */
2943 if (gimple_in_ssa_p (cfun
) && rhs
&& def
&& is_gimple_reg (p
)
2945 || (TREE_READONLY (p
)
2946 && is_gimple_min_invariant (rhs
)))
2947 && (TREE_CODE (rhs
) == SSA_NAME
2948 || is_gimple_min_invariant (rhs
))
2949 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
2951 insert_decl_map (id
, def
, rhs
);
2952 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
2955 /* If the value of argument is never used, don't care about initializing
2957 if (optimize
&& gimple_in_ssa_p (cfun
) && !def
&& is_gimple_reg (p
))
2959 gcc_assert (!value
|| !TREE_SIDE_EFFECTS (value
));
2960 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
2963 /* Initialize this VAR_DECL from the equivalent argument. Convert
2964 the argument to the proper type in case it was promoted. */
2967 if (rhs
== error_mark_node
)
2969 insert_decl_map (id
, p
, var
);
2970 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
2973 STRIP_USELESS_TYPE_CONVERSION (rhs
);
2975 /* If we are in SSA form properly remap the default definition
2976 or assign to a dummy SSA name if the parameter is unused and
2977 we are not optimizing. */
2978 if (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
))
2982 def
= remap_ssa_name (def
, id
);
2983 init_stmt
= gimple_build_assign (def
, rhs
);
2984 SSA_NAME_IS_DEFAULT_DEF (def
) = 0;
2985 set_ssa_default_def (cfun
, var
, NULL
);
2989 def
= make_ssa_name (var
, NULL
);
2990 init_stmt
= gimple_build_assign (def
, rhs
);
2994 init_stmt
= gimple_build_assign (var
, rhs
);
2996 if (bb
&& init_stmt
)
2997 insert_init_stmt (id
, bb
, init_stmt
);
3002 /* Generate code to initialize the parameters of the function at the
3003 top of the stack in ID from the GIMPLE_CALL STMT. */
3006 initialize_inlined_parameters (copy_body_data
*id
, gimple stmt
,
3007 tree fn
, basic_block bb
)
3012 tree vars
= NULL_TREE
;
3013 tree static_chain
= gimple_call_chain (stmt
);
3015 /* Figure out what the parameters are. */
3016 parms
= DECL_ARGUMENTS (fn
);
3018 /* Loop through the parameter declarations, replacing each with an
3019 equivalent VAR_DECL, appropriately initialized. */
3020 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
3023 val
= i
< gimple_call_num_args (stmt
) ? gimple_call_arg (stmt
, i
) : NULL
;
3024 setup_one_parameter (id
, p
, val
, fn
, bb
, &vars
);
3026 /* After remapping parameters remap their types. This has to be done
3027 in a second loop over all parameters to appropriately remap
3028 variable sized arrays when the size is specified in a
3029 parameter following the array. */
3030 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
3032 tree
*varp
= (tree
*) pointer_map_contains (id
->decl_map
, p
);
3034 && TREE_CODE (*varp
) == VAR_DECL
)
3036 tree def
= (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
)
3037 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
3039 TREE_TYPE (var
) = remap_type (TREE_TYPE (var
), id
);
3040 /* Also remap the default definition if it was remapped
3041 to the default definition of the parameter replacement
3042 by the parameter setup. */
3045 tree
*defp
= (tree
*) pointer_map_contains (id
->decl_map
, def
);
3047 && TREE_CODE (*defp
) == SSA_NAME
3048 && SSA_NAME_VAR (*defp
) == var
)
3049 TREE_TYPE (*defp
) = TREE_TYPE (var
);
3054 /* Initialize the static chain. */
3055 p
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
3056 gcc_assert (fn
!= current_function_decl
);
3059 /* No static chain? Seems like a bug in tree-nested.c. */
3060 gcc_assert (static_chain
);
3062 setup_one_parameter (id
, p
, static_chain
, fn
, bb
, &vars
);
3065 declare_inline_vars (id
->block
, vars
);
3069 /* Declare a return variable to replace the RESULT_DECL for the
3070 function we are calling. An appropriate DECL_STMT is returned.
3071 The USE_STMT is filled to contain a use of the declaration to
3072 indicate the return value of the function.
3074 RETURN_SLOT, if non-null is place where to store the result. It
3075 is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null,
3076 was the LHS of the MODIFY_EXPR to which this call is the RHS.
3078 The return value is a (possibly null) value that holds the result
3079 as seen by the caller. */
3082 declare_return_variable (copy_body_data
*id
, tree return_slot
, tree modify_dest
,
3083 basic_block entry_bb
)
3085 tree callee
= id
->src_fn
;
3086 tree result
= DECL_RESULT (callee
);
3087 tree callee_type
= TREE_TYPE (result
);
3091 /* Handle type-mismatches in the function declaration return type
3092 vs. the call expression. */
3094 caller_type
= TREE_TYPE (modify_dest
);
3096 caller_type
= TREE_TYPE (TREE_TYPE (callee
));
3098 /* We don't need to do anything for functions that don't return anything. */
3099 if (VOID_TYPE_P (callee_type
))
3102 /* If there was a return slot, then the return value is the
3103 dereferenced address of that object. */
3106 /* The front end shouldn't have used both return_slot and
3107 a modify expression. */
3108 gcc_assert (!modify_dest
);
3109 if (DECL_BY_REFERENCE (result
))
3111 tree return_slot_addr
= build_fold_addr_expr (return_slot
);
3112 STRIP_USELESS_TYPE_CONVERSION (return_slot_addr
);
3114 /* We are going to construct *&return_slot and we can't do that
3115 for variables believed to be not addressable.
3117 FIXME: This check possibly can match, because values returned
3118 via return slot optimization are not believed to have address
3119 taken by alias analysis. */
3120 gcc_assert (TREE_CODE (return_slot
) != SSA_NAME
);
3121 var
= return_slot_addr
;
3126 gcc_assert (TREE_CODE (var
) != SSA_NAME
);
3127 if (TREE_ADDRESSABLE (result
))
3128 mark_addressable (var
);
3130 if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
3131 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
3132 && !DECL_GIMPLE_REG_P (result
)
3134 DECL_GIMPLE_REG_P (var
) = 0;
3139 /* All types requiring non-trivial constructors should have been handled. */
3140 gcc_assert (!TREE_ADDRESSABLE (callee_type
));
3142 /* Attempt to avoid creating a new temporary variable. */
3144 && TREE_CODE (modify_dest
) != SSA_NAME
)
3146 bool use_it
= false;
3148 /* We can't use MODIFY_DEST if there's type promotion involved. */
3149 if (!useless_type_conversion_p (callee_type
, caller_type
))
3152 /* ??? If we're assigning to a variable sized type, then we must
3153 reuse the destination variable, because we've no good way to
3154 create variable sized temporaries at this point. */
3155 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type
)) != INTEGER_CST
)
3158 /* If the callee cannot possibly modify MODIFY_DEST, then we can
3159 reuse it as the result of the call directly. Don't do this if
3160 it would promote MODIFY_DEST to addressable. */
3161 else if (TREE_ADDRESSABLE (result
))
3165 tree base_m
= get_base_address (modify_dest
);
3167 /* If the base isn't a decl, then it's a pointer, and we don't
3168 know where that's going to go. */
3169 if (!DECL_P (base_m
))
3171 else if (is_global_var (base_m
))
3173 else if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
3174 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
3175 && !DECL_GIMPLE_REG_P (result
)
3176 && DECL_GIMPLE_REG_P (base_m
))
3178 else if (!TREE_ADDRESSABLE (base_m
))
3190 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type
)) == INTEGER_CST
);
3192 var
= copy_result_decl_to_var (result
, id
);
3193 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
3195 /* Do not have the rest of GCC warn about this variable as it should
3196 not be visible to the user. */
3197 TREE_NO_WARNING (var
) = 1;
3199 declare_inline_vars (id
->block
, var
);
3201 /* Build the use expr. If the return type of the function was
3202 promoted, convert it back to the expected type. */
3204 if (!useless_type_conversion_p (caller_type
, TREE_TYPE (var
)))
3206 /* If we can match up types by promotion/demotion do so. */
3207 if (fold_convertible_p (caller_type
, var
))
3208 use
= fold_convert (caller_type
, var
);
3211 /* ??? For valid programs we should not end up here.
3212 Still if we end up with truly mismatched types here, fall back
3213 to using a MEM_REF to not leak invalid GIMPLE to the following
3215 /* Prevent var from being written into SSA form. */
3216 if (TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
3217 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
)
3218 DECL_GIMPLE_REG_P (var
) = false;
3219 else if (is_gimple_reg_type (TREE_TYPE (var
)))
3220 TREE_ADDRESSABLE (var
) = true;
3221 use
= fold_build2 (MEM_REF
, caller_type
,
3222 build_fold_addr_expr (var
),
3223 build_int_cst (ptr_type_node
, 0));
3227 STRIP_USELESS_TYPE_CONVERSION (use
);
3229 if (DECL_BY_REFERENCE (result
))
3231 TREE_ADDRESSABLE (var
) = 1;
3232 var
= build_fold_addr_expr (var
);
3236 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
3237 way, when the RESULT_DECL is encountered, it will be
3238 automatically replaced by the VAR_DECL.
3240 When returning by reference, ensure that RESULT_DECL remaps to
3242 if (DECL_BY_REFERENCE (result
)
3243 && !is_gimple_val (var
))
3245 tree temp
= create_tmp_var (TREE_TYPE (result
), "retvalptr");
3246 insert_decl_map (id
, result
, temp
);
3247 /* When RESULT_DECL is in SSA form, we need to remap and initialize
3248 it's default_def SSA_NAME. */
3249 if (gimple_in_ssa_p (id
->src_cfun
)
3250 && is_gimple_reg (result
))
3252 temp
= make_ssa_name (temp
, NULL
);
3253 insert_decl_map (id
, ssa_default_def (id
->src_cfun
, result
), temp
);
3255 insert_init_stmt (id
, entry_bb
, gimple_build_assign (temp
, var
));
3258 insert_decl_map (id
, result
, var
);
3260 /* Remember this so we can ignore it in remap_decls. */
3266 /* Callback through walk_tree. Determine if a DECL_INITIAL makes reference
3267 to a local label. */
3270 has_label_address_in_static_1 (tree
*nodep
, int *walk_subtrees
, void *fnp
)
3273 tree fn
= (tree
) fnp
;
3275 if (TREE_CODE (node
) == LABEL_DECL
&& DECL_CONTEXT (node
) == fn
)
3284 /* Determine if the function can be copied. If so return NULL. If
3285 not return a string describng the reason for failure. */
3288 copy_forbidden (struct function
*fun
, tree fndecl
)
3290 const char *reason
= fun
->cannot_be_copied_reason
;
3294 /* Only examine the function once. */
3295 if (fun
->cannot_be_copied_set
)
3298 /* We cannot copy a function that receives a non-local goto
3299 because we cannot remap the destination label used in the
3300 function that is performing the non-local goto. */
3301 /* ??? Actually, this should be possible, if we work at it.
3302 No doubt there's just a handful of places that simply
3303 assume it doesn't happen and don't substitute properly. */
3304 if (fun
->has_nonlocal_label
)
3306 reason
= G_("function %q+F can never be copied "
3307 "because it receives a non-local goto");
3311 FOR_EACH_LOCAL_DECL (fun
, ix
, decl
)
3312 if (TREE_CODE (decl
) == VAR_DECL
3313 && TREE_STATIC (decl
)
3314 && !DECL_EXTERNAL (decl
)
3315 && DECL_INITIAL (decl
)
3316 && walk_tree_without_duplicates (&DECL_INITIAL (decl
),
3317 has_label_address_in_static_1
,
3320 reason
= G_("function %q+F can never be copied because it saves "
3321 "address of local label in a static variable");
3326 fun
->cannot_be_copied_reason
= reason
;
3327 fun
->cannot_be_copied_set
= true;
3332 static const char *inline_forbidden_reason
;
3334 /* A callback for walk_gimple_seq to handle statements. Returns non-null
3335 iff a function can not be inlined. Also sets the reason why. */
3338 inline_forbidden_p_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
3339 struct walk_stmt_info
*wip
)
3341 tree fn
= (tree
) wip
->info
;
3343 gimple stmt
= gsi_stmt (*gsi
);
3345 switch (gimple_code (stmt
))
3348 /* Refuse to inline alloca call unless user explicitly forced so as
3349 this may change program's memory overhead drastically when the
3350 function using alloca is called in loop. In GCC present in
3351 SPEC2000 inlining into schedule_block cause it to require 2GB of
3352 RAM instead of 256MB. Don't do so for alloca calls emitted for
3353 VLA objects as those can't cause unbounded growth (they're always
3354 wrapped inside stack_save/stack_restore regions. */
3355 if (gimple_alloca_call_p (stmt
)
3356 && !gimple_call_alloca_for_var_p (stmt
)
3357 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
3359 inline_forbidden_reason
3360 = G_("function %q+F can never be inlined because it uses "
3361 "alloca (override using the always_inline attribute)");
3362 *handled_ops_p
= true;
3366 t
= gimple_call_fndecl (stmt
);
3370 /* We cannot inline functions that call setjmp. */
3371 if (setjmp_call_p (t
))
3373 inline_forbidden_reason
3374 = G_("function %q+F can never be inlined because it uses setjmp");
3375 *handled_ops_p
= true;
3379 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
3380 switch (DECL_FUNCTION_CODE (t
))
3382 /* We cannot inline functions that take a variable number of
3384 case BUILT_IN_VA_START
:
3385 case BUILT_IN_NEXT_ARG
:
3386 case BUILT_IN_VA_END
:
3387 inline_forbidden_reason
3388 = G_("function %q+F can never be inlined because it "
3389 "uses variable argument lists");
3390 *handled_ops_p
= true;
3393 case BUILT_IN_LONGJMP
:
3394 /* We can't inline functions that call __builtin_longjmp at
3395 all. The non-local goto machinery really requires the
3396 destination be in a different function. If we allow the
3397 function calling __builtin_longjmp to be inlined into the
3398 function calling __builtin_setjmp, Things will Go Awry. */
3399 inline_forbidden_reason
3400 = G_("function %q+F can never be inlined because "
3401 "it uses setjmp-longjmp exception handling");
3402 *handled_ops_p
= true;
3405 case BUILT_IN_NONLOCAL_GOTO
:
3407 inline_forbidden_reason
3408 = G_("function %q+F can never be inlined because "
3409 "it uses non-local goto");
3410 *handled_ops_p
= true;
3413 case BUILT_IN_RETURN
:
3414 case BUILT_IN_APPLY_ARGS
:
3415 /* If a __builtin_apply_args caller would be inlined,
3416 it would be saving arguments of the function it has
3417 been inlined into. Similarly __builtin_return would
3418 return from the function the inline has been inlined into. */
3419 inline_forbidden_reason
3420 = G_("function %q+F can never be inlined because "
3421 "it uses __builtin_return or __builtin_apply_args");
3422 *handled_ops_p
= true;
3431 t
= gimple_goto_dest (stmt
);
3433 /* We will not inline a function which uses computed goto. The
3434 addresses of its local labels, which may be tucked into
3435 global storage, are of course not constant across
3436 instantiations, which causes unexpected behavior. */
3437 if (TREE_CODE (t
) != LABEL_DECL
)
3439 inline_forbidden_reason
3440 = G_("function %q+F can never be inlined "
3441 "because it contains a computed goto");
3442 *handled_ops_p
= true;
3451 *handled_ops_p
= false;
3455 /* Return true if FNDECL is a function that cannot be inlined into
3459 inline_forbidden_p (tree fndecl
)
3461 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
3462 struct walk_stmt_info wi
;
3463 struct pointer_set_t
*visited_nodes
;
3465 bool forbidden_p
= false;
3467 /* First check for shared reasons not to copy the code. */
3468 inline_forbidden_reason
= copy_forbidden (fun
, fndecl
);
3469 if (inline_forbidden_reason
!= NULL
)
3472 /* Next, walk the statements of the function looking for
3473 constraucts we can't handle, or are non-optimal for inlining. */
3474 visited_nodes
= pointer_set_create ();
3475 memset (&wi
, 0, sizeof (wi
));
3476 wi
.info
= (void *) fndecl
;
3477 wi
.pset
= visited_nodes
;
3479 FOR_EACH_BB_FN (bb
, fun
)
3482 gimple_seq seq
= bb_seq (bb
);
3483 ret
= walk_gimple_seq (seq
, inline_forbidden_p_stmt
, NULL
, &wi
);
3484 forbidden_p
= (ret
!= NULL
);
3489 pointer_set_destroy (visited_nodes
);
3493 /* Return false if the function FNDECL cannot be inlined on account of its
3494 attributes, true otherwise. */
3496 function_attribute_inlinable_p (const_tree fndecl
)
3498 if (targetm
.attribute_table
)
3502 for (a
= DECL_ATTRIBUTES (fndecl
); a
; a
= TREE_CHAIN (a
))
3504 const_tree name
= TREE_PURPOSE (a
);
3507 for (i
= 0; targetm
.attribute_table
[i
].name
!= NULL
; i
++)
3508 if (is_attribute_p (targetm
.attribute_table
[i
].name
, name
))
3509 return targetm
.function_attribute_inlinable_p (fndecl
);
3516 /* Returns nonzero if FN is a function that does not have any
3517 fundamental inline blocking properties. */
3520 tree_inlinable_function_p (tree fn
)
3522 bool inlinable
= true;
3526 /* If we've already decided this function shouldn't be inlined,
3527 there's no need to check again. */
3528 if (DECL_UNINLINABLE (fn
))
3531 /* We only warn for functions declared `inline' by the user. */
3532 do_warning
= (warn_inline
3533 && DECL_DECLARED_INLINE_P (fn
)
3534 && !DECL_NO_INLINE_WARNING_P (fn
)
3535 && !DECL_IN_SYSTEM_HEADER (fn
));
3537 always_inline
= lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
));
3540 && always_inline
== NULL
)
3543 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3544 "is suppressed using -fno-inline", fn
);
3548 else if (!function_attribute_inlinable_p (fn
))
3551 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3552 "uses attributes conflicting with inlining", fn
);
3556 else if (inline_forbidden_p (fn
))
3558 /* See if we should warn about uninlinable functions. Previously,
3559 some of these warnings would be issued while trying to expand
3560 the function inline, but that would cause multiple warnings
3561 about functions that would for example call alloca. But since
3562 this a property of the function, just one warning is enough.
3563 As a bonus we can now give more details about the reason why a
3564 function is not inlinable. */
3566 error (inline_forbidden_reason
, fn
);
3567 else if (do_warning
)
3568 warning (OPT_Winline
, inline_forbidden_reason
, fn
);
3573 /* Squirrel away the result so that we don't have to check again. */
3574 DECL_UNINLINABLE (fn
) = !inlinable
;
3579 /* Estimate the cost of a memory move. Use machine dependent
3580 word size and take possible memcpy call into account. */
3583 estimate_move_cost (tree type
)
3587 gcc_assert (!VOID_TYPE_P (type
));
3589 if (TREE_CODE (type
) == VECTOR_TYPE
)
3591 enum machine_mode inner
= TYPE_MODE (TREE_TYPE (type
));
3592 enum machine_mode simd
3593 = targetm
.vectorize
.preferred_simd_mode (inner
);
3594 int simd_mode_size
= GET_MODE_SIZE (simd
);
3595 return ((GET_MODE_SIZE (TYPE_MODE (type
)) + simd_mode_size
- 1)
3599 size
= int_size_in_bytes (type
);
3601 if (size
< 0 || size
> MOVE_MAX_PIECES
* MOVE_RATIO (!optimize_size
))
3602 /* Cost of a memcpy call, 3 arguments and the call. */
3605 return ((size
+ MOVE_MAX_PIECES
- 1) / MOVE_MAX_PIECES
);
3608 /* Returns cost of operation CODE, according to WEIGHTS */
3611 estimate_operator_cost (enum tree_code code
, eni_weights
*weights
,
3612 tree op1 ATTRIBUTE_UNUSED
, tree op2
)
3616 /* These are "free" conversions, or their presumed cost
3617 is folded into other operations. */
3622 case VIEW_CONVERT_EXPR
:
3625 /* Assign cost of 1 to usual operations.
3626 ??? We may consider mapping RTL costs to this. */
3632 case POINTER_PLUS_EXPR
:
3635 case MULT_HIGHPART_EXPR
:
3638 case ADDR_SPACE_CONVERT_EXPR
:
3639 case FIXED_CONVERT_EXPR
:
3640 case FIX_TRUNC_EXPR
:
3652 case VEC_LSHIFT_EXPR
:
3653 case VEC_RSHIFT_EXPR
:
3660 case TRUTH_ANDIF_EXPR
:
3661 case TRUTH_ORIF_EXPR
:
3662 case TRUTH_AND_EXPR
:
3664 case TRUTH_XOR_EXPR
:
3665 case TRUTH_NOT_EXPR
:
3674 case UNORDERED_EXPR
:
3685 case PREDECREMENT_EXPR
:
3686 case PREINCREMENT_EXPR
:
3687 case POSTDECREMENT_EXPR
:
3688 case POSTINCREMENT_EXPR
:
3690 case REALIGN_LOAD_EXPR
:
3692 case REDUC_MAX_EXPR
:
3693 case REDUC_MIN_EXPR
:
3694 case REDUC_PLUS_EXPR
:
3695 case WIDEN_SUM_EXPR
:
3696 case WIDEN_MULT_EXPR
:
3698 case WIDEN_MULT_PLUS_EXPR
:
3699 case WIDEN_MULT_MINUS_EXPR
:
3700 case WIDEN_LSHIFT_EXPR
:
3702 case VEC_WIDEN_MULT_HI_EXPR
:
3703 case VEC_WIDEN_MULT_LO_EXPR
:
3704 case VEC_WIDEN_MULT_EVEN_EXPR
:
3705 case VEC_WIDEN_MULT_ODD_EXPR
:
3706 case VEC_UNPACK_HI_EXPR
:
3707 case VEC_UNPACK_LO_EXPR
:
3708 case VEC_UNPACK_FLOAT_HI_EXPR
:
3709 case VEC_UNPACK_FLOAT_LO_EXPR
:
3710 case VEC_PACK_TRUNC_EXPR
:
3711 case VEC_PACK_SAT_EXPR
:
3712 case VEC_PACK_FIX_TRUNC_EXPR
:
3713 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3714 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3718 /* Few special cases of expensive operations. This is useful
3719 to avoid inlining on functions having too many of these. */
3720 case TRUNC_DIV_EXPR
:
3722 case FLOOR_DIV_EXPR
:
3723 case ROUND_DIV_EXPR
:
3724 case EXACT_DIV_EXPR
:
3725 case TRUNC_MOD_EXPR
:
3727 case FLOOR_MOD_EXPR
:
3728 case ROUND_MOD_EXPR
:
3730 if (TREE_CODE (op2
) != INTEGER_CST
)
3731 return weights
->div_mod_cost
;
3735 /* We expect a copy assignment with no operator. */
3736 gcc_assert (get_gimple_rhs_class (code
) == GIMPLE_SINGLE_RHS
);
3742 /* Estimate number of instructions that will be created by expanding
3743 the statements in the statement sequence STMTS.
3744 WEIGHTS contains weights attributed to various constructs. */
3747 int estimate_num_insns_seq (gimple_seq stmts
, eni_weights
*weights
)
3750 gimple_stmt_iterator gsi
;
3753 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3754 cost
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
3760 /* Estimate number of instructions that will be created by expanding STMT.
3761 WEIGHTS contains weights attributed to various constructs. */
3764 estimate_num_insns (gimple stmt
, eni_weights
*weights
)
3767 enum gimple_code code
= gimple_code (stmt
);
3774 /* Try to estimate the cost of assignments. We have three cases to
3776 1) Simple assignments to registers;
3777 2) Stores to things that must live in memory. This includes
3778 "normal" stores to scalars, but also assignments of large
3779 structures, or constructors of big arrays;
3781 Let us look at the first two cases, assuming we have "a = b + C":
3782 <GIMPLE_ASSIGN <var_decl "a">
3783 <plus_expr <var_decl "b"> <constant C>>
3784 If "a" is a GIMPLE register, the assignment to it is free on almost
3785 any target, because "a" usually ends up in a real register. Hence
3786 the only cost of this expression comes from the PLUS_EXPR, and we
3787 can ignore the GIMPLE_ASSIGN.
3788 If "a" is not a GIMPLE register, the assignment to "a" will most
3789 likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost
3790 of moving something into "a", which we compute using the function
3791 estimate_move_cost. */
3792 if (gimple_clobber_p (stmt
))
3793 return 0; /* ={v} {CLOBBER} stmt expands to nothing. */
3795 lhs
= gimple_assign_lhs (stmt
);
3796 rhs
= gimple_assign_rhs1 (stmt
);
3800 /* Account for the cost of moving to / from memory. */
3801 if (gimple_store_p (stmt
))
3802 cost
+= estimate_move_cost (TREE_TYPE (lhs
));
3803 if (gimple_assign_load_p (stmt
))
3804 cost
+= estimate_move_cost (TREE_TYPE (rhs
));
3806 cost
+= estimate_operator_cost (gimple_assign_rhs_code (stmt
), weights
,
3807 gimple_assign_rhs1 (stmt
),
3808 get_gimple_rhs_class (gimple_assign_rhs_code (stmt
))
3809 == GIMPLE_BINARY_RHS
3810 ? gimple_assign_rhs2 (stmt
) : NULL
);
3814 cost
= 1 + estimate_operator_cost (gimple_cond_code (stmt
), weights
,
3815 gimple_op (stmt
, 0),
3816 gimple_op (stmt
, 1));
3820 /* Take into account cost of the switch + guess 2 conditional jumps for
3823 TODO: once the switch expansion logic is sufficiently separated, we can
3824 do better job on estimating cost of the switch. */
3825 if (weights
->time_based
)
3826 cost
= floor_log2 (gimple_switch_num_labels (stmt
)) * 2;
3828 cost
= gimple_switch_num_labels (stmt
) * 2;
3835 if (gimple_call_internal_p (stmt
))
3837 else if ((decl
= gimple_call_fndecl (stmt
))
3838 && DECL_BUILT_IN (decl
))
3840 /* Do not special case builtins where we see the body.
3841 This just confuse inliner. */
3842 struct cgraph_node
*node
;
3843 if (!(node
= cgraph_get_node (decl
))
3844 || node
->definition
)
3846 /* For buitins that are likely expanded to nothing or
3847 inlined do not account operand costs. */
3848 else if (is_simple_builtin (decl
))
3850 else if (is_inexpensive_builtin (decl
))
3851 return weights
->target_builtin_call_cost
;
3852 else if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
3854 /* We canonicalize x * x to pow (x, 2.0) with -ffast-math, so
3855 specialize the cheap expansion we do here.
3856 ??? This asks for a more general solution. */
3857 switch (DECL_FUNCTION_CODE (decl
))
3862 if (TREE_CODE (gimple_call_arg (stmt
, 1)) == REAL_CST
3863 && REAL_VALUES_EQUAL
3864 (TREE_REAL_CST (gimple_call_arg (stmt
, 1)), dconst2
))
3865 return estimate_operator_cost
3866 (MULT_EXPR
, weights
, gimple_call_arg (stmt
, 0),
3867 gimple_call_arg (stmt
, 0));
3876 cost
= decl
? weights
->call_cost
: weights
->indirect_call_cost
;
3877 if (gimple_call_lhs (stmt
))
3878 cost
+= estimate_move_cost (TREE_TYPE (gimple_call_lhs (stmt
)));
3879 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
3881 tree arg
= gimple_call_arg (stmt
, i
);
3882 cost
+= estimate_move_cost (TREE_TYPE (arg
));
3888 return weights
->return_cost
;
3894 case GIMPLE_PREDICT
:
3900 int count
= asm_str_count (gimple_asm_string (stmt
));
3901 /* 1000 means infinity. This avoids overflows later
3902 with very long asm statements. */
3909 /* This is either going to be an external function call with one
3910 argument, or two register copy statements plus a goto. */
3913 case GIMPLE_EH_DISPATCH
:
3914 /* ??? This is going to turn into a switch statement. Ideally
3915 we'd have a look at the eh region and estimate the number of
3920 return estimate_num_insns_seq (gimple_bind_body (stmt
), weights
);
3922 case GIMPLE_EH_FILTER
:
3923 return estimate_num_insns_seq (gimple_eh_filter_failure (stmt
), weights
);
3926 return estimate_num_insns_seq (gimple_catch_handler (stmt
), weights
);
3929 return (estimate_num_insns_seq (gimple_try_eval (stmt
), weights
)
3930 + estimate_num_insns_seq (gimple_try_cleanup (stmt
), weights
));
3932 /* OpenMP directives are generally very expensive. */
3934 case GIMPLE_OMP_RETURN
:
3935 case GIMPLE_OMP_SECTIONS_SWITCH
:
3936 case GIMPLE_OMP_ATOMIC_STORE
:
3937 case GIMPLE_OMP_CONTINUE
:
3938 /* ...except these, which are cheap. */
3941 case GIMPLE_OMP_ATOMIC_LOAD
:
3942 return weights
->omp_cost
;
3944 case GIMPLE_OMP_FOR
:
3945 return (weights
->omp_cost
3946 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
)
3947 + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt
), weights
));
3949 case GIMPLE_OMP_PARALLEL
:
3950 case GIMPLE_OMP_TASK
:
3951 case GIMPLE_OMP_CRITICAL
:
3952 case GIMPLE_OMP_MASTER
:
3953 case GIMPLE_OMP_TASKGROUP
:
3954 case GIMPLE_OMP_ORDERED
:
3955 case GIMPLE_OMP_SECTION
:
3956 case GIMPLE_OMP_SECTIONS
:
3957 case GIMPLE_OMP_SINGLE
:
3958 case GIMPLE_OMP_TARGET
:
3959 case GIMPLE_OMP_TEAMS
:
3960 return (weights
->omp_cost
3961 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
));
3963 case GIMPLE_TRANSACTION
:
3964 return (weights
->tm_cost
3965 + estimate_num_insns_seq (gimple_transaction_body (stmt
),
3975 /* Estimate number of instructions that will be created by expanding
3976 function FNDECL. WEIGHTS contains weights attributed to various
3980 estimate_num_insns_fn (tree fndecl
, eni_weights
*weights
)
3982 struct function
*my_function
= DECL_STRUCT_FUNCTION (fndecl
);
3983 gimple_stmt_iterator bsi
;
3987 gcc_assert (my_function
&& my_function
->cfg
);
3988 FOR_EACH_BB_FN (bb
, my_function
)
3990 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
3991 n
+= estimate_num_insns (gsi_stmt (bsi
), weights
);
3998 /* Initializes weights used by estimate_num_insns. */
4001 init_inline_once (void)
4003 eni_size_weights
.call_cost
= 1;
4004 eni_size_weights
.indirect_call_cost
= 3;
4005 eni_size_weights
.target_builtin_call_cost
= 1;
4006 eni_size_weights
.div_mod_cost
= 1;
4007 eni_size_weights
.omp_cost
= 40;
4008 eni_size_weights
.tm_cost
= 10;
4009 eni_size_weights
.time_based
= false;
4010 eni_size_weights
.return_cost
= 1;
4012 /* Estimating time for call is difficult, since we have no idea what the
4013 called function does. In the current uses of eni_time_weights,
4014 underestimating the cost does less harm than overestimating it, so
4015 we choose a rather small value here. */
4016 eni_time_weights
.call_cost
= 10;
4017 eni_time_weights
.indirect_call_cost
= 15;
4018 eni_time_weights
.target_builtin_call_cost
= 1;
4019 eni_time_weights
.div_mod_cost
= 10;
4020 eni_time_weights
.omp_cost
= 40;
4021 eni_time_weights
.tm_cost
= 40;
4022 eni_time_weights
.time_based
= true;
4023 eni_time_weights
.return_cost
= 2;
4026 /* Estimate the number of instructions in a gimple_seq. */
4029 count_insns_seq (gimple_seq seq
, eni_weights
*weights
)
4031 gimple_stmt_iterator gsi
;
4033 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4034 n
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
4040 /* Install new lexical TREE_BLOCK underneath 'current_block'. */
4043 prepend_lexical_block (tree current_block
, tree new_block
)
4045 BLOCK_CHAIN (new_block
) = BLOCK_SUBBLOCKS (current_block
);
4046 BLOCK_SUBBLOCKS (current_block
) = new_block
;
4047 BLOCK_SUPERCONTEXT (new_block
) = current_block
;
4050 /* Add local variables from CALLEE to CALLER. */
4053 add_local_variables (struct function
*callee
, struct function
*caller
,
4059 FOR_EACH_LOCAL_DECL (callee
, ix
, var
)
4060 if (!can_be_nonlocal (var
, id
))
4062 tree new_var
= remap_decl (var
, id
);
4064 /* Remap debug-expressions. */
4065 if (TREE_CODE (new_var
) == VAR_DECL
4066 && DECL_HAS_DEBUG_EXPR_P (var
)
4069 tree tem
= DECL_DEBUG_EXPR (var
);
4070 bool old_regimplify
= id
->regimplify
;
4071 id
->remapping_type_depth
++;
4072 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
4073 id
->remapping_type_depth
--;
4074 id
->regimplify
= old_regimplify
;
4075 SET_DECL_DEBUG_EXPR (new_var
, tem
);
4076 DECL_HAS_DEBUG_EXPR_P (new_var
) = 1;
4078 add_local_decl (caller
, new_var
);
4082 /* If STMT is a GIMPLE_CALL, replace it with its inline expansion. */
4085 expand_call_inline (basic_block bb
, gimple stmt
, copy_body_data
*id
)
4089 struct pointer_map_t
*st
, *dst
;
4092 location_t saved_location
;
4093 struct cgraph_edge
*cg_edge
;
4094 cgraph_inline_failed_t reason
;
4095 basic_block return_block
;
4097 gimple_stmt_iterator gsi
, stmt_gsi
;
4098 bool successfully_inlined
= FALSE
;
4099 bool purge_dead_abnormal_edges
;
4101 /* Set input_location here so we get the right instantiation context
4102 if we call instantiate_decl from inlinable_function_p. */
4103 /* FIXME: instantiate_decl isn't called by inlinable_function_p. */
4104 saved_location
= input_location
;
4105 input_location
= gimple_location (stmt
);
4107 /* From here on, we're only interested in CALL_EXPRs. */
4108 if (gimple_code (stmt
) != GIMPLE_CALL
)
4111 cg_edge
= cgraph_edge (id
->dst_node
, stmt
);
4112 gcc_checking_assert (cg_edge
);
4113 /* First, see if we can figure out what function is being called.
4114 If we cannot, then there is no hope of inlining the function. */
4115 if (cg_edge
->indirect_unknown_callee
)
4117 fn
= cg_edge
->callee
->decl
;
4118 gcc_checking_assert (fn
);
4120 /* If FN is a declaration of a function in a nested scope that was
4121 globally declared inline, we don't set its DECL_INITIAL.
4122 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
4123 C++ front-end uses it for cdtors to refer to their internal
4124 declarations, that are not real functions. Fortunately those
4125 don't have trees to be saved, so we can tell by checking their
4127 if (!DECL_INITIAL (fn
)
4128 && DECL_ABSTRACT_ORIGIN (fn
)
4129 && gimple_has_body_p (DECL_ABSTRACT_ORIGIN (fn
)))
4130 fn
= DECL_ABSTRACT_ORIGIN (fn
);
4132 /* Don't try to inline functions that are not well-suited to inlining. */
4133 if (cg_edge
->inline_failed
)
4135 reason
= cg_edge
->inline_failed
;
4136 /* If this call was originally indirect, we do not want to emit any
4137 inlining related warnings or sorry messages because there are no
4138 guarantees regarding those. */
4139 if (cg_edge
->indirect_inlining_edge
)
4142 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
))
4143 /* For extern inline functions that get redefined we always
4144 silently ignored always_inline flag. Better behaviour would
4145 be to be able to keep both bodies and use extern inline body
4146 for inlining, but we can't do that because frontends overwrite
4148 && !cg_edge
->callee
->local
.redefined_extern_inline
4149 /* During early inline pass, report only when optimization is
4151 && (cgraph_global_info_ready
4153 || cgraph_inline_failed_type (reason
) == CIF_FINAL_ERROR
)
4154 /* PR 20090218-1_0.c. Body can be provided by another module. */
4155 && (reason
!= CIF_BODY_NOT_AVAILABLE
|| !flag_generate_lto
))
4157 error ("inlining failed in call to always_inline %q+F: %s", fn
,
4158 cgraph_inline_failed_string (reason
));
4159 error ("called from here");
4161 else if (warn_inline
4162 && DECL_DECLARED_INLINE_P (fn
)
4163 && !DECL_NO_INLINE_WARNING_P (fn
)
4164 && !DECL_IN_SYSTEM_HEADER (fn
)
4165 && reason
!= CIF_UNSPECIFIED
4166 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn
))
4167 /* Do not warn about not inlined recursive calls. */
4168 && !cgraph_edge_recursive_p (cg_edge
)
4169 /* Avoid warnings during early inline pass. */
4170 && cgraph_global_info_ready
)
4172 warning (OPT_Winline
, "inlining failed in call to %q+F: %s",
4173 fn
, _(cgraph_inline_failed_string (reason
)));
4174 warning (OPT_Winline
, "called from here");
4178 fn
= cg_edge
->callee
->decl
;
4179 cgraph_get_body (cg_edge
->callee
);
4181 #ifdef ENABLE_CHECKING
4182 if (cg_edge
->callee
->decl
!= id
->dst_node
->decl
)
4183 verify_cgraph_node (cg_edge
->callee
);
4186 /* We will be inlining this callee. */
4187 id
->eh_lp_nr
= lookup_stmt_eh_lp (stmt
);
4189 /* Update the callers EH personality. */
4190 if (DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->decl
))
4191 DECL_FUNCTION_PERSONALITY (cg_edge
->caller
->decl
)
4192 = DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->decl
);
4194 /* Split the block holding the GIMPLE_CALL. */
4195 e
= split_block (bb
, stmt
);
4197 return_block
= e
->dest
;
4200 /* split_block splits after the statement; work around this by
4201 moving the call into the second block manually. Not pretty,
4202 but seems easier than doing the CFG manipulation by hand
4203 when the GIMPLE_CALL is in the last statement of BB. */
4204 stmt_gsi
= gsi_last_bb (bb
);
4205 gsi_remove (&stmt_gsi
, false);
4207 /* If the GIMPLE_CALL was in the last statement of BB, it may have
4208 been the source of abnormal edges. In this case, schedule
4209 the removal of dead abnormal edges. */
4210 gsi
= gsi_start_bb (return_block
);
4211 if (gsi_end_p (gsi
))
4213 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
4214 purge_dead_abnormal_edges
= true;
4218 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
4219 purge_dead_abnormal_edges
= false;
4222 stmt_gsi
= gsi_start_bb (return_block
);
4224 /* Build a block containing code to initialize the arguments, the
4225 actual inline expansion of the body, and a label for the return
4226 statements within the function to jump to. The type of the
4227 statement expression is the return type of the function call.
4228 ??? If the call does not have an associated block then we will
4229 remap all callee blocks to NULL, effectively dropping most of
4230 its debug information. This should only happen for calls to
4231 artificial decls inserted by the compiler itself. We need to
4232 either link the inlined blocks into the caller block tree or
4233 not refer to them in any way to not break GC for locations. */
4234 if (gimple_block (stmt
))
4236 id
->block
= make_node (BLOCK
);
4237 BLOCK_ABSTRACT_ORIGIN (id
->block
) = fn
;
4238 BLOCK_SOURCE_LOCATION (id
->block
) = LOCATION_LOCUS (input_location
);
4239 prepend_lexical_block (gimple_block (stmt
), id
->block
);
4242 /* Local declarations will be replaced by their equivalents in this
4245 id
->decl_map
= pointer_map_create ();
4246 dst
= id
->debug_map
;
4247 id
->debug_map
= NULL
;
4249 /* Record the function we are about to inline. */
4251 id
->src_node
= cg_edge
->callee
;
4252 id
->src_cfun
= DECL_STRUCT_FUNCTION (fn
);
4253 id
->gimple_call
= stmt
;
4255 gcc_assert (!id
->src_cfun
->after_inlining
);
4258 if (lookup_attribute ("cold", DECL_ATTRIBUTES (fn
)))
4260 gimple_stmt_iterator si
= gsi_last_bb (bb
);
4261 gsi_insert_after (&si
, gimple_build_predict (PRED_COLD_FUNCTION
,
4265 initialize_inlined_parameters (id
, stmt
, fn
, bb
);
4267 if (DECL_INITIAL (fn
))
4269 if (gimple_block (stmt
))
4273 prepend_lexical_block (id
->block
,
4274 remap_blocks (DECL_INITIAL (fn
), id
));
4275 gcc_checking_assert (BLOCK_SUBBLOCKS (id
->block
)
4276 && (BLOCK_CHAIN (BLOCK_SUBBLOCKS (id
->block
))
4278 /* Move vars for PARM_DECLs from DECL_INITIAL block to id->block,
4279 otherwise for DWARF DW_TAG_formal_parameter will not be children of
4280 DW_TAG_inlined_subroutine, but of a DW_TAG_lexical_block
4281 under it. The parameters can be then evaluated in the debugger,
4282 but don't show in backtraces. */
4283 for (var
= &BLOCK_VARS (BLOCK_SUBBLOCKS (id
->block
)); *var
; )
4284 if (TREE_CODE (DECL_ORIGIN (*var
)) == PARM_DECL
)
4287 *var
= TREE_CHAIN (v
);
4288 TREE_CHAIN (v
) = BLOCK_VARS (id
->block
);
4289 BLOCK_VARS (id
->block
) = v
;
4292 var
= &TREE_CHAIN (*var
);
4295 remap_blocks_to_null (DECL_INITIAL (fn
), id
);
4298 /* Return statements in the function body will be replaced by jumps
4299 to the RET_LABEL. */
4300 gcc_assert (DECL_INITIAL (fn
));
4301 gcc_assert (TREE_CODE (DECL_INITIAL (fn
)) == BLOCK
);
4303 /* Find the LHS to which the result of this call is assigned. */
4305 if (gimple_call_lhs (stmt
))
4307 modify_dest
= gimple_call_lhs (stmt
);
4309 /* The function which we are inlining might not return a value,
4310 in which case we should issue a warning that the function
4311 does not return a value. In that case the optimizers will
4312 see that the variable to which the value is assigned was not
4313 initialized. We do not want to issue a warning about that
4314 uninitialized variable. */
4315 if (DECL_P (modify_dest
))
4316 TREE_NO_WARNING (modify_dest
) = 1;
4318 if (gimple_call_return_slot_opt_p (stmt
))
4320 return_slot
= modify_dest
;
4327 /* If we are inlining a call to the C++ operator new, we don't want
4328 to use type based alias analysis on the return value. Otherwise
4329 we may get confused if the compiler sees that the inlined new
4330 function returns a pointer which was just deleted. See bug
4332 if (DECL_IS_OPERATOR_NEW (fn
))
4338 /* Declare the return variable for the function. */
4339 use_retvar
= declare_return_variable (id
, return_slot
, modify_dest
, bb
);
4341 /* Add local vars in this inlined callee to caller. */
4342 add_local_variables (id
->src_cfun
, cfun
, id
);
4344 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4346 fprintf (dump_file
, "Inlining ");
4347 print_generic_expr (dump_file
, id
->src_fn
, 0);
4348 fprintf (dump_file
, " to ");
4349 print_generic_expr (dump_file
, id
->dst_fn
, 0);
4350 fprintf (dump_file
, " with frequency %i\n", cg_edge
->frequency
);
4353 /* This is it. Duplicate the callee body. Assume callee is
4354 pre-gimplified. Note that we must not alter the caller
4355 function in any way before this point, as this CALL_EXPR may be
4356 a self-referential call; if we're calling ourselves, we need to
4357 duplicate our body before altering anything. */
4358 copy_body (id
, bb
->count
,
4359 GCOV_COMPUTE_SCALE (cg_edge
->frequency
, CGRAPH_FREQ_BASE
),
4360 bb
, return_block
, NULL
);
4362 /* Reset the escaped solution. */
4363 if (cfun
->gimple_df
)
4364 pt_solution_reset (&cfun
->gimple_df
->escaped
);
4369 pointer_map_destroy (id
->debug_map
);
4370 id
->debug_map
= dst
;
4372 pointer_map_destroy (id
->decl_map
);
4375 /* Unlink the calls virtual operands before replacing it. */
4376 unlink_stmt_vdef (stmt
);
4377 if (gimple_vdef (stmt
)
4378 && TREE_CODE (gimple_vdef (stmt
)) == SSA_NAME
)
4379 release_ssa_name (gimple_vdef (stmt
));
4381 /* If the inlined function returns a result that we care about,
4382 substitute the GIMPLE_CALL with an assignment of the return
4383 variable to the LHS of the call. That is, if STMT was
4384 'a = foo (...)', substitute the call with 'a = USE_RETVAR'. */
4385 if (use_retvar
&& gimple_call_lhs (stmt
))
4387 gimple old_stmt
= stmt
;
4388 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), use_retvar
);
4389 gsi_replace (&stmt_gsi
, stmt
, false);
4390 maybe_clean_or_replace_eh_stmt (old_stmt
, stmt
);
4394 /* Handle the case of inlining a function with no return
4395 statement, which causes the return value to become undefined. */
4396 if (gimple_call_lhs (stmt
)
4397 && TREE_CODE (gimple_call_lhs (stmt
)) == SSA_NAME
)
4399 tree name
= gimple_call_lhs (stmt
);
4400 tree var
= SSA_NAME_VAR (name
);
4401 tree def
= ssa_default_def (cfun
, var
);
4405 /* If the variable is used undefined, make this name
4406 undefined via a move. */
4407 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), def
);
4408 gsi_replace (&stmt_gsi
, stmt
, true);
4412 /* Otherwise make this variable undefined. */
4413 gsi_remove (&stmt_gsi
, true);
4414 set_ssa_default_def (cfun
, var
, name
);
4415 SSA_NAME_DEF_STMT (name
) = gimple_build_nop ();
4419 gsi_remove (&stmt_gsi
, true);
4422 if (purge_dead_abnormal_edges
)
4424 gimple_purge_dead_eh_edges (return_block
);
4425 gimple_purge_dead_abnormal_call_edges (return_block
);
4428 /* If the value of the new expression is ignored, that's OK. We
4429 don't warn about this for CALL_EXPRs, so we shouldn't warn about
4430 the equivalent inlined version either. */
4431 if (is_gimple_assign (stmt
))
4433 gcc_assert (gimple_assign_single_p (stmt
)
4434 || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
)));
4435 TREE_USED (gimple_assign_rhs1 (stmt
)) = 1;
4438 /* Output the inlining info for this abstract function, since it has been
4439 inlined. If we don't do this now, we can lose the information about the
4440 variables in the function when the blocks get blown away as soon as we
4441 remove the cgraph node. */
4442 if (gimple_block (stmt
))
4443 (*debug_hooks
->outlining_inline_function
) (cg_edge
->callee
->decl
);
4445 /* Update callgraph if needed. */
4446 cgraph_remove_node (cg_edge
->callee
);
4448 id
->block
= NULL_TREE
;
4449 successfully_inlined
= TRUE
;
4452 input_location
= saved_location
;
4453 return successfully_inlined
;
4456 /* Expand call statements reachable from STMT_P.
4457 We can only have CALL_EXPRs as the "toplevel" tree code or nested
4458 in a MODIFY_EXPR. */
4461 gimple_expand_calls_inline (basic_block bb
, copy_body_data
*id
)
4463 gimple_stmt_iterator gsi
;
4465 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4467 gimple stmt
= gsi_stmt (gsi
);
4469 if (is_gimple_call (stmt
)
4470 && !gimple_call_internal_p (stmt
)
4471 && expand_call_inline (bb
, stmt
, id
))
4479 /* Walk all basic blocks created after FIRST and try to fold every statement
4480 in the STATEMENTS pointer set. */
4483 fold_marked_statements (int first
, struct pointer_set_t
*statements
)
4485 for (; first
< n_basic_blocks_for_fn (cfun
); first
++)
4486 if (BASIC_BLOCK_FOR_FN (cfun
, first
))
4488 gimple_stmt_iterator gsi
;
4490 for (gsi
= gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, first
));
4493 if (pointer_set_contains (statements
, gsi_stmt (gsi
)))
4495 gimple old_stmt
= gsi_stmt (gsi
);
4496 tree old_decl
= is_gimple_call (old_stmt
) ? gimple_call_fndecl (old_stmt
) : 0;
4498 if (old_decl
&& DECL_BUILT_IN (old_decl
))
4500 /* Folding builtins can create multiple instructions,
4501 we need to look at all of them. */
4502 gimple_stmt_iterator i2
= gsi
;
4504 if (fold_stmt (&gsi
))
4507 /* If a builtin at the end of a bb folded into nothing,
4508 the following loop won't work. */
4509 if (gsi_end_p (gsi
))
4511 cgraph_update_edges_for_call_stmt (old_stmt
,
4516 i2
= gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, first
));
4521 new_stmt
= gsi_stmt (i2
);
4522 update_stmt (new_stmt
);
4523 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4526 if (new_stmt
== gsi_stmt (gsi
))
4528 /* It is okay to check only for the very last
4529 of these statements. If it is a throwing
4530 statement nothing will change. If it isn't
4531 this can remove EH edges. If that weren't
4532 correct then because some intermediate stmts
4533 throw, but not the last one. That would mean
4534 we'd have to split the block, which we can't
4535 here and we'd loose anyway. And as builtins
4536 probably never throw, this all
4538 if (maybe_clean_or_replace_eh_stmt (old_stmt
,
4540 gimple_purge_dead_eh_edges (
4541 BASIC_BLOCK_FOR_FN (cfun
, first
));
4548 else if (fold_stmt (&gsi
))
4550 /* Re-read the statement from GSI as fold_stmt() may
4552 gimple new_stmt
= gsi_stmt (gsi
);
4553 update_stmt (new_stmt
);
4555 if (is_gimple_call (old_stmt
)
4556 || is_gimple_call (new_stmt
))
4557 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4560 if (maybe_clean_or_replace_eh_stmt (old_stmt
, new_stmt
))
4561 gimple_purge_dead_eh_edges (BASIC_BLOCK_FOR_FN (cfun
,
4568 /* Expand calls to inline functions in the body of FN. */
4571 optimize_inline_calls (tree fn
)
4575 int last
= n_basic_blocks_for_fn (cfun
);
4576 bool inlined_p
= false;
4579 memset (&id
, 0, sizeof (id
));
4581 id
.src_node
= id
.dst_node
= cgraph_get_node (fn
);
4582 gcc_assert (id
.dst_node
->definition
);
4584 /* Or any functions that aren't finished yet. */
4585 if (current_function_decl
)
4586 id
.dst_fn
= current_function_decl
;
4588 id
.copy_decl
= copy_decl_maybe_to_var
;
4589 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
4590 id
.transform_new_cfg
= false;
4591 id
.transform_return_to_modify
= true;
4592 id
.transform_parameter
= true;
4593 id
.transform_lang_insert_block
= NULL
;
4594 id
.statements_to_fold
= pointer_set_create ();
4596 push_gimplify_context ();
4598 /* We make no attempts to keep dominance info up-to-date. */
4599 free_dominance_info (CDI_DOMINATORS
);
4600 free_dominance_info (CDI_POST_DOMINATORS
);
4602 /* Register specific gimple functions. */
4603 gimple_register_cfg_hooks ();
4605 /* Reach the trees by walking over the CFG, and note the
4606 enclosing basic-blocks in the call edges. */
4607 /* We walk the blocks going forward, because inlined function bodies
4608 will split id->current_basic_block, and the new blocks will
4609 follow it; we'll trudge through them, processing their CALL_EXPRs
4611 FOR_EACH_BB_FN (bb
, cfun
)
4612 inlined_p
|= gimple_expand_calls_inline (bb
, &id
);
4614 pop_gimplify_context (NULL
);
4616 #ifdef ENABLE_CHECKING
4618 struct cgraph_edge
*e
;
4620 verify_cgraph_node (id
.dst_node
);
4622 /* Double check that we inlined everything we are supposed to inline. */
4623 for (e
= id
.dst_node
->callees
; e
; e
= e
->next_callee
)
4624 gcc_assert (e
->inline_failed
);
4628 /* Fold queued statements. */
4629 fold_marked_statements (last
, id
.statements_to_fold
);
4630 pointer_set_destroy (id
.statements_to_fold
);
4632 gcc_assert (!id
.debug_stmts
.exists ());
4634 /* If we didn't inline into the function there is nothing to do. */
4638 /* Renumber the lexical scoping (non-code) blocks consecutively. */
4641 delete_unreachable_blocks_update_callgraph (&id
);
4642 #ifdef ENABLE_CHECKING
4643 verify_cgraph_node (id
.dst_node
);
4646 /* It would be nice to check SSA/CFG/statement consistency here, but it is
4647 not possible yet - the IPA passes might make various functions to not
4648 throw and they don't care to proactively update local EH info. This is
4649 done later in fixup_cfg pass that also execute the verification. */
4650 return (TODO_update_ssa
4652 | (gimple_in_ssa_p (cfun
) ? TODO_remove_unused_locals
: 0)
4653 | (gimple_in_ssa_p (cfun
) ? TODO_update_address_taken
: 0)
4654 | (profile_status_for_fn (cfun
) != PROFILE_ABSENT
4655 ? TODO_rebuild_frequencies
: 0));
4658 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
4661 copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
4663 enum tree_code code
= TREE_CODE (*tp
);
4664 enum tree_code_class cl
= TREE_CODE_CLASS (code
);
4666 /* We make copies of most nodes. */
4667 if (IS_EXPR_CODE_CLASS (cl
)
4668 || code
== TREE_LIST
4670 || code
== TYPE_DECL
4671 || code
== OMP_CLAUSE
)
4673 /* Because the chain gets clobbered when we make a copy, we save it
4675 tree chain
= NULL_TREE
, new_tree
;
4677 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
4678 chain
= TREE_CHAIN (*tp
);
4680 /* Copy the node. */
4681 new_tree
= copy_node (*tp
);
4685 /* Now, restore the chain, if appropriate. That will cause
4686 walk_tree to walk into the chain as well. */
4687 if (code
== PARM_DECL
4688 || code
== TREE_LIST
4689 || code
== OMP_CLAUSE
)
4690 TREE_CHAIN (*tp
) = chain
;
4692 /* For now, we don't update BLOCKs when we make copies. So, we
4693 have to nullify all BIND_EXPRs. */
4694 if (TREE_CODE (*tp
) == BIND_EXPR
)
4695 BIND_EXPR_BLOCK (*tp
) = NULL_TREE
;
4697 else if (code
== CONSTRUCTOR
)
4699 /* CONSTRUCTOR nodes need special handling because
4700 we need to duplicate the vector of elements. */
4703 new_tree
= copy_node (*tp
);
4704 CONSTRUCTOR_ELTS (new_tree
) = vec_safe_copy (CONSTRUCTOR_ELTS (*tp
));
4707 else if (code
== STATEMENT_LIST
)
4708 /* We used to just abort on STATEMENT_LIST, but we can run into them
4709 with statement-expressions (c++/40975). */
4710 copy_statement_list (tp
);
4711 else if (TREE_CODE_CLASS (code
) == tcc_type
)
4713 else if (TREE_CODE_CLASS (code
) == tcc_declaration
)
4715 else if (TREE_CODE_CLASS (code
) == tcc_constant
)
4720 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
4721 information indicating to what new SAVE_EXPR this one should be mapped,
4722 use that one. Otherwise, create a new node and enter it in ST. FN is
4723 the function into which the copy will be placed. */
4726 remap_save_expr (tree
*tp
, void *st_
, int *walk_subtrees
)
4728 struct pointer_map_t
*st
= (struct pointer_map_t
*) st_
;
4732 /* See if we already encountered this SAVE_EXPR. */
4733 n
= (tree
*) pointer_map_contains (st
, *tp
);
4735 /* If we didn't already remap this SAVE_EXPR, do so now. */
4738 t
= copy_node (*tp
);
4740 /* Remember this SAVE_EXPR. */
4741 *pointer_map_insert (st
, *tp
) = t
;
4742 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
4743 *pointer_map_insert (st
, t
) = t
;
4747 /* We've already walked into this SAVE_EXPR; don't do it again. */
4752 /* Replace this SAVE_EXPR with the copy. */
4756 /* Called via walk_gimple_seq. If *GSIP points to a GIMPLE_LABEL for a local
4757 label, copies the declaration and enters it in the splay_tree in DATA (which
4758 is really a 'copy_body_data *'. */
4761 mark_local_labels_stmt (gimple_stmt_iterator
*gsip
,
4762 bool *handled_ops_p ATTRIBUTE_UNUSED
,
4763 struct walk_stmt_info
*wi
)
4765 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4766 gimple stmt
= gsi_stmt (*gsip
);
4768 if (gimple_code (stmt
) == GIMPLE_LABEL
)
4770 tree decl
= gimple_label_label (stmt
);
4772 /* Copy the decl and remember the copy. */
4773 insert_decl_map (id
, decl
, id
->copy_decl (decl
, id
));
4780 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
4781 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
4782 remaps all local declarations to appropriate replacements in gimple
4786 replace_locals_op (tree
*tp
, int *walk_subtrees
, void *data
)
4788 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
4789 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4790 struct pointer_map_t
*st
= id
->decl_map
;
4794 /* Only a local declaration (variable or label). */
4795 if ((TREE_CODE (expr
) == VAR_DECL
4796 && !TREE_STATIC (expr
))
4797 || TREE_CODE (expr
) == LABEL_DECL
)
4799 /* Lookup the declaration. */
4800 n
= (tree
*) pointer_map_contains (st
, expr
);
4802 /* If it's there, remap it. */
4807 else if (TREE_CODE (expr
) == STATEMENT_LIST
4808 || TREE_CODE (expr
) == BIND_EXPR
4809 || TREE_CODE (expr
) == SAVE_EXPR
)
4811 else if (TREE_CODE (expr
) == TARGET_EXPR
)
4813 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
4814 It's OK for this to happen if it was part of a subtree that
4815 isn't immediately expanded, such as operand 2 of another
4817 if (!TREE_OPERAND (expr
, 1))
4819 TREE_OPERAND (expr
, 1) = TREE_OPERAND (expr
, 3);
4820 TREE_OPERAND (expr
, 3) = NULL_TREE
;
4824 /* Keep iterating. */
4829 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
4830 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
4831 remaps all local declarations to appropriate replacements in gimple
4835 replace_locals_stmt (gimple_stmt_iterator
*gsip
,
4836 bool *handled_ops_p ATTRIBUTE_UNUSED
,
4837 struct walk_stmt_info
*wi
)
4839 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4840 gimple stmt
= gsi_stmt (*gsip
);
4842 if (gimple_code (stmt
) == GIMPLE_BIND
)
4844 tree block
= gimple_bind_block (stmt
);
4848 remap_block (&block
, id
);
4849 gimple_bind_set_block (stmt
, block
);
4852 /* This will remap a lot of the same decls again, but this should be
4854 if (gimple_bind_vars (stmt
))
4855 gimple_bind_set_vars (stmt
, remap_decls (gimple_bind_vars (stmt
),
4859 /* Keep iterating. */
4864 /* Copies everything in SEQ and replaces variables and labels local to
4865 current_function_decl. */
4868 copy_gimple_seq_and_replace_locals (gimple_seq seq
)
4871 struct walk_stmt_info wi
;
4872 struct pointer_set_t
*visited
;
4875 /* There's nothing to do for NULL_TREE. */
4880 memset (&id
, 0, sizeof (id
));
4881 id
.src_fn
= current_function_decl
;
4882 id
.dst_fn
= current_function_decl
;
4883 id
.decl_map
= pointer_map_create ();
4884 id
.debug_map
= NULL
;
4886 id
.copy_decl
= copy_decl_no_change
;
4887 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
4888 id
.transform_new_cfg
= false;
4889 id
.transform_return_to_modify
= false;
4890 id
.transform_parameter
= false;
4891 id
.transform_lang_insert_block
= NULL
;
4893 /* Walk the tree once to find local labels. */
4894 memset (&wi
, 0, sizeof (wi
));
4895 visited
= pointer_set_create ();
4898 walk_gimple_seq (seq
, mark_local_labels_stmt
, NULL
, &wi
);
4899 pointer_set_destroy (visited
);
4901 copy
= gimple_seq_copy (seq
);
4903 /* Walk the copy, remapping decls. */
4904 memset (&wi
, 0, sizeof (wi
));
4906 walk_gimple_seq (copy
, replace_locals_stmt
, replace_locals_op
, &wi
);
4909 pointer_map_destroy (id
.decl_map
);
4911 pointer_map_destroy (id
.debug_map
);
4917 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
4920 debug_find_tree_1 (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
, void *data
)
4929 debug_find_tree (tree top
, tree search
)
4931 return walk_tree_without_duplicates (&top
, debug_find_tree_1
, search
) != 0;
4935 /* Declare the variables created by the inliner. Add all the variables in
4936 VARS to BIND_EXPR. */
4939 declare_inline_vars (tree block
, tree vars
)
4942 for (t
= vars
; t
; t
= DECL_CHAIN (t
))
4944 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
4945 gcc_assert (!TREE_STATIC (t
) && !TREE_ASM_WRITTEN (t
));
4946 add_local_decl (cfun
, t
);
4950 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), vars
);
4953 /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN,
4954 but now it will be in the TO_FN. PARM_TO_VAR means enable PARM_DECL to
4955 VAR_DECL translation. */
4958 copy_decl_for_dup_finish (copy_body_data
*id
, tree decl
, tree copy
)
4960 /* Don't generate debug information for the copy if we wouldn't have
4961 generated it for the copy either. */
4962 DECL_ARTIFICIAL (copy
) = DECL_ARTIFICIAL (decl
);
4963 DECL_IGNORED_P (copy
) = DECL_IGNORED_P (decl
);
4965 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
4966 declaration inspired this copy. */
4967 DECL_ABSTRACT_ORIGIN (copy
) = DECL_ORIGIN (decl
);
4969 /* The new variable/label has no RTL, yet. */
4970 if (CODE_CONTAINS_STRUCT (TREE_CODE (copy
), TS_DECL_WRTL
)
4971 && !TREE_STATIC (copy
) && !DECL_EXTERNAL (copy
))
4972 SET_DECL_RTL (copy
, 0);
4974 /* These args would always appear unused, if not for this. */
4975 TREE_USED (copy
) = 1;
4977 /* Set the context for the new declaration. */
4978 if (!DECL_CONTEXT (decl
))
4979 /* Globals stay global. */
4981 else if (DECL_CONTEXT (decl
) != id
->src_fn
)
4982 /* Things that weren't in the scope of the function we're inlining
4983 from aren't in the scope we're inlining to, either. */
4985 else if (TREE_STATIC (decl
))
4986 /* Function-scoped static variables should stay in the original
4990 /* Ordinary automatic local variables are now in the scope of the
4992 DECL_CONTEXT (copy
) = id
->dst_fn
;
4998 copy_decl_to_var (tree decl
, copy_body_data
*id
)
5002 gcc_assert (TREE_CODE (decl
) == PARM_DECL
5003 || TREE_CODE (decl
) == RESULT_DECL
);
5005 type
= TREE_TYPE (decl
);
5007 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
5008 VAR_DECL
, DECL_NAME (decl
), type
);
5009 if (DECL_PT_UID_SET_P (decl
))
5010 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
5011 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
5012 TREE_READONLY (copy
) = TREE_READONLY (decl
);
5013 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
5014 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
5016 return copy_decl_for_dup_finish (id
, decl
, copy
);
5019 /* Like copy_decl_to_var, but create a return slot object instead of a
5020 pointer variable for return by invisible reference. */
5023 copy_result_decl_to_var (tree decl
, copy_body_data
*id
)
5027 gcc_assert (TREE_CODE (decl
) == PARM_DECL
5028 || TREE_CODE (decl
) == RESULT_DECL
);
5030 type
= TREE_TYPE (decl
);
5031 if (DECL_BY_REFERENCE (decl
))
5032 type
= TREE_TYPE (type
);
5034 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
5035 VAR_DECL
, DECL_NAME (decl
), type
);
5036 if (DECL_PT_UID_SET_P (decl
))
5037 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
5038 TREE_READONLY (copy
) = TREE_READONLY (decl
);
5039 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
5040 if (!DECL_BY_REFERENCE (decl
))
5042 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
5043 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
5046 return copy_decl_for_dup_finish (id
, decl
, copy
);
5050 copy_decl_no_change (tree decl
, copy_body_data
*id
)
5054 copy
= copy_node (decl
);
5056 /* The COPY is not abstract; it will be generated in DST_FN. */
5057 DECL_ABSTRACT (copy
) = 0;
5058 lang_hooks
.dup_lang_specific_decl (copy
);
5060 /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
5061 been taken; it's for internal bookkeeping in expand_goto_internal. */
5062 if (TREE_CODE (copy
) == LABEL_DECL
)
5064 TREE_ADDRESSABLE (copy
) = 0;
5065 LABEL_DECL_UID (copy
) = -1;
5068 return copy_decl_for_dup_finish (id
, decl
, copy
);
5072 copy_decl_maybe_to_var (tree decl
, copy_body_data
*id
)
5074 if (TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
)
5075 return copy_decl_to_var (decl
, id
);
5077 return copy_decl_no_change (decl
, id
);
5080 /* Return a copy of the function's argument tree. */
5082 copy_arguments_for_versioning (tree orig_parm
, copy_body_data
* id
,
5083 bitmap args_to_skip
, tree
*vars
)
5086 tree new_parm
= NULL
;
5091 for (arg
= orig_parm
; arg
; arg
= DECL_CHAIN (arg
), i
++)
5092 if (!args_to_skip
|| !bitmap_bit_p (args_to_skip
, i
))
5094 tree new_tree
= remap_decl (arg
, id
);
5095 if (TREE_CODE (new_tree
) != PARM_DECL
)
5096 new_tree
= id
->copy_decl (arg
, id
);
5097 lang_hooks
.dup_lang_specific_decl (new_tree
);
5099 parg
= &DECL_CHAIN (new_tree
);
5101 else if (!pointer_map_contains (id
->decl_map
, arg
))
5103 /* Make an equivalent VAR_DECL. If the argument was used
5104 as temporary variable later in function, the uses will be
5105 replaced by local variable. */
5106 tree var
= copy_decl_to_var (arg
, id
);
5107 insert_decl_map (id
, arg
, var
);
5108 /* Declare this new variable. */
5109 DECL_CHAIN (var
) = *vars
;
5115 /* Return a copy of the function's static chain. */
5117 copy_static_chain (tree static_chain
, copy_body_data
* id
)
5119 tree
*chain_copy
, *pvar
;
5121 chain_copy
= &static_chain
;
5122 for (pvar
= chain_copy
; *pvar
; pvar
= &DECL_CHAIN (*pvar
))
5124 tree new_tree
= remap_decl (*pvar
, id
);
5125 lang_hooks
.dup_lang_specific_decl (new_tree
);
5126 DECL_CHAIN (new_tree
) = DECL_CHAIN (*pvar
);
5129 return static_chain
;
5132 /* Return true if the function is allowed to be versioned.
5133 This is a guard for the versioning functionality. */
5136 tree_versionable_function_p (tree fndecl
)
5138 return (!lookup_attribute ("noclone", DECL_ATTRIBUTES (fndecl
))
5139 && copy_forbidden (DECL_STRUCT_FUNCTION (fndecl
), fndecl
) == NULL
);
5142 /* Delete all unreachable basic blocks and update callgraph.
5143 Doing so is somewhat nontrivial because we need to update all clones and
5144 remove inline function that become unreachable. */
5147 delete_unreachable_blocks_update_callgraph (copy_body_data
*id
)
5149 bool changed
= false;
5150 basic_block b
, next_bb
;
5152 find_unreachable_blocks ();
5154 /* Delete all unreachable basic blocks. */
5156 for (b
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
; b
5157 != EXIT_BLOCK_PTR_FOR_FN (cfun
); b
= next_bb
)
5159 next_bb
= b
->next_bb
;
5161 if (!(b
->flags
& BB_REACHABLE
))
5163 gimple_stmt_iterator bsi
;
5165 for (bsi
= gsi_start_bb (b
); !gsi_end_p (bsi
); gsi_next (&bsi
))
5167 struct cgraph_edge
*e
;
5168 struct cgraph_node
*node
;
5170 ipa_remove_stmt_references (id
->dst_node
, gsi_stmt (bsi
));
5172 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
5173 &&(e
= cgraph_edge (id
->dst_node
, gsi_stmt (bsi
))) != NULL
)
5175 if (!e
->inline_failed
)
5176 cgraph_remove_node_and_inline_clones (e
->callee
, id
->dst_node
);
5178 cgraph_remove_edge (e
);
5180 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
5181 && id
->dst_node
->clones
)
5182 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
5184 ipa_remove_stmt_references (node
, gsi_stmt (bsi
));
5185 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
5186 && (e
= cgraph_edge (node
, gsi_stmt (bsi
))) != NULL
)
5188 if (!e
->inline_failed
)
5189 cgraph_remove_node_and_inline_clones (e
->callee
, id
->dst_node
);
5191 cgraph_remove_edge (e
);
5195 node
= node
->clones
;
5196 else if (node
->next_sibling_clone
)
5197 node
= node
->next_sibling_clone
;
5200 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5201 node
= node
->clone_of
;
5202 if (node
!= id
->dst_node
)
5203 node
= node
->next_sibling_clone
;
5207 delete_basic_block (b
);
5215 /* Update clone info after duplication. */
5218 update_clone_info (copy_body_data
* id
)
5220 struct cgraph_node
*node
;
5221 if (!id
->dst_node
->clones
)
5223 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
5225 /* First update replace maps to match the new body. */
5226 if (node
->clone
.tree_map
)
5229 for (i
= 0; i
< vec_safe_length (node
->clone
.tree_map
); i
++)
5231 struct ipa_replace_map
*replace_info
;
5232 replace_info
= (*node
->clone
.tree_map
)[i
];
5233 walk_tree (&replace_info
->old_tree
, copy_tree_body_r
, id
, NULL
);
5234 walk_tree (&replace_info
->new_tree
, copy_tree_body_r
, id
, NULL
);
5238 node
= node
->clones
;
5239 else if (node
->next_sibling_clone
)
5240 node
= node
->next_sibling_clone
;
5243 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
5244 node
= node
->clone_of
;
5245 if (node
!= id
->dst_node
)
5246 node
= node
->next_sibling_clone
;
5251 /* Create a copy of a function's tree.
5252 OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
5253 of the original function and the new copied function
5254 respectively. In case we want to replace a DECL
5255 tree with another tree while duplicating the function's
5256 body, TREE_MAP represents the mapping between these
5257 trees. If UPDATE_CLONES is set, the call_stmt fields
5258 of edges of clones of the function will be updated.
5260 If non-NULL ARGS_TO_SKIP determine function parameters to remove
5262 If SKIP_RETURN is true, the new version will return void.
5263 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
5264 If non_NULL NEW_ENTRY determine new entry BB of the clone.
5267 tree_function_versioning (tree old_decl
, tree new_decl
,
5268 vec
<ipa_replace_map_p
, va_gc
> *tree_map
,
5269 bool update_clones
, bitmap args_to_skip
,
5270 bool skip_return
, bitmap blocks_to_copy
,
5271 basic_block new_entry
)
5273 struct cgraph_node
*old_version_node
;
5274 struct cgraph_node
*new_version_node
;
5278 struct ipa_replace_map
*replace_info
;
5279 basic_block old_entry_block
, bb
;
5280 auto_vec
<gimple
, 10> init_stmts
;
5281 tree vars
= NULL_TREE
;
5283 gcc_assert (TREE_CODE (old_decl
) == FUNCTION_DECL
5284 && TREE_CODE (new_decl
) == FUNCTION_DECL
);
5285 DECL_POSSIBLY_INLINED (old_decl
) = 1;
5287 old_version_node
= cgraph_get_node (old_decl
);
5288 gcc_checking_assert (old_version_node
);
5289 new_version_node
= cgraph_get_node (new_decl
);
5290 gcc_checking_assert (new_version_node
);
5292 /* Copy over debug args. */
5293 if (DECL_HAS_DEBUG_ARGS_P (old_decl
))
5295 vec
<tree
, va_gc
> **new_debug_args
, **old_debug_args
;
5296 gcc_checking_assert (decl_debug_args_lookup (new_decl
) == NULL
);
5297 DECL_HAS_DEBUG_ARGS_P (new_decl
) = 0;
5298 old_debug_args
= decl_debug_args_lookup (old_decl
);
5301 new_debug_args
= decl_debug_args_insert (new_decl
);
5302 *new_debug_args
= vec_safe_copy (*old_debug_args
);
5306 /* Output the inlining info for this abstract function, since it has been
5307 inlined. If we don't do this now, we can lose the information about the
5308 variables in the function when the blocks get blown away as soon as we
5309 remove the cgraph node. */
5310 (*debug_hooks
->outlining_inline_function
) (old_decl
);
5312 DECL_ARTIFICIAL (new_decl
) = 1;
5313 DECL_ABSTRACT_ORIGIN (new_decl
) = DECL_ORIGIN (old_decl
);
5314 if (DECL_ORIGIN (old_decl
) == old_decl
)
5315 old_version_node
->used_as_abstract_origin
= true;
5316 DECL_FUNCTION_PERSONALITY (new_decl
) = DECL_FUNCTION_PERSONALITY (old_decl
);
5318 /* Prepare the data structures for the tree copy. */
5319 memset (&id
, 0, sizeof (id
));
5321 /* Generate a new name for the new version. */
5322 id
.statements_to_fold
= pointer_set_create ();
5324 id
.decl_map
= pointer_map_create ();
5325 id
.debug_map
= NULL
;
5326 id
.src_fn
= old_decl
;
5327 id
.dst_fn
= new_decl
;
5328 id
.src_node
= old_version_node
;
5329 id
.dst_node
= new_version_node
;
5330 id
.src_cfun
= DECL_STRUCT_FUNCTION (old_decl
);
5331 id
.blocks_to_copy
= blocks_to_copy
;
5333 id
.copy_decl
= copy_decl_no_change
;
5334 id
.transform_call_graph_edges
5335 = update_clones
? CB_CGE_MOVE_CLONES
: CB_CGE_MOVE
;
5336 id
.transform_new_cfg
= true;
5337 id
.transform_return_to_modify
= false;
5338 id
.transform_parameter
= false;
5339 id
.transform_lang_insert_block
= NULL
;
5341 old_entry_block
= ENTRY_BLOCK_PTR_FOR_FN
5342 (DECL_STRUCT_FUNCTION (old_decl
));
5343 DECL_RESULT (new_decl
) = DECL_RESULT (old_decl
);
5344 DECL_ARGUMENTS (new_decl
) = DECL_ARGUMENTS (old_decl
);
5345 initialize_cfun (new_decl
, old_decl
,
5346 old_entry_block
->count
);
5347 DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
->ipa_pta
5348 = id
.src_cfun
->gimple_df
->ipa_pta
;
5350 /* Copy the function's static chain. */
5351 p
= DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
;
5353 DECL_STRUCT_FUNCTION (new_decl
)->static_chain_decl
=
5354 copy_static_chain (DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
,
5357 /* If there's a tree_map, prepare for substitution. */
5359 for (i
= 0; i
< tree_map
->length (); i
++)
5362 replace_info
= (*tree_map
)[i
];
5363 if (replace_info
->replace_p
)
5365 if (!replace_info
->old_tree
)
5367 int i
= replace_info
->parm_num
;
5371 for (parm
= DECL_ARGUMENTS (old_decl
); i
; parm
= DECL_CHAIN (parm
))
5373 replace_info
->old_tree
= parm
;
5374 req_type
= TREE_TYPE (parm
);
5375 if (!useless_type_conversion_p (req_type
, TREE_TYPE (replace_info
->new_tree
)))
5377 if (fold_convertible_p (req_type
, replace_info
->new_tree
))
5378 replace_info
->new_tree
= fold_build1 (NOP_EXPR
, req_type
, replace_info
->new_tree
);
5379 else if (TYPE_SIZE (req_type
) == TYPE_SIZE (TREE_TYPE (replace_info
->new_tree
)))
5380 replace_info
->new_tree
= fold_build1 (VIEW_CONVERT_EXPR
, req_type
, replace_info
->new_tree
);
5385 fprintf (dump_file
, " const ");
5386 print_generic_expr (dump_file
, replace_info
->new_tree
, 0);
5387 fprintf (dump_file
, " can't be converted to param ");
5388 print_generic_expr (dump_file
, parm
, 0);
5389 fprintf (dump_file
, "\n");
5391 replace_info
->old_tree
= NULL
;
5396 gcc_assert (TREE_CODE (replace_info
->old_tree
) == PARM_DECL
);
5397 if (replace_info
->old_tree
)
5399 init
= setup_one_parameter (&id
, replace_info
->old_tree
,
5400 replace_info
->new_tree
, id
.src_fn
,
5404 init_stmts
.safe_push (init
);
5408 /* Copy the function's arguments. */
5409 if (DECL_ARGUMENTS (old_decl
) != NULL_TREE
)
5410 DECL_ARGUMENTS (new_decl
) =
5411 copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl
), &id
,
5412 args_to_skip
, &vars
);
5414 DECL_INITIAL (new_decl
) = remap_blocks (DECL_INITIAL (id
.src_fn
), &id
);
5415 BLOCK_SUPERCONTEXT (DECL_INITIAL (new_decl
)) = new_decl
;
5417 declare_inline_vars (DECL_INITIAL (new_decl
), vars
);
5419 if (!vec_safe_is_empty (DECL_STRUCT_FUNCTION (old_decl
)->local_decls
))
5420 /* Add local vars. */
5421 add_local_variables (DECL_STRUCT_FUNCTION (old_decl
), cfun
, &id
);
5423 if (DECL_RESULT (old_decl
) == NULL_TREE
)
5425 else if (skip_return
&& !VOID_TYPE_P (TREE_TYPE (DECL_RESULT (old_decl
))))
5427 DECL_RESULT (new_decl
)
5428 = build_decl (DECL_SOURCE_LOCATION (DECL_RESULT (old_decl
)),
5429 RESULT_DECL
, NULL_TREE
, void_type_node
);
5430 DECL_CONTEXT (DECL_RESULT (new_decl
)) = new_decl
;
5431 cfun
->returns_struct
= 0;
5432 cfun
->returns_pcc_struct
= 0;
5437 DECL_RESULT (new_decl
) = remap_decl (DECL_RESULT (old_decl
), &id
);
5438 lang_hooks
.dup_lang_specific_decl (DECL_RESULT (new_decl
));
5439 if (gimple_in_ssa_p (id
.src_cfun
)
5440 && DECL_BY_REFERENCE (DECL_RESULT (old_decl
))
5441 && (old_name
= ssa_default_def (id
.src_cfun
, DECL_RESULT (old_decl
))))
5443 tree new_name
= make_ssa_name (DECL_RESULT (new_decl
), NULL
);
5444 insert_decl_map (&id
, old_name
, new_name
);
5445 SSA_NAME_DEF_STMT (new_name
) = gimple_build_nop ();
5446 set_ssa_default_def (cfun
, DECL_RESULT (new_decl
), new_name
);
5450 /* Set up the destination functions loop tree. */
5451 if (loops_for_fn (DECL_STRUCT_FUNCTION (old_decl
)) != NULL
)
5453 cfun
->curr_properties
&= ~PROP_loops
;
5454 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
5455 cfun
->curr_properties
|= PROP_loops
;
5458 /* Copy the Function's body. */
5459 copy_body (&id
, old_entry_block
->count
, REG_BR_PROB_BASE
,
5460 ENTRY_BLOCK_PTR_FOR_FN (cfun
), EXIT_BLOCK_PTR_FOR_FN (cfun
),
5463 /* Renumber the lexical scoping (non-code) blocks consecutively. */
5464 number_blocks (new_decl
);
5466 /* We want to create the BB unconditionally, so that the addition of
5467 debug stmts doesn't affect BB count, which may in the end cause
5468 codegen differences. */
5469 bb
= split_edge (single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
5470 while (init_stmts
.length ())
5471 insert_init_stmt (&id
, bb
, init_stmts
.pop ());
5472 update_clone_info (&id
);
5474 /* Remap the nonlocal_goto_save_area, if any. */
5475 if (cfun
->nonlocal_goto_save_area
)
5477 struct walk_stmt_info wi
;
5479 memset (&wi
, 0, sizeof (wi
));
5481 walk_tree (&cfun
->nonlocal_goto_save_area
, remap_gimple_op_r
, &wi
, NULL
);
5485 pointer_map_destroy (id
.decl_map
);
5487 pointer_map_destroy (id
.debug_map
);
5488 free_dominance_info (CDI_DOMINATORS
);
5489 free_dominance_info (CDI_POST_DOMINATORS
);
5491 fold_marked_statements (0, id
.statements_to_fold
);
5492 pointer_set_destroy (id
.statements_to_fold
);
5493 fold_cond_expr_cond ();
5494 delete_unreachable_blocks_update_callgraph (&id
);
5495 if (id
.dst_node
->definition
)
5496 cgraph_rebuild_references ();
5497 update_ssa (TODO_update_ssa
);
5499 /* After partial cloning we need to rescale frequencies, so they are
5500 within proper range in the cloned function. */
5503 struct cgraph_edge
*e
;
5504 rebuild_frequencies ();
5506 new_version_node
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5507 for (e
= new_version_node
->callees
; e
; e
= e
->next_callee
)
5509 basic_block bb
= gimple_bb (e
->call_stmt
);
5510 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
5512 e
->count
= bb
->count
;
5514 for (e
= new_version_node
->indirect_calls
; e
; e
= e
->next_callee
)
5516 basic_block bb
= gimple_bb (e
->call_stmt
);
5517 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
5519 e
->count
= bb
->count
;
5523 free_dominance_info (CDI_DOMINATORS
);
5524 free_dominance_info (CDI_POST_DOMINATORS
);
5526 gcc_assert (!id
.debug_stmts
.exists ());
5531 /* EXP is CALL_EXPR present in a GENERIC expression tree. Try to integrate
5532 the callee and return the inlined body on success. */
5535 maybe_inline_call_in_expr (tree exp
)
5537 tree fn
= get_callee_fndecl (exp
);
5539 /* We can only try to inline "const" functions. */
5540 if (fn
&& TREE_READONLY (fn
) && DECL_SAVED_TREE (fn
))
5542 struct pointer_map_t
*decl_map
= pointer_map_create ();
5543 call_expr_arg_iterator iter
;
5547 /* Remap the parameters. */
5548 for (param
= DECL_ARGUMENTS (fn
), arg
= first_call_expr_arg (exp
, &iter
);
5550 param
= DECL_CHAIN (param
), arg
= next_call_expr_arg (&iter
))
5551 *pointer_map_insert (decl_map
, param
) = arg
;
5553 memset (&id
, 0, sizeof (id
));
5555 id
.dst_fn
= current_function_decl
;
5556 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
5557 id
.decl_map
= decl_map
;
5559 id
.copy_decl
= copy_decl_no_change
;
5560 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5561 id
.transform_new_cfg
= false;
5562 id
.transform_return_to_modify
= true;
5563 id
.transform_parameter
= true;
5564 id
.transform_lang_insert_block
= NULL
;
5566 /* Make sure not to unshare trees behind the front-end's back
5567 since front-end specific mechanisms may rely on sharing. */
5568 id
.regimplify
= false;
5569 id
.do_not_unshare
= true;
5571 /* We're not inside any EH region. */
5574 t
= copy_tree_body (&id
);
5575 pointer_map_destroy (decl_map
);
5577 /* We can only return something suitable for use in a GENERIC
5579 if (TREE_CODE (t
) == MODIFY_EXPR
)
5580 return TREE_OPERAND (t
, 1);
5586 /* Duplicate a type, fields and all. */
5589 build_duplicate_type (tree type
)
5591 struct copy_body_data id
;
5593 memset (&id
, 0, sizeof (id
));
5594 id
.src_fn
= current_function_decl
;
5595 id
.dst_fn
= current_function_decl
;
5597 id
.decl_map
= pointer_map_create ();
5598 id
.debug_map
= NULL
;
5599 id
.copy_decl
= copy_decl_no_change
;
5601 type
= remap_type_1 (type
, &id
);
5603 pointer_map_destroy (id
.decl_map
);
5605 pointer_map_destroy (id
.debug_map
);
5607 TYPE_CANONICAL (type
) = type
;