2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
4 Contributed by Alexandre Oliva <aoliva@redhat.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
26 #include "toplev.h" /* floor_log2 */
27 #include "diagnostic-core.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"
40 #include "tree-mudflap.h"
41 #include "tree-flow.h"
43 #include "tree-flow.h"
44 #include "tree-pretty-print.h"
47 #include "pointer-set.h"
49 #include "value-prof.h"
50 #include "tree-pass.h"
52 #include "integrate.h"
54 #include "rtl.h" /* FIXME: For asm_str_count. */
56 /* I'm not real happy about this, but we need to handle gimple and
60 /* Inlining, Cloning, Versioning, Parallelization
62 Inlining: a function body is duplicated, but the PARM_DECLs are
63 remapped into VAR_DECLs, and non-void RETURN_EXPRs become
64 MODIFY_EXPRs that store to a dedicated returned-value variable.
65 The duplicated eh_region info of the copy will later be appended
66 to the info for the caller; the eh_region info in copied throwing
67 statements and RESX statements are adjusted accordingly.
69 Cloning: (only in C++) We have one body for a con/de/structor, and
70 multiple function decls, each with a unique parameter list.
71 Duplicate the body, using the given splay tree; some parameters
72 will become constants (like 0 or 1).
74 Versioning: a function body is duplicated and the result is a new
75 function rather than into blocks of an existing function as with
76 inlining. Some parameters will become constants.
78 Parallelization: a region of a function is duplicated resulting in
79 a new function. Variables may be replaced with complex expressions
80 to enable shared variable semantics.
82 All of these will simultaneously lookup any callgraph edges. If
83 we're going to inline the duplicated function body, and the given
84 function has some cloned callgraph nodes (one for each place this
85 function will be inlined) those callgraph edges will be duplicated.
86 If we're cloning the body, those callgraph edges will be
87 updated to point into the new body. (Note that the original
88 callgraph node and edge list will not be altered.)
90 See the CALL_EXPR handling case in copy_tree_body_r (). */
94 o In order to make inlining-on-trees work, we pessimized
95 function-local static constants. In particular, they are now
96 always output, even when not addressed. Fix this by treating
97 function-local static constants just like global static
98 constants; the back-end already knows not to output them if they
101 o Provide heuristics to clamp inlining of recursive template
105 /* Weights that estimate_num_insns uses to estimate the size of the
108 eni_weights eni_size_weights
;
110 /* Weights that estimate_num_insns uses to estimate the time necessary
111 to execute the produced code. */
113 eni_weights eni_time_weights
;
117 static tree
declare_return_variable (copy_body_data
*, tree
, tree
, basic_block
);
118 static void remap_block (tree
*, copy_body_data
*);
119 static void copy_bind_expr (tree
*, int *, copy_body_data
*);
120 static tree
mark_local_for_remap_r (tree
*, int *, void *);
121 static void unsave_expr_1 (tree
);
122 static tree
unsave_r (tree
*, int *, void *);
123 static void declare_inline_vars (tree
, tree
);
124 static void remap_save_expr (tree
*, void *, int *);
125 static void prepend_lexical_block (tree current_block
, tree new_block
);
126 static tree
copy_decl_to_var (tree
, copy_body_data
*);
127 static tree
copy_result_decl_to_var (tree
, copy_body_data
*);
128 static tree
copy_decl_maybe_to_var (tree
, copy_body_data
*);
129 static gimple
remap_gimple_stmt (gimple
, copy_body_data
*);
130 static bool delete_unreachable_blocks_update_callgraph (copy_body_data
*id
);
132 /* Insert a tree->tree mapping for ID. Despite the name suggests
133 that the trees should be variables, it is used for more than that. */
136 insert_decl_map (copy_body_data
*id
, tree key
, tree value
)
138 *pointer_map_insert (id
->decl_map
, key
) = value
;
140 /* Always insert an identity map as well. If we see this same new
141 node again, we won't want to duplicate it a second time. */
143 *pointer_map_insert (id
->decl_map
, value
) = value
;
146 /* Insert a tree->tree mapping for ID. This is only used for
150 insert_debug_decl_map (copy_body_data
*id
, tree key
, tree value
)
152 if (!gimple_in_ssa_p (id
->src_cfun
))
155 if (!MAY_HAVE_DEBUG_STMTS
)
158 if (!target_for_debug_bind (key
))
161 gcc_assert (TREE_CODE (key
) == PARM_DECL
);
162 gcc_assert (TREE_CODE (value
) == VAR_DECL
);
165 id
->debug_map
= pointer_map_create ();
167 *pointer_map_insert (id
->debug_map
, key
) = value
;
170 /* If nonzero, we're remapping the contents of inlined debug
171 statements. If negative, an error has occurred, such as a
172 reference to a variable that isn't available in the inlined
174 static int processing_debug_stmt
= 0;
176 /* Construct new SSA name for old NAME. ID is the inline context. */
179 remap_ssa_name (tree name
, copy_body_data
*id
)
184 gcc_assert (TREE_CODE (name
) == SSA_NAME
);
186 n
= (tree
*) pointer_map_contains (id
->decl_map
, name
);
188 return unshare_expr (*n
);
190 if (processing_debug_stmt
)
192 processing_debug_stmt
= -1;
196 /* Do not set DEF_STMT yet as statement is not copied yet. We do that
198 new_tree
= remap_decl (SSA_NAME_VAR (name
), id
);
200 /* We might've substituted constant or another SSA_NAME for
203 Replace the SSA name representing RESULT_DECL by variable during
204 inlining: this saves us from need to introduce PHI node in a case
205 return value is just partly initialized. */
206 if ((TREE_CODE (new_tree
) == VAR_DECL
|| TREE_CODE (new_tree
) == PARM_DECL
)
207 && (TREE_CODE (SSA_NAME_VAR (name
)) != RESULT_DECL
208 || !id
->transform_return_to_modify
))
210 struct ptr_info_def
*pi
;
211 new_tree
= make_ssa_name (new_tree
, NULL
);
212 insert_decl_map (id
, name
, new_tree
);
213 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
214 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
215 TREE_TYPE (new_tree
) = TREE_TYPE (SSA_NAME_VAR (new_tree
));
216 /* At least IPA points-to info can be directly transferred. */
217 if (id
->src_cfun
->gimple_df
218 && id
->src_cfun
->gimple_df
->ipa_pta
219 && (pi
= SSA_NAME_PTR_INFO (name
))
222 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
225 if (gimple_nop_p (SSA_NAME_DEF_STMT (name
)))
227 /* By inlining function having uninitialized variable, we might
228 extend the lifetime (variable might get reused). This cause
229 ICE in the case we end up extending lifetime of SSA name across
230 abnormal edge, but also increase register pressure.
232 We simply initialize all uninitialized vars by 0 except
233 for case we are inlining to very first BB. We can avoid
234 this for all BBs that are not inside strongly connected
235 regions of the CFG, but this is expensive to test. */
237 && is_gimple_reg (SSA_NAME_VAR (name
))
238 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
)
239 && TREE_CODE (SSA_NAME_VAR (name
)) != PARM_DECL
240 && (id
->entry_bb
!= EDGE_SUCC (ENTRY_BLOCK_PTR
, 0)->dest
241 || EDGE_COUNT (id
->entry_bb
->preds
) != 1))
243 gimple_stmt_iterator gsi
= gsi_last_bb (id
->entry_bb
);
245 tree zero
= build_zero_cst (TREE_TYPE (new_tree
));
247 init_stmt
= gimple_build_assign (new_tree
, zero
);
248 gsi_insert_after (&gsi
, init_stmt
, GSI_NEW_STMT
);
249 SSA_NAME_IS_DEFAULT_DEF (new_tree
) = 0;
253 SSA_NAME_DEF_STMT (new_tree
) = gimple_build_nop ();
254 if (gimple_default_def (id
->src_cfun
, SSA_NAME_VAR (name
))
256 set_default_def (SSA_NAME_VAR (new_tree
), new_tree
);
261 insert_decl_map (id
, name
, new_tree
);
265 /* Remap DECL during the copying of the BLOCK tree for the function. */
268 remap_decl (tree decl
, copy_body_data
*id
)
272 /* We only remap local variables in the current function. */
274 /* See if we have remapped this declaration. */
276 n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
278 if (!n
&& processing_debug_stmt
)
280 processing_debug_stmt
= -1;
284 /* If we didn't already have an equivalent for this declaration,
288 /* Make a copy of the variable or label. */
289 tree t
= id
->copy_decl (decl
, id
);
291 /* Remember it, so that if we encounter this local entity again
292 we can reuse this copy. Do this early because remap_type may
293 need this decl for TYPE_STUB_DECL. */
294 insert_decl_map (id
, decl
, t
);
299 /* Remap types, if necessary. */
300 TREE_TYPE (t
) = remap_type (TREE_TYPE (t
), id
);
301 if (TREE_CODE (t
) == TYPE_DECL
)
302 DECL_ORIGINAL_TYPE (t
) = remap_type (DECL_ORIGINAL_TYPE (t
), id
);
304 /* Remap sizes as necessary. */
305 walk_tree (&DECL_SIZE (t
), copy_tree_body_r
, id
, NULL
);
306 walk_tree (&DECL_SIZE_UNIT (t
), copy_tree_body_r
, id
, NULL
);
308 /* If fields, do likewise for offset and qualifier. */
309 if (TREE_CODE (t
) == FIELD_DECL
)
311 walk_tree (&DECL_FIELD_OFFSET (t
), copy_tree_body_r
, id
, NULL
);
312 if (TREE_CODE (DECL_CONTEXT (t
)) == QUAL_UNION_TYPE
)
313 walk_tree (&DECL_QUALIFIER (t
), copy_tree_body_r
, id
, NULL
);
316 if (cfun
&& gimple_in_ssa_p (cfun
)
317 && (TREE_CODE (t
) == VAR_DECL
318 || TREE_CODE (t
) == RESULT_DECL
|| TREE_CODE (t
) == PARM_DECL
))
321 add_referenced_var (t
);
326 if (id
->do_not_unshare
)
329 return unshare_expr (*n
);
333 remap_type_1 (tree type
, copy_body_data
*id
)
337 /* We do need a copy. build and register it now. If this is a pointer or
338 reference type, remap the designated type and make a new pointer or
340 if (TREE_CODE (type
) == POINTER_TYPE
)
342 new_tree
= build_pointer_type_for_mode (remap_type (TREE_TYPE (type
), id
),
344 TYPE_REF_CAN_ALIAS_ALL (type
));
345 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
346 new_tree
= build_type_attribute_qual_variant (new_tree
,
347 TYPE_ATTRIBUTES (type
),
349 insert_decl_map (id
, type
, new_tree
);
352 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
354 new_tree
= build_reference_type_for_mode (remap_type (TREE_TYPE (type
), id
),
356 TYPE_REF_CAN_ALIAS_ALL (type
));
357 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
358 new_tree
= build_type_attribute_qual_variant (new_tree
,
359 TYPE_ATTRIBUTES (type
),
361 insert_decl_map (id
, type
, new_tree
);
365 new_tree
= copy_node (type
);
367 insert_decl_map (id
, type
, new_tree
);
369 /* This is a new type, not a copy of an old type. Need to reassociate
370 variants. We can handle everything except the main variant lazily. */
371 t
= TYPE_MAIN_VARIANT (type
);
374 t
= remap_type (t
, id
);
375 TYPE_MAIN_VARIANT (new_tree
) = t
;
376 TYPE_NEXT_VARIANT (new_tree
) = TYPE_NEXT_VARIANT (t
);
377 TYPE_NEXT_VARIANT (t
) = new_tree
;
381 TYPE_MAIN_VARIANT (new_tree
) = new_tree
;
382 TYPE_NEXT_VARIANT (new_tree
) = NULL
;
385 if (TYPE_STUB_DECL (type
))
386 TYPE_STUB_DECL (new_tree
) = remap_decl (TYPE_STUB_DECL (type
), id
);
388 /* Lazily create pointer and reference types. */
389 TYPE_POINTER_TO (new_tree
) = NULL
;
390 TYPE_REFERENCE_TO (new_tree
) = NULL
;
392 switch (TREE_CODE (new_tree
))
396 case FIXED_POINT_TYPE
:
399 t
= TYPE_MIN_VALUE (new_tree
);
400 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
401 walk_tree (&TYPE_MIN_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
403 t
= TYPE_MAX_VALUE (new_tree
);
404 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
405 walk_tree (&TYPE_MAX_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
409 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
410 walk_tree (&TYPE_ARG_TYPES (new_tree
), copy_tree_body_r
, id
, NULL
);
414 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
415 TYPE_DOMAIN (new_tree
) = remap_type (TYPE_DOMAIN (new_tree
), id
);
420 case QUAL_UNION_TYPE
:
424 for (f
= TYPE_FIELDS (new_tree
); f
; f
= DECL_CHAIN (f
))
426 t
= remap_decl (f
, id
);
427 DECL_CONTEXT (t
) = new_tree
;
431 TYPE_FIELDS (new_tree
) = nreverse (nf
);
437 /* Shouldn't have been thought variable sized. */
441 walk_tree (&TYPE_SIZE (new_tree
), copy_tree_body_r
, id
, NULL
);
442 walk_tree (&TYPE_SIZE_UNIT (new_tree
), copy_tree_body_r
, id
, NULL
);
448 remap_type (tree type
, copy_body_data
*id
)
456 /* See if we have remapped this type. */
457 node
= (tree
*) pointer_map_contains (id
->decl_map
, type
);
461 /* The type only needs remapping if it's variably modified. */
462 if (! variably_modified_type_p (type
, id
->src_fn
))
464 insert_decl_map (id
, type
, type
);
468 id
->remapping_type_depth
++;
469 tmp
= remap_type_1 (type
, id
);
470 id
->remapping_type_depth
--;
475 /* Return previously remapped type of TYPE in ID. Return NULL if TYPE
476 is NULL or TYPE has not been remapped before. */
479 remapped_type (tree type
, copy_body_data
*id
)
486 /* See if we have remapped this type. */
487 node
= (tree
*) pointer_map_contains (id
->decl_map
, type
);
494 /* The type only needs remapping if it's variably modified. */
495 /* Decide if DECL can be put into BLOCK_NONLOCAL_VARs. */
498 can_be_nonlocal (tree decl
, copy_body_data
*id
)
500 /* We can not duplicate function decls. */
501 if (TREE_CODE (decl
) == FUNCTION_DECL
)
504 /* Local static vars must be non-local or we get multiple declaration
506 if (TREE_CODE (decl
) == VAR_DECL
507 && !auto_var_in_fn_p (decl
, id
->src_fn
))
510 /* At the moment dwarf2out can handle only these types of nodes. We
511 can support more later. */
512 if (TREE_CODE (decl
) != VAR_DECL
&& TREE_CODE (decl
) != PARM_DECL
)
515 /* We must use global type. We call remapped_type instead of
516 remap_type since we don't want to remap this type here if it
517 hasn't been remapped before. */
518 if (TREE_TYPE (decl
) != remapped_type (TREE_TYPE (decl
), id
))
521 /* Wihtout SSA we can't tell if variable is used. */
522 if (!gimple_in_ssa_p (cfun
))
525 /* Live variables must be copied so we can attach DECL_RTL. */
533 remap_decls (tree decls
, VEC(tree
,gc
) **nonlocalized_list
, copy_body_data
*id
)
536 tree new_decls
= NULL_TREE
;
538 /* Remap its variables. */
539 for (old_var
= decls
; old_var
; old_var
= DECL_CHAIN (old_var
))
543 if (can_be_nonlocal (old_var
, id
))
545 if (TREE_CODE (old_var
) == VAR_DECL
546 && ! DECL_EXTERNAL (old_var
)
547 && (var_ann (old_var
) || !gimple_in_ssa_p (cfun
)))
548 add_local_decl (cfun
, old_var
);
549 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
550 && !DECL_IGNORED_P (old_var
)
551 && nonlocalized_list
)
552 VEC_safe_push (tree
, gc
, *nonlocalized_list
, old_var
);
556 /* Remap the variable. */
557 new_var
= remap_decl (old_var
, id
);
559 /* If we didn't remap this variable, we can't mess with its
560 TREE_CHAIN. If we remapped this variable to the return slot, it's
561 already declared somewhere else, so don't declare it here. */
563 if (new_var
== id
->retvar
)
567 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
568 && !DECL_IGNORED_P (old_var
)
569 && nonlocalized_list
)
570 VEC_safe_push (tree
, gc
, *nonlocalized_list
, old_var
);
574 gcc_assert (DECL_P (new_var
));
575 DECL_CHAIN (new_var
) = new_decls
;
578 /* Also copy value-expressions. */
579 if (TREE_CODE (new_var
) == VAR_DECL
580 && DECL_HAS_VALUE_EXPR_P (new_var
))
582 tree tem
= DECL_VALUE_EXPR (new_var
);
583 bool old_regimplify
= id
->regimplify
;
584 id
->remapping_type_depth
++;
585 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
586 id
->remapping_type_depth
--;
587 id
->regimplify
= old_regimplify
;
588 SET_DECL_VALUE_EXPR (new_var
, tem
);
593 return nreverse (new_decls
);
596 /* Copy the BLOCK to contain remapped versions of the variables
597 therein. And hook the new block into the block-tree. */
600 remap_block (tree
*block
, copy_body_data
*id
)
605 /* Make the new block. */
607 new_block
= make_node (BLOCK
);
608 TREE_USED (new_block
) = TREE_USED (old_block
);
609 BLOCK_ABSTRACT_ORIGIN (new_block
) = old_block
;
610 BLOCK_SOURCE_LOCATION (new_block
) = BLOCK_SOURCE_LOCATION (old_block
);
611 BLOCK_NONLOCALIZED_VARS (new_block
)
612 = VEC_copy (tree
, gc
, BLOCK_NONLOCALIZED_VARS (old_block
));
615 /* Remap its variables. */
616 BLOCK_VARS (new_block
) = remap_decls (BLOCK_VARS (old_block
),
617 &BLOCK_NONLOCALIZED_VARS (new_block
),
620 if (id
->transform_lang_insert_block
)
621 id
->transform_lang_insert_block (new_block
);
623 /* Remember the remapped block. */
624 insert_decl_map (id
, old_block
, new_block
);
627 /* Copy the whole block tree and root it in id->block. */
629 remap_blocks (tree block
, copy_body_data
*id
)
632 tree new_tree
= block
;
637 remap_block (&new_tree
, id
);
638 gcc_assert (new_tree
!= block
);
639 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
640 prepend_lexical_block (new_tree
, remap_blocks (t
, id
));
641 /* Blocks are in arbitrary order, but make things slightly prettier and do
642 not swap order when producing a copy. */
643 BLOCK_SUBBLOCKS (new_tree
) = blocks_nreverse (BLOCK_SUBBLOCKS (new_tree
));
648 copy_statement_list (tree
*tp
)
650 tree_stmt_iterator oi
, ni
;
653 new_tree
= alloc_stmt_list ();
654 ni
= tsi_start (new_tree
);
655 oi
= tsi_start (*tp
);
656 TREE_TYPE (new_tree
) = TREE_TYPE (*tp
);
659 for (; !tsi_end_p (oi
); tsi_next (&oi
))
661 tree stmt
= tsi_stmt (oi
);
662 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
663 copy_statement_list (&stmt
);
664 tsi_link_after (&ni
, stmt
, TSI_CONTINUE_LINKING
);
669 copy_bind_expr (tree
*tp
, int *walk_subtrees
, copy_body_data
*id
)
671 tree block
= BIND_EXPR_BLOCK (*tp
);
672 /* Copy (and replace) the statement. */
673 copy_tree_r (tp
, walk_subtrees
, NULL
);
676 remap_block (&block
, id
);
677 BIND_EXPR_BLOCK (*tp
) = block
;
680 if (BIND_EXPR_VARS (*tp
))
681 /* This will remap a lot of the same decls again, but this should be
683 BIND_EXPR_VARS (*tp
) = remap_decls (BIND_EXPR_VARS (*tp
), NULL
, id
);
687 /* Create a new gimple_seq by remapping all the statements in BODY
688 using the inlining information in ID. */
691 remap_gimple_seq (gimple_seq body
, copy_body_data
*id
)
693 gimple_stmt_iterator si
;
694 gimple_seq new_body
= NULL
;
696 for (si
= gsi_start (body
); !gsi_end_p (si
); gsi_next (&si
))
698 gimple new_stmt
= remap_gimple_stmt (gsi_stmt (si
), id
);
699 gimple_seq_add_stmt (&new_body
, new_stmt
);
706 /* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its
707 block using the mapping information in ID. */
710 copy_gimple_bind (gimple stmt
, copy_body_data
*id
)
713 tree new_block
, new_vars
;
714 gimple_seq body
, new_body
;
716 /* Copy the statement. Note that we purposely don't use copy_stmt
717 here because we need to remap statements as we copy. */
718 body
= gimple_bind_body (stmt
);
719 new_body
= remap_gimple_seq (body
, id
);
721 new_block
= gimple_bind_block (stmt
);
723 remap_block (&new_block
, id
);
725 /* This will remap a lot of the same decls again, but this should be
727 new_vars
= gimple_bind_vars (stmt
);
729 new_vars
= remap_decls (new_vars
, NULL
, id
);
731 new_bind
= gimple_build_bind (new_vars
, new_body
, new_block
);
737 /* Remap the GIMPLE operand pointed to by *TP. DATA is really a
738 'struct walk_stmt_info *'. DATA->INFO is a 'copy_body_data *'.
739 WALK_SUBTREES is used to indicate walk_gimple_op whether to keep
740 recursing into the children nodes of *TP. */
743 remap_gimple_op_r (tree
*tp
, int *walk_subtrees
, void *data
)
745 struct walk_stmt_info
*wi_p
= (struct walk_stmt_info
*) data
;
746 copy_body_data
*id
= (copy_body_data
*) wi_p
->info
;
747 tree fn
= id
->src_fn
;
749 if (TREE_CODE (*tp
) == SSA_NAME
)
751 *tp
= remap_ssa_name (*tp
, id
);
755 else if (auto_var_in_fn_p (*tp
, fn
))
757 /* Local variables and labels need to be replaced by equivalent
758 variables. We don't want to copy static variables; there's
759 only one of those, no matter how many times we inline the
760 containing function. Similarly for globals from an outer
764 /* Remap the declaration. */
765 new_decl
= remap_decl (*tp
, id
);
766 gcc_assert (new_decl
);
767 /* Replace this variable with the copy. */
768 STRIP_TYPE_NOPS (new_decl
);
769 /* ??? The C++ frontend uses void * pointer zero to initialize
770 any other type. This confuses the middle-end type verification.
771 As cloned bodies do not go through gimplification again the fixup
772 there doesn't trigger. */
773 if (TREE_CODE (new_decl
) == INTEGER_CST
774 && !useless_type_conversion_p (TREE_TYPE (*tp
), TREE_TYPE (new_decl
)))
775 new_decl
= fold_convert (TREE_TYPE (*tp
), new_decl
);
779 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
781 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
783 else if (TREE_CODE (*tp
) == LABEL_DECL
784 && (!DECL_CONTEXT (*tp
)
785 || decl_function_context (*tp
) == id
->src_fn
))
786 /* These may need to be remapped for EH handling. */
787 *tp
= remap_decl (*tp
, id
);
788 else if (TYPE_P (*tp
))
789 /* Types may need remapping as well. */
790 *tp
= remap_type (*tp
, id
);
791 else if (CONSTANT_CLASS_P (*tp
))
793 /* If this is a constant, we have to copy the node iff the type
794 will be remapped. copy_tree_r will not copy a constant. */
795 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
797 if (new_type
== TREE_TYPE (*tp
))
800 else if (TREE_CODE (*tp
) == INTEGER_CST
)
801 *tp
= build_int_cst_wide (new_type
, TREE_INT_CST_LOW (*tp
),
802 TREE_INT_CST_HIGH (*tp
));
805 *tp
= copy_node (*tp
);
806 TREE_TYPE (*tp
) = new_type
;
811 /* Otherwise, just copy the node. Note that copy_tree_r already
812 knows not to copy VAR_DECLs, etc., so this is safe. */
813 if (TREE_CODE (*tp
) == MEM_REF
)
815 /* We need to re-canonicalize MEM_REFs from inline substitutions
816 that can happen when a pointer argument is an ADDR_EXPR. */
817 tree decl
= TREE_OPERAND (*tp
, 0);
820 /* See remap_ssa_name. */
821 if (TREE_CODE (decl
) == SSA_NAME
822 && TREE_CODE (SSA_NAME_VAR (decl
)) == RESULT_DECL
823 && id
->transform_return_to_modify
)
824 decl
= SSA_NAME_VAR (decl
);
826 n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
830 tree ptr
= unshare_expr (*n
);
832 if ((tem
= maybe_fold_offset_to_reference (EXPR_LOCATION (*tp
),
834 TREE_OPERAND (*tp
, 1),
836 && TREE_THIS_VOLATILE (tem
) == TREE_THIS_VOLATILE (old
))
838 tree
*tem_basep
= &tem
;
839 while (handled_component_p (*tem_basep
))
840 tem_basep
= &TREE_OPERAND (*tem_basep
, 0);
841 if (TREE_CODE (*tem_basep
) == MEM_REF
)
843 = build2 (MEM_REF
, TREE_TYPE (*tem_basep
),
844 TREE_OPERAND (*tem_basep
, 0),
845 fold_convert (TREE_TYPE (TREE_OPERAND (*tp
, 1)),
846 TREE_OPERAND (*tem_basep
, 1)));
849 = build2 (MEM_REF
, TREE_TYPE (*tem_basep
),
850 build_fold_addr_expr (*tem_basep
),
852 (TREE_TYPE (TREE_OPERAND (*tp
, 1)), 0));
857 *tp
= fold_build2 (MEM_REF
, TREE_TYPE (*tp
),
858 ptr
, TREE_OPERAND (*tp
, 1));
859 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
860 TREE_THIS_NOTRAP (*tp
) = TREE_THIS_NOTRAP (old
);
862 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
868 /* Here is the "usual case". Copy this tree node, and then
869 tweak some special cases. */
870 copy_tree_r (tp
, walk_subtrees
, NULL
);
872 /* Global variables we haven't seen yet need to go into referenced
873 vars. If not referenced from types only. */
874 if (gimple_in_ssa_p (cfun
)
875 && TREE_CODE (*tp
) == VAR_DECL
876 && id
->remapping_type_depth
== 0
877 && !processing_debug_stmt
)
878 add_referenced_var (*tp
);
880 /* We should never have TREE_BLOCK set on non-statements. */
882 gcc_assert (!TREE_BLOCK (*tp
));
884 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
885 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
887 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
889 /* The copied TARGET_EXPR has never been expanded, even if the
890 original node was expanded already. */
891 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
892 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
894 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
896 /* Variable substitution need not be simple. In particular,
897 the MEM_REF substitution above. Make sure that
898 TREE_CONSTANT and friends are up-to-date. But make sure
899 to not improperly set TREE_BLOCK on some sub-expressions. */
900 int invariant
= is_gimple_min_invariant (*tp
);
901 tree block
= id
->block
;
902 id
->block
= NULL_TREE
;
903 walk_tree (&TREE_OPERAND (*tp
, 0), remap_gimple_op_r
, data
, NULL
);
905 recompute_tree_invariant_for_addr_expr (*tp
);
907 /* If this used to be invariant, but is not any longer,
908 then regimplification is probably needed. */
909 if (invariant
&& !is_gimple_min_invariant (*tp
))
910 id
->regimplify
= true;
916 /* Keep iterating. */
921 /* Called from copy_body_id via walk_tree. DATA is really a
922 `copy_body_data *'. */
925 copy_tree_body_r (tree
*tp
, int *walk_subtrees
, void *data
)
927 copy_body_data
*id
= (copy_body_data
*) data
;
928 tree fn
= id
->src_fn
;
931 /* Begin by recognizing trees that we'll completely rewrite for the
932 inlining context. Our output for these trees is completely
933 different from out input (e.g. RETURN_EXPR is deleted, and morphs
934 into an edge). Further down, we'll handle trees that get
935 duplicated and/or tweaked. */
937 /* When requested, RETURN_EXPRs should be transformed to just the
938 contained MODIFY_EXPR. The branch semantics of the return will
939 be handled elsewhere by manipulating the CFG rather than a statement. */
940 if (TREE_CODE (*tp
) == RETURN_EXPR
&& id
->transform_return_to_modify
)
942 tree assignment
= TREE_OPERAND (*tp
, 0);
944 /* If we're returning something, just turn that into an
945 assignment into the equivalent of the original RESULT_DECL.
946 If the "assignment" is just the result decl, the result
947 decl has already been set (e.g. a recent "foo (&result_decl,
948 ...)"); just toss the entire RETURN_EXPR. */
949 if (assignment
&& TREE_CODE (assignment
) == MODIFY_EXPR
)
951 /* Replace the RETURN_EXPR with (a copy of) the
952 MODIFY_EXPR hanging underneath. */
953 *tp
= copy_node (assignment
);
955 else /* Else the RETURN_EXPR returns no value. */
958 return (tree
) (void *)1;
961 else if (TREE_CODE (*tp
) == SSA_NAME
)
963 *tp
= remap_ssa_name (*tp
, id
);
968 /* Local variables and labels need to be replaced by equivalent
969 variables. We don't want to copy static variables; there's only
970 one of those, no matter how many times we inline the containing
971 function. Similarly for globals from an outer function. */
972 else if (auto_var_in_fn_p (*tp
, fn
))
976 /* Remap the declaration. */
977 new_decl
= remap_decl (*tp
, id
);
978 gcc_assert (new_decl
);
979 /* Replace this variable with the copy. */
980 STRIP_TYPE_NOPS (new_decl
);
984 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
985 copy_statement_list (tp
);
986 else if (TREE_CODE (*tp
) == SAVE_EXPR
987 || TREE_CODE (*tp
) == TARGET_EXPR
)
988 remap_save_expr (tp
, id
->decl_map
, walk_subtrees
);
989 else if (TREE_CODE (*tp
) == LABEL_DECL
990 && (! DECL_CONTEXT (*tp
)
991 || decl_function_context (*tp
) == id
->src_fn
))
992 /* These may need to be remapped for EH handling. */
993 *tp
= remap_decl (*tp
, id
);
994 else if (TREE_CODE (*tp
) == BIND_EXPR
)
995 copy_bind_expr (tp
, walk_subtrees
, id
);
996 /* Types may need remapping as well. */
997 else if (TYPE_P (*tp
))
998 *tp
= remap_type (*tp
, id
);
1000 /* If this is a constant, we have to copy the node iff the type will be
1001 remapped. copy_tree_r will not copy a constant. */
1002 else if (CONSTANT_CLASS_P (*tp
))
1004 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
1006 if (new_type
== TREE_TYPE (*tp
))
1009 else if (TREE_CODE (*tp
) == INTEGER_CST
)
1010 *tp
= build_int_cst_wide (new_type
, TREE_INT_CST_LOW (*tp
),
1011 TREE_INT_CST_HIGH (*tp
));
1014 *tp
= copy_node (*tp
);
1015 TREE_TYPE (*tp
) = new_type
;
1019 /* Otherwise, just copy the node. Note that copy_tree_r already
1020 knows not to copy VAR_DECLs, etc., so this is safe. */
1023 /* Here we handle trees that are not completely rewritten.
1024 First we detect some inlining-induced bogosities for
1026 if (TREE_CODE (*tp
) == MODIFY_EXPR
1027 && TREE_OPERAND (*tp
, 0) == TREE_OPERAND (*tp
, 1)
1028 && (auto_var_in_fn_p (TREE_OPERAND (*tp
, 0), fn
)))
1030 /* Some assignments VAR = VAR; don't generate any rtl code
1031 and thus don't count as variable modification. Avoid
1032 keeping bogosities like 0 = 0. */
1033 tree decl
= TREE_OPERAND (*tp
, 0), value
;
1036 n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
1040 STRIP_TYPE_NOPS (value
);
1041 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1043 *tp
= build_empty_stmt (EXPR_LOCATION (*tp
));
1044 return copy_tree_body_r (tp
, walk_subtrees
, data
);
1048 else if (TREE_CODE (*tp
) == INDIRECT_REF
)
1050 /* Get rid of *& from inline substitutions that can happen when a
1051 pointer argument is an ADDR_EXPR. */
1052 tree decl
= TREE_OPERAND (*tp
, 0);
1055 n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
1060 /* If we happen to get an ADDR_EXPR in n->value, strip
1061 it manually here as we'll eventually get ADDR_EXPRs
1062 which lie about their types pointed to. In this case
1063 build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
1064 but we absolutely rely on that. As fold_indirect_ref
1065 does other useful transformations, try that first, though. */
1066 tree type
= TREE_TYPE (TREE_TYPE (*n
));
1067 if (id
->do_not_unshare
)
1070 new_tree
= unshare_expr (*n
);
1072 *tp
= gimple_fold_indirect_ref (new_tree
);
1075 if (TREE_CODE (new_tree
) == ADDR_EXPR
)
1077 *tp
= fold_indirect_ref_1 (EXPR_LOCATION (new_tree
),
1079 /* ??? We should either assert here or build
1080 a VIEW_CONVERT_EXPR instead of blindly leaking
1081 incompatible types to our IL. */
1083 *tp
= TREE_OPERAND (new_tree
, 0);
1087 *tp
= build1 (INDIRECT_REF
, type
, new_tree
);
1088 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1089 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1090 TREE_READONLY (*tp
) = TREE_READONLY (old
);
1091 TREE_THIS_NOTRAP (*tp
) = TREE_THIS_NOTRAP (old
);
1098 else if (TREE_CODE (*tp
) == MEM_REF
)
1100 /* We need to re-canonicalize MEM_REFs from inline substitutions
1101 that can happen when a pointer argument is an ADDR_EXPR. */
1102 tree decl
= TREE_OPERAND (*tp
, 0);
1105 n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
1109 *tp
= fold_build2 (MEM_REF
, TREE_TYPE (*tp
),
1110 unshare_expr (*n
), TREE_OPERAND (*tp
, 1));
1111 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1112 TREE_NO_WARNING (*tp
) = TREE_NO_WARNING (old
);
1118 /* Here is the "usual case". Copy this tree node, and then
1119 tweak some special cases. */
1120 copy_tree_r (tp
, walk_subtrees
, NULL
);
1122 /* Global variables we haven't seen yet needs to go into referenced
1123 vars. If not referenced from types or debug stmts only. */
1124 if (gimple_in_ssa_p (cfun
)
1125 && TREE_CODE (*tp
) == VAR_DECL
1126 && id
->remapping_type_depth
== 0
1127 && !processing_debug_stmt
)
1128 add_referenced_var (*tp
);
1130 /* If EXPR has block defined, map it to newly constructed block.
1131 When inlining we want EXPRs without block appear in the block
1132 of function call if we are not remapping a type. */
1135 new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
1136 if (TREE_BLOCK (*tp
))
1139 n
= (tree
*) pointer_map_contains (id
->decl_map
,
1141 gcc_assert (n
|| id
->remapping_type_depth
!= 0);
1145 TREE_BLOCK (*tp
) = new_block
;
1148 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
1149 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
1151 /* The copied TARGET_EXPR has never been expanded, even if the
1152 original node was expanded already. */
1153 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
1155 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
1156 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
1159 /* Variable substitution need not be simple. In particular, the
1160 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
1161 and friends are up-to-date. */
1162 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
1164 int invariant
= is_gimple_min_invariant (*tp
);
1165 walk_tree (&TREE_OPERAND (*tp
, 0), copy_tree_body_r
, id
, NULL
);
1167 /* Handle the case where we substituted an INDIRECT_REF
1168 into the operand of the ADDR_EXPR. */
1169 if (TREE_CODE (TREE_OPERAND (*tp
, 0)) == INDIRECT_REF
)
1170 *tp
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0);
1172 recompute_tree_invariant_for_addr_expr (*tp
);
1174 /* If this used to be invariant, but is not any longer,
1175 then regimplification is probably needed. */
1176 if (invariant
&& !is_gimple_min_invariant (*tp
))
1177 id
->regimplify
= true;
1183 /* Keep iterating. */
1187 /* Helper for remap_gimple_stmt. Given an EH region number for the
1188 source function, map that to the duplicate EH region number in
1189 the destination function. */
1192 remap_eh_region_nr (int old_nr
, copy_body_data
*id
)
1194 eh_region old_r
, new_r
;
1197 old_r
= get_eh_region_from_number_fn (id
->src_cfun
, old_nr
);
1198 slot
= pointer_map_contains (id
->eh_map
, old_r
);
1199 new_r
= (eh_region
) *slot
;
1201 return new_r
->index
;
1204 /* Similar, but operate on INTEGER_CSTs. */
1207 remap_eh_region_tree_nr (tree old_t_nr
, copy_body_data
*id
)
1211 old_nr
= tree_low_cst (old_t_nr
, 0);
1212 new_nr
= remap_eh_region_nr (old_nr
, id
);
1214 return build_int_cst (NULL
, new_nr
);
1217 /* Helper for copy_bb. Remap statement STMT using the inlining
1218 information in ID. Return the new statement copy. */
1221 remap_gimple_stmt (gimple stmt
, copy_body_data
*id
)
1224 struct walk_stmt_info wi
;
1226 bool skip_first
= false;
1228 /* Begin by recognizing trees that we'll completely rewrite for the
1229 inlining context. Our output for these trees is completely
1230 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1231 into an edge). Further down, we'll handle trees that get
1232 duplicated and/or tweaked. */
1234 /* When requested, GIMPLE_RETURNs should be transformed to just the
1235 contained GIMPLE_ASSIGN. The branch semantics of the return will
1236 be handled elsewhere by manipulating the CFG rather than the
1238 if (gimple_code (stmt
) == GIMPLE_RETURN
&& id
->transform_return_to_modify
)
1240 tree retval
= gimple_return_retval (stmt
);
1242 /* If we're returning something, just turn that into an
1243 assignment into the equivalent of the original RESULT_DECL.
1244 If RETVAL is just the result decl, the result decl has
1245 already been set (e.g. a recent "foo (&result_decl, ...)");
1246 just toss the entire GIMPLE_RETURN. */
1248 && (TREE_CODE (retval
) != RESULT_DECL
1249 && (TREE_CODE (retval
) != SSA_NAME
1250 || TREE_CODE (SSA_NAME_VAR (retval
)) != RESULT_DECL
)))
1252 copy
= gimple_build_assign (id
->retvar
, retval
);
1253 /* id->retvar is already substituted. Skip it on later remapping. */
1257 return gimple_build_nop ();
1259 else if (gimple_has_substatements (stmt
))
1263 /* When cloning bodies from the C++ front end, we will be handed bodies
1264 in High GIMPLE form. Handle here all the High GIMPLE statements that
1265 have embedded statements. */
1266 switch (gimple_code (stmt
))
1269 copy
= copy_gimple_bind (stmt
, id
);
1273 s1
= remap_gimple_seq (gimple_catch_handler (stmt
), id
);
1274 copy
= gimple_build_catch (gimple_catch_types (stmt
), s1
);
1277 case GIMPLE_EH_FILTER
:
1278 s1
= remap_gimple_seq (gimple_eh_filter_failure (stmt
), id
);
1279 copy
= gimple_build_eh_filter (gimple_eh_filter_types (stmt
), s1
);
1283 s1
= remap_gimple_seq (gimple_try_eval (stmt
), id
);
1284 s2
= remap_gimple_seq (gimple_try_cleanup (stmt
), id
);
1285 copy
= gimple_build_try (s1
, s2
, gimple_try_kind (stmt
));
1288 case GIMPLE_WITH_CLEANUP_EXPR
:
1289 s1
= remap_gimple_seq (gimple_wce_cleanup (stmt
), id
);
1290 copy
= gimple_build_wce (s1
);
1293 case GIMPLE_OMP_PARALLEL
:
1294 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1295 copy
= gimple_build_omp_parallel
1297 gimple_omp_parallel_clauses (stmt
),
1298 gimple_omp_parallel_child_fn (stmt
),
1299 gimple_omp_parallel_data_arg (stmt
));
1302 case GIMPLE_OMP_TASK
:
1303 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1304 copy
= gimple_build_omp_task
1306 gimple_omp_task_clauses (stmt
),
1307 gimple_omp_task_child_fn (stmt
),
1308 gimple_omp_task_data_arg (stmt
),
1309 gimple_omp_task_copy_fn (stmt
),
1310 gimple_omp_task_arg_size (stmt
),
1311 gimple_omp_task_arg_align (stmt
));
1314 case GIMPLE_OMP_FOR
:
1315 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1316 s2
= remap_gimple_seq (gimple_omp_for_pre_body (stmt
), id
);
1317 copy
= gimple_build_omp_for (s1
, gimple_omp_for_clauses (stmt
),
1318 gimple_omp_for_collapse (stmt
), s2
);
1321 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1323 gimple_omp_for_set_index (copy
, i
,
1324 gimple_omp_for_index (stmt
, i
));
1325 gimple_omp_for_set_initial (copy
, i
,
1326 gimple_omp_for_initial (stmt
, i
));
1327 gimple_omp_for_set_final (copy
, i
,
1328 gimple_omp_for_final (stmt
, i
));
1329 gimple_omp_for_set_incr (copy
, i
,
1330 gimple_omp_for_incr (stmt
, i
));
1331 gimple_omp_for_set_cond (copy
, i
,
1332 gimple_omp_for_cond (stmt
, i
));
1337 case GIMPLE_OMP_MASTER
:
1338 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1339 copy
= gimple_build_omp_master (s1
);
1342 case GIMPLE_OMP_ORDERED
:
1343 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1344 copy
= gimple_build_omp_ordered (s1
);
1347 case GIMPLE_OMP_SECTION
:
1348 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1349 copy
= gimple_build_omp_section (s1
);
1352 case GIMPLE_OMP_SECTIONS
:
1353 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1354 copy
= gimple_build_omp_sections
1355 (s1
, gimple_omp_sections_clauses (stmt
));
1358 case GIMPLE_OMP_SINGLE
:
1359 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1360 copy
= gimple_build_omp_single
1361 (s1
, gimple_omp_single_clauses (stmt
));
1364 case GIMPLE_OMP_CRITICAL
:
1365 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1367 = gimple_build_omp_critical (s1
, gimple_omp_critical_name (stmt
));
1376 if (gimple_assign_copy_p (stmt
)
1377 && gimple_assign_lhs (stmt
) == gimple_assign_rhs1 (stmt
)
1378 && auto_var_in_fn_p (gimple_assign_lhs (stmt
), id
->src_fn
))
1380 /* Here we handle statements that are not completely rewritten.
1381 First we detect some inlining-induced bogosities for
1384 /* Some assignments VAR = VAR; don't generate any rtl code
1385 and thus don't count as variable modification. Avoid
1386 keeping bogosities like 0 = 0. */
1387 tree decl
= gimple_assign_lhs (stmt
), value
;
1390 n
= (tree
*) pointer_map_contains (id
->decl_map
, decl
);
1394 STRIP_TYPE_NOPS (value
);
1395 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1396 return gimple_build_nop ();
1400 if (gimple_debug_bind_p (stmt
))
1402 copy
= gimple_build_debug_bind (gimple_debug_bind_get_var (stmt
),
1403 gimple_debug_bind_get_value (stmt
),
1405 VEC_safe_push (gimple
, heap
, id
->debug_stmts
, copy
);
1409 /* Create a new deep copy of the statement. */
1410 copy
= gimple_copy (stmt
);
1412 /* Remap the region numbers for __builtin_eh_{pointer,filter},
1413 RESX and EH_DISPATCH. */
1415 switch (gimple_code (copy
))
1419 tree r
, fndecl
= gimple_call_fndecl (copy
);
1420 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
1421 switch (DECL_FUNCTION_CODE (fndecl
))
1423 case BUILT_IN_EH_COPY_VALUES
:
1424 r
= gimple_call_arg (copy
, 1);
1425 r
= remap_eh_region_tree_nr (r
, id
);
1426 gimple_call_set_arg (copy
, 1, r
);
1429 case BUILT_IN_EH_POINTER
:
1430 case BUILT_IN_EH_FILTER
:
1431 r
= gimple_call_arg (copy
, 0);
1432 r
= remap_eh_region_tree_nr (r
, id
);
1433 gimple_call_set_arg (copy
, 0, r
);
1440 /* Reset alias info if we didn't apply measures to
1441 keep it valid over inlining by setting DECL_PT_UID. */
1442 if (!id
->src_cfun
->gimple_df
1443 || !id
->src_cfun
->gimple_df
->ipa_pta
)
1444 gimple_call_reset_alias_info (copy
);
1450 int r
= gimple_resx_region (copy
);
1451 r
= remap_eh_region_nr (r
, id
);
1452 gimple_resx_set_region (copy
, r
);
1456 case GIMPLE_EH_DISPATCH
:
1458 int r
= gimple_eh_dispatch_region (copy
);
1459 r
= remap_eh_region_nr (r
, id
);
1460 gimple_eh_dispatch_set_region (copy
, r
);
1469 /* If STMT has a block defined, map it to the newly constructed
1470 block. When inlining we want statements without a block to
1471 appear in the block of the function call. */
1472 new_block
= id
->block
;
1473 if (gimple_block (copy
))
1476 n
= (tree
*) pointer_map_contains (id
->decl_map
, gimple_block (copy
));
1481 gimple_set_block (copy
, new_block
);
1483 if (gimple_debug_bind_p (copy
))
1486 /* Remap all the operands in COPY. */
1487 memset (&wi
, 0, sizeof (wi
));
1490 walk_tree (gimple_op_ptr (copy
, 1), remap_gimple_op_r
, &wi
, NULL
);
1492 walk_gimple_op (copy
, remap_gimple_op_r
, &wi
);
1494 /* Clear the copied virtual operands. We are not remapping them here
1495 but are going to recreate them from scratch. */
1496 if (gimple_has_mem_ops (copy
))
1498 gimple_set_vdef (copy
, NULL_TREE
);
1499 gimple_set_vuse (copy
, NULL_TREE
);
1506 /* Copy basic block, scale profile accordingly. Edges will be taken care of
1510 copy_bb (copy_body_data
*id
, basic_block bb
, int frequency_scale
,
1511 gcov_type count_scale
)
1513 gimple_stmt_iterator gsi
, copy_gsi
, seq_gsi
;
1514 basic_block copy_basic_block
;
1519 /* Search for previous copied basic block. */
1522 prev
= prev
->prev_bb
;
1524 /* create_basic_block() will append every new block to
1525 basic_block_info automatically. */
1526 copy_basic_block
= create_basic_block (NULL
, (void *) 0,
1527 (basic_block
) prev
->aux
);
1528 copy_basic_block
->count
= bb
->count
* count_scale
/ REG_BR_PROB_BASE
;
1530 /* We are going to rebuild frequencies from scratch. These values
1531 have just small importance to drive canonicalize_loop_headers. */
1532 freq
= ((gcov_type
)bb
->frequency
* frequency_scale
/ REG_BR_PROB_BASE
);
1534 /* We recompute frequencies after inlining, so this is quite safe. */
1535 if (freq
> BB_FREQ_MAX
)
1537 copy_basic_block
->frequency
= freq
;
1539 copy_gsi
= gsi_start_bb (copy_basic_block
);
1541 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1543 gimple stmt
= gsi_stmt (gsi
);
1544 gimple orig_stmt
= stmt
;
1546 id
->regimplify
= false;
1547 stmt
= remap_gimple_stmt (stmt
, id
);
1548 if (gimple_nop_p (stmt
))
1551 gimple_duplicate_stmt_histograms (cfun
, stmt
, id
->src_cfun
, orig_stmt
);
1554 /* With return slot optimization we can end up with
1555 non-gimple (foo *)&this->m, fix that here. */
1556 if (is_gimple_assign (stmt
)
1557 && gimple_assign_rhs_code (stmt
) == NOP_EXPR
1558 && !is_gimple_val (gimple_assign_rhs1 (stmt
)))
1561 new_rhs
= force_gimple_operand_gsi (&seq_gsi
,
1562 gimple_assign_rhs1 (stmt
),
1564 GSI_CONTINUE_LINKING
);
1565 gimple_assign_set_rhs1 (stmt
, new_rhs
);
1566 id
->regimplify
= false;
1569 gsi_insert_after (&seq_gsi
, stmt
, GSI_NEW_STMT
);
1572 gimple_regimplify_operands (stmt
, &seq_gsi
);
1574 /* If copy_basic_block has been empty at the start of this iteration,
1575 call gsi_start_bb again to get at the newly added statements. */
1576 if (gsi_end_p (copy_gsi
))
1577 copy_gsi
= gsi_start_bb (copy_basic_block
);
1579 gsi_next (©_gsi
);
1581 /* Process the new statement. The call to gimple_regimplify_operands
1582 possibly turned the statement into multiple statements, we
1583 need to process all of them. */
1588 stmt
= gsi_stmt (copy_gsi
);
1589 if (is_gimple_call (stmt
)
1590 && gimple_call_va_arg_pack_p (stmt
)
1593 /* __builtin_va_arg_pack () should be replaced by
1594 all arguments corresponding to ... in the caller. */
1597 VEC(tree
, heap
) *argarray
;
1598 size_t nargs
= gimple_call_num_args (id
->gimple_call
);
1601 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1604 /* Create the new array of arguments. */
1605 n
= nargs
+ gimple_call_num_args (stmt
);
1606 argarray
= VEC_alloc (tree
, heap
, n
);
1607 VEC_safe_grow (tree
, heap
, argarray
, n
);
1609 /* Copy all the arguments before '...' */
1610 memcpy (VEC_address (tree
, argarray
),
1611 gimple_call_arg_ptr (stmt
, 0),
1612 gimple_call_num_args (stmt
) * sizeof (tree
));
1614 /* Append the arguments passed in '...' */
1615 memcpy (VEC_address(tree
, argarray
) + gimple_call_num_args (stmt
),
1616 gimple_call_arg_ptr (id
->gimple_call
, 0)
1617 + (gimple_call_num_args (id
->gimple_call
) - nargs
),
1618 nargs
* sizeof (tree
));
1620 new_call
= gimple_build_call_vec (gimple_call_fn (stmt
),
1623 VEC_free (tree
, heap
, argarray
);
1625 /* Copy all GIMPLE_CALL flags, location and block, except
1626 GF_CALL_VA_ARG_PACK. */
1627 gimple_call_copy_flags (new_call
, stmt
);
1628 gimple_call_set_va_arg_pack (new_call
, false);
1629 gimple_set_location (new_call
, gimple_location (stmt
));
1630 gimple_set_block (new_call
, gimple_block (stmt
));
1631 gimple_call_set_lhs (new_call
, gimple_call_lhs (stmt
));
1633 gsi_replace (©_gsi
, new_call
, false);
1636 else if (is_gimple_call (stmt
)
1638 && (decl
= gimple_call_fndecl (stmt
))
1639 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
1640 && DECL_FUNCTION_CODE (decl
) == BUILT_IN_VA_ARG_PACK_LEN
)
1642 /* __builtin_va_arg_pack_len () should be replaced by
1643 the number of anonymous arguments. */
1644 size_t nargs
= gimple_call_num_args (id
->gimple_call
);
1648 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
1651 count
= build_int_cst (integer_type_node
, nargs
);
1652 new_stmt
= gimple_build_assign (gimple_call_lhs (stmt
), count
);
1653 gsi_replace (©_gsi
, new_stmt
, false);
1657 /* Statements produced by inlining can be unfolded, especially
1658 when we constant propagated some operands. We can't fold
1659 them right now for two reasons:
1660 1) folding require SSA_NAME_DEF_STMTs to be correct
1661 2) we can't change function calls to builtins.
1662 So we just mark statement for later folding. We mark
1663 all new statements, instead just statements that has changed
1664 by some nontrivial substitution so even statements made
1665 foldable indirectly are updated. If this turns out to be
1666 expensive, copy_body can be told to watch for nontrivial
1668 if (id
->statements_to_fold
)
1669 pointer_set_insert (id
->statements_to_fold
, stmt
);
1671 /* We're duplicating a CALL_EXPR. Find any corresponding
1672 callgraph edges and update or duplicate them. */
1673 if (is_gimple_call (stmt
))
1675 struct cgraph_edge
*edge
;
1678 switch (id
->transform_call_graph_edges
)
1680 case CB_CGE_DUPLICATE
:
1681 edge
= cgraph_edge (id
->src_node
, orig_stmt
);
1684 int edge_freq
= edge
->frequency
;
1685 edge
= cgraph_clone_edge (edge
, id
->dst_node
, stmt
,
1687 REG_BR_PROB_BASE
, CGRAPH_FREQ_BASE
,
1688 edge
->frequency
, true);
1689 /* We could also just rescale the frequency, but
1690 doing so would introduce roundoff errors and make
1691 verifier unhappy. */
1693 = compute_call_stmt_bb_frequency (id
->dst_node
->decl
,
1696 && profile_status_for_function (cfun
) != PROFILE_ABSENT
1697 && (edge_freq
> edge
->frequency
+ 10
1698 || edge_freq
< edge
->frequency
- 10))
1700 fprintf (dump_file
, "Edge frequency estimated by "
1701 "cgraph %i diverge from inliner's estimate %i\n",
1705 "Orig bb: %i, orig bb freq %i, new bb freq %i\n",
1708 copy_basic_block
->frequency
);
1710 stmt
= cgraph_redirect_edge_call_stmt_to_callee (edge
);
1714 case CB_CGE_MOVE_CLONES
:
1715 cgraph_set_call_stmt_including_clones (id
->dst_node
,
1717 edge
= cgraph_edge (id
->dst_node
, stmt
);
1721 edge
= cgraph_edge (id
->dst_node
, orig_stmt
);
1723 cgraph_set_call_stmt (edge
, stmt
);
1730 /* Constant propagation on argument done during inlining
1731 may create new direct call. Produce an edge for it. */
1733 || (edge
->indirect_inlining_edge
1734 && id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
))
1735 && (fn
= gimple_call_fndecl (stmt
)) != NULL
)
1737 struct cgraph_node
*dest
= cgraph_node (fn
);
1739 /* We have missing edge in the callgraph. This can happen
1740 when previous inlining turned an indirect call into a
1741 direct call by constant propagating arguments or we are
1742 producing dead clone (for further cloning). In all
1743 other cases we hit a bug (incorrect node sharing is the
1744 most common reason for missing edges). */
1745 gcc_assert (dest
->needed
|| !dest
->analyzed
1746 || dest
->address_taken
1747 || !id
->src_node
->analyzed
1748 || !id
->dst_node
->analyzed
);
1749 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
)
1750 cgraph_create_edge_including_clones
1751 (id
->dst_node
, dest
, orig_stmt
, stmt
, bb
->count
,
1752 compute_call_stmt_bb_frequency (id
->dst_node
->decl
,
1754 bb
->loop_depth
, CIF_ORIGINALLY_INDIRECT_CALL
);
1756 cgraph_create_edge (id
->dst_node
, dest
, stmt
,
1758 compute_call_stmt_bb_frequency
1759 (id
->dst_node
->decl
, copy_basic_block
),
1760 bb
->loop_depth
)->inline_failed
1761 = CIF_ORIGINALLY_INDIRECT_CALL
;
1764 fprintf (dump_file
, "Created new direct edge to %s\n",
1765 cgraph_node_name (dest
));
1769 flags
= gimple_call_flags (stmt
);
1770 if (flags
& ECF_MAY_BE_ALLOCA
)
1771 cfun
->calls_alloca
= true;
1772 if (flags
& ECF_RETURNS_TWICE
)
1773 cfun
->calls_setjmp
= true;
1776 maybe_duplicate_eh_stmt_fn (cfun
, stmt
, id
->src_cfun
, orig_stmt
,
1777 id
->eh_map
, id
->eh_lp_nr
);
1779 if (gimple_in_ssa_p (cfun
) && !is_gimple_debug (stmt
))
1784 find_new_referenced_vars (gsi_stmt (copy_gsi
));
1785 FOR_EACH_SSA_TREE_OPERAND (def
, stmt
, i
, SSA_OP_DEF
)
1786 if (TREE_CODE (def
) == SSA_NAME
)
1787 SSA_NAME_DEF_STMT (def
) = stmt
;
1790 gsi_next (©_gsi
);
1792 while (!gsi_end_p (copy_gsi
));
1794 copy_gsi
= gsi_last_bb (copy_basic_block
);
1797 return copy_basic_block
;
1800 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
1801 form is quite easy, since dominator relationship for old basic blocks does
1804 There is however exception where inlining might change dominator relation
1805 across EH edges from basic block within inlined functions destinating
1806 to landing pads in function we inline into.
1808 The function fills in PHI_RESULTs of such PHI nodes if they refer
1809 to gimple regs. Otherwise, the function mark PHI_RESULT of such
1810 PHI nodes for renaming. For non-gimple regs, renaming is safe: the
1811 EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
1812 set, and this means that there will be no overlapping live ranges
1813 for the underlying symbol.
1815 This might change in future if we allow redirecting of EH edges and
1816 we might want to change way build CFG pre-inlining to include
1817 all the possible edges then. */
1819 update_ssa_across_abnormal_edges (basic_block bb
, basic_block ret_bb
,
1820 bool can_throw
, bool nonlocal_goto
)
1825 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1827 || ((basic_block
)e
->dest
->aux
)->index
== ENTRY_BLOCK
)
1830 gimple_stmt_iterator si
;
1833 gcc_assert (e
->flags
& EDGE_EH
);
1836 gcc_assert (!(e
->flags
& EDGE_EH
));
1838 for (si
= gsi_start_phis (e
->dest
); !gsi_end_p (si
); gsi_next (&si
))
1842 phi
= gsi_stmt (si
);
1844 /* There shouldn't be any PHI nodes in the ENTRY_BLOCK. */
1845 gcc_assert (!e
->dest
->aux
);
1847 gcc_assert ((e
->flags
& EDGE_EH
)
1848 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi
)));
1850 if (!is_gimple_reg (PHI_RESULT (phi
)))
1852 mark_sym_for_renaming (SSA_NAME_VAR (PHI_RESULT (phi
)));
1856 re
= find_edge (ret_bb
, e
->dest
);
1858 gcc_assert ((re
->flags
& (EDGE_EH
| EDGE_ABNORMAL
))
1859 == (e
->flags
& (EDGE_EH
| EDGE_ABNORMAL
)));
1861 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, e
),
1862 USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, re
)));
1868 /* Copy edges from BB into its copy constructed earlier, scale profile
1869 accordingly. Edges will be taken care of later. Assume aux
1870 pointers to point to the copies of each BB. Return true if any
1871 debug stmts are left after a statement that must end the basic block. */
1874 copy_edges_for_bb (basic_block bb
, gcov_type count_scale
, basic_block ret_bb
)
1876 basic_block new_bb
= (basic_block
) bb
->aux
;
1879 gimple_stmt_iterator si
;
1881 bool need_debug_cleanup
= false;
1883 /* Use the indices from the original blocks to create edges for the
1885 FOR_EACH_EDGE (old_edge
, ei
, bb
->succs
)
1886 if (!(old_edge
->flags
& EDGE_EH
))
1890 flags
= old_edge
->flags
;
1892 /* Return edges do get a FALLTHRU flag when the get inlined. */
1893 if (old_edge
->dest
->index
== EXIT_BLOCK
&& !old_edge
->flags
1894 && old_edge
->dest
->aux
!= EXIT_BLOCK_PTR
)
1895 flags
|= EDGE_FALLTHRU
;
1896 new_edge
= make_edge (new_bb
, (basic_block
) old_edge
->dest
->aux
, flags
);
1897 new_edge
->count
= old_edge
->count
* count_scale
/ REG_BR_PROB_BASE
;
1898 new_edge
->probability
= old_edge
->probability
;
1901 if (bb
->index
== ENTRY_BLOCK
|| bb
->index
== EXIT_BLOCK
)
1904 for (si
= gsi_start_bb (new_bb
); !gsi_end_p (si
);)
1907 bool can_throw
, nonlocal_goto
;
1909 copy_stmt
= gsi_stmt (si
);
1910 if (!is_gimple_debug (copy_stmt
))
1912 update_stmt (copy_stmt
);
1913 if (gimple_in_ssa_p (cfun
))
1914 mark_symbols_for_renaming (copy_stmt
);
1917 /* Do this before the possible split_block. */
1920 /* If this tree could throw an exception, there are two
1921 cases where we need to add abnormal edge(s): the
1922 tree wasn't in a region and there is a "current
1923 region" in the caller; or the original tree had
1924 EH edges. In both cases split the block after the tree,
1925 and add abnormal edge(s) as needed; we need both
1926 those from the callee and the caller.
1927 We check whether the copy can throw, because the const
1928 propagation can change an INDIRECT_REF which throws
1929 into a COMPONENT_REF which doesn't. If the copy
1930 can throw, the original could also throw. */
1931 can_throw
= stmt_can_throw_internal (copy_stmt
);
1932 nonlocal_goto
= stmt_can_make_abnormal_goto (copy_stmt
);
1934 if (can_throw
|| nonlocal_goto
)
1936 if (!gsi_end_p (si
))
1938 while (!gsi_end_p (si
) && is_gimple_debug (gsi_stmt (si
)))
1941 need_debug_cleanup
= true;
1943 if (!gsi_end_p (si
))
1944 /* Note that bb's predecessor edges aren't necessarily
1945 right at this point; split_block doesn't care. */
1947 edge e
= split_block (new_bb
, copy_stmt
);
1950 new_bb
->aux
= e
->src
->aux
;
1951 si
= gsi_start_bb (new_bb
);
1955 if (gimple_code (copy_stmt
) == GIMPLE_EH_DISPATCH
)
1956 make_eh_dispatch_edges (copy_stmt
);
1958 make_eh_edges (copy_stmt
);
1961 make_abnormal_goto_edges (gimple_bb (copy_stmt
), true);
1963 if ((can_throw
|| nonlocal_goto
)
1964 && gimple_in_ssa_p (cfun
))
1965 update_ssa_across_abnormal_edges (gimple_bb (copy_stmt
), ret_bb
,
1966 can_throw
, nonlocal_goto
);
1968 return need_debug_cleanup
;
1971 /* Copy the PHIs. All blocks and edges are copied, some blocks
1972 was possibly split and new outgoing EH edges inserted.
1973 BB points to the block of original function and AUX pointers links
1974 the original and newly copied blocks. */
1977 copy_phis_for_bb (basic_block bb
, copy_body_data
*id
)
1979 basic_block
const new_bb
= (basic_block
) bb
->aux
;
1982 gimple_stmt_iterator si
;
1984 bool inserted
= false;
1986 for (si
= gsi_start (phi_nodes (bb
)); !gsi_end_p (si
); gsi_next (&si
))
1991 phi
= gsi_stmt (si
);
1992 res
= PHI_RESULT (phi
);
1994 if (is_gimple_reg (res
))
1996 walk_tree (&new_res
, copy_tree_body_r
, id
, NULL
);
1997 SSA_NAME_DEF_STMT (new_res
)
1998 = new_phi
= create_phi_node (new_res
, new_bb
);
1999 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2001 edge old_edge
= find_edge ((basic_block
) new_edge
->src
->aux
, bb
);
2004 tree block
= id
->block
;
2007 /* When doing partial cloning, we allow PHIs on the entry block
2008 as long as all the arguments are the same. Find any input
2009 edge to see argument to copy. */
2011 FOR_EACH_EDGE (old_edge
, ei2
, bb
->preds
)
2012 if (!old_edge
->src
->aux
)
2015 arg
= PHI_ARG_DEF_FROM_EDGE (phi
, old_edge
);
2017 id
->block
= NULL_TREE
;
2018 walk_tree (&new_arg
, copy_tree_body_r
, id
, NULL
);
2020 gcc_assert (new_arg
);
2021 /* With return slot optimization we can end up with
2022 non-gimple (foo *)&this->m, fix that here. */
2023 if (TREE_CODE (new_arg
) != SSA_NAME
2024 && TREE_CODE (new_arg
) != FUNCTION_DECL
2025 && !is_gimple_val (new_arg
))
2027 gimple_seq stmts
= NULL
;
2028 new_arg
= force_gimple_operand (new_arg
, &stmts
, true, NULL
);
2029 gsi_insert_seq_on_edge (new_edge
, stmts
);
2032 add_phi_arg (new_phi
, new_arg
, new_edge
,
2033 gimple_phi_arg_location_from_edge (phi
, old_edge
));
2038 /* Commit the delayed edge insertions. */
2040 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2041 gsi_commit_one_edge_insert (new_edge
, NULL
);
2045 /* Wrapper for remap_decl so it can be used as a callback. */
2048 remap_decl_1 (tree decl
, void *data
)
2050 return remap_decl (decl
, (copy_body_data
*) data
);
2053 /* Build struct function and associated datastructures for the new clone
2054 NEW_FNDECL to be build. CALLEE_FNDECL is the original */
2057 initialize_cfun (tree new_fndecl
, tree callee_fndecl
, gcov_type count
)
2059 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2060 gcov_type count_scale
;
2062 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
)
2063 count_scale
= (REG_BR_PROB_BASE
* count
2064 / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
);
2066 count_scale
= REG_BR_PROB_BASE
;
2068 /* Register specific tree functions. */
2069 gimple_register_cfg_hooks ();
2071 /* Get clean struct function. */
2072 push_struct_function (new_fndecl
);
2074 /* We will rebuild these, so just sanity check that they are empty. */
2075 gcc_assert (VALUE_HISTOGRAMS (cfun
) == NULL
);
2076 gcc_assert (cfun
->local_decls
== NULL
);
2077 gcc_assert (cfun
->cfg
== NULL
);
2078 gcc_assert (cfun
->decl
== new_fndecl
);
2080 /* Copy items we preserve during cloning. */
2081 cfun
->static_chain_decl
= src_cfun
->static_chain_decl
;
2082 cfun
->nonlocal_goto_save_area
= src_cfun
->nonlocal_goto_save_area
;
2083 cfun
->function_end_locus
= src_cfun
->function_end_locus
;
2084 cfun
->curr_properties
= src_cfun
->curr_properties
;
2085 cfun
->last_verified
= src_cfun
->last_verified
;
2086 cfun
->va_list_gpr_size
= src_cfun
->va_list_gpr_size
;
2087 cfun
->va_list_fpr_size
= src_cfun
->va_list_fpr_size
;
2088 cfun
->has_nonlocal_label
= src_cfun
->has_nonlocal_label
;
2089 cfun
->stdarg
= src_cfun
->stdarg
;
2090 cfun
->dont_save_pending_sizes_p
= src_cfun
->dont_save_pending_sizes_p
;
2091 cfun
->after_inlining
= src_cfun
->after_inlining
;
2092 cfun
->can_throw_non_call_exceptions
2093 = src_cfun
->can_throw_non_call_exceptions
;
2094 cfun
->returns_struct
= src_cfun
->returns_struct
;
2095 cfun
->returns_pcc_struct
= src_cfun
->returns_pcc_struct
;
2096 cfun
->after_tree_profile
= src_cfun
->after_tree_profile
;
2098 init_empty_tree_cfg ();
2100 profile_status_for_function (cfun
) = profile_status_for_function (src_cfun
);
2101 ENTRY_BLOCK_PTR
->count
=
2102 (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
* count_scale
/
2104 ENTRY_BLOCK_PTR
->frequency
2105 = ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->frequency
;
2106 EXIT_BLOCK_PTR
->count
=
2107 (EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
* count_scale
/
2109 EXIT_BLOCK_PTR
->frequency
=
2110 EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->frequency
;
2112 init_eh_for_function ();
2114 if (src_cfun
->gimple_df
)
2116 init_tree_ssa (cfun
);
2117 cfun
->gimple_df
->in_ssa_p
= true;
2118 init_ssa_operands ();
2123 /* Helper function for copy_cfg_body. Move debug stmts from the end
2124 of NEW_BB to the beginning of successor basic blocks when needed. If the
2125 successor has multiple predecessors, reset them, otherwise keep
2129 maybe_move_debug_stmts_to_successors (copy_body_data
*id
, basic_block new_bb
)
2133 gimple_stmt_iterator si
= gsi_last_nondebug_bb (new_bb
);
2136 || gsi_one_before_end_p (si
)
2137 || !(stmt_can_throw_internal (gsi_stmt (si
))
2138 || stmt_can_make_abnormal_goto (gsi_stmt (si
))))
2141 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
2143 gimple_stmt_iterator ssi
= gsi_last_bb (new_bb
);
2144 gimple_stmt_iterator dsi
= gsi_after_labels (e
->dest
);
2145 while (is_gimple_debug (gsi_stmt (ssi
)))
2147 gimple stmt
= gsi_stmt (ssi
), new_stmt
;
2151 /* For the last edge move the debug stmts instead of copying
2153 if (ei_one_before_end_p (ei
))
2157 if (!single_pred_p (e
->dest
))
2158 gimple_debug_bind_reset_value (stmt
);
2159 gsi_remove (&si
, false);
2160 gsi_insert_before (&dsi
, stmt
, GSI_SAME_STMT
);
2164 var
= gimple_debug_bind_get_var (stmt
);
2165 if (single_pred_p (e
->dest
))
2167 value
= gimple_debug_bind_get_value (stmt
);
2168 value
= unshare_expr (value
);
2172 new_stmt
= gimple_build_debug_bind (var
, value
, stmt
);
2173 gsi_insert_before (&dsi
, new_stmt
, GSI_SAME_STMT
);
2174 VEC_safe_push (gimple
, heap
, id
->debug_stmts
, new_stmt
);
2180 /* Make a copy of the body of FN so that it can be inserted inline in
2181 another function. Walks FN via CFG, returns new fndecl. */
2184 copy_cfg_body (copy_body_data
* id
, gcov_type count
, int frequency_scale
,
2185 basic_block entry_block_map
, basic_block exit_block_map
,
2186 bitmap blocks_to_copy
, basic_block new_entry
)
2188 tree callee_fndecl
= id
->src_fn
;
2189 /* Original cfun for the callee, doesn't change. */
2190 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2191 struct function
*cfun_to_copy
;
2193 tree new_fndecl
= NULL
;
2194 bool need_debug_cleanup
= false;
2195 gcov_type count_scale
;
2197 int incoming_frequency
= 0;
2198 gcov_type incoming_count
= 0;
2200 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
)
2201 count_scale
= (REG_BR_PROB_BASE
* count
2202 / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun
)->count
);
2204 count_scale
= REG_BR_PROB_BASE
;
2206 /* Register specific tree functions. */
2207 gimple_register_cfg_hooks ();
2209 /* If we are inlining just region of the function, make sure to connect new entry
2210 to ENTRY_BLOCK_PTR. Since new entry can be part of loop, we must compute
2211 frequency and probability of ENTRY_BLOCK_PTR based on the frequencies and
2212 probabilities of edges incoming from nonduplicated region. */
2218 FOR_EACH_EDGE (e
, ei
, new_entry
->preds
)
2221 incoming_frequency
+= EDGE_FREQUENCY (e
);
2222 incoming_count
+= e
->count
;
2224 incoming_count
= incoming_count
* count_scale
/ REG_BR_PROB_BASE
;
2226 = incoming_frequency
* frequency_scale
/ REG_BR_PROB_BASE
;
2227 ENTRY_BLOCK_PTR
->count
= incoming_count
;
2228 ENTRY_BLOCK_PTR
->frequency
= incoming_frequency
;
2231 /* Must have a CFG here at this point. */
2232 gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION
2233 (DECL_STRUCT_FUNCTION (callee_fndecl
)));
2235 cfun_to_copy
= id
->src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2237 ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy
)->aux
= entry_block_map
;
2238 EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy
)->aux
= exit_block_map
;
2239 entry_block_map
->aux
= ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy
);
2240 exit_block_map
->aux
= EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy
);
2242 /* Duplicate any exception-handling regions. */
2244 id
->eh_map
= duplicate_eh_regions (cfun_to_copy
, NULL
, id
->eh_lp_nr
,
2247 /* Use aux pointers to map the original blocks to copy. */
2248 FOR_EACH_BB_FN (bb
, cfun_to_copy
)
2249 if (!blocks_to_copy
|| bitmap_bit_p (blocks_to_copy
, bb
->index
))
2251 basic_block new_bb
= copy_bb (id
, bb
, frequency_scale
, count_scale
);
2256 last
= last_basic_block
;
2258 /* Now that we've duplicated the blocks, duplicate their edges. */
2259 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2261 || (bb
->index
> 0 && bitmap_bit_p (blocks_to_copy
, bb
->index
)))
2262 need_debug_cleanup
|= copy_edges_for_bb (bb
, count_scale
, exit_block_map
);
2266 edge e
= make_edge (entry_block_map
, (basic_block
)new_entry
->aux
, EDGE_FALLTHRU
);
2267 e
->probability
= REG_BR_PROB_BASE
;
2268 e
->count
= incoming_count
;
2271 if (gimple_in_ssa_p (cfun
))
2272 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2274 || (bb
->index
> 0 && bitmap_bit_p (blocks_to_copy
, bb
->index
)))
2275 copy_phis_for_bb (bb
, id
);
2277 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
2280 if (need_debug_cleanup
2281 && bb
->index
!= ENTRY_BLOCK
2282 && bb
->index
!= EXIT_BLOCK
)
2283 maybe_move_debug_stmts_to_successors (id
, (basic_block
) bb
->aux
);
2284 ((basic_block
)bb
->aux
)->aux
= NULL
;
2288 /* Zero out AUX fields of newly created block during EH edge
2290 for (; last
< last_basic_block
; last
++)
2292 if (need_debug_cleanup
)
2293 maybe_move_debug_stmts_to_successors (id
, BASIC_BLOCK (last
));
2294 BASIC_BLOCK (last
)->aux
= NULL
;
2296 entry_block_map
->aux
= NULL
;
2297 exit_block_map
->aux
= NULL
;
2301 pointer_map_destroy (id
->eh_map
);
2308 /* Copy the debug STMT using ID. We deal with these statements in a
2309 special way: if any variable in their VALUE expression wasn't
2310 remapped yet, we won't remap it, because that would get decl uids
2311 out of sync, causing codegen differences between -g and -g0. If
2312 this arises, we drop the VALUE expression altogether. */
2315 copy_debug_stmt (gimple stmt
, copy_body_data
*id
)
2318 struct walk_stmt_info wi
;
2321 if (gimple_block (stmt
))
2324 n
= (tree
*) pointer_map_contains (id
->decl_map
, gimple_block (stmt
));
2328 gimple_set_block (stmt
, t
);
2330 /* Remap all the operands in COPY. */
2331 memset (&wi
, 0, sizeof (wi
));
2334 processing_debug_stmt
= 1;
2336 t
= gimple_debug_bind_get_var (stmt
);
2338 if (TREE_CODE (t
) == PARM_DECL
&& id
->debug_map
2339 && (n
= (tree
*) pointer_map_contains (id
->debug_map
, t
)))
2341 gcc_assert (TREE_CODE (*n
) == VAR_DECL
);
2344 else if (TREE_CODE (t
) == VAR_DECL
2346 && gimple_in_ssa_p (cfun
)
2347 && !pointer_map_contains (id
->decl_map
, t
)
2349 /* T is a non-localized variable. */;
2351 walk_tree (&t
, remap_gimple_op_r
, &wi
, NULL
);
2353 gimple_debug_bind_set_var (stmt
, t
);
2355 if (gimple_debug_bind_has_value_p (stmt
))
2356 walk_tree (gimple_debug_bind_get_value_ptr (stmt
),
2357 remap_gimple_op_r
, &wi
, NULL
);
2359 /* Punt if any decl couldn't be remapped. */
2360 if (processing_debug_stmt
< 0)
2361 gimple_debug_bind_reset_value (stmt
);
2363 processing_debug_stmt
= 0;
2366 if (gimple_in_ssa_p (cfun
))
2367 mark_symbols_for_renaming (stmt
);
2370 /* Process deferred debug stmts. In order to give values better odds
2371 of being successfully remapped, we delay the processing of debug
2372 stmts until all other stmts that might require remapping are
2376 copy_debug_stmts (copy_body_data
*id
)
2381 if (!id
->debug_stmts
)
2384 FOR_EACH_VEC_ELT (gimple
, id
->debug_stmts
, i
, stmt
)
2385 copy_debug_stmt (stmt
, id
);
2387 VEC_free (gimple
, heap
, id
->debug_stmts
);
2390 /* Make a copy of the body of SRC_FN so that it can be inserted inline in
2391 another function. */
2394 copy_tree_body (copy_body_data
*id
)
2396 tree fndecl
= id
->src_fn
;
2397 tree body
= DECL_SAVED_TREE (fndecl
);
2399 walk_tree (&body
, copy_tree_body_r
, id
, NULL
);
2404 /* Make a copy of the body of FN so that it can be inserted inline in
2405 another function. */
2408 copy_body (copy_body_data
*id
, gcov_type count
, int frequency_scale
,
2409 basic_block entry_block_map
, basic_block exit_block_map
,
2410 bitmap blocks_to_copy
, basic_block new_entry
)
2412 tree fndecl
= id
->src_fn
;
2415 /* If this body has a CFG, walk CFG and copy. */
2416 gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (fndecl
)));
2417 body
= copy_cfg_body (id
, count
, frequency_scale
, entry_block_map
, exit_block_map
,
2418 blocks_to_copy
, new_entry
);
2419 copy_debug_stmts (id
);
2424 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
2425 defined in function FN, or of a data member thereof. */
2428 self_inlining_addr_expr (tree value
, tree fn
)
2432 if (TREE_CODE (value
) != ADDR_EXPR
)
2435 var
= get_base_address (TREE_OPERAND (value
, 0));
2437 return var
&& auto_var_in_fn_p (var
, fn
);
2440 /* Append to BB a debug annotation that binds VAR to VALUE, inheriting
2441 lexical block and line number information from base_stmt, if given,
2442 or from the last stmt of the block otherwise. */
2445 insert_init_debug_bind (copy_body_data
*id
,
2446 basic_block bb
, tree var
, tree value
,
2450 gimple_stmt_iterator gsi
;
2453 if (!gimple_in_ssa_p (id
->src_cfun
))
2456 if (!MAY_HAVE_DEBUG_STMTS
)
2459 tracked_var
= target_for_debug_bind (var
);
2465 gsi
= gsi_last_bb (bb
);
2466 if (!base_stmt
&& !gsi_end_p (gsi
))
2467 base_stmt
= gsi_stmt (gsi
);
2470 note
= gimple_build_debug_bind (tracked_var
, value
, base_stmt
);
2474 if (!gsi_end_p (gsi
))
2475 gsi_insert_after (&gsi
, note
, GSI_SAME_STMT
);
2477 gsi_insert_before (&gsi
, note
, GSI_SAME_STMT
);
2484 insert_init_stmt (copy_body_data
*id
, basic_block bb
, gimple init_stmt
)
2486 /* If VAR represents a zero-sized variable, it's possible that the
2487 assignment statement may result in no gimple statements. */
2490 gimple_stmt_iterator si
= gsi_last_bb (bb
);
2492 /* We can end up with init statements that store to a non-register
2493 from a rhs with a conversion. Handle that here by forcing the
2494 rhs into a temporary. gimple_regimplify_operands is not
2495 prepared to do this for us. */
2496 if (!is_gimple_debug (init_stmt
)
2497 && !is_gimple_reg (gimple_assign_lhs (init_stmt
))
2498 && is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (init_stmt
)))
2499 && gimple_assign_rhs_class (init_stmt
) == GIMPLE_UNARY_RHS
)
2501 tree rhs
= build1 (gimple_assign_rhs_code (init_stmt
),
2502 gimple_expr_type (init_stmt
),
2503 gimple_assign_rhs1 (init_stmt
));
2504 rhs
= force_gimple_operand_gsi (&si
, rhs
, true, NULL_TREE
, false,
2506 gimple_assign_set_rhs_code (init_stmt
, TREE_CODE (rhs
));
2507 gimple_assign_set_rhs1 (init_stmt
, rhs
);
2509 gsi_insert_after (&si
, init_stmt
, GSI_NEW_STMT
);
2510 gimple_regimplify_operands (init_stmt
, &si
);
2511 mark_symbols_for_renaming (init_stmt
);
2513 if (!is_gimple_debug (init_stmt
) && MAY_HAVE_DEBUG_STMTS
)
2515 tree var
, def
= gimple_assign_lhs (init_stmt
);
2517 if (TREE_CODE (def
) == SSA_NAME
)
2518 var
= SSA_NAME_VAR (def
);
2522 insert_init_debug_bind (id
, bb
, var
, def
, init_stmt
);
2527 /* Initialize parameter P with VALUE. If needed, produce init statement
2528 at the end of BB. When BB is NULL, we return init statement to be
2531 setup_one_parameter (copy_body_data
*id
, tree p
, tree value
, tree fn
,
2532 basic_block bb
, tree
*vars
)
2534 gimple init_stmt
= NULL
;
2537 tree def
= (gimple_in_ssa_p (cfun
)
2538 ? gimple_default_def (id
->src_cfun
, p
) : NULL
);
2541 && value
!= error_mark_node
2542 && !useless_type_conversion_p (TREE_TYPE (p
), TREE_TYPE (value
)))
2544 if (fold_convertible_p (TREE_TYPE (p
), value
))
2545 rhs
= fold_build1 (NOP_EXPR
, TREE_TYPE (p
), value
);
2547 /* ??? For valid (GIMPLE) programs we should not end up here.
2548 Still if something has gone wrong and we end up with truly
2549 mismatched types here, fall back to using a VIEW_CONVERT_EXPR
2550 to not leak invalid GIMPLE to the following passes. */
2551 rhs
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (p
), value
);
2554 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
2555 here since the type of this decl must be visible to the calling
2557 var
= copy_decl_to_var (p
, id
);
2559 /* We're actually using the newly-created var. */
2560 if (gimple_in_ssa_p (cfun
) && TREE_CODE (var
) == VAR_DECL
)
2563 add_referenced_var (var
);
2566 /* Declare this new variable. */
2567 DECL_CHAIN (var
) = *vars
;
2570 /* Make gimplifier happy about this variable. */
2571 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
2573 /* If the parameter is never assigned to, has no SSA_NAMEs created,
2574 we would not need to create a new variable here at all, if it
2575 weren't for debug info. Still, we can just use the argument
2577 if (TREE_READONLY (p
)
2578 && !TREE_ADDRESSABLE (p
)
2579 && value
&& !TREE_SIDE_EFFECTS (value
)
2582 /* We may produce non-gimple trees by adding NOPs or introduce
2583 invalid sharing when operand is not really constant.
2584 It is not big deal to prohibit constant propagation here as
2585 we will constant propagate in DOM1 pass anyway. */
2586 if (is_gimple_min_invariant (value
)
2587 && useless_type_conversion_p (TREE_TYPE (p
),
2589 /* We have to be very careful about ADDR_EXPR. Make sure
2590 the base variable isn't a local variable of the inlined
2591 function, e.g., when doing recursive inlining, direct or
2592 mutually-recursive or whatever, which is why we don't
2593 just test whether fn == current_function_decl. */
2594 && ! self_inlining_addr_expr (value
, fn
))
2596 insert_decl_map (id
, p
, value
);
2597 insert_debug_decl_map (id
, p
, var
);
2598 return insert_init_debug_bind (id
, bb
, var
, value
, NULL
);
2602 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
2603 that way, when the PARM_DECL is encountered, it will be
2604 automatically replaced by the VAR_DECL. */
2605 insert_decl_map (id
, p
, var
);
2607 /* Even if P was TREE_READONLY, the new VAR should not be.
2608 In the original code, we would have constructed a
2609 temporary, and then the function body would have never
2610 changed the value of P. However, now, we will be
2611 constructing VAR directly. The constructor body may
2612 change its value multiple times as it is being
2613 constructed. Therefore, it must not be TREE_READONLY;
2614 the back-end assumes that TREE_READONLY variable is
2615 assigned to only once. */
2616 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p
)))
2617 TREE_READONLY (var
) = 0;
2619 /* If there is no setup required and we are in SSA, take the easy route
2620 replacing all SSA names representing the function parameter by the
2621 SSA name passed to function.
2623 We need to construct map for the variable anyway as it might be used
2624 in different SSA names when parameter is set in function.
2626 Do replacement at -O0 for const arguments replaced by constant.
2627 This is important for builtin_constant_p and other construct requiring
2628 constant argument to be visible in inlined function body. */
2629 if (gimple_in_ssa_p (cfun
) && rhs
&& def
&& is_gimple_reg (p
)
2631 || (TREE_READONLY (p
)
2632 && is_gimple_min_invariant (rhs
)))
2633 && (TREE_CODE (rhs
) == SSA_NAME
2634 || is_gimple_min_invariant (rhs
))
2635 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
2637 insert_decl_map (id
, def
, rhs
);
2638 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
2641 /* If the value of argument is never used, don't care about initializing
2643 if (optimize
&& gimple_in_ssa_p (cfun
) && !def
&& is_gimple_reg (p
))
2645 gcc_assert (!value
|| !TREE_SIDE_EFFECTS (value
));
2646 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
2649 /* Initialize this VAR_DECL from the equivalent argument. Convert
2650 the argument to the proper type in case it was promoted. */
2653 if (rhs
== error_mark_node
)
2655 insert_decl_map (id
, p
, var
);
2656 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
2659 STRIP_USELESS_TYPE_CONVERSION (rhs
);
2661 /* We want to use MODIFY_EXPR, not INIT_EXPR here so that we
2662 keep our trees in gimple form. */
2663 if (def
&& gimple_in_ssa_p (cfun
) && is_gimple_reg (p
))
2665 def
= remap_ssa_name (def
, id
);
2666 init_stmt
= gimple_build_assign (def
, rhs
);
2667 SSA_NAME_IS_DEFAULT_DEF (def
) = 0;
2668 set_default_def (var
, NULL
);
2671 init_stmt
= gimple_build_assign (var
, rhs
);
2673 if (bb
&& init_stmt
)
2674 insert_init_stmt (id
, bb
, init_stmt
);
2679 /* Generate code to initialize the parameters of the function at the
2680 top of the stack in ID from the GIMPLE_CALL STMT. */
2683 initialize_inlined_parameters (copy_body_data
*id
, gimple stmt
,
2684 tree fn
, basic_block bb
)
2689 tree vars
= NULL_TREE
;
2690 tree static_chain
= gimple_call_chain (stmt
);
2692 /* Figure out what the parameters are. */
2693 parms
= DECL_ARGUMENTS (fn
);
2695 /* Loop through the parameter declarations, replacing each with an
2696 equivalent VAR_DECL, appropriately initialized. */
2697 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
2700 val
= i
< gimple_call_num_args (stmt
) ? gimple_call_arg (stmt
, i
) : NULL
;
2701 setup_one_parameter (id
, p
, val
, fn
, bb
, &vars
);
2703 /* After remapping parameters remap their types. This has to be done
2704 in a second loop over all parameters to appropriately remap
2705 variable sized arrays when the size is specified in a
2706 parameter following the array. */
2707 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
2709 tree
*varp
= (tree
*) pointer_map_contains (id
->decl_map
, p
);
2711 && TREE_CODE (*varp
) == VAR_DECL
)
2713 tree def
= (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
)
2714 ? gimple_default_def (id
->src_cfun
, p
) : NULL
);
2716 TREE_TYPE (var
) = remap_type (TREE_TYPE (var
), id
);
2717 /* Also remap the default definition if it was remapped
2718 to the default definition of the parameter replacement
2719 by the parameter setup. */
2722 tree
*defp
= (tree
*) pointer_map_contains (id
->decl_map
, def
);
2724 && TREE_CODE (*defp
) == SSA_NAME
2725 && SSA_NAME_VAR (*defp
) == var
)
2726 TREE_TYPE (*defp
) = TREE_TYPE (var
);
2731 /* Initialize the static chain. */
2732 p
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
2733 gcc_assert (fn
!= current_function_decl
);
2736 /* No static chain? Seems like a bug in tree-nested.c. */
2737 gcc_assert (static_chain
);
2739 setup_one_parameter (id
, p
, static_chain
, fn
, bb
, &vars
);
2742 declare_inline_vars (id
->block
, vars
);
2746 /* Declare a return variable to replace the RESULT_DECL for the
2747 function we are calling. An appropriate DECL_STMT is returned.
2748 The USE_STMT is filled to contain a use of the declaration to
2749 indicate the return value of the function.
2751 RETURN_SLOT, if non-null is place where to store the result. It
2752 is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null,
2753 was the LHS of the MODIFY_EXPR to which this call is the RHS.
2755 The return value is a (possibly null) value that holds the result
2756 as seen by the caller. */
2759 declare_return_variable (copy_body_data
*id
, tree return_slot
, tree modify_dest
,
2760 basic_block entry_bb
)
2762 tree callee
= id
->src_fn
;
2763 tree caller
= id
->dst_fn
;
2764 tree result
= DECL_RESULT (callee
);
2765 tree callee_type
= TREE_TYPE (result
);
2769 /* Handle type-mismatches in the function declaration return type
2770 vs. the call expression. */
2772 caller_type
= TREE_TYPE (modify_dest
);
2774 caller_type
= TREE_TYPE (TREE_TYPE (callee
));
2776 /* We don't need to do anything for functions that don't return
2778 if (!result
|| VOID_TYPE_P (callee_type
))
2781 /* If there was a return slot, then the return value is the
2782 dereferenced address of that object. */
2785 /* The front end shouldn't have used both return_slot and
2786 a modify expression. */
2787 gcc_assert (!modify_dest
);
2788 if (DECL_BY_REFERENCE (result
))
2790 tree return_slot_addr
= build_fold_addr_expr (return_slot
);
2791 STRIP_USELESS_TYPE_CONVERSION (return_slot_addr
);
2793 /* We are going to construct *&return_slot and we can't do that
2794 for variables believed to be not addressable.
2796 FIXME: This check possibly can match, because values returned
2797 via return slot optimization are not believed to have address
2798 taken by alias analysis. */
2799 gcc_assert (TREE_CODE (return_slot
) != SSA_NAME
);
2800 var
= return_slot_addr
;
2805 gcc_assert (TREE_CODE (var
) != SSA_NAME
);
2806 TREE_ADDRESSABLE (var
) |= TREE_ADDRESSABLE (result
);
2808 if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
2809 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
2810 && !DECL_GIMPLE_REG_P (result
)
2812 DECL_GIMPLE_REG_P (var
) = 0;
2817 /* All types requiring non-trivial constructors should have been handled. */
2818 gcc_assert (!TREE_ADDRESSABLE (callee_type
));
2820 /* Attempt to avoid creating a new temporary variable. */
2822 && TREE_CODE (modify_dest
) != SSA_NAME
)
2824 bool use_it
= false;
2826 /* We can't use MODIFY_DEST if there's type promotion involved. */
2827 if (!useless_type_conversion_p (callee_type
, caller_type
))
2830 /* ??? If we're assigning to a variable sized type, then we must
2831 reuse the destination variable, because we've no good way to
2832 create variable sized temporaries at this point. */
2833 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type
)) != INTEGER_CST
)
2836 /* If the callee cannot possibly modify MODIFY_DEST, then we can
2837 reuse it as the result of the call directly. Don't do this if
2838 it would promote MODIFY_DEST to addressable. */
2839 else if (TREE_ADDRESSABLE (result
))
2843 tree base_m
= get_base_address (modify_dest
);
2845 /* If the base isn't a decl, then it's a pointer, and we don't
2846 know where that's going to go. */
2847 if (!DECL_P (base_m
))
2849 else if (is_global_var (base_m
))
2851 else if ((TREE_CODE (TREE_TYPE (result
)) == COMPLEX_TYPE
2852 || TREE_CODE (TREE_TYPE (result
)) == VECTOR_TYPE
)
2853 && !DECL_GIMPLE_REG_P (result
)
2854 && DECL_GIMPLE_REG_P (base_m
))
2856 else if (!TREE_ADDRESSABLE (base_m
))
2868 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type
)) == INTEGER_CST
);
2870 var
= copy_result_decl_to_var (result
, id
);
2871 if (gimple_in_ssa_p (cfun
))
2874 add_referenced_var (var
);
2877 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
2878 add_local_decl (DECL_STRUCT_FUNCTION (caller
), var
);
2880 /* Do not have the rest of GCC warn about this variable as it should
2881 not be visible to the user. */
2882 TREE_NO_WARNING (var
) = 1;
2884 declare_inline_vars (id
->block
, var
);
2886 /* Build the use expr. If the return type of the function was
2887 promoted, convert it back to the expected type. */
2889 if (!useless_type_conversion_p (caller_type
, TREE_TYPE (var
)))
2890 use
= fold_convert (caller_type
, var
);
2892 STRIP_USELESS_TYPE_CONVERSION (use
);
2894 if (DECL_BY_REFERENCE (result
))
2896 TREE_ADDRESSABLE (var
) = 1;
2897 var
= build_fold_addr_expr (var
);
2901 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
2902 way, when the RESULT_DECL is encountered, it will be
2903 automatically replaced by the VAR_DECL.
2905 When returning by reference, ensure that RESULT_DECL remaps to
2907 if (DECL_BY_REFERENCE (result
)
2908 && !is_gimple_val (var
))
2910 tree temp
= create_tmp_var (TREE_TYPE (result
), "retvalptr");
2911 if (gimple_in_ssa_p (id
->src_cfun
))
2914 add_referenced_var (temp
);
2916 insert_decl_map (id
, result
, temp
);
2917 /* When RESULT_DECL is in SSA form, we need to use it's default_def
2919 if (gimple_in_ssa_p (id
->src_cfun
) && gimple_default_def (id
->src_cfun
, result
))
2920 temp
= remap_ssa_name (gimple_default_def (id
->src_cfun
, result
), id
);
2921 insert_init_stmt (id
, entry_bb
, gimple_build_assign (temp
, var
));
2924 insert_decl_map (id
, result
, var
);
2926 /* Remember this so we can ignore it in remap_decls. */
2932 /* Callback through walk_tree. Determine if a DECL_INITIAL makes reference
2933 to a local label. */
2936 has_label_address_in_static_1 (tree
*nodep
, int *walk_subtrees
, void *fnp
)
2939 tree fn
= (tree
) fnp
;
2941 if (TREE_CODE (node
) == LABEL_DECL
&& DECL_CONTEXT (node
) == fn
)
2950 /* Determine if the function can be copied. If so return NULL. If
2951 not return a string describng the reason for failure. */
2954 copy_forbidden (struct function
*fun
, tree fndecl
)
2956 const char *reason
= fun
->cannot_be_copied_reason
;
2960 /* Only examine the function once. */
2961 if (fun
->cannot_be_copied_set
)
2964 /* We cannot copy a function that receives a non-local goto
2965 because we cannot remap the destination label used in the
2966 function that is performing the non-local goto. */
2967 /* ??? Actually, this should be possible, if we work at it.
2968 No doubt there's just a handful of places that simply
2969 assume it doesn't happen and don't substitute properly. */
2970 if (fun
->has_nonlocal_label
)
2972 reason
= G_("function %q+F can never be copied "
2973 "because it receives a non-local goto");
2977 FOR_EACH_LOCAL_DECL (fun
, ix
, decl
)
2978 if (TREE_CODE (decl
) == VAR_DECL
2979 && TREE_STATIC (decl
)
2980 && !DECL_EXTERNAL (decl
)
2981 && DECL_INITIAL (decl
)
2982 && walk_tree_without_duplicates (&DECL_INITIAL (decl
),
2983 has_label_address_in_static_1
,
2986 reason
= G_("function %q+F can never be copied because it saves "
2987 "address of local label in a static variable");
2992 fun
->cannot_be_copied_reason
= reason
;
2993 fun
->cannot_be_copied_set
= true;
2998 static const char *inline_forbidden_reason
;
3000 /* A callback for walk_gimple_seq to handle statements. Returns non-null
3001 iff a function can not be inlined. Also sets the reason why. */
3004 inline_forbidden_p_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
3005 struct walk_stmt_info
*wip
)
3007 tree fn
= (tree
) wip
->info
;
3009 gimple stmt
= gsi_stmt (*gsi
);
3011 switch (gimple_code (stmt
))
3014 /* Refuse to inline alloca call unless user explicitly forced so as
3015 this may change program's memory overhead drastically when the
3016 function using alloca is called in loop. In GCC present in
3017 SPEC2000 inlining into schedule_block cause it to require 2GB of
3018 RAM instead of 256MB. */
3019 if (gimple_alloca_call_p (stmt
)
3020 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
3022 inline_forbidden_reason
3023 = G_("function %q+F can never be inlined because it uses "
3024 "alloca (override using the always_inline attribute)");
3025 *handled_ops_p
= true;
3029 t
= gimple_call_fndecl (stmt
);
3033 /* We cannot inline functions that call setjmp. */
3034 if (setjmp_call_p (t
))
3036 inline_forbidden_reason
3037 = G_("function %q+F can never be inlined because it uses setjmp");
3038 *handled_ops_p
= true;
3042 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
3043 switch (DECL_FUNCTION_CODE (t
))
3045 /* We cannot inline functions that take a variable number of
3047 case BUILT_IN_VA_START
:
3048 case BUILT_IN_NEXT_ARG
:
3049 case BUILT_IN_VA_END
:
3050 inline_forbidden_reason
3051 = G_("function %q+F can never be inlined because it "
3052 "uses variable argument lists");
3053 *handled_ops_p
= true;
3056 case BUILT_IN_LONGJMP
:
3057 /* We can't inline functions that call __builtin_longjmp at
3058 all. The non-local goto machinery really requires the
3059 destination be in a different function. If we allow the
3060 function calling __builtin_longjmp to be inlined into the
3061 function calling __builtin_setjmp, Things will Go Awry. */
3062 inline_forbidden_reason
3063 = G_("function %q+F can never be inlined because "
3064 "it uses setjmp-longjmp exception handling");
3065 *handled_ops_p
= true;
3068 case BUILT_IN_NONLOCAL_GOTO
:
3070 inline_forbidden_reason
3071 = G_("function %q+F can never be inlined because "
3072 "it uses non-local goto");
3073 *handled_ops_p
= true;
3076 case BUILT_IN_RETURN
:
3077 case BUILT_IN_APPLY_ARGS
:
3078 /* If a __builtin_apply_args caller would be inlined,
3079 it would be saving arguments of the function it has
3080 been inlined into. Similarly __builtin_return would
3081 return from the function the inline has been inlined into. */
3082 inline_forbidden_reason
3083 = G_("function %q+F can never be inlined because "
3084 "it uses __builtin_return or __builtin_apply_args");
3085 *handled_ops_p
= true;
3094 t
= gimple_goto_dest (stmt
);
3096 /* We will not inline a function which uses computed goto. The
3097 addresses of its local labels, which may be tucked into
3098 global storage, are of course not constant across
3099 instantiations, which causes unexpected behavior. */
3100 if (TREE_CODE (t
) != LABEL_DECL
)
3102 inline_forbidden_reason
3103 = G_("function %q+F can never be inlined "
3104 "because it contains a computed goto");
3105 *handled_ops_p
= true;
3114 *handled_ops_p
= false;
3118 /* Return true if FNDECL is a function that cannot be inlined into
3122 inline_forbidden_p (tree fndecl
)
3124 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
3125 struct walk_stmt_info wi
;
3126 struct pointer_set_t
*visited_nodes
;
3128 bool forbidden_p
= false;
3130 /* First check for shared reasons not to copy the code. */
3131 inline_forbidden_reason
= copy_forbidden (fun
, fndecl
);
3132 if (inline_forbidden_reason
!= NULL
)
3135 /* Next, walk the statements of the function looking for
3136 constraucts we can't handle, or are non-optimal for inlining. */
3137 visited_nodes
= pointer_set_create ();
3138 memset (&wi
, 0, sizeof (wi
));
3139 wi
.info
= (void *) fndecl
;
3140 wi
.pset
= visited_nodes
;
3142 FOR_EACH_BB_FN (bb
, fun
)
3145 gimple_seq seq
= bb_seq (bb
);
3146 ret
= walk_gimple_seq (seq
, inline_forbidden_p_stmt
, NULL
, &wi
);
3147 forbidden_p
= (ret
!= NULL
);
3152 pointer_set_destroy (visited_nodes
);
3156 /* Return true if CALLEE cannot be inlined into CALLER. */
3159 inline_forbidden_into_p (tree caller
, tree callee
)
3161 /* Don't inline if the functions have different EH personalities. */
3162 if (DECL_FUNCTION_PERSONALITY (caller
)
3163 && DECL_FUNCTION_PERSONALITY (callee
)
3164 && (DECL_FUNCTION_PERSONALITY (caller
)
3165 != DECL_FUNCTION_PERSONALITY (callee
)))
3168 /* Don't inline if the callee can throw non-call exceptions but the
3170 if (DECL_STRUCT_FUNCTION (callee
)
3171 && DECL_STRUCT_FUNCTION (callee
)->can_throw_non_call_exceptions
3172 && !(DECL_STRUCT_FUNCTION (caller
)
3173 && DECL_STRUCT_FUNCTION (caller
)->can_throw_non_call_exceptions
))
3179 /* Returns nonzero if FN is a function that does not have any
3180 fundamental inline blocking properties. */
3183 tree_inlinable_function_p (tree fn
)
3185 bool inlinable
= true;
3189 /* If we've already decided this function shouldn't be inlined,
3190 there's no need to check again. */
3191 if (DECL_UNINLINABLE (fn
))
3194 /* We only warn for functions declared `inline' by the user. */
3195 do_warning
= (warn_inline
3196 && DECL_DECLARED_INLINE_P (fn
)
3197 && !DECL_NO_INLINE_WARNING_P (fn
)
3198 && !DECL_IN_SYSTEM_HEADER (fn
));
3200 always_inline
= lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
));
3203 && always_inline
== NULL
)
3206 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3207 "is suppressed using -fno-inline", fn
);
3211 else if (!function_attribute_inlinable_p (fn
))
3214 warning (OPT_Winline
, "function %q+F can never be inlined because it "
3215 "uses attributes conflicting with inlining", fn
);
3219 else if (inline_forbidden_p (fn
))
3221 /* See if we should warn about uninlinable functions. Previously,
3222 some of these warnings would be issued while trying to expand
3223 the function inline, but that would cause multiple warnings
3224 about functions that would for example call alloca. But since
3225 this a property of the function, just one warning is enough.
3226 As a bonus we can now give more details about the reason why a
3227 function is not inlinable. */
3229 sorry (inline_forbidden_reason
, fn
);
3230 else if (do_warning
)
3231 warning (OPT_Winline
, inline_forbidden_reason
, fn
);
3236 /* Squirrel away the result so that we don't have to check again. */
3237 DECL_UNINLINABLE (fn
) = !inlinable
;
3242 /* Estimate the cost of a memory move. Use machine dependent
3243 word size and take possible memcpy call into account. */
3246 estimate_move_cost (tree type
)
3250 gcc_assert (!VOID_TYPE_P (type
));
3252 size
= int_size_in_bytes (type
);
3254 if (size
< 0 || size
> MOVE_MAX_PIECES
* MOVE_RATIO (!optimize_size
))
3255 /* Cost of a memcpy call, 3 arguments and the call. */
3258 return ((size
+ MOVE_MAX_PIECES
- 1) / MOVE_MAX_PIECES
);
3261 /* Returns cost of operation CODE, according to WEIGHTS */
3264 estimate_operator_cost (enum tree_code code
, eni_weights
*weights
,
3265 tree op1 ATTRIBUTE_UNUSED
, tree op2
)
3269 /* These are "free" conversions, or their presumed cost
3270 is folded into other operations. */
3277 /* Assign cost of 1 to usual operations.
3278 ??? We may consider mapping RTL costs to this. */
3283 case POINTER_PLUS_EXPR
:
3287 case ADDR_SPACE_CONVERT_EXPR
:
3288 case FIXED_CONVERT_EXPR
:
3289 case FIX_TRUNC_EXPR
:
3301 case VEC_LSHIFT_EXPR
:
3302 case VEC_RSHIFT_EXPR
:
3309 case TRUTH_ANDIF_EXPR
:
3310 case TRUTH_ORIF_EXPR
:
3311 case TRUTH_AND_EXPR
:
3313 case TRUTH_XOR_EXPR
:
3314 case TRUTH_NOT_EXPR
:
3323 case UNORDERED_EXPR
:
3334 case PREDECREMENT_EXPR
:
3335 case PREINCREMENT_EXPR
:
3336 case POSTDECREMENT_EXPR
:
3337 case POSTINCREMENT_EXPR
:
3339 case REALIGN_LOAD_EXPR
:
3341 case REDUC_MAX_EXPR
:
3342 case REDUC_MIN_EXPR
:
3343 case REDUC_PLUS_EXPR
:
3344 case WIDEN_SUM_EXPR
:
3345 case WIDEN_MULT_EXPR
:
3347 case WIDEN_MULT_PLUS_EXPR
:
3348 case WIDEN_MULT_MINUS_EXPR
:
3350 case VEC_WIDEN_MULT_HI_EXPR
:
3351 case VEC_WIDEN_MULT_LO_EXPR
:
3352 case VEC_UNPACK_HI_EXPR
:
3353 case VEC_UNPACK_LO_EXPR
:
3354 case VEC_UNPACK_FLOAT_HI_EXPR
:
3355 case VEC_UNPACK_FLOAT_LO_EXPR
:
3356 case VEC_PACK_TRUNC_EXPR
:
3357 case VEC_PACK_SAT_EXPR
:
3358 case VEC_PACK_FIX_TRUNC_EXPR
:
3359 case VEC_EXTRACT_EVEN_EXPR
:
3360 case VEC_EXTRACT_ODD_EXPR
:
3361 case VEC_INTERLEAVE_HIGH_EXPR
:
3362 case VEC_INTERLEAVE_LOW_EXPR
:
3366 /* Few special cases of expensive operations. This is useful
3367 to avoid inlining on functions having too many of these. */
3368 case TRUNC_DIV_EXPR
:
3370 case FLOOR_DIV_EXPR
:
3371 case ROUND_DIV_EXPR
:
3372 case EXACT_DIV_EXPR
:
3373 case TRUNC_MOD_EXPR
:
3375 case FLOOR_MOD_EXPR
:
3376 case ROUND_MOD_EXPR
:
3378 if (TREE_CODE (op2
) != INTEGER_CST
)
3379 return weights
->div_mod_cost
;
3383 /* We expect a copy assignment with no operator. */
3384 gcc_assert (get_gimple_rhs_class (code
) == GIMPLE_SINGLE_RHS
);
3390 /* Estimate number of instructions that will be created by expanding
3391 the statements in the statement sequence STMTS.
3392 WEIGHTS contains weights attributed to various constructs. */
3395 int estimate_num_insns_seq (gimple_seq stmts
, eni_weights
*weights
)
3398 gimple_stmt_iterator gsi
;
3401 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3402 cost
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
3408 /* Estimate number of instructions that will be created by expanding STMT.
3409 WEIGHTS contains weights attributed to various constructs. */
3412 estimate_num_insns (gimple stmt
, eni_weights
*weights
)
3415 enum gimple_code code
= gimple_code (stmt
);
3422 /* Try to estimate the cost of assignments. We have three cases to
3424 1) Simple assignments to registers;
3425 2) Stores to things that must live in memory. This includes
3426 "normal" stores to scalars, but also assignments of large
3427 structures, or constructors of big arrays;
3429 Let us look at the first two cases, assuming we have "a = b + C":
3430 <GIMPLE_ASSIGN <var_decl "a">
3431 <plus_expr <var_decl "b"> <constant C>>
3432 If "a" is a GIMPLE register, the assignment to it is free on almost
3433 any target, because "a" usually ends up in a real register. Hence
3434 the only cost of this expression comes from the PLUS_EXPR, and we
3435 can ignore the GIMPLE_ASSIGN.
3436 If "a" is not a GIMPLE register, the assignment to "a" will most
3437 likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost
3438 of moving something into "a", which we compute using the function
3439 estimate_move_cost. */
3440 lhs
= gimple_assign_lhs (stmt
);
3441 rhs
= gimple_assign_rhs1 (stmt
);
3443 if (is_gimple_reg (lhs
))
3446 cost
= estimate_move_cost (TREE_TYPE (lhs
));
3448 if (!is_gimple_reg (rhs
) && !is_gimple_min_invariant (rhs
))
3449 cost
+= estimate_move_cost (TREE_TYPE (rhs
));
3451 cost
+= estimate_operator_cost (gimple_assign_rhs_code (stmt
), weights
,
3452 gimple_assign_rhs1 (stmt
),
3453 get_gimple_rhs_class (gimple_assign_rhs_code (stmt
))
3454 == GIMPLE_BINARY_RHS
3455 ? gimple_assign_rhs2 (stmt
) : NULL
);
3459 cost
= 1 + estimate_operator_cost (gimple_cond_code (stmt
), weights
,
3460 gimple_op (stmt
, 0),
3461 gimple_op (stmt
, 1));
3465 /* Take into account cost of the switch + guess 2 conditional jumps for
3468 TODO: once the switch expansion logic is sufficiently separated, we can
3469 do better job on estimating cost of the switch. */
3470 if (weights
->time_based
)
3471 cost
= floor_log2 (gimple_switch_num_labels (stmt
)) * 2;
3473 cost
= gimple_switch_num_labels (stmt
) * 2;
3478 tree decl
= gimple_call_fndecl (stmt
);
3479 tree addr
= gimple_call_fn (stmt
);
3480 tree funtype
= TREE_TYPE (addr
);
3481 bool stdarg
= false;
3483 if (POINTER_TYPE_P (funtype
))
3484 funtype
= TREE_TYPE (funtype
);
3486 if (is_simple_builtin (decl
))
3488 else if (is_inexpensive_builtin (decl
))
3489 cost
= weights
->target_builtin_call_cost
;
3491 cost
= weights
->call_cost
;
3494 funtype
= TREE_TYPE (decl
);
3496 if (!VOID_TYPE_P (TREE_TYPE (funtype
)))
3497 cost
+= estimate_move_cost (TREE_TYPE (funtype
));
3500 stdarg
= stdarg_p (funtype
);
3502 /* Our cost must be kept in sync with
3503 cgraph_estimate_size_after_inlining that does use function
3504 declaration to figure out the arguments.
3506 For functions taking variable list of arguments we must
3507 look into call statement intself. This is safe because
3508 we will get only higher costs and in most cases we will
3509 not inline these anyway. */
3510 if (decl
&& DECL_ARGUMENTS (decl
) && !stdarg
)
3513 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= DECL_CHAIN (arg
))
3514 if (!VOID_TYPE_P (TREE_TYPE (arg
)))
3515 cost
+= estimate_move_cost (TREE_TYPE (arg
));
3517 else if (funtype
&& prototype_p (funtype
) && !stdarg
)
3520 for (t
= TYPE_ARG_TYPES (funtype
); t
&& t
!= void_list_node
;
3522 if (!VOID_TYPE_P (TREE_VALUE (t
)))
3523 cost
+= estimate_move_cost (TREE_VALUE (t
));
3527 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
3529 tree arg
= gimple_call_arg (stmt
, i
);
3530 if (!VOID_TYPE_P (TREE_TYPE (arg
)))
3531 cost
+= estimate_move_cost (TREE_TYPE (arg
));
3543 case GIMPLE_PREDICT
:
3548 return asm_str_count (gimple_asm_string (stmt
));
3551 /* This is either going to be an external function call with one
3552 argument, or two register copy statements plus a goto. */
3555 case GIMPLE_EH_DISPATCH
:
3556 /* ??? This is going to turn into a switch statement. Ideally
3557 we'd have a look at the eh region and estimate the number of
3562 return estimate_num_insns_seq (gimple_bind_body (stmt
), weights
);
3564 case GIMPLE_EH_FILTER
:
3565 return estimate_num_insns_seq (gimple_eh_filter_failure (stmt
), weights
);
3568 return estimate_num_insns_seq (gimple_catch_handler (stmt
), weights
);
3571 return (estimate_num_insns_seq (gimple_try_eval (stmt
), weights
)
3572 + estimate_num_insns_seq (gimple_try_cleanup (stmt
), weights
));
3574 /* OpenMP directives are generally very expensive. */
3576 case GIMPLE_OMP_RETURN
:
3577 case GIMPLE_OMP_SECTIONS_SWITCH
:
3578 case GIMPLE_OMP_ATOMIC_STORE
:
3579 case GIMPLE_OMP_CONTINUE
:
3580 /* ...except these, which are cheap. */
3583 case GIMPLE_OMP_ATOMIC_LOAD
:
3584 return weights
->omp_cost
;
3586 case GIMPLE_OMP_FOR
:
3587 return (weights
->omp_cost
3588 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
)
3589 + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt
), weights
));
3591 case GIMPLE_OMP_PARALLEL
:
3592 case GIMPLE_OMP_TASK
:
3593 case GIMPLE_OMP_CRITICAL
:
3594 case GIMPLE_OMP_MASTER
:
3595 case GIMPLE_OMP_ORDERED
:
3596 case GIMPLE_OMP_SECTION
:
3597 case GIMPLE_OMP_SECTIONS
:
3598 case GIMPLE_OMP_SINGLE
:
3599 return (weights
->omp_cost
3600 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
));
3609 /* Estimate number of instructions that will be created by expanding
3610 function FNDECL. WEIGHTS contains weights attributed to various
3614 estimate_num_insns_fn (tree fndecl
, eni_weights
*weights
)
3616 struct function
*my_function
= DECL_STRUCT_FUNCTION (fndecl
);
3617 gimple_stmt_iterator bsi
;
3621 gcc_assert (my_function
&& my_function
->cfg
);
3622 FOR_EACH_BB_FN (bb
, my_function
)
3624 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
3625 n
+= estimate_num_insns (gsi_stmt (bsi
), weights
);
3632 /* Initializes weights used by estimate_num_insns. */
3635 init_inline_once (void)
3637 eni_size_weights
.call_cost
= 1;
3638 eni_size_weights
.target_builtin_call_cost
= 1;
3639 eni_size_weights
.div_mod_cost
= 1;
3640 eni_size_weights
.omp_cost
= 40;
3641 eni_size_weights
.time_based
= false;
3643 /* Estimating time for call is difficult, since we have no idea what the
3644 called function does. In the current uses of eni_time_weights,
3645 underestimating the cost does less harm than overestimating it, so
3646 we choose a rather small value here. */
3647 eni_time_weights
.call_cost
= 10;
3648 eni_time_weights
.target_builtin_call_cost
= 10;
3649 eni_time_weights
.div_mod_cost
= 10;
3650 eni_time_weights
.omp_cost
= 40;
3651 eni_time_weights
.time_based
= true;
3654 /* Estimate the number of instructions in a gimple_seq. */
3657 count_insns_seq (gimple_seq seq
, eni_weights
*weights
)
3659 gimple_stmt_iterator gsi
;
3661 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3662 n
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
3668 /* Install new lexical TREE_BLOCK underneath 'current_block'. */
3671 prepend_lexical_block (tree current_block
, tree new_block
)
3673 BLOCK_CHAIN (new_block
) = BLOCK_SUBBLOCKS (current_block
);
3674 BLOCK_SUBBLOCKS (current_block
) = new_block
;
3675 BLOCK_SUPERCONTEXT (new_block
) = current_block
;
3678 /* Add local variables from CALLEE to CALLER. */
3681 add_local_variables (struct function
*callee
, struct function
*caller
,
3682 copy_body_data
*id
, bool check_var_ann
)
3687 FOR_EACH_LOCAL_DECL (callee
, ix
, var
)
3688 if (TREE_STATIC (var
) && !TREE_ASM_WRITTEN (var
))
3691 || (var_ann (var
) && add_referenced_var (var
)))
3692 add_local_decl (caller
, var
);
3694 else if (!can_be_nonlocal (var
, id
))
3696 tree new_var
= remap_decl (var
, id
);
3698 /* Remap debug-expressions. */
3699 if (TREE_CODE (new_var
) == VAR_DECL
3700 && DECL_DEBUG_EXPR_IS_FROM (new_var
)
3703 tree tem
= DECL_DEBUG_EXPR (var
);
3704 bool old_regimplify
= id
->regimplify
;
3705 id
->remapping_type_depth
++;
3706 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
3707 id
->remapping_type_depth
--;
3708 id
->regimplify
= old_regimplify
;
3709 SET_DECL_DEBUG_EXPR (new_var
, tem
);
3711 add_local_decl (caller
, new_var
);
3715 /* If STMT is a GIMPLE_CALL, replace it with its inline expansion. */
3718 expand_call_inline (basic_block bb
, gimple stmt
, copy_body_data
*id
)
3722 struct pointer_map_t
*st
, *dst
;
3725 location_t saved_location
;
3726 struct cgraph_edge
*cg_edge
;
3727 cgraph_inline_failed_t reason
;
3728 basic_block return_block
;
3730 gimple_stmt_iterator gsi
, stmt_gsi
;
3731 bool successfully_inlined
= FALSE
;
3732 bool purge_dead_abnormal_edges
;
3734 /* Set input_location here so we get the right instantiation context
3735 if we call instantiate_decl from inlinable_function_p. */
3736 saved_location
= input_location
;
3737 if (gimple_has_location (stmt
))
3738 input_location
= gimple_location (stmt
);
3740 /* From here on, we're only interested in CALL_EXPRs. */
3741 if (gimple_code (stmt
) != GIMPLE_CALL
)
3744 /* First, see if we can figure out what function is being called.
3745 If we cannot, then there is no hope of inlining the function. */
3746 fn
= gimple_call_fndecl (stmt
);
3750 /* Turn forward declarations into real ones. */
3751 fn
= cgraph_node (fn
)->decl
;
3753 /* If FN is a declaration of a function in a nested scope that was
3754 globally declared inline, we don't set its DECL_INITIAL.
3755 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
3756 C++ front-end uses it for cdtors to refer to their internal
3757 declarations, that are not real functions. Fortunately those
3758 don't have trees to be saved, so we can tell by checking their
3760 if (!DECL_INITIAL (fn
)
3761 && DECL_ABSTRACT_ORIGIN (fn
)
3762 && gimple_has_body_p (DECL_ABSTRACT_ORIGIN (fn
)))
3763 fn
= DECL_ABSTRACT_ORIGIN (fn
);
3765 /* Objective C and fortran still calls tree_rest_of_compilation directly.
3766 Kill this check once this is fixed. */
3767 if (!id
->dst_node
->analyzed
)
3770 cg_edge
= cgraph_edge (id
->dst_node
, stmt
);
3772 /* First check that inlining isn't simply forbidden in this case. */
3773 if (inline_forbidden_into_p (cg_edge
->caller
->decl
, cg_edge
->callee
->decl
))
3776 /* Don't try to inline functions that are not well-suited to inlining. */
3777 if (!cgraph_inline_p (cg_edge
, &reason
))
3779 /* If this call was originally indirect, we do not want to emit any
3780 inlining related warnings or sorry messages because there are no
3781 guarantees regarding those. */
3782 if (cg_edge
->indirect_inlining_edge
)
3785 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
))
3786 /* Avoid warnings during early inline pass. */
3787 && cgraph_global_info_ready
)
3789 sorry ("inlining failed in call to %q+F: %s", fn
,
3790 _(cgraph_inline_failed_string (reason
)));
3791 sorry ("called from here");
3793 else if (warn_inline
&& DECL_DECLARED_INLINE_P (fn
)
3794 && !DECL_IN_SYSTEM_HEADER (fn
)
3795 && reason
!= CIF_UNSPECIFIED
3796 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn
))
3797 /* Avoid warnings during early inline pass. */
3798 && cgraph_global_info_ready
)
3800 warning (OPT_Winline
, "inlining failed in call to %q+F: %s",
3801 fn
, _(cgraph_inline_failed_string (reason
)));
3802 warning (OPT_Winline
, "called from here");
3806 fn
= cg_edge
->callee
->decl
;
3808 #ifdef ENABLE_CHECKING
3809 if (cg_edge
->callee
->decl
!= id
->dst_node
->decl
)
3810 verify_cgraph_node (cg_edge
->callee
);
3813 /* We will be inlining this callee. */
3814 id
->eh_lp_nr
= lookup_stmt_eh_lp (stmt
);
3816 /* Update the callers EH personality. */
3817 if (DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->decl
))
3818 DECL_FUNCTION_PERSONALITY (cg_edge
->caller
->decl
)
3819 = DECL_FUNCTION_PERSONALITY (cg_edge
->callee
->decl
);
3821 /* Split the block holding the GIMPLE_CALL. */
3822 e
= split_block (bb
, stmt
);
3824 return_block
= e
->dest
;
3827 /* split_block splits after the statement; work around this by
3828 moving the call into the second block manually. Not pretty,
3829 but seems easier than doing the CFG manipulation by hand
3830 when the GIMPLE_CALL is in the last statement of BB. */
3831 stmt_gsi
= gsi_last_bb (bb
);
3832 gsi_remove (&stmt_gsi
, false);
3834 /* If the GIMPLE_CALL was in the last statement of BB, it may have
3835 been the source of abnormal edges. In this case, schedule
3836 the removal of dead abnormal edges. */
3837 gsi
= gsi_start_bb (return_block
);
3838 if (gsi_end_p (gsi
))
3840 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
3841 purge_dead_abnormal_edges
= true;
3845 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
3846 purge_dead_abnormal_edges
= false;
3849 stmt_gsi
= gsi_start_bb (return_block
);
3851 /* Build a block containing code to initialize the arguments, the
3852 actual inline expansion of the body, and a label for the return
3853 statements within the function to jump to. The type of the
3854 statement expression is the return type of the function call. */
3855 id
->block
= make_node (BLOCK
);
3856 BLOCK_ABSTRACT_ORIGIN (id
->block
) = fn
;
3857 BLOCK_SOURCE_LOCATION (id
->block
) = input_location
;
3858 prepend_lexical_block (gimple_block (stmt
), id
->block
);
3860 /* Local declarations will be replaced by their equivalents in this
3863 id
->decl_map
= pointer_map_create ();
3864 dst
= id
->debug_map
;
3865 id
->debug_map
= NULL
;
3867 /* Record the function we are about to inline. */
3869 id
->src_node
= cg_edge
->callee
;
3870 id
->src_cfun
= DECL_STRUCT_FUNCTION (fn
);
3871 id
->gimple_call
= stmt
;
3873 gcc_assert (!id
->src_cfun
->after_inlining
);
3876 if (lookup_attribute ("cold", DECL_ATTRIBUTES (fn
)))
3878 gimple_stmt_iterator si
= gsi_last_bb (bb
);
3879 gsi_insert_after (&si
, gimple_build_predict (PRED_COLD_FUNCTION
,
3883 initialize_inlined_parameters (id
, stmt
, fn
, bb
);
3885 if (DECL_INITIAL (fn
))
3886 prepend_lexical_block (id
->block
, remap_blocks (DECL_INITIAL (fn
), id
));
3888 /* Return statements in the function body will be replaced by jumps
3889 to the RET_LABEL. */
3890 gcc_assert (DECL_INITIAL (fn
));
3891 gcc_assert (TREE_CODE (DECL_INITIAL (fn
)) == BLOCK
);
3893 /* Find the LHS to which the result of this call is assigned. */
3895 if (gimple_call_lhs (stmt
))
3897 modify_dest
= gimple_call_lhs (stmt
);
3899 /* The function which we are inlining might not return a value,
3900 in which case we should issue a warning that the function
3901 does not return a value. In that case the optimizers will
3902 see that the variable to which the value is assigned was not
3903 initialized. We do not want to issue a warning about that
3904 uninitialized variable. */
3905 if (DECL_P (modify_dest
))
3906 TREE_NO_WARNING (modify_dest
) = 1;
3908 if (gimple_call_return_slot_opt_p (stmt
))
3910 return_slot
= modify_dest
;
3917 /* If we are inlining a call to the C++ operator new, we don't want
3918 to use type based alias analysis on the return value. Otherwise
3919 we may get confused if the compiler sees that the inlined new
3920 function returns a pointer which was just deleted. See bug
3922 if (DECL_IS_OPERATOR_NEW (fn
))
3928 /* Declare the return variable for the function. */
3929 use_retvar
= declare_return_variable (id
, return_slot
, modify_dest
, bb
);
3931 /* Add local vars in this inlined callee to caller. */
3932 add_local_variables (id
->src_cfun
, cfun
, id
, true);
3934 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3936 fprintf (dump_file
, "Inlining ");
3937 print_generic_expr (dump_file
, id
->src_fn
, 0);
3938 fprintf (dump_file
, " to ");
3939 print_generic_expr (dump_file
, id
->dst_fn
, 0);
3940 fprintf (dump_file
, " with frequency %i\n", cg_edge
->frequency
);
3943 /* This is it. Duplicate the callee body. Assume callee is
3944 pre-gimplified. Note that we must not alter the caller
3945 function in any way before this point, as this CALL_EXPR may be
3946 a self-referential call; if we're calling ourselves, we need to
3947 duplicate our body before altering anything. */
3948 copy_body (id
, bb
->count
,
3949 cg_edge
->frequency
* REG_BR_PROB_BASE
/ CGRAPH_FREQ_BASE
,
3950 bb
, return_block
, NULL
, NULL
);
3952 /* Reset the escaped solution. */
3953 if (cfun
->gimple_df
)
3954 pt_solution_reset (&cfun
->gimple_df
->escaped
);
3959 pointer_map_destroy (id
->debug_map
);
3960 id
->debug_map
= dst
;
3962 pointer_map_destroy (id
->decl_map
);
3965 /* Unlink the calls virtual operands before replacing it. */
3966 unlink_stmt_vdef (stmt
);
3968 /* If the inlined function returns a result that we care about,
3969 substitute the GIMPLE_CALL with an assignment of the return
3970 variable to the LHS of the call. That is, if STMT was
3971 'a = foo (...)', substitute the call with 'a = USE_RETVAR'. */
3972 if (use_retvar
&& gimple_call_lhs (stmt
))
3974 gimple old_stmt
= stmt
;
3975 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), use_retvar
);
3976 gsi_replace (&stmt_gsi
, stmt
, false);
3977 if (gimple_in_ssa_p (cfun
))
3978 mark_symbols_for_renaming (stmt
);
3979 maybe_clean_or_replace_eh_stmt (old_stmt
, stmt
);
3983 /* Handle the case of inlining a function with no return
3984 statement, which causes the return value to become undefined. */
3985 if (gimple_call_lhs (stmt
)
3986 && TREE_CODE (gimple_call_lhs (stmt
)) == SSA_NAME
)
3988 tree name
= gimple_call_lhs (stmt
);
3989 tree var
= SSA_NAME_VAR (name
);
3990 tree def
= gimple_default_def (cfun
, var
);
3994 /* If the variable is used undefined, make this name
3995 undefined via a move. */
3996 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), def
);
3997 gsi_replace (&stmt_gsi
, stmt
, true);
4001 /* Otherwise make this variable undefined. */
4002 gsi_remove (&stmt_gsi
, true);
4003 set_default_def (var
, name
);
4004 SSA_NAME_DEF_STMT (name
) = gimple_build_nop ();
4008 gsi_remove (&stmt_gsi
, true);
4011 if (purge_dead_abnormal_edges
)
4013 gimple_purge_dead_eh_edges (return_block
);
4014 gimple_purge_dead_abnormal_call_edges (return_block
);
4017 /* If the value of the new expression is ignored, that's OK. We
4018 don't warn about this for CALL_EXPRs, so we shouldn't warn about
4019 the equivalent inlined version either. */
4020 if (is_gimple_assign (stmt
))
4022 gcc_assert (gimple_assign_single_p (stmt
)
4023 || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
)));
4024 TREE_USED (gimple_assign_rhs1 (stmt
)) = 1;
4027 /* Output the inlining info for this abstract function, since it has been
4028 inlined. If we don't do this now, we can lose the information about the
4029 variables in the function when the blocks get blown away as soon as we
4030 remove the cgraph node. */
4031 (*debug_hooks
->outlining_inline_function
) (cg_edge
->callee
->decl
);
4033 /* Update callgraph if needed. */
4034 cgraph_remove_node (cg_edge
->callee
);
4036 id
->block
= NULL_TREE
;
4037 successfully_inlined
= TRUE
;
4040 input_location
= saved_location
;
4041 return successfully_inlined
;
4044 /* Expand call statements reachable from STMT_P.
4045 We can only have CALL_EXPRs as the "toplevel" tree code or nested
4046 in a MODIFY_EXPR. See gimple.c:get_call_expr_in(). We can
4047 unfortunately not use that function here because we need a pointer
4048 to the CALL_EXPR, not the tree itself. */
4051 gimple_expand_calls_inline (basic_block bb
, copy_body_data
*id
)
4053 gimple_stmt_iterator gsi
;
4055 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4057 gimple stmt
= gsi_stmt (gsi
);
4059 if (is_gimple_call (stmt
)
4060 && expand_call_inline (bb
, stmt
, id
))
4068 /* Walk all basic blocks created after FIRST and try to fold every statement
4069 in the STATEMENTS pointer set. */
4072 fold_marked_statements (int first
, struct pointer_set_t
*statements
)
4074 for (; first
< n_basic_blocks
; first
++)
4075 if (BASIC_BLOCK (first
))
4077 gimple_stmt_iterator gsi
;
4079 for (gsi
= gsi_start_bb (BASIC_BLOCK (first
));
4082 if (pointer_set_contains (statements
, gsi_stmt (gsi
)))
4084 gimple old_stmt
= gsi_stmt (gsi
);
4085 tree old_decl
= is_gimple_call (old_stmt
) ? gimple_call_fndecl (old_stmt
) : 0;
4087 if (old_decl
&& DECL_BUILT_IN (old_decl
))
4089 /* Folding builtins can create multiple instructions,
4090 we need to look at all of them. */
4091 gimple_stmt_iterator i2
= gsi
;
4093 if (fold_stmt (&gsi
))
4097 i2
= gsi_start_bb (BASIC_BLOCK (first
));
4102 new_stmt
= gsi_stmt (i2
);
4103 update_stmt (new_stmt
);
4104 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4107 if (new_stmt
== gsi_stmt (gsi
))
4109 /* It is okay to check only for the very last
4110 of these statements. If it is a throwing
4111 statement nothing will change. If it isn't
4112 this can remove EH edges. If that weren't
4113 correct then because some intermediate stmts
4114 throw, but not the last one. That would mean
4115 we'd have to split the block, which we can't
4116 here and we'd loose anyway. And as builtins
4117 probably never throw, this all
4119 if (maybe_clean_or_replace_eh_stmt (old_stmt
,
4121 gimple_purge_dead_eh_edges (BASIC_BLOCK (first
));
4128 else if (fold_stmt (&gsi
))
4130 /* Re-read the statement from GSI as fold_stmt() may
4132 gimple new_stmt
= gsi_stmt (gsi
);
4133 update_stmt (new_stmt
);
4135 if (is_gimple_call (old_stmt
)
4136 || is_gimple_call (new_stmt
))
4137 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
4140 if (maybe_clean_or_replace_eh_stmt (old_stmt
, new_stmt
))
4141 gimple_purge_dead_eh_edges (BASIC_BLOCK (first
));
4147 /* Return true if BB has at least one abnormal outgoing edge. */
4150 has_abnormal_outgoing_edge_p (basic_block bb
)
4155 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
4156 if (e
->flags
& EDGE_ABNORMAL
)
4162 /* Expand calls to inline functions in the body of FN. */
4165 optimize_inline_calls (tree fn
)
4169 int last
= n_basic_blocks
;
4170 struct gimplify_ctx gctx
;
4171 bool inlined_p
= false;
4173 /* There is no point in performing inlining if errors have already
4174 occurred -- and we might crash if we try to inline invalid
4180 memset (&id
, 0, sizeof (id
));
4182 id
.src_node
= id
.dst_node
= cgraph_node (fn
);
4184 /* Or any functions that aren't finished yet. */
4185 if (current_function_decl
)
4186 id
.dst_fn
= current_function_decl
;
4188 id
.copy_decl
= copy_decl_maybe_to_var
;
4189 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
4190 id
.transform_new_cfg
= false;
4191 id
.transform_return_to_modify
= true;
4192 id
.transform_lang_insert_block
= NULL
;
4193 id
.statements_to_fold
= pointer_set_create ();
4195 push_gimplify_context (&gctx
);
4197 /* We make no attempts to keep dominance info up-to-date. */
4198 free_dominance_info (CDI_DOMINATORS
);
4199 free_dominance_info (CDI_POST_DOMINATORS
);
4201 /* Register specific gimple functions. */
4202 gimple_register_cfg_hooks ();
4204 /* Reach the trees by walking over the CFG, and note the
4205 enclosing basic-blocks in the call edges. */
4206 /* We walk the blocks going forward, because inlined function bodies
4207 will split id->current_basic_block, and the new blocks will
4208 follow it; we'll trudge through them, processing their CALL_EXPRs
4211 inlined_p
|= gimple_expand_calls_inline (bb
, &id
);
4213 pop_gimplify_context (NULL
);
4215 #ifdef ENABLE_CHECKING
4217 struct cgraph_edge
*e
;
4219 verify_cgraph_node (id
.dst_node
);
4221 /* Double check that we inlined everything we are supposed to inline. */
4222 for (e
= id
.dst_node
->callees
; e
; e
= e
->next_callee
)
4223 gcc_assert (e
->inline_failed
);
4227 /* Fold queued statements. */
4228 fold_marked_statements (last
, id
.statements_to_fold
);
4229 pointer_set_destroy (id
.statements_to_fold
);
4231 gcc_assert (!id
.debug_stmts
);
4233 /* If we didn't inline into the function there is nothing to do. */
4237 /* Renumber the lexical scoping (non-code) blocks consecutively. */
4240 delete_unreachable_blocks_update_callgraph (&id
);
4241 #ifdef ENABLE_CHECKING
4242 verify_cgraph_node (id
.dst_node
);
4245 /* It would be nice to check SSA/CFG/statement consistency here, but it is
4246 not possible yet - the IPA passes might make various functions to not
4247 throw and they don't care to proactively update local EH info. This is
4248 done later in fixup_cfg pass that also execute the verification. */
4249 return (TODO_update_ssa
4251 | (gimple_in_ssa_p (cfun
) ? TODO_remove_unused_locals
: 0)
4252 | (gimple_in_ssa_p (cfun
) ? TODO_update_address_taken
: 0)
4253 | (profile_status
!= PROFILE_ABSENT
? TODO_rebuild_frequencies
: 0));
4256 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
4259 copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
4261 enum tree_code code
= TREE_CODE (*tp
);
4262 enum tree_code_class cl
= TREE_CODE_CLASS (code
);
4264 /* We make copies of most nodes. */
4265 if (IS_EXPR_CODE_CLASS (cl
)
4266 || code
== TREE_LIST
4268 || code
== TYPE_DECL
4269 || code
== OMP_CLAUSE
)
4271 /* Because the chain gets clobbered when we make a copy, we save it
4273 tree chain
= NULL_TREE
, new_tree
;
4275 chain
= TREE_CHAIN (*tp
);
4277 /* Copy the node. */
4278 new_tree
= copy_node (*tp
);
4280 /* Propagate mudflap marked-ness. */
4281 if (flag_mudflap
&& mf_marked_p (*tp
))
4286 /* Now, restore the chain, if appropriate. That will cause
4287 walk_tree to walk into the chain as well. */
4288 if (code
== PARM_DECL
4289 || code
== TREE_LIST
4290 || code
== OMP_CLAUSE
)
4291 TREE_CHAIN (*tp
) = chain
;
4293 /* For now, we don't update BLOCKs when we make copies. So, we
4294 have to nullify all BIND_EXPRs. */
4295 if (TREE_CODE (*tp
) == BIND_EXPR
)
4296 BIND_EXPR_BLOCK (*tp
) = NULL_TREE
;
4298 else if (code
== CONSTRUCTOR
)
4300 /* CONSTRUCTOR nodes need special handling because
4301 we need to duplicate the vector of elements. */
4304 new_tree
= copy_node (*tp
);
4306 /* Propagate mudflap marked-ness. */
4307 if (flag_mudflap
&& mf_marked_p (*tp
))
4310 CONSTRUCTOR_ELTS (new_tree
) = VEC_copy (constructor_elt
, gc
,
4311 CONSTRUCTOR_ELTS (*tp
));
4314 else if (TREE_CODE_CLASS (code
) == tcc_type
)
4316 else if (TREE_CODE_CLASS (code
) == tcc_declaration
)
4318 else if (TREE_CODE_CLASS (code
) == tcc_constant
)
4321 gcc_assert (code
!= STATEMENT_LIST
);
4325 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
4326 information indicating to what new SAVE_EXPR this one should be mapped,
4327 use that one. Otherwise, create a new node and enter it in ST. FN is
4328 the function into which the copy will be placed. */
4331 remap_save_expr (tree
*tp
, void *st_
, int *walk_subtrees
)
4333 struct pointer_map_t
*st
= (struct pointer_map_t
*) st_
;
4337 /* See if we already encountered this SAVE_EXPR. */
4338 n
= (tree
*) pointer_map_contains (st
, *tp
);
4340 /* If we didn't already remap this SAVE_EXPR, do so now. */
4343 t
= copy_node (*tp
);
4345 /* Remember this SAVE_EXPR. */
4346 *pointer_map_insert (st
, *tp
) = t
;
4347 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
4348 *pointer_map_insert (st
, t
) = t
;
4352 /* We've already walked into this SAVE_EXPR; don't do it again. */
4357 /* Replace this SAVE_EXPR with the copy. */
4361 /* Called via walk_tree. If *TP points to a DECL_STMT for a local label,
4362 copies the declaration and enters it in the splay_tree in DATA (which is
4363 really an `copy_body_data *'). */
4366 mark_local_for_remap_r (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
,
4369 copy_body_data
*id
= (copy_body_data
*) data
;
4371 /* Don't walk into types. */
4375 else if (TREE_CODE (*tp
) == LABEL_EXPR
)
4377 tree decl
= TREE_OPERAND (*tp
, 0);
4379 /* Copy the decl and remember the copy. */
4380 insert_decl_map (id
, decl
, id
->copy_decl (decl
, id
));
4386 /* Perform any modifications to EXPR required when it is unsaved. Does
4387 not recurse into EXPR's subtrees. */
4390 unsave_expr_1 (tree expr
)
4392 switch (TREE_CODE (expr
))
4395 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
4396 It's OK for this to happen if it was part of a subtree that
4397 isn't immediately expanded, such as operand 2 of another
4399 if (TREE_OPERAND (expr
, 1))
4402 TREE_OPERAND (expr
, 1) = TREE_OPERAND (expr
, 3);
4403 TREE_OPERAND (expr
, 3) = NULL_TREE
;
4411 /* Called via walk_tree when an expression is unsaved. Using the
4412 splay_tree pointed to by ST (which is really a `splay_tree'),
4413 remaps all local declarations to appropriate replacements. */
4416 unsave_r (tree
*tp
, int *walk_subtrees
, void *data
)
4418 copy_body_data
*id
= (copy_body_data
*) data
;
4419 struct pointer_map_t
*st
= id
->decl_map
;
4422 /* Only a local declaration (variable or label). */
4423 if ((TREE_CODE (*tp
) == VAR_DECL
&& !TREE_STATIC (*tp
))
4424 || TREE_CODE (*tp
) == LABEL_DECL
)
4426 /* Lookup the declaration. */
4427 n
= (tree
*) pointer_map_contains (st
, *tp
);
4429 /* If it's there, remap it. */
4434 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
4436 else if (TREE_CODE (*tp
) == BIND_EXPR
)
4437 copy_bind_expr (tp
, walk_subtrees
, id
);
4438 else if (TREE_CODE (*tp
) == SAVE_EXPR
4439 || TREE_CODE (*tp
) == TARGET_EXPR
)
4440 remap_save_expr (tp
, st
, walk_subtrees
);
4443 copy_tree_r (tp
, walk_subtrees
, NULL
);
4445 /* Do whatever unsaving is required. */
4446 unsave_expr_1 (*tp
);
4449 /* Keep iterating. */
4453 /* Copies everything in EXPR and replaces variables, labels
4454 and SAVE_EXPRs local to EXPR. */
4457 unsave_expr_now (tree expr
)
4461 /* There's nothing to do for NULL_TREE. */
4466 memset (&id
, 0, sizeof (id
));
4467 id
.src_fn
= current_function_decl
;
4468 id
.dst_fn
= current_function_decl
;
4469 id
.decl_map
= pointer_map_create ();
4470 id
.debug_map
= NULL
;
4472 id
.copy_decl
= copy_decl_no_change
;
4473 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
4474 id
.transform_new_cfg
= false;
4475 id
.transform_return_to_modify
= false;
4476 id
.transform_lang_insert_block
= NULL
;
4478 /* Walk the tree once to find local labels. */
4479 walk_tree_without_duplicates (&expr
, mark_local_for_remap_r
, &id
);
4481 /* Walk the tree again, copying, remapping, and unsaving. */
4482 walk_tree (&expr
, unsave_r
, &id
, NULL
);
4485 pointer_map_destroy (id
.decl_map
);
4487 pointer_map_destroy (id
.debug_map
);
4492 /* Called via walk_gimple_seq. If *GSIP points to a GIMPLE_LABEL for a local
4493 label, copies the declaration and enters it in the splay_tree in DATA (which
4494 is really a 'copy_body_data *'. */
4497 mark_local_labels_stmt (gimple_stmt_iterator
*gsip
,
4498 bool *handled_ops_p ATTRIBUTE_UNUSED
,
4499 struct walk_stmt_info
*wi
)
4501 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4502 gimple stmt
= gsi_stmt (*gsip
);
4504 if (gimple_code (stmt
) == GIMPLE_LABEL
)
4506 tree decl
= gimple_label_label (stmt
);
4508 /* Copy the decl and remember the copy. */
4509 insert_decl_map (id
, decl
, id
->copy_decl (decl
, id
));
4516 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
4517 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
4518 remaps all local declarations to appropriate replacements in gimple
4522 replace_locals_op (tree
*tp
, int *walk_subtrees
, void *data
)
4524 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
4525 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4526 struct pointer_map_t
*st
= id
->decl_map
;
4530 /* Only a local declaration (variable or label). */
4531 if ((TREE_CODE (expr
) == VAR_DECL
4532 && !TREE_STATIC (expr
))
4533 || TREE_CODE (expr
) == LABEL_DECL
)
4535 /* Lookup the declaration. */
4536 n
= (tree
*) pointer_map_contains (st
, expr
);
4538 /* If it's there, remap it. */
4543 else if (TREE_CODE (expr
) == STATEMENT_LIST
4544 || TREE_CODE (expr
) == BIND_EXPR
4545 || TREE_CODE (expr
) == SAVE_EXPR
)
4547 else if (TREE_CODE (expr
) == TARGET_EXPR
)
4549 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
4550 It's OK for this to happen if it was part of a subtree that
4551 isn't immediately expanded, such as operand 2 of another
4553 if (!TREE_OPERAND (expr
, 1))
4555 TREE_OPERAND (expr
, 1) = TREE_OPERAND (expr
, 3);
4556 TREE_OPERAND (expr
, 3) = NULL_TREE
;
4560 /* Keep iterating. */
4565 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
4566 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
4567 remaps all local declarations to appropriate replacements in gimple
4571 replace_locals_stmt (gimple_stmt_iterator
*gsip
,
4572 bool *handled_ops_p ATTRIBUTE_UNUSED
,
4573 struct walk_stmt_info
*wi
)
4575 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
4576 gimple stmt
= gsi_stmt (*gsip
);
4578 if (gimple_code (stmt
) == GIMPLE_BIND
)
4580 tree block
= gimple_bind_block (stmt
);
4584 remap_block (&block
, id
);
4585 gimple_bind_set_block (stmt
, block
);
4588 /* This will remap a lot of the same decls again, but this should be
4590 if (gimple_bind_vars (stmt
))
4591 gimple_bind_set_vars (stmt
, remap_decls (gimple_bind_vars (stmt
), NULL
, id
));
4594 /* Keep iterating. */
4599 /* Copies everything in SEQ and replaces variables and labels local to
4600 current_function_decl. */
4603 copy_gimple_seq_and_replace_locals (gimple_seq seq
)
4606 struct walk_stmt_info wi
;
4607 struct pointer_set_t
*visited
;
4610 /* There's nothing to do for NULL_TREE. */
4615 memset (&id
, 0, sizeof (id
));
4616 id
.src_fn
= current_function_decl
;
4617 id
.dst_fn
= current_function_decl
;
4618 id
.decl_map
= pointer_map_create ();
4619 id
.debug_map
= NULL
;
4621 id
.copy_decl
= copy_decl_no_change
;
4622 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
4623 id
.transform_new_cfg
= false;
4624 id
.transform_return_to_modify
= false;
4625 id
.transform_lang_insert_block
= NULL
;
4627 /* Walk the tree once to find local labels. */
4628 memset (&wi
, 0, sizeof (wi
));
4629 visited
= pointer_set_create ();
4632 walk_gimple_seq (seq
, mark_local_labels_stmt
, NULL
, &wi
);
4633 pointer_set_destroy (visited
);
4635 copy
= gimple_seq_copy (seq
);
4637 /* Walk the copy, remapping decls. */
4638 memset (&wi
, 0, sizeof (wi
));
4640 walk_gimple_seq (copy
, replace_locals_stmt
, replace_locals_op
, &wi
);
4643 pointer_map_destroy (id
.decl_map
);
4645 pointer_map_destroy (id
.debug_map
);
4651 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
4654 debug_find_tree_1 (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
, void *data
)
4663 debug_find_tree (tree top
, tree search
)
4665 return walk_tree_without_duplicates (&top
, debug_find_tree_1
, search
) != 0;
4669 /* Declare the variables created by the inliner. Add all the variables in
4670 VARS to BIND_EXPR. */
4673 declare_inline_vars (tree block
, tree vars
)
4676 for (t
= vars
; t
; t
= DECL_CHAIN (t
))
4678 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
4679 gcc_assert (!TREE_STATIC (t
) && !TREE_ASM_WRITTEN (t
));
4680 add_local_decl (cfun
, t
);
4684 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), vars
);
4687 /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN,
4688 but now it will be in the TO_FN. PARM_TO_VAR means enable PARM_DECL to
4689 VAR_DECL translation. */
4692 copy_decl_for_dup_finish (copy_body_data
*id
, tree decl
, tree copy
)
4694 /* Don't generate debug information for the copy if we wouldn't have
4695 generated it for the copy either. */
4696 DECL_ARTIFICIAL (copy
) = DECL_ARTIFICIAL (decl
);
4697 DECL_IGNORED_P (copy
) = DECL_IGNORED_P (decl
);
4699 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
4700 declaration inspired this copy. */
4701 DECL_ABSTRACT_ORIGIN (copy
) = DECL_ORIGIN (decl
);
4703 /* The new variable/label has no RTL, yet. */
4704 if (CODE_CONTAINS_STRUCT (TREE_CODE (copy
), TS_DECL_WRTL
)
4705 && !TREE_STATIC (copy
) && !DECL_EXTERNAL (copy
))
4706 SET_DECL_RTL (copy
, 0);
4708 /* These args would always appear unused, if not for this. */
4709 TREE_USED (copy
) = 1;
4711 /* Set the context for the new declaration. */
4712 if (!DECL_CONTEXT (decl
))
4713 /* Globals stay global. */
4715 else if (DECL_CONTEXT (decl
) != id
->src_fn
)
4716 /* Things that weren't in the scope of the function we're inlining
4717 from aren't in the scope we're inlining to, either. */
4719 else if (TREE_STATIC (decl
))
4720 /* Function-scoped static variables should stay in the original
4724 /* Ordinary automatic local variables are now in the scope of the
4726 DECL_CONTEXT (copy
) = id
->dst_fn
;
4732 copy_decl_to_var (tree decl
, copy_body_data
*id
)
4736 gcc_assert (TREE_CODE (decl
) == PARM_DECL
4737 || TREE_CODE (decl
) == RESULT_DECL
);
4739 type
= TREE_TYPE (decl
);
4741 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
4742 VAR_DECL
, DECL_NAME (decl
), type
);
4743 if (DECL_PT_UID_SET_P (decl
))
4744 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
4745 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
4746 TREE_READONLY (copy
) = TREE_READONLY (decl
);
4747 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
4748 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
4750 return copy_decl_for_dup_finish (id
, decl
, copy
);
4753 /* Like copy_decl_to_var, but create a return slot object instead of a
4754 pointer variable for return by invisible reference. */
4757 copy_result_decl_to_var (tree decl
, copy_body_data
*id
)
4761 gcc_assert (TREE_CODE (decl
) == PARM_DECL
4762 || TREE_CODE (decl
) == RESULT_DECL
);
4764 type
= TREE_TYPE (decl
);
4765 if (DECL_BY_REFERENCE (decl
))
4766 type
= TREE_TYPE (type
);
4768 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
4769 VAR_DECL
, DECL_NAME (decl
), type
);
4770 if (DECL_PT_UID_SET_P (decl
))
4771 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
4772 TREE_READONLY (copy
) = TREE_READONLY (decl
);
4773 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
4774 if (!DECL_BY_REFERENCE (decl
))
4776 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
4777 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (decl
);
4780 return copy_decl_for_dup_finish (id
, decl
, copy
);
4784 copy_decl_no_change (tree decl
, copy_body_data
*id
)
4788 copy
= copy_node (decl
);
4790 /* The COPY is not abstract; it will be generated in DST_FN. */
4791 DECL_ABSTRACT (copy
) = 0;
4792 lang_hooks
.dup_lang_specific_decl (copy
);
4794 /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
4795 been taken; it's for internal bookkeeping in expand_goto_internal. */
4796 if (TREE_CODE (copy
) == LABEL_DECL
)
4798 TREE_ADDRESSABLE (copy
) = 0;
4799 LABEL_DECL_UID (copy
) = -1;
4802 return copy_decl_for_dup_finish (id
, decl
, copy
);
4806 copy_decl_maybe_to_var (tree decl
, copy_body_data
*id
)
4808 if (TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
)
4809 return copy_decl_to_var (decl
, id
);
4811 return copy_decl_no_change (decl
, id
);
4814 /* Return a copy of the function's argument tree. */
4816 copy_arguments_for_versioning (tree orig_parm
, copy_body_data
* id
,
4817 bitmap args_to_skip
, tree
*vars
)
4820 tree new_parm
= NULL
;
4825 for (arg
= orig_parm
; arg
; arg
= DECL_CHAIN (arg
), i
++)
4826 if (!args_to_skip
|| !bitmap_bit_p (args_to_skip
, i
))
4828 tree new_tree
= remap_decl (arg
, id
);
4829 lang_hooks
.dup_lang_specific_decl (new_tree
);
4831 parg
= &DECL_CHAIN (new_tree
);
4833 else if (!pointer_map_contains (id
->decl_map
, arg
))
4835 /* Make an equivalent VAR_DECL. If the argument was used
4836 as temporary variable later in function, the uses will be
4837 replaced by local variable. */
4838 tree var
= copy_decl_to_var (arg
, id
);
4840 add_referenced_var (var
);
4841 insert_decl_map (id
, arg
, var
);
4842 /* Declare this new variable. */
4843 DECL_CHAIN (var
) = *vars
;
4849 /* Return a copy of the function's static chain. */
4851 copy_static_chain (tree static_chain
, copy_body_data
* id
)
4853 tree
*chain_copy
, *pvar
;
4855 chain_copy
= &static_chain
;
4856 for (pvar
= chain_copy
; *pvar
; pvar
= &DECL_CHAIN (*pvar
))
4858 tree new_tree
= remap_decl (*pvar
, id
);
4859 lang_hooks
.dup_lang_specific_decl (new_tree
);
4860 DECL_CHAIN (new_tree
) = DECL_CHAIN (*pvar
);
4863 return static_chain
;
4866 /* Return true if the function is allowed to be versioned.
4867 This is a guard for the versioning functionality. */
4870 tree_versionable_function_p (tree fndecl
)
4872 return (!lookup_attribute ("noclone", DECL_ATTRIBUTES (fndecl
))
4873 && copy_forbidden (DECL_STRUCT_FUNCTION (fndecl
), fndecl
) == NULL
);
4876 /* Delete all unreachable basic blocks and update callgraph.
4877 Doing so is somewhat nontrivial because we need to update all clones and
4878 remove inline function that become unreachable. */
4881 delete_unreachable_blocks_update_callgraph (copy_body_data
*id
)
4883 bool changed
= false;
4884 basic_block b
, next_bb
;
4886 find_unreachable_blocks ();
4888 /* Delete all unreachable basic blocks. */
4890 for (b
= ENTRY_BLOCK_PTR
->next_bb
; b
!= EXIT_BLOCK_PTR
; b
= next_bb
)
4892 next_bb
= b
->next_bb
;
4894 if (!(b
->flags
& BB_REACHABLE
))
4896 gimple_stmt_iterator bsi
;
4898 for (bsi
= gsi_start_bb (b
); !gsi_end_p (bsi
); gsi_next (&bsi
))
4899 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
)
4901 struct cgraph_edge
*e
;
4902 struct cgraph_node
*node
;
4904 if ((e
= cgraph_edge (id
->dst_node
, gsi_stmt (bsi
))) != NULL
)
4906 if (!e
->inline_failed
)
4907 cgraph_remove_node_and_inline_clones (e
->callee
);
4909 cgraph_remove_edge (e
);
4911 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
4912 && id
->dst_node
->clones
)
4913 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
4915 if ((e
= cgraph_edge (node
, gsi_stmt (bsi
))) != NULL
)
4917 if (!e
->inline_failed
)
4918 cgraph_remove_node_and_inline_clones (e
->callee
);
4920 cgraph_remove_edge (e
);
4924 node
= node
->clones
;
4925 else if (node
->next_sibling_clone
)
4926 node
= node
->next_sibling_clone
;
4929 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
4930 node
= node
->clone_of
;
4931 if (node
!= id
->dst_node
)
4932 node
= node
->next_sibling_clone
;
4936 delete_basic_block (b
);
4942 tidy_fallthru_edges ();
4946 /* Update clone info after duplication. */
4949 update_clone_info (copy_body_data
* id
)
4951 struct cgraph_node
*node
;
4952 if (!id
->dst_node
->clones
)
4954 for (node
= id
->dst_node
->clones
; node
!= id
->dst_node
;)
4956 /* First update replace maps to match the new body. */
4957 if (node
->clone
.tree_map
)
4960 for (i
= 0; i
< VEC_length (ipa_replace_map_p
, node
->clone
.tree_map
); i
++)
4962 struct ipa_replace_map
*replace_info
;
4963 replace_info
= VEC_index (ipa_replace_map_p
, node
->clone
.tree_map
, i
);
4964 walk_tree (&replace_info
->old_tree
, copy_tree_body_r
, id
, NULL
);
4965 walk_tree (&replace_info
->new_tree
, copy_tree_body_r
, id
, NULL
);
4969 node
= node
->clones
;
4970 else if (node
->next_sibling_clone
)
4971 node
= node
->next_sibling_clone
;
4974 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
4975 node
= node
->clone_of
;
4976 if (node
!= id
->dst_node
)
4977 node
= node
->next_sibling_clone
;
4982 /* Create a copy of a function's tree.
4983 OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
4984 of the original function and the new copied function
4985 respectively. In case we want to replace a DECL
4986 tree with another tree while duplicating the function's
4987 body, TREE_MAP represents the mapping between these
4988 trees. If UPDATE_CLONES is set, the call_stmt fields
4989 of edges of clones of the function will be updated.
4991 If non-NULL ARGS_TO_SKIP determine function parameters to remove
4993 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
4994 If non_NULL NEW_ENTRY determine new entry BB of the clone.
4997 tree_function_versioning (tree old_decl
, tree new_decl
,
4998 VEC(ipa_replace_map_p
,gc
)* tree_map
,
4999 bool update_clones
, bitmap args_to_skip
,
5000 bitmap blocks_to_copy
, basic_block new_entry
)
5002 struct cgraph_node
*old_version_node
;
5003 struct cgraph_node
*new_version_node
;
5007 struct ipa_replace_map
*replace_info
;
5008 basic_block old_entry_block
, bb
;
5009 VEC (gimple
, heap
) *init_stmts
= VEC_alloc (gimple
, heap
, 10);
5011 tree old_current_function_decl
= current_function_decl
;
5012 tree vars
= NULL_TREE
;
5014 gcc_assert (TREE_CODE (old_decl
) == FUNCTION_DECL
5015 && TREE_CODE (new_decl
) == FUNCTION_DECL
);
5016 DECL_POSSIBLY_INLINED (old_decl
) = 1;
5018 old_version_node
= cgraph_node (old_decl
);
5019 new_version_node
= cgraph_node (new_decl
);
5021 /* Output the inlining info for this abstract function, since it has been
5022 inlined. If we don't do this now, we can lose the information about the
5023 variables in the function when the blocks get blown away as soon as we
5024 remove the cgraph node. */
5025 (*debug_hooks
->outlining_inline_function
) (old_decl
);
5027 DECL_ARTIFICIAL (new_decl
) = 1;
5028 DECL_ABSTRACT_ORIGIN (new_decl
) = DECL_ORIGIN (old_decl
);
5029 DECL_FUNCTION_PERSONALITY (new_decl
) = DECL_FUNCTION_PERSONALITY (old_decl
);
5031 /* Prepare the data structures for the tree copy. */
5032 memset (&id
, 0, sizeof (id
));
5034 /* Generate a new name for the new version. */
5035 id
.statements_to_fold
= pointer_set_create ();
5037 id
.decl_map
= pointer_map_create ();
5038 id
.debug_map
= NULL
;
5039 id
.src_fn
= old_decl
;
5040 id
.dst_fn
= new_decl
;
5041 id
.src_node
= old_version_node
;
5042 id
.dst_node
= new_version_node
;
5043 id
.src_cfun
= DECL_STRUCT_FUNCTION (old_decl
);
5044 if (id
.src_node
->ipa_transforms_to_apply
)
5046 VEC(ipa_opt_pass
,heap
) * old_transforms_to_apply
= id
.dst_node
->ipa_transforms_to_apply
;
5049 id
.dst_node
->ipa_transforms_to_apply
= VEC_copy (ipa_opt_pass
, heap
,
5050 id
.src_node
->ipa_transforms_to_apply
);
5051 for (i
= 0; i
< VEC_length (ipa_opt_pass
, old_transforms_to_apply
); i
++)
5052 VEC_safe_push (ipa_opt_pass
, heap
, id
.dst_node
->ipa_transforms_to_apply
,
5053 VEC_index (ipa_opt_pass
,
5054 old_transforms_to_apply
,
5058 id
.copy_decl
= copy_decl_no_change
;
5059 id
.transform_call_graph_edges
5060 = update_clones
? CB_CGE_MOVE_CLONES
: CB_CGE_MOVE
;
5061 id
.transform_new_cfg
= true;
5062 id
.transform_return_to_modify
= false;
5063 id
.transform_lang_insert_block
= NULL
;
5065 current_function_decl
= new_decl
;
5066 old_entry_block
= ENTRY_BLOCK_PTR_FOR_FUNCTION
5067 (DECL_STRUCT_FUNCTION (old_decl
));
5068 initialize_cfun (new_decl
, old_decl
,
5069 old_entry_block
->count
);
5070 DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
->ipa_pta
5071 = id
.src_cfun
->gimple_df
->ipa_pta
;
5072 push_cfun (DECL_STRUCT_FUNCTION (new_decl
));
5074 /* Copy the function's static chain. */
5075 p
= DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
;
5077 DECL_STRUCT_FUNCTION (new_decl
)->static_chain_decl
=
5078 copy_static_chain (DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
,
5081 /* If there's a tree_map, prepare for substitution. */
5083 for (i
= 0; i
< VEC_length (ipa_replace_map_p
, tree_map
); i
++)
5086 replace_info
= VEC_index (ipa_replace_map_p
, tree_map
, i
);
5087 if (replace_info
->replace_p
)
5089 tree op
= replace_info
->new_tree
;
5090 if (!replace_info
->old_tree
)
5092 int i
= replace_info
->parm_num
;
5094 for (parm
= DECL_ARGUMENTS (old_decl
); i
; parm
= DECL_CHAIN (parm
))
5096 replace_info
->old_tree
= parm
;
5102 if (TREE_CODE (op
) == VIEW_CONVERT_EXPR
)
5103 op
= TREE_OPERAND (op
, 0);
5105 if (TREE_CODE (op
) == ADDR_EXPR
)
5107 op
= TREE_OPERAND (op
, 0);
5108 while (handled_component_p (op
))
5109 op
= TREE_OPERAND (op
, 0);
5110 if (TREE_CODE (op
) == VAR_DECL
)
5111 add_referenced_var (op
);
5113 gcc_assert (TREE_CODE (replace_info
->old_tree
) == PARM_DECL
);
5114 init
= setup_one_parameter (&id
, replace_info
->old_tree
,
5115 replace_info
->new_tree
, id
.src_fn
,
5119 VEC_safe_push (gimple
, heap
, init_stmts
, init
);
5122 /* Copy the function's arguments. */
5123 if (DECL_ARGUMENTS (old_decl
) != NULL_TREE
)
5124 DECL_ARGUMENTS (new_decl
) =
5125 copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl
), &id
,
5126 args_to_skip
, &vars
);
5128 DECL_INITIAL (new_decl
) = remap_blocks (DECL_INITIAL (id
.src_fn
), &id
);
5130 declare_inline_vars (DECL_INITIAL (new_decl
), vars
);
5132 if (!VEC_empty (tree
, DECL_STRUCT_FUNCTION (old_decl
)->local_decls
))
5133 /* Add local vars. */
5134 add_local_variables (DECL_STRUCT_FUNCTION (old_decl
), cfun
, &id
, false);
5136 /* Copy the Function's body. */
5137 copy_body (&id
, old_entry_block
->count
, REG_BR_PROB_BASE
,
5138 ENTRY_BLOCK_PTR
, EXIT_BLOCK_PTR
, blocks_to_copy
, new_entry
);
5140 if (DECL_RESULT (old_decl
) != NULL_TREE
)
5142 tree
*res_decl
= &DECL_RESULT (old_decl
);
5143 DECL_RESULT (new_decl
) = remap_decl (*res_decl
, &id
);
5144 lang_hooks
.dup_lang_specific_decl (DECL_RESULT (new_decl
));
5147 /* Renumber the lexical scoping (non-code) blocks consecutively. */
5148 number_blocks (new_decl
);
5150 /* We want to create the BB unconditionally, so that the addition of
5151 debug stmts doesn't affect BB count, which may in the end cause
5152 codegen differences. */
5153 bb
= split_edge (single_succ_edge (ENTRY_BLOCK_PTR
));
5154 while (VEC_length (gimple
, init_stmts
))
5155 insert_init_stmt (&id
, bb
, VEC_pop (gimple
, init_stmts
));
5156 update_clone_info (&id
);
5158 /* Remap the nonlocal_goto_save_area, if any. */
5159 if (cfun
->nonlocal_goto_save_area
)
5161 struct walk_stmt_info wi
;
5163 memset (&wi
, 0, sizeof (wi
));
5165 walk_tree (&cfun
->nonlocal_goto_save_area
, remap_gimple_op_r
, &wi
, NULL
);
5169 pointer_map_destroy (id
.decl_map
);
5171 pointer_map_destroy (id
.debug_map
);
5172 free_dominance_info (CDI_DOMINATORS
);
5173 free_dominance_info (CDI_POST_DOMINATORS
);
5175 fold_marked_statements (0, id
.statements_to_fold
);
5176 pointer_set_destroy (id
.statements_to_fold
);
5177 fold_cond_expr_cond ();
5178 delete_unreachable_blocks_update_callgraph (&id
);
5179 if (id
.dst_node
->analyzed
)
5180 cgraph_rebuild_references ();
5181 update_ssa (TODO_update_ssa
);
5183 /* After partial cloning we need to rescale frequencies, so they are
5184 within proper range in the cloned function. */
5187 struct cgraph_edge
*e
;
5188 rebuild_frequencies ();
5190 new_version_node
->count
= ENTRY_BLOCK_PTR
->count
;
5191 for (e
= new_version_node
->callees
; e
; e
= e
->next_callee
)
5193 basic_block bb
= gimple_bb (e
->call_stmt
);
5194 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
5196 e
->count
= bb
->count
;
5198 for (e
= new_version_node
->indirect_calls
; e
; e
= e
->next_callee
)
5200 basic_block bb
= gimple_bb (e
->call_stmt
);
5201 e
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
5203 e
->count
= bb
->count
;
5207 free_dominance_info (CDI_DOMINATORS
);
5208 free_dominance_info (CDI_POST_DOMINATORS
);
5210 gcc_assert (!id
.debug_stmts
);
5211 VEC_free (gimple
, heap
, init_stmts
);
5213 current_function_decl
= old_current_function_decl
;
5214 gcc_assert (!current_function_decl
5215 || DECL_STRUCT_FUNCTION (current_function_decl
) == cfun
);
5219 /* EXP is CALL_EXPR present in a GENERIC expression tree. Try to integrate
5220 the callee and return the inlined body on success. */
5223 maybe_inline_call_in_expr (tree exp
)
5225 tree fn
= get_callee_fndecl (exp
);
5227 /* We can only try to inline "const" functions. */
5228 if (fn
&& TREE_READONLY (fn
) && DECL_SAVED_TREE (fn
))
5230 struct pointer_map_t
*decl_map
= pointer_map_create ();
5231 call_expr_arg_iterator iter
;
5235 /* Remap the parameters. */
5236 for (param
= DECL_ARGUMENTS (fn
), arg
= first_call_expr_arg (exp
, &iter
);
5238 param
= DECL_CHAIN (param
), arg
= next_call_expr_arg (&iter
))
5239 *pointer_map_insert (decl_map
, param
) = arg
;
5241 memset (&id
, 0, sizeof (id
));
5243 id
.dst_fn
= current_function_decl
;
5244 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
5245 id
.decl_map
= decl_map
;
5247 id
.copy_decl
= copy_decl_no_change
;
5248 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5249 id
.transform_new_cfg
= false;
5250 id
.transform_return_to_modify
= true;
5251 id
.transform_lang_insert_block
= false;
5253 /* Make sure not to unshare trees behind the front-end's back
5254 since front-end specific mechanisms may rely on sharing. */
5255 id
.regimplify
= false;
5256 id
.do_not_unshare
= true;
5258 /* We're not inside any EH region. */
5261 t
= copy_tree_body (&id
);
5262 pointer_map_destroy (decl_map
);
5264 /* We can only return something suitable for use in a GENERIC
5266 if (TREE_CODE (t
) == MODIFY_EXPR
)
5267 return TREE_OPERAND (t
, 1);
5273 /* Duplicate a type, fields and all. */
5276 build_duplicate_type (tree type
)
5278 struct copy_body_data id
;
5280 memset (&id
, 0, sizeof (id
));
5281 id
.src_fn
= current_function_decl
;
5282 id
.dst_fn
= current_function_decl
;
5284 id
.decl_map
= pointer_map_create ();
5285 id
.debug_map
= NULL
;
5286 id
.copy_decl
= copy_decl_no_change
;
5288 type
= remap_type_1 (type
, &id
);
5290 pointer_map_destroy (id
.decl_map
);
5292 pointer_map_destroy (id
.debug_map
);
5294 TYPE_CANONICAL (type
) = type
;
5299 /* Return whether it is safe to inline a function because it used different
5300 target specific options or call site actual types mismatch parameter types.
5301 E is the call edge to be checked. */
5303 tree_can_inline_p (struct cgraph_edge
*e
)
5306 /* This causes a regression in SPEC in that it prevents a cold function from
5307 inlining a hot function. Perhaps this should only apply to functions
5308 that the user declares hot/cold/optimize explicitly. */
5310 /* Don't inline a function with a higher optimization level than the
5311 caller, or with different space constraints (hot/cold functions). */
5312 tree caller_tree
= DECL_FUNCTION_SPECIFIC_OPTIMIZATION (caller
);
5313 tree callee_tree
= DECL_FUNCTION_SPECIFIC_OPTIMIZATION (callee
);
5315 if (caller_tree
!= callee_tree
)
5317 struct cl_optimization
*caller_opt
5318 = TREE_OPTIMIZATION ((caller_tree
)
5320 : optimization_default_node
);
5322 struct cl_optimization
*callee_opt
5323 = TREE_OPTIMIZATION ((callee_tree
)
5325 : optimization_default_node
);
5327 if ((caller_opt
->optimize
> callee_opt
->optimize
)
5328 || (caller_opt
->optimize_size
!= callee_opt
->optimize_size
))
5332 tree caller
, callee
, lhs
;
5334 caller
= e
->caller
->decl
;
5335 callee
= e
->callee
->decl
;
5337 /* First check that inlining isn't simply forbidden in this case. */
5338 if (inline_forbidden_into_p (caller
, callee
))
5340 e
->inline_failed
= CIF_UNSPECIFIED
;
5341 gimple_call_set_cannot_inline (e
->call_stmt
, true);
5345 /* Allow the backend to decide if inlining is ok. */
5346 if (!targetm
.target_option
.can_inline_p (caller
, callee
))
5348 e
->inline_failed
= CIF_TARGET_OPTION_MISMATCH
;
5349 gimple_call_set_cannot_inline (e
->call_stmt
, true);
5350 e
->call_stmt_cannot_inline_p
= true;
5354 /* Do not inline calls where we cannot triviall work around mismatches
5355 in argument or return types. */
5357 && ((DECL_RESULT (callee
)
5358 && !DECL_BY_REFERENCE (DECL_RESULT (callee
))
5359 && (lhs
= gimple_call_lhs (e
->call_stmt
)) != NULL_TREE
5360 && !useless_type_conversion_p (TREE_TYPE (DECL_RESULT (callee
)),
5362 && !fold_convertible_p (TREE_TYPE (DECL_RESULT (callee
)), lhs
))
5363 || !gimple_check_call_args (e
->call_stmt
)))
5365 e
->inline_failed
= CIF_MISMATCHED_ARGUMENTS
;
5366 gimple_call_set_cannot_inline (e
->call_stmt
, true);
5367 e
->call_stmt_cannot_inline_p
= true;