2 Copyright (C) 2001-2021 Free Software Foundation, Inc.
3 Contributed by Alexandre Oliva <aoliva@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
30 #include "tree-pass.h"
33 #include "tree-pretty-print.h"
34 #include "diagnostic-core.h"
35 #include "gimple-predict.h"
36 #include "fold-const.h"
37 #include "stor-layout.h"
39 #include "tree-inline.h"
40 #include "langhooks.h"
42 #include "tree-iterator.h"
44 #include "gimple-fold.h"
47 #include "gimple-iterator.h"
48 #include "gimplify-me.h"
49 #include "gimple-walk.h"
51 #include "tree-into-ssa.h"
56 #include "value-prof.h"
59 #include "stringpool.h"
62 #include "tree-cfgcleanup.h"
63 #include "tree-ssa-live.h"
64 #include "alloc-pool.h"
65 #include "symbol-summary.h"
66 #include "symtab-thunks.h"
67 #include "symtab-clones.h"
69 /* I'm not real happy about this, but we need to handle gimple and
72 /* Inlining, Cloning, Versioning, Parallelization
74 Inlining: a function body is duplicated, but the PARM_DECLs are
75 remapped into VAR_DECLs, and non-void RETURN_EXPRs become
76 MODIFY_EXPRs that store to a dedicated returned-value variable.
77 The duplicated eh_region info of the copy will later be appended
78 to the info for the caller; the eh_region info in copied throwing
79 statements and RESX statements are adjusted accordingly.
81 Cloning: (only in C++) We have one body for a con/de/structor, and
82 multiple function decls, each with a unique parameter list.
83 Duplicate the body, using the given splay tree; some parameters
84 will become constants (like 0 or 1).
86 Versioning: a function body is duplicated and the result is a new
87 function rather than into blocks of an existing function as with
88 inlining. Some parameters will become constants.
90 Parallelization: a region of a function is duplicated resulting in
91 a new function. Variables may be replaced with complex expressions
92 to enable shared variable semantics.
94 All of these will simultaneously lookup any callgraph edges. If
95 we're going to inline the duplicated function body, and the given
96 function has some cloned callgraph nodes (one for each place this
97 function will be inlined) those callgraph edges will be duplicated.
98 If we're cloning the body, those callgraph edges will be
99 updated to point into the new body. (Note that the original
100 callgraph node and edge list will not be altered.)
102 See the CALL_EXPR handling case in copy_tree_body_r (). */
106 o In order to make inlining-on-trees work, we pessimized
107 function-local static constants. In particular, they are now
108 always output, even when not addressed. Fix this by treating
109 function-local static constants just like global static
110 constants; the back-end already knows not to output them if they
113 o Provide heuristics to clamp inlining of recursive template
117 /* Weights that estimate_num_insns uses to estimate the size of the
120 eni_weights eni_size_weights
;
122 /* Weights that estimate_num_insns uses to estimate the time necessary
123 to execute the produced code. */
125 eni_weights eni_time_weights
;
129 static tree
declare_return_variable (copy_body_data
*, tree
, tree
,
131 static void remap_block (tree
*, copy_body_data
*);
132 static void copy_bind_expr (tree
*, int *, copy_body_data
*);
133 static void declare_inline_vars (tree
, tree
);
134 static void remap_save_expr (tree
*, hash_map
<tree
, tree
> *, int *);
135 static void prepend_lexical_block (tree current_block
, tree new_block
);
136 static tree
copy_result_decl_to_var (tree
, copy_body_data
*);
137 static tree
copy_decl_maybe_to_var (tree
, copy_body_data
*);
138 static gimple_seq
remap_gimple_stmt (gimple
*, copy_body_data
*);
139 static void insert_init_stmt (copy_body_data
*, basic_block
, gimple
*);
141 /* Insert a tree->tree mapping for ID. Despite the name suggests
142 that the trees should be variables, it is used for more than that. */
145 insert_decl_map (copy_body_data
*id
, tree key
, tree value
)
147 id
->decl_map
->put (key
, value
);
149 /* Always insert an identity map as well. If we see this same new
150 node again, we won't want to duplicate it a second time. */
152 id
->decl_map
->put (value
, value
);
155 /* If nonzero, we're remapping the contents of inlined debug
156 statements. If negative, an error has occurred, such as a
157 reference to a variable that isn't available in the inlined
159 static int processing_debug_stmt
= 0;
161 /* Construct new SSA name for old NAME. ID is the inline context. */
164 remap_ssa_name (tree name
, copy_body_data
*id
)
169 gcc_assert (TREE_CODE (name
) == SSA_NAME
);
171 n
= id
->decl_map
->get (name
);
174 /* WHen we perform edge redirection as part of CFG copy, IPA-SRA can
175 remove an unused LHS from a call statement. Such LHS can however
176 still appear in debug statements, but their value is lost in this
177 function and we do not want to map them. */
178 if (id
->killed_new_ssa_names
179 && id
->killed_new_ssa_names
->contains (*n
))
181 gcc_assert (processing_debug_stmt
);
182 processing_debug_stmt
= -1;
186 return unshare_expr (*n
);
189 if (processing_debug_stmt
)
191 if (SSA_NAME_IS_DEFAULT_DEF (name
)
192 && TREE_CODE (SSA_NAME_VAR (name
)) == PARM_DECL
193 && id
->entry_bb
== NULL
194 && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (cfun
)))
196 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
198 gimple_stmt_iterator gsi
;
199 tree val
= SSA_NAME_VAR (name
);
201 n
= id
->decl_map
->get (val
);
204 if (TREE_CODE (val
) != PARM_DECL
205 && !(VAR_P (val
) && DECL_ABSTRACT_ORIGIN (val
)))
207 processing_debug_stmt
= -1;
210 n
= id
->decl_map
->get (val
);
211 if (n
&& TREE_CODE (*n
) == DEBUG_EXPR_DECL
)
213 def_temp
= gimple_build_debug_source_bind (vexpr
, val
, NULL
);
214 DECL_ARTIFICIAL (vexpr
) = 1;
215 TREE_TYPE (vexpr
) = TREE_TYPE (name
);
216 SET_DECL_MODE (vexpr
, DECL_MODE (SSA_NAME_VAR (name
)));
217 gsi
= gsi_after_labels (single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
218 gsi_insert_before (&gsi
, def_temp
, GSI_SAME_STMT
);
219 insert_decl_map (id
, val
, vexpr
);
223 processing_debug_stmt
= -1;
227 /* Remap anonymous SSA names or SSA names of anonymous decls. */
228 var
= SSA_NAME_VAR (name
);
230 || (!SSA_NAME_IS_DEFAULT_DEF (name
)
232 && !VAR_DECL_IS_VIRTUAL_OPERAND (var
)
233 && DECL_ARTIFICIAL (var
)
234 && DECL_IGNORED_P (var
)
235 && !DECL_NAME (var
)))
237 struct ptr_info_def
*pi
;
238 new_tree
= make_ssa_name (remap_type (TREE_TYPE (name
), id
));
239 if (!var
&& SSA_NAME_IDENTIFIER (name
))
240 SET_SSA_NAME_VAR_OR_IDENTIFIER (new_tree
, SSA_NAME_IDENTIFIER (name
));
241 insert_decl_map (id
, name
, new_tree
);
242 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
243 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
244 /* At least IPA points-to info can be directly transferred. */
245 if (id
->src_cfun
->gimple_df
246 && id
->src_cfun
->gimple_df
->ipa_pta
247 && POINTER_TYPE_P (TREE_TYPE (name
))
248 && (pi
= SSA_NAME_PTR_INFO (name
))
251 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
254 /* So can range-info. */
255 if (!POINTER_TYPE_P (TREE_TYPE (name
))
256 && SSA_NAME_RANGE_INFO (name
))
257 duplicate_ssa_name_range_info (new_tree
, SSA_NAME_RANGE_TYPE (name
),
258 SSA_NAME_RANGE_INFO (name
));
262 /* Do not set DEF_STMT yet as statement is not copied yet. We do that
264 new_tree
= remap_decl (var
, id
);
266 /* We might've substituted constant or another SSA_NAME for
269 Replace the SSA name representing RESULT_DECL by variable during
270 inlining: this saves us from need to introduce PHI node in a case
271 return value is just partly initialized. */
272 if ((VAR_P (new_tree
) || TREE_CODE (new_tree
) == PARM_DECL
)
273 && (!SSA_NAME_VAR (name
)
274 || TREE_CODE (SSA_NAME_VAR (name
)) != RESULT_DECL
275 || !id
->transform_return_to_modify
))
277 struct ptr_info_def
*pi
;
278 new_tree
= make_ssa_name (new_tree
);
279 insert_decl_map (id
, name
, new_tree
);
280 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree
)
281 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
);
282 /* At least IPA points-to info can be directly transferred. */
283 if (id
->src_cfun
->gimple_df
284 && id
->src_cfun
->gimple_df
->ipa_pta
285 && POINTER_TYPE_P (TREE_TYPE (name
))
286 && (pi
= SSA_NAME_PTR_INFO (name
))
289 struct ptr_info_def
*new_pi
= get_ptr_info (new_tree
);
292 /* So can range-info. */
293 if (!POINTER_TYPE_P (TREE_TYPE (name
))
294 && SSA_NAME_RANGE_INFO (name
))
295 duplicate_ssa_name_range_info (new_tree
, SSA_NAME_RANGE_TYPE (name
),
296 SSA_NAME_RANGE_INFO (name
));
297 if (SSA_NAME_IS_DEFAULT_DEF (name
))
299 /* By inlining function having uninitialized variable, we might
300 extend the lifetime (variable might get reused). This cause
301 ICE in the case we end up extending lifetime of SSA name across
302 abnormal edge, but also increase register pressure.
304 We simply initialize all uninitialized vars by 0 except
305 for case we are inlining to very first BB. We can avoid
306 this for all BBs that are not inside strongly connected
307 regions of the CFG, but this is expensive to test. */
309 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
)
310 && (!SSA_NAME_VAR (name
)
311 || TREE_CODE (SSA_NAME_VAR (name
)) != PARM_DECL
)
312 && (id
->entry_bb
!= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
),
314 || EDGE_COUNT (id
->entry_bb
->preds
) != 1))
316 gimple_stmt_iterator gsi
= gsi_last_bb (id
->entry_bb
);
318 tree zero
= build_zero_cst (TREE_TYPE (new_tree
));
320 init_stmt
= gimple_build_assign (new_tree
, zero
);
321 gsi_insert_after (&gsi
, init_stmt
, GSI_NEW_STMT
);
322 SSA_NAME_IS_DEFAULT_DEF (new_tree
) = 0;
326 SSA_NAME_DEF_STMT (new_tree
) = gimple_build_nop ();
327 set_ssa_default_def (cfun
, SSA_NAME_VAR (new_tree
), new_tree
);
332 insert_decl_map (id
, name
, new_tree
);
336 /* Remap DECL during the copying of the BLOCK tree for the function. */
339 remap_decl (tree decl
, copy_body_data
*id
)
343 /* We only remap local variables in the current function. */
345 /* See if we have remapped this declaration. */
347 n
= id
->decl_map
->get (decl
);
349 if (!n
&& processing_debug_stmt
)
351 processing_debug_stmt
= -1;
355 /* When remapping a type within copy_gimple_seq_and_replace_locals, all
356 necessary DECLs have already been remapped and we do not want to duplicate
357 a decl coming from outside of the sequence we are copying. */
359 && id
->prevent_decl_creation_for_types
360 && id
->remapping_type_depth
> 0
361 && (VAR_P (decl
) || TREE_CODE (decl
) == PARM_DECL
))
364 /* If we didn't already have an equivalent for this declaration, create one
368 /* Make a copy of the variable or label. */
369 tree t
= id
->copy_decl (decl
, id
);
371 /* Remember it, so that if we encounter this local entity again
372 we can reuse this copy. Do this early because remap_type may
373 need this decl for TYPE_STUB_DECL. */
374 insert_decl_map (id
, decl
, t
);
379 /* Remap types, if necessary. */
380 TREE_TYPE (t
) = remap_type (TREE_TYPE (t
), id
);
381 if (TREE_CODE (t
) == TYPE_DECL
)
383 DECL_ORIGINAL_TYPE (t
) = remap_type (DECL_ORIGINAL_TYPE (t
), id
);
385 /* Preserve the invariant that DECL_ORIGINAL_TYPE != TREE_TYPE,
386 which is enforced in gen_typedef_die when DECL_ABSTRACT_ORIGIN
387 is not set on the TYPE_DECL, for example in LTO mode. */
388 if (DECL_ORIGINAL_TYPE (t
) == TREE_TYPE (t
))
390 tree x
= build_variant_type_copy (TREE_TYPE (t
));
391 TYPE_STUB_DECL (x
) = TYPE_STUB_DECL (TREE_TYPE (t
));
392 TYPE_NAME (x
) = TYPE_NAME (TREE_TYPE (t
));
393 DECL_ORIGINAL_TYPE (t
) = x
;
397 /* Remap sizes as necessary. */
398 walk_tree (&DECL_SIZE (t
), copy_tree_body_r
, id
, NULL
);
399 walk_tree (&DECL_SIZE_UNIT (t
), copy_tree_body_r
, id
, NULL
);
401 /* If fields, do likewise for offset and qualifier. */
402 if (TREE_CODE (t
) == FIELD_DECL
)
404 walk_tree (&DECL_FIELD_OFFSET (t
), copy_tree_body_r
, id
, NULL
);
405 if (TREE_CODE (DECL_CONTEXT (t
)) == QUAL_UNION_TYPE
)
406 walk_tree (&DECL_QUALIFIER (t
), copy_tree_body_r
, id
, NULL
);
412 if (id
->do_not_unshare
)
415 return unshare_expr (*n
);
419 remap_type_1 (tree type
, copy_body_data
*id
)
423 /* We do need a copy. build and register it now. If this is a pointer or
424 reference type, remap the designated type and make a new pointer or
426 if (TREE_CODE (type
) == POINTER_TYPE
)
428 new_tree
= build_pointer_type_for_mode (remap_type (TREE_TYPE (type
), id
),
430 TYPE_REF_CAN_ALIAS_ALL (type
));
431 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
432 new_tree
= build_type_attribute_qual_variant (new_tree
,
433 TYPE_ATTRIBUTES (type
),
435 insert_decl_map (id
, type
, new_tree
);
438 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
440 new_tree
= build_reference_type_for_mode (remap_type (TREE_TYPE (type
), id
),
442 TYPE_REF_CAN_ALIAS_ALL (type
));
443 if (TYPE_ATTRIBUTES (type
) || TYPE_QUALS (type
))
444 new_tree
= build_type_attribute_qual_variant (new_tree
,
445 TYPE_ATTRIBUTES (type
),
447 insert_decl_map (id
, type
, new_tree
);
451 new_tree
= copy_node (type
);
453 insert_decl_map (id
, type
, new_tree
);
455 /* This is a new type, not a copy of an old type. Need to reassociate
456 variants. We can handle everything except the main variant lazily. */
457 t
= TYPE_MAIN_VARIANT (type
);
460 t
= remap_type (t
, id
);
461 TYPE_MAIN_VARIANT (new_tree
) = t
;
462 TYPE_NEXT_VARIANT (new_tree
) = TYPE_NEXT_VARIANT (t
);
463 TYPE_NEXT_VARIANT (t
) = new_tree
;
467 TYPE_MAIN_VARIANT (new_tree
) = new_tree
;
468 TYPE_NEXT_VARIANT (new_tree
) = NULL
;
471 if (TYPE_STUB_DECL (type
))
472 TYPE_STUB_DECL (new_tree
) = remap_decl (TYPE_STUB_DECL (type
), id
);
474 /* Lazily create pointer and reference types. */
475 TYPE_POINTER_TO (new_tree
) = NULL
;
476 TYPE_REFERENCE_TO (new_tree
) = NULL
;
478 /* Copy all types that may contain references to local variables; be sure to
479 preserve sharing in between type and its main variant when possible. */
480 switch (TREE_CODE (new_tree
))
484 case FIXED_POINT_TYPE
:
487 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
489 gcc_checking_assert (TYPE_MIN_VALUE (type
) == TYPE_MIN_VALUE (TYPE_MAIN_VARIANT (type
)));
490 gcc_checking_assert (TYPE_MAX_VALUE (type
) == TYPE_MAX_VALUE (TYPE_MAIN_VARIANT (type
)));
492 TYPE_MIN_VALUE (new_tree
) = TYPE_MIN_VALUE (TYPE_MAIN_VARIANT (new_tree
));
493 TYPE_MAX_VALUE (new_tree
) = TYPE_MAX_VALUE (TYPE_MAIN_VARIANT (new_tree
));
497 t
= TYPE_MIN_VALUE (new_tree
);
498 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
499 walk_tree (&TYPE_MIN_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
501 t
= TYPE_MAX_VALUE (new_tree
);
502 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
503 walk_tree (&TYPE_MAX_VALUE (new_tree
), copy_tree_body_r
, id
, NULL
);
508 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
509 && TREE_TYPE (type
) == TREE_TYPE (TYPE_MAIN_VARIANT (type
)))
510 TREE_TYPE (new_tree
) = TREE_TYPE (TYPE_MAIN_VARIANT (new_tree
));
512 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
513 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
514 && TYPE_ARG_TYPES (type
) == TYPE_ARG_TYPES (TYPE_MAIN_VARIANT (type
)))
515 TYPE_ARG_TYPES (new_tree
) = TYPE_ARG_TYPES (TYPE_MAIN_VARIANT (new_tree
));
517 walk_tree (&TYPE_ARG_TYPES (new_tree
), copy_tree_body_r
, id
, NULL
);
521 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
522 && TREE_TYPE (type
) == TREE_TYPE (TYPE_MAIN_VARIANT (type
)))
523 TREE_TYPE (new_tree
) = TREE_TYPE (TYPE_MAIN_VARIANT (new_tree
));
525 TREE_TYPE (new_tree
) = remap_type (TREE_TYPE (new_tree
), id
);
527 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
529 gcc_checking_assert (TYPE_DOMAIN (type
)
530 == TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)));
531 TYPE_DOMAIN (new_tree
) = TYPE_DOMAIN (TYPE_MAIN_VARIANT (new_tree
));
535 TYPE_DOMAIN (new_tree
) = remap_type (TYPE_DOMAIN (new_tree
), id
);
536 /* For array bounds where we have decided not to copy over the bounds
537 variable which isn't used in OpenMP/OpenACC region, change them to
538 an uninitialized VAR_DECL temporary. */
539 if (id
->adjust_array_error_bounds
540 && TYPE_DOMAIN (new_tree
)
541 && TYPE_MAX_VALUE (TYPE_DOMAIN (new_tree
)) == error_mark_node
542 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != error_mark_node
)
544 tree v
= create_tmp_var (TREE_TYPE (TYPE_DOMAIN (new_tree
)));
546 = tree_cons (get_identifier ("omp dummy var"), NULL_TREE
,
547 DECL_ATTRIBUTES (v
));
548 TYPE_MAX_VALUE (TYPE_DOMAIN (new_tree
)) = v
;
555 case QUAL_UNION_TYPE
:
556 if (TYPE_MAIN_VARIANT (type
) != type
557 && TYPE_FIELDS (type
) == TYPE_FIELDS (TYPE_MAIN_VARIANT (type
)))
558 TYPE_FIELDS (new_tree
) = TYPE_FIELDS (TYPE_MAIN_VARIANT (new_tree
));
563 for (f
= TYPE_FIELDS (new_tree
); f
; f
= DECL_CHAIN (f
))
565 t
= remap_decl (f
, id
);
566 DECL_CONTEXT (t
) = new_tree
;
570 TYPE_FIELDS (new_tree
) = nreverse (nf
);
576 /* Shouldn't have been thought variable sized. */
580 /* All variants of type share the same size, so use the already remaped data. */
581 if (TYPE_MAIN_VARIANT (new_tree
) != new_tree
)
583 tree s
= TYPE_SIZE (type
);
584 tree mvs
= TYPE_SIZE (TYPE_MAIN_VARIANT (type
));
585 tree su
= TYPE_SIZE_UNIT (type
);
586 tree mvsu
= TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type
));
587 gcc_checking_assert ((TREE_CODE (s
) == PLACEHOLDER_EXPR
588 && (TREE_CODE (mvs
) == PLACEHOLDER_EXPR
))
590 gcc_checking_assert ((TREE_CODE (su
) == PLACEHOLDER_EXPR
591 && (TREE_CODE (mvsu
) == PLACEHOLDER_EXPR
))
593 TYPE_SIZE (new_tree
) = TYPE_SIZE (TYPE_MAIN_VARIANT (new_tree
));
594 TYPE_SIZE_UNIT (new_tree
) = TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (new_tree
));
598 walk_tree (&TYPE_SIZE (new_tree
), copy_tree_body_r
, id
, NULL
);
599 walk_tree (&TYPE_SIZE_UNIT (new_tree
), copy_tree_body_r
, id
, NULL
);
605 /* Helper function for remap_type_2, called through walk_tree. */
608 remap_type_3 (tree
*tp
, int *walk_subtrees
, void *data
)
610 copy_body_data
*id
= (copy_body_data
*) data
;
615 else if (DECL_P (*tp
) && remap_decl (*tp
, id
) != *tp
)
621 /* Return true if TYPE needs to be remapped because remap_decl on any
622 needed embedded decl returns something other than that decl. */
625 remap_type_2 (tree type
, copy_body_data
*id
)
629 #define RETURN_TRUE_IF_VAR(T) \
635 if (DECL_P (_t) && remap_decl (_t, id) != _t) \
637 if (!TYPE_SIZES_GIMPLIFIED (type) \
638 && walk_tree (&_t, remap_type_3, id, NULL)) \
644 switch (TREE_CODE (type
))
650 return remap_type_2 (TREE_TYPE (type
), id
);
654 case FIXED_POINT_TYPE
:
657 RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type
));
658 RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type
));
662 if (remap_type_2 (TREE_TYPE (type
), id
)
663 || (TYPE_DOMAIN (type
) && remap_type_2 (TYPE_DOMAIN (type
), id
)))
669 case QUAL_UNION_TYPE
:
670 for (t
= TYPE_FIELDS (type
); t
; t
= DECL_CHAIN (t
))
671 if (TREE_CODE (t
) == FIELD_DECL
)
673 RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t
));
674 RETURN_TRUE_IF_VAR (DECL_SIZE (t
));
675 RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t
));
676 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
677 RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t
));
685 RETURN_TRUE_IF_VAR (TYPE_SIZE (type
));
686 RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type
));
688 #undef RETURN_TRUE_IF_VAR
692 remap_type (tree type
, copy_body_data
*id
)
700 /* See if we have remapped this type. */
701 node
= id
->decl_map
->get (type
);
705 /* The type only needs remapping if it's variably modified. */
706 if (! variably_modified_type_p (type
, id
->src_fn
)
707 /* Don't remap if copy_decl method doesn't always return a new
708 decl and for all embedded decls returns the passed in decl. */
709 || (id
->dont_remap_vla_if_no_change
&& !remap_type_2 (type
, id
)))
711 insert_decl_map (id
, type
, type
);
715 id
->remapping_type_depth
++;
716 tmp
= remap_type_1 (type
, id
);
717 id
->remapping_type_depth
--;
722 /* Decide if DECL can be put into BLOCK_NONLOCAL_VARs. */
725 can_be_nonlocal (tree decl
, copy_body_data
*id
)
727 /* We cannot duplicate function decls. */
728 if (TREE_CODE (decl
) == FUNCTION_DECL
)
731 /* Local static vars must be non-local or we get multiple declaration
733 if (VAR_P (decl
) && !auto_var_in_fn_p (decl
, id
->src_fn
))
740 remap_decls (tree decls
, vec
<tree
, va_gc
> **nonlocalized_list
,
744 tree new_decls
= NULL_TREE
;
746 /* Remap its variables. */
747 for (old_var
= decls
; old_var
; old_var
= DECL_CHAIN (old_var
))
751 if (can_be_nonlocal (old_var
, id
))
753 /* We need to add this variable to the local decls as otherwise
754 nothing else will do so. */
755 if (VAR_P (old_var
) && ! DECL_EXTERNAL (old_var
) && cfun
)
756 add_local_decl (cfun
, old_var
);
757 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
758 && !DECL_IGNORED_P (old_var
)
759 && nonlocalized_list
)
760 vec_safe_push (*nonlocalized_list
, old_var
);
764 /* Remap the variable. */
765 new_var
= remap_decl (old_var
, id
);
767 /* If we didn't remap this variable, we can't mess with its
768 TREE_CHAIN. If we remapped this variable to the return slot, it's
769 already declared somewhere else, so don't declare it here. */
771 if (new_var
== id
->retvar
)
775 if ((!optimize
|| debug_info_level
> DINFO_LEVEL_TERSE
)
776 && !DECL_IGNORED_P (old_var
)
777 && nonlocalized_list
)
778 vec_safe_push (*nonlocalized_list
, old_var
);
782 gcc_assert (DECL_P (new_var
));
783 DECL_CHAIN (new_var
) = new_decls
;
786 /* Also copy value-expressions. */
787 if (VAR_P (new_var
) && DECL_HAS_VALUE_EXPR_P (new_var
))
789 tree tem
= DECL_VALUE_EXPR (new_var
);
790 bool old_regimplify
= id
->regimplify
;
791 id
->remapping_type_depth
++;
792 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
793 id
->remapping_type_depth
--;
794 id
->regimplify
= old_regimplify
;
795 SET_DECL_VALUE_EXPR (new_var
, tem
);
800 return nreverse (new_decls
);
803 /* Copy the BLOCK to contain remapped versions of the variables
804 therein. And hook the new block into the block-tree. */
807 remap_block (tree
*block
, copy_body_data
*id
)
812 /* Make the new block. */
814 new_block
= make_node (BLOCK
);
815 TREE_USED (new_block
) = TREE_USED (old_block
);
816 BLOCK_ABSTRACT_ORIGIN (new_block
) = BLOCK_ORIGIN (old_block
);
817 BLOCK_SOURCE_LOCATION (new_block
) = BLOCK_SOURCE_LOCATION (old_block
);
818 BLOCK_NONLOCALIZED_VARS (new_block
)
819 = vec_safe_copy (BLOCK_NONLOCALIZED_VARS (old_block
));
822 /* Remap its variables. */
823 BLOCK_VARS (new_block
) = remap_decls (BLOCK_VARS (old_block
),
824 &BLOCK_NONLOCALIZED_VARS (new_block
),
827 if (id
->transform_lang_insert_block
)
828 id
->transform_lang_insert_block (new_block
);
830 /* Remember the remapped block. */
831 insert_decl_map (id
, old_block
, new_block
);
834 /* Copy the whole block tree and root it in id->block. */
837 remap_blocks (tree block
, copy_body_data
*id
)
840 tree new_tree
= block
;
845 remap_block (&new_tree
, id
);
846 gcc_assert (new_tree
!= block
);
847 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
848 prepend_lexical_block (new_tree
, remap_blocks (t
, id
));
849 /* Blocks are in arbitrary order, but make things slightly prettier and do
850 not swap order when producing a copy. */
851 BLOCK_SUBBLOCKS (new_tree
) = blocks_nreverse (BLOCK_SUBBLOCKS (new_tree
));
855 /* Remap the block tree rooted at BLOCK to nothing. */
858 remap_blocks_to_null (tree block
, copy_body_data
*id
)
861 insert_decl_map (id
, block
, NULL_TREE
);
862 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
863 remap_blocks_to_null (t
, id
);
866 /* Remap the location info pointed to by LOCUS. */
869 remap_location (location_t locus
, copy_body_data
*id
)
871 if (LOCATION_BLOCK (locus
))
873 tree
*n
= id
->decl_map
->get (LOCATION_BLOCK (locus
));
876 return set_block (locus
, *n
);
879 locus
= LOCATION_LOCUS (locus
);
881 if (locus
!= UNKNOWN_LOCATION
&& id
->block
)
882 return set_block (locus
, id
->block
);
888 copy_statement_list (tree
*tp
)
890 tree_stmt_iterator oi
, ni
;
893 new_tree
= alloc_stmt_list ();
894 ni
= tsi_start (new_tree
);
895 oi
= tsi_start (*tp
);
896 TREE_TYPE (new_tree
) = TREE_TYPE (*tp
);
899 for (; !tsi_end_p (oi
); tsi_next (&oi
))
901 tree stmt
= tsi_stmt (oi
);
902 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
903 /* This copy is not redundant; tsi_link_after will smash this
904 STATEMENT_LIST into the end of the one we're building, and we
905 don't want to do that with the original. */
906 copy_statement_list (&stmt
);
907 tsi_link_after (&ni
, stmt
, TSI_CONTINUE_LINKING
);
912 copy_bind_expr (tree
*tp
, int *walk_subtrees
, copy_body_data
*id
)
914 tree block
= BIND_EXPR_BLOCK (*tp
);
915 /* Copy (and replace) the statement. */
916 copy_tree_r (tp
, walk_subtrees
, NULL
);
919 remap_block (&block
, id
);
920 BIND_EXPR_BLOCK (*tp
) = block
;
923 if (BIND_EXPR_VARS (*tp
))
924 /* This will remap a lot of the same decls again, but this should be
926 BIND_EXPR_VARS (*tp
) = remap_decls (BIND_EXPR_VARS (*tp
), NULL
, id
);
930 /* Create a new gimple_seq by remapping all the statements in BODY
931 using the inlining information in ID. */
934 remap_gimple_seq (gimple_seq body
, copy_body_data
*id
)
936 gimple_stmt_iterator si
;
937 gimple_seq new_body
= NULL
;
939 for (si
= gsi_start (body
); !gsi_end_p (si
); gsi_next (&si
))
941 gimple_seq new_stmts
= remap_gimple_stmt (gsi_stmt (si
), id
);
942 gimple_seq_add_seq (&new_body
, new_stmts
);
949 /* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its
950 block using the mapping information in ID. */
953 copy_gimple_bind (gbind
*stmt
, copy_body_data
*id
)
956 tree new_block
, new_vars
;
957 gimple_seq body
, new_body
;
959 /* Copy the statement. Note that we purposely don't use copy_stmt
960 here because we need to remap statements as we copy. */
961 body
= gimple_bind_body (stmt
);
962 new_body
= remap_gimple_seq (body
, id
);
964 new_block
= gimple_bind_block (stmt
);
966 remap_block (&new_block
, id
);
968 /* This will remap a lot of the same decls again, but this should be
970 new_vars
= gimple_bind_vars (stmt
);
972 new_vars
= remap_decls (new_vars
, NULL
, id
);
974 new_bind
= gimple_build_bind (new_vars
, new_body
, new_block
);
979 /* Return true if DECL is a parameter or a SSA_NAME for a parameter. */
984 if (TREE_CODE (decl
) == SSA_NAME
)
986 decl
= SSA_NAME_VAR (decl
);
991 return (TREE_CODE (decl
) == PARM_DECL
);
994 /* Remap the dependence CLIQUE from the source to the destination function
995 as specified in ID. */
997 static unsigned short
998 remap_dependence_clique (copy_body_data
*id
, unsigned short clique
)
1000 if (clique
== 0 || processing_debug_stmt
)
1002 if (!id
->dependence_map
)
1003 id
->dependence_map
= new hash_map
<dependence_hash
, unsigned short>;
1005 unsigned short &newc
= id
->dependence_map
->get_or_insert (clique
, &existed
);
1008 /* Clique 1 is reserved for local ones set by PTA. */
1009 if (cfun
->last_clique
== 0)
1010 cfun
->last_clique
= 1;
1011 newc
= ++cfun
->last_clique
;
1016 /* Remap the GIMPLE operand pointed to by *TP. DATA is really a
1017 'struct walk_stmt_info *'. DATA->INFO is a 'copy_body_data *'.
1018 WALK_SUBTREES is used to indicate walk_gimple_op whether to keep
1019 recursing into the children nodes of *TP. */
1022 remap_gimple_op_r (tree
*tp
, int *walk_subtrees
, void *data
)
1024 struct walk_stmt_info
*wi_p
= (struct walk_stmt_info
*) data
;
1025 copy_body_data
*id
= (copy_body_data
*) wi_p
->info
;
1026 tree fn
= id
->src_fn
;
1028 /* For recursive invocations this is no longer the LHS itself. */
1029 bool is_lhs
= wi_p
->is_lhs
;
1030 wi_p
->is_lhs
= false;
1032 if (TREE_CODE (*tp
) == SSA_NAME
)
1034 *tp
= remap_ssa_name (*tp
, id
);
1037 SSA_NAME_DEF_STMT (*tp
) = wi_p
->stmt
;
1040 else if (auto_var_in_fn_p (*tp
, fn
))
1042 /* Local variables and labels need to be replaced by equivalent
1043 variables. We don't want to copy static variables; there's
1044 only one of those, no matter how many times we inline the
1045 containing function. Similarly for globals from an outer
1049 /* Remap the declaration. */
1050 new_decl
= remap_decl (*tp
, id
);
1051 gcc_assert (new_decl
);
1052 /* Replace this variable with the copy. */
1053 STRIP_TYPE_NOPS (new_decl
);
1054 /* ??? The C++ frontend uses void * pointer zero to initialize
1055 any other type. This confuses the middle-end type verification.
1056 As cloned bodies do not go through gimplification again the fixup
1057 there doesn't trigger. */
1058 if (TREE_CODE (new_decl
) == INTEGER_CST
1059 && !useless_type_conversion_p (TREE_TYPE (*tp
), TREE_TYPE (new_decl
)))
1060 new_decl
= fold_convert (TREE_TYPE (*tp
), new_decl
);
1064 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
1066 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
1068 else if (TREE_CODE (*tp
) == LABEL_DECL
1069 && (!DECL_CONTEXT (*tp
)
1070 || decl_function_context (*tp
) == id
->src_fn
))
1071 /* These may need to be remapped for EH handling. */
1072 *tp
= remap_decl (*tp
, id
);
1073 else if (TREE_CODE (*tp
) == FIELD_DECL
)
1075 /* If the enclosing record type is variably_modified_type_p, the field
1076 has already been remapped. Otherwise, it need not be. */
1077 tree
*n
= id
->decl_map
->get (*tp
);
1082 else if (TYPE_P (*tp
))
1083 /* Types may need remapping as well. */
1084 *tp
= remap_type (*tp
, id
);
1085 else if (CONSTANT_CLASS_P (*tp
))
1087 /* If this is a constant, we have to copy the node iff the type
1088 will be remapped. copy_tree_r will not copy a constant. */
1089 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
1091 if (new_type
== TREE_TYPE (*tp
))
1094 else if (TREE_CODE (*tp
) == INTEGER_CST
)
1095 *tp
= wide_int_to_tree (new_type
, wi::to_wide (*tp
));
1098 *tp
= copy_node (*tp
);
1099 TREE_TYPE (*tp
) = new_type
;
1104 /* Otherwise, just copy the node. Note that copy_tree_r already
1105 knows not to copy VAR_DECLs, etc., so this is safe. */
1107 if (TREE_CODE (*tp
) == MEM_REF
&& !id
->do_not_fold
)
1109 /* We need to re-canonicalize MEM_REFs from inline substitutions
1110 that can happen when a pointer argument is an ADDR_EXPR.
1111 Recurse here manually to allow that. */
1112 tree ptr
= TREE_OPERAND (*tp
, 0);
1113 tree type
= remap_type (TREE_TYPE (*tp
), id
);
1115 walk_tree (&ptr
, remap_gimple_op_r
, data
, NULL
);
1116 *tp
= fold_build2 (MEM_REF
, type
, ptr
, TREE_OPERAND (*tp
, 1));
1117 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1118 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1119 copy_warning (*tp
, old
);
1120 if (MR_DEPENDENCE_CLIQUE (old
) != 0)
1122 MR_DEPENDENCE_CLIQUE (*tp
)
1123 = remap_dependence_clique (id
, MR_DEPENDENCE_CLIQUE (old
));
1124 MR_DEPENDENCE_BASE (*tp
) = MR_DEPENDENCE_BASE (old
);
1126 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
1127 remapped a parameter as the property might be valid only
1128 for the parameter itself. */
1129 if (TREE_THIS_NOTRAP (old
)
1130 && (!is_parm (TREE_OPERAND (old
, 0))
1131 || (!id
->transform_parameter
&& is_parm (ptr
))))
1132 TREE_THIS_NOTRAP (*tp
) = 1;
1133 REF_REVERSE_STORAGE_ORDER (*tp
) = REF_REVERSE_STORAGE_ORDER (old
);
1138 /* Here is the "usual case". Copy this tree node, and then
1139 tweak some special cases. */
1140 copy_tree_r (tp
, walk_subtrees
, NULL
);
1142 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
1143 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
1145 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
1147 /* The copied TARGET_EXPR has never been expanded, even if the
1148 original node was expanded already. */
1149 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
1150 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
1152 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
1154 /* Variable substitution need not be simple. In particular,
1155 the MEM_REF substitution above. Make sure that
1156 TREE_CONSTANT and friends are up-to-date. */
1157 int invariant
= is_gimple_min_invariant (*tp
);
1158 walk_tree (&TREE_OPERAND (*tp
, 0), remap_gimple_op_r
, data
, NULL
);
1159 recompute_tree_invariant_for_addr_expr (*tp
);
1161 /* If this used to be invariant, but is not any longer,
1162 then regimplification is probably needed. */
1163 if (invariant
&& !is_gimple_min_invariant (*tp
))
1164 id
->regimplify
= true;
1170 /* Update the TREE_BLOCK for the cloned expr. */
1173 tree new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
1174 tree old_block
= TREE_BLOCK (*tp
);
1178 n
= id
->decl_map
->get (TREE_BLOCK (*tp
));
1182 TREE_SET_BLOCK (*tp
, new_block
);
1185 /* Keep iterating. */
1190 /* Called from copy_body_id via walk_tree. DATA is really a
1191 `copy_body_data *'. */
1194 copy_tree_body_r (tree
*tp
, int *walk_subtrees
, void *data
)
1196 copy_body_data
*id
= (copy_body_data
*) data
;
1197 tree fn
= id
->src_fn
;
1200 /* Begin by recognizing trees that we'll completely rewrite for the
1201 inlining context. Our output for these trees is completely
1202 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1203 into an edge). Further down, we'll handle trees that get
1204 duplicated and/or tweaked. */
1206 /* When requested, RETURN_EXPRs should be transformed to just the
1207 contained MODIFY_EXPR. The branch semantics of the return will
1208 be handled elsewhere by manipulating the CFG rather than a statement. */
1209 if (TREE_CODE (*tp
) == RETURN_EXPR
&& id
->transform_return_to_modify
)
1211 tree assignment
= TREE_OPERAND (*tp
, 0);
1213 /* If we're returning something, just turn that into an
1214 assignment into the equivalent of the original RESULT_DECL.
1215 If the "assignment" is just the result decl, the result
1216 decl has already been set (e.g. a recent "foo (&result_decl,
1217 ...)"); just toss the entire RETURN_EXPR. */
1218 if (assignment
&& TREE_CODE (assignment
) == MODIFY_EXPR
)
1220 /* Replace the RETURN_EXPR with (a copy of) the
1221 MODIFY_EXPR hanging underneath. */
1222 *tp
= copy_node (assignment
);
1224 else /* Else the RETURN_EXPR returns no value. */
1227 return (tree
) (void *)1;
1230 else if (TREE_CODE (*tp
) == SSA_NAME
)
1232 *tp
= remap_ssa_name (*tp
, id
);
1237 /* Local variables and labels need to be replaced by equivalent
1238 variables. We don't want to copy static variables; there's only
1239 one of those, no matter how many times we inline the containing
1240 function. Similarly for globals from an outer function. */
1241 else if (auto_var_in_fn_p (*tp
, fn
))
1245 /* Remap the declaration. */
1246 new_decl
= remap_decl (*tp
, id
);
1247 gcc_assert (new_decl
);
1248 /* Replace this variable with the copy. */
1249 STRIP_TYPE_NOPS (new_decl
);
1253 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
1254 copy_statement_list (tp
);
1255 else if (TREE_CODE (*tp
) == SAVE_EXPR
1256 || TREE_CODE (*tp
) == TARGET_EXPR
)
1257 remap_save_expr (tp
, id
->decl_map
, walk_subtrees
);
1258 else if (TREE_CODE (*tp
) == LABEL_DECL
1259 && (! DECL_CONTEXT (*tp
)
1260 || decl_function_context (*tp
) == id
->src_fn
))
1261 /* These may need to be remapped for EH handling. */
1262 *tp
= remap_decl (*tp
, id
);
1263 else if (TREE_CODE (*tp
) == BIND_EXPR
)
1264 copy_bind_expr (tp
, walk_subtrees
, id
);
1265 /* Types may need remapping as well. */
1266 else if (TYPE_P (*tp
))
1267 *tp
= remap_type (*tp
, id
);
1269 /* If this is a constant, we have to copy the node iff the type will be
1270 remapped. copy_tree_r will not copy a constant. */
1271 else if (CONSTANT_CLASS_P (*tp
))
1273 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
1275 if (new_type
== TREE_TYPE (*tp
))
1278 else if (TREE_CODE (*tp
) == INTEGER_CST
)
1279 *tp
= wide_int_to_tree (new_type
, wi::to_wide (*tp
));
1282 *tp
= copy_node (*tp
);
1283 TREE_TYPE (*tp
) = new_type
;
1287 /* Otherwise, just copy the node. Note that copy_tree_r already
1288 knows not to copy VAR_DECLs, etc., so this is safe. */
1291 /* Here we handle trees that are not completely rewritten.
1292 First we detect some inlining-induced bogosities for
1294 if (TREE_CODE (*tp
) == MODIFY_EXPR
1295 && TREE_OPERAND (*tp
, 0) == TREE_OPERAND (*tp
, 1)
1296 && (auto_var_in_fn_p (TREE_OPERAND (*tp
, 0), fn
)))
1298 /* Some assignments VAR = VAR; don't generate any rtl code
1299 and thus don't count as variable modification. Avoid
1300 keeping bogosities like 0 = 0. */
1301 tree decl
= TREE_OPERAND (*tp
, 0), value
;
1304 n
= id
->decl_map
->get (decl
);
1308 STRIP_TYPE_NOPS (value
);
1309 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1311 *tp
= build_empty_stmt (EXPR_LOCATION (*tp
));
1312 return copy_tree_body_r (tp
, walk_subtrees
, data
);
1316 else if (TREE_CODE (*tp
) == INDIRECT_REF
)
1318 /* Get rid of *& from inline substitutions that can happen when a
1319 pointer argument is an ADDR_EXPR. */
1320 tree decl
= TREE_OPERAND (*tp
, 0);
1321 tree
*n
= id
->decl_map
->get (decl
);
1324 /* If we happen to get an ADDR_EXPR in n->value, strip
1325 it manually here as we'll eventually get ADDR_EXPRs
1326 which lie about their types pointed to. In this case
1327 build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
1328 but we absolutely rely on that. As fold_indirect_ref
1329 does other useful transformations, try that first, though. */
1330 tree type
= TREE_TYPE (*tp
);
1331 tree ptr
= id
->do_not_unshare
? *n
: unshare_expr (*n
);
1333 *tp
= id
->do_not_fold
? NULL
: gimple_fold_indirect_ref (ptr
);
1336 type
= remap_type (type
, id
);
1337 if (TREE_CODE (ptr
) == ADDR_EXPR
&& !id
->do_not_fold
)
1340 = fold_indirect_ref_1 (EXPR_LOCATION (ptr
), type
, ptr
);
1341 /* ??? We should either assert here or build
1342 a VIEW_CONVERT_EXPR instead of blindly leaking
1343 incompatible types to our IL. */
1345 *tp
= TREE_OPERAND (ptr
, 0);
1349 *tp
= build1 (INDIRECT_REF
, type
, ptr
);
1350 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1351 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1352 TREE_READONLY (*tp
) = TREE_READONLY (old
);
1353 /* We cannot propagate the TREE_THIS_NOTRAP flag if we
1354 have remapped a parameter as the property might be
1355 valid only for the parameter itself. */
1356 if (TREE_THIS_NOTRAP (old
)
1357 && (!is_parm (TREE_OPERAND (old
, 0))
1358 || (!id
->transform_parameter
&& is_parm (ptr
))))
1359 TREE_THIS_NOTRAP (*tp
) = 1;
1366 else if (TREE_CODE (*tp
) == MEM_REF
&& !id
->do_not_fold
)
1368 /* We need to re-canonicalize MEM_REFs from inline substitutions
1369 that can happen when a pointer argument is an ADDR_EXPR.
1370 Recurse here manually to allow that. */
1371 tree ptr
= TREE_OPERAND (*tp
, 0);
1372 tree type
= remap_type (TREE_TYPE (*tp
), id
);
1374 walk_tree (&ptr
, copy_tree_body_r
, data
, NULL
);
1375 *tp
= fold_build2 (MEM_REF
, type
, ptr
, TREE_OPERAND (*tp
, 1));
1376 TREE_THIS_VOLATILE (*tp
) = TREE_THIS_VOLATILE (old
);
1377 TREE_SIDE_EFFECTS (*tp
) = TREE_SIDE_EFFECTS (old
);
1378 copy_warning (*tp
, old
);
1379 if (MR_DEPENDENCE_CLIQUE (old
) != 0)
1381 MR_DEPENDENCE_CLIQUE (*tp
)
1382 = remap_dependence_clique (id
, MR_DEPENDENCE_CLIQUE (old
));
1383 MR_DEPENDENCE_BASE (*tp
) = MR_DEPENDENCE_BASE (old
);
1385 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
1386 remapped a parameter as the property might be valid only
1387 for the parameter itself. */
1388 if (TREE_THIS_NOTRAP (old
)
1389 && (!is_parm (TREE_OPERAND (old
, 0))
1390 || (!id
->transform_parameter
&& is_parm (ptr
))))
1391 TREE_THIS_NOTRAP (*tp
) = 1;
1392 REF_REVERSE_STORAGE_ORDER (*tp
) = REF_REVERSE_STORAGE_ORDER (old
);
1397 /* Here is the "usual case". Copy this tree node, and then
1398 tweak some special cases. */
1399 copy_tree_r (tp
, walk_subtrees
, NULL
);
1401 /* If EXPR has block defined, map it to newly constructed block.
1402 When inlining we want EXPRs without block appear in the block
1403 of function call if we are not remapping a type. */
1406 new_block
= id
->remapping_type_depth
== 0 ? id
->block
: NULL
;
1407 if (TREE_BLOCK (*tp
))
1410 n
= id
->decl_map
->get (TREE_BLOCK (*tp
));
1414 TREE_SET_BLOCK (*tp
, new_block
);
1417 if (TREE_CODE (*tp
) != OMP_CLAUSE
)
1418 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
1420 /* The copied TARGET_EXPR has never been expanded, even if the
1421 original node was expanded already. */
1422 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
1424 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
1425 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
1428 /* Variable substitution need not be simple. In particular, the
1429 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
1430 and friends are up-to-date. */
1431 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
1433 int invariant
= is_gimple_min_invariant (*tp
);
1434 walk_tree (&TREE_OPERAND (*tp
, 0), copy_tree_body_r
, id
, NULL
);
1436 /* Handle the case where we substituted an INDIRECT_REF
1437 into the operand of the ADDR_EXPR. */
1438 if (TREE_CODE (TREE_OPERAND (*tp
, 0)) == INDIRECT_REF
1439 && !id
->do_not_fold
)
1441 tree t
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0);
1442 if (TREE_TYPE (t
) != TREE_TYPE (*tp
))
1443 t
= fold_convert (remap_type (TREE_TYPE (*tp
), id
), t
);
1447 recompute_tree_invariant_for_addr_expr (*tp
);
1449 /* If this used to be invariant, but is not any longer,
1450 then regimplification is probably needed. */
1451 if (invariant
&& !is_gimple_min_invariant (*tp
))
1452 id
->regimplify
= true;
1456 else if (TREE_CODE (*tp
) == OMP_CLAUSE
1457 && (OMP_CLAUSE_CODE (*tp
) == OMP_CLAUSE_AFFINITY
1458 || OMP_CLAUSE_CODE (*tp
) == OMP_CLAUSE_DEPEND
))
1460 tree t
= OMP_CLAUSE_DECL (*tp
);
1462 && TREE_CODE (t
) == TREE_LIST
1464 && TREE_CODE (TREE_PURPOSE (t
)) == TREE_VEC
)
1467 OMP_CLAUSE_DECL (*tp
) = copy_node (t
);
1468 t
= OMP_CLAUSE_DECL (*tp
);
1469 TREE_PURPOSE (t
) = copy_node (TREE_PURPOSE (t
));
1470 for (int i
= 0; i
<= 4; i
++)
1471 walk_tree (&TREE_VEC_ELT (TREE_PURPOSE (t
), i
),
1472 copy_tree_body_r
, id
, NULL
);
1473 if (TREE_VEC_ELT (TREE_PURPOSE (t
), 5))
1474 remap_block (&TREE_VEC_ELT (TREE_PURPOSE (t
), 5), id
);
1475 walk_tree (&TREE_VALUE (t
), copy_tree_body_r
, id
, NULL
);
1480 /* Keep iterating. */
1484 /* Helper for remap_gimple_stmt. Given an EH region number for the
1485 source function, map that to the duplicate EH region number in
1486 the destination function. */
1489 remap_eh_region_nr (int old_nr
, copy_body_data
*id
)
1491 eh_region old_r
, new_r
;
1493 old_r
= get_eh_region_from_number_fn (id
->src_cfun
, old_nr
);
1494 new_r
= static_cast<eh_region
> (*id
->eh_map
->get (old_r
));
1496 return new_r
->index
;
1499 /* Similar, but operate on INTEGER_CSTs. */
1502 remap_eh_region_tree_nr (tree old_t_nr
, copy_body_data
*id
)
1506 old_nr
= tree_to_shwi (old_t_nr
);
1507 new_nr
= remap_eh_region_nr (old_nr
, id
);
1509 return build_int_cst (integer_type_node
, new_nr
);
1512 /* Helper for copy_bb. Remap statement STMT using the inlining
1513 information in ID. Return the new statement copy. */
1516 remap_gimple_stmt (gimple
*stmt
, copy_body_data
*id
)
1518 gimple
*copy
= NULL
;
1519 struct walk_stmt_info wi
;
1520 bool skip_first
= false;
1521 gimple_seq stmts
= NULL
;
1523 if (is_gimple_debug (stmt
)
1524 && (gimple_debug_nonbind_marker_p (stmt
)
1525 ? !DECL_STRUCT_FUNCTION (id
->dst_fn
)->debug_nonbind_markers
1526 : !opt_for_fn (id
->dst_fn
, flag_var_tracking_assignments
)))
1529 if (!is_gimple_debug (stmt
)
1530 && id
->param_body_adjs
1531 && id
->param_body_adjs
->m_dead_stmts
.contains (stmt
))
1533 tree
*dval
= id
->param_body_adjs
->m_dead_stmt_debug_equiv
.get (stmt
);
1537 gcc_assert (is_gimple_assign (stmt
));
1538 tree lhs
= gimple_assign_lhs (stmt
);
1539 tree
*dvar
= id
->param_body_adjs
->m_dead_ssa_debug_equiv
.get (lhs
);
1540 gdebug
*bind
= gimple_build_debug_bind (*dvar
, *dval
, stmt
);
1541 if (id
->reset_location
)
1542 gimple_set_location (bind
, input_location
);
1543 id
->debug_stmts
.safe_push (bind
);
1544 gimple_seq_add_stmt (&stmts
, bind
);
1548 /* Begin by recognizing trees that we'll completely rewrite for the
1549 inlining context. Our output for these trees is completely
1550 different from our input (e.g. RETURN_EXPR is deleted and morphs
1551 into an edge). Further down, we'll handle trees that get
1552 duplicated and/or tweaked. */
1554 /* When requested, GIMPLE_RETURN should be transformed to just the
1555 contained GIMPLE_ASSIGN. The branch semantics of the return will
1556 be handled elsewhere by manipulating the CFG rather than the
1558 if (gimple_code (stmt
) == GIMPLE_RETURN
&& id
->transform_return_to_modify
)
1560 tree retval
= gimple_return_retval (as_a
<greturn
*> (stmt
));
1562 /* If we're returning something, just turn that into an
1563 assignment to the equivalent of the original RESULT_DECL.
1564 If RETVAL is just the result decl, the result decl has
1565 already been set (e.g. a recent "foo (&result_decl, ...)");
1566 just toss the entire GIMPLE_RETURN. Likewise for when the
1567 call doesn't want the return value. */
1569 && (TREE_CODE (retval
) != RESULT_DECL
1571 || gimple_call_lhs (id
->call_stmt
) != NULL_TREE
)
1572 && (TREE_CODE (retval
) != SSA_NAME
1573 || ! SSA_NAME_VAR (retval
)
1574 || TREE_CODE (SSA_NAME_VAR (retval
)) != RESULT_DECL
)))
1576 copy
= gimple_build_assign (id
->do_not_unshare
1577 ? id
->retvar
: unshare_expr (id
->retvar
),
1579 /* id->retvar is already substituted. Skip it on later remapping. */
1585 else if (gimple_has_substatements (stmt
))
1589 /* When cloning bodies from the C++ front end, we will be handed bodies
1590 in High GIMPLE form. Handle here all the High GIMPLE statements that
1591 have embedded statements. */
1592 switch (gimple_code (stmt
))
1595 copy
= copy_gimple_bind (as_a
<gbind
*> (stmt
), id
);
1600 gcatch
*catch_stmt
= as_a
<gcatch
*> (stmt
);
1601 s1
= remap_gimple_seq (gimple_catch_handler (catch_stmt
), id
);
1602 copy
= gimple_build_catch (gimple_catch_types (catch_stmt
), s1
);
1606 case GIMPLE_EH_FILTER
:
1607 s1
= remap_gimple_seq (gimple_eh_filter_failure (stmt
), id
);
1608 copy
= gimple_build_eh_filter (gimple_eh_filter_types (stmt
), s1
);
1612 s1
= remap_gimple_seq (gimple_try_eval (stmt
), id
);
1613 s2
= remap_gimple_seq (gimple_try_cleanup (stmt
), id
);
1614 copy
= gimple_build_try (s1
, s2
, gimple_try_kind (stmt
));
1617 case GIMPLE_WITH_CLEANUP_EXPR
:
1618 s1
= remap_gimple_seq (gimple_wce_cleanup (stmt
), id
);
1619 copy
= gimple_build_wce (s1
);
1622 case GIMPLE_OMP_PARALLEL
:
1624 gomp_parallel
*omp_par_stmt
= as_a
<gomp_parallel
*> (stmt
);
1625 s1
= remap_gimple_seq (gimple_omp_body (omp_par_stmt
), id
);
1626 copy
= gimple_build_omp_parallel
1628 gimple_omp_parallel_clauses (omp_par_stmt
),
1629 gimple_omp_parallel_child_fn (omp_par_stmt
),
1630 gimple_omp_parallel_data_arg (omp_par_stmt
));
1634 case GIMPLE_OMP_TASK
:
1635 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1636 copy
= gimple_build_omp_task
1638 gimple_omp_task_clauses (stmt
),
1639 gimple_omp_task_child_fn (stmt
),
1640 gimple_omp_task_data_arg (stmt
),
1641 gimple_omp_task_copy_fn (stmt
),
1642 gimple_omp_task_arg_size (stmt
),
1643 gimple_omp_task_arg_align (stmt
));
1646 case GIMPLE_OMP_FOR
:
1647 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1648 s2
= remap_gimple_seq (gimple_omp_for_pre_body (stmt
), id
);
1649 copy
= gimple_build_omp_for (s1
, gimple_omp_for_kind (stmt
),
1650 gimple_omp_for_clauses (stmt
),
1651 gimple_omp_for_collapse (stmt
), s2
);
1654 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1656 gimple_omp_for_set_index (copy
, i
,
1657 gimple_omp_for_index (stmt
, i
));
1658 gimple_omp_for_set_initial (copy
, i
,
1659 gimple_omp_for_initial (stmt
, i
));
1660 gimple_omp_for_set_final (copy
, i
,
1661 gimple_omp_for_final (stmt
, i
));
1662 gimple_omp_for_set_incr (copy
, i
,
1663 gimple_omp_for_incr (stmt
, i
));
1664 gimple_omp_for_set_cond (copy
, i
,
1665 gimple_omp_for_cond (stmt
, i
));
1670 case GIMPLE_OMP_MASTER
:
1671 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1672 copy
= gimple_build_omp_master (s1
);
1675 case GIMPLE_OMP_MASKED
:
1676 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1677 copy
= gimple_build_omp_masked
1678 (s1
, gimple_omp_masked_clauses (stmt
));
1681 case GIMPLE_OMP_SCOPE
:
1682 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1683 copy
= gimple_build_omp_scope
1684 (s1
, gimple_omp_scope_clauses (stmt
));
1687 case GIMPLE_OMP_TASKGROUP
:
1688 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1689 copy
= gimple_build_omp_taskgroup
1690 (s1
, gimple_omp_taskgroup_clauses (stmt
));
1693 case GIMPLE_OMP_ORDERED
:
1694 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1695 copy
= gimple_build_omp_ordered
1697 gimple_omp_ordered_clauses (as_a
<gomp_ordered
*> (stmt
)));
1700 case GIMPLE_OMP_SCAN
:
1701 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1702 copy
= gimple_build_omp_scan
1703 (s1
, gimple_omp_scan_clauses (as_a
<gomp_scan
*> (stmt
)));
1706 case GIMPLE_OMP_SECTION
:
1707 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1708 copy
= gimple_build_omp_section (s1
);
1711 case GIMPLE_OMP_SECTIONS
:
1712 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1713 copy
= gimple_build_omp_sections
1714 (s1
, gimple_omp_sections_clauses (stmt
));
1717 case GIMPLE_OMP_SINGLE
:
1718 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1719 copy
= gimple_build_omp_single
1720 (s1
, gimple_omp_single_clauses (stmt
));
1723 case GIMPLE_OMP_TARGET
:
1724 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1725 copy
= gimple_build_omp_target
1726 (s1
, gimple_omp_target_kind (stmt
),
1727 gimple_omp_target_clauses (stmt
));
1730 case GIMPLE_OMP_TEAMS
:
1731 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1732 copy
= gimple_build_omp_teams
1733 (s1
, gimple_omp_teams_clauses (stmt
));
1736 case GIMPLE_OMP_CRITICAL
:
1737 s1
= remap_gimple_seq (gimple_omp_body (stmt
), id
);
1738 copy
= gimple_build_omp_critical (s1
,
1739 gimple_omp_critical_name
1740 (as_a
<gomp_critical
*> (stmt
)),
1741 gimple_omp_critical_clauses
1742 (as_a
<gomp_critical
*> (stmt
)));
1745 case GIMPLE_TRANSACTION
:
1747 gtransaction
*old_trans_stmt
= as_a
<gtransaction
*> (stmt
);
1748 gtransaction
*new_trans_stmt
;
1749 s1
= remap_gimple_seq (gimple_transaction_body (old_trans_stmt
),
1751 copy
= new_trans_stmt
= gimple_build_transaction (s1
);
1752 gimple_transaction_set_subcode (new_trans_stmt
,
1753 gimple_transaction_subcode (old_trans_stmt
));
1754 gimple_transaction_set_label_norm (new_trans_stmt
,
1755 gimple_transaction_label_norm (old_trans_stmt
));
1756 gimple_transaction_set_label_uninst (new_trans_stmt
,
1757 gimple_transaction_label_uninst (old_trans_stmt
));
1758 gimple_transaction_set_label_over (new_trans_stmt
,
1759 gimple_transaction_label_over (old_trans_stmt
));
1769 if (gimple_assign_copy_p (stmt
)
1770 && gimple_assign_lhs (stmt
) == gimple_assign_rhs1 (stmt
)
1771 && auto_var_in_fn_p (gimple_assign_lhs (stmt
), id
->src_fn
))
1773 /* Here we handle statements that are not completely rewritten.
1774 First we detect some inlining-induced bogosities for
1777 /* Some assignments VAR = VAR; don't generate any rtl code
1778 and thus don't count as variable modification. Avoid
1779 keeping bogosities like 0 = 0. */
1780 tree decl
= gimple_assign_lhs (stmt
), value
;
1783 n
= id
->decl_map
->get (decl
);
1787 STRIP_TYPE_NOPS (value
);
1788 if (TREE_CONSTANT (value
) || TREE_READONLY (value
))
1793 /* For *ptr_N ={v} {CLOBBER}, if ptr_N is SSA_NAME defined
1794 in a block that we aren't copying during tree_function_versioning,
1795 just drop the clobber stmt. */
1796 if (id
->blocks_to_copy
&& gimple_clobber_p (stmt
))
1798 tree lhs
= gimple_assign_lhs (stmt
);
1799 if (TREE_CODE (lhs
) == MEM_REF
1800 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == SSA_NAME
)
1802 gimple
*def_stmt
= SSA_NAME_DEF_STMT (TREE_OPERAND (lhs
, 0));
1803 if (gimple_bb (def_stmt
)
1804 && !bitmap_bit_p (id
->blocks_to_copy
,
1805 gimple_bb (def_stmt
)->index
))
1810 /* We do not allow CLOBBERs of handled components. In case
1811 returned value is stored via such handled component, remove
1812 the clobber so stmt verifier is happy. */
1813 if (gimple_clobber_p (stmt
)
1814 && TREE_CODE (gimple_assign_lhs (stmt
)) == RESULT_DECL
)
1816 tree remapped
= remap_decl (gimple_assign_lhs (stmt
), id
);
1817 if (!DECL_P (remapped
)
1818 && TREE_CODE (remapped
) != MEM_REF
)
1822 if (gimple_debug_bind_p (stmt
))
1824 tree var
= gimple_debug_bind_get_var (stmt
);
1825 tree value
= gimple_debug_bind_get_value (stmt
);
1826 if (id
->param_body_adjs
1827 && id
->param_body_adjs
->m_dead_stmts
.contains (stmt
))
1829 value
= unshare_expr_without_location (value
);
1830 id
->param_body_adjs
->remap_with_debug_expressions (&value
);
1833 gdebug
*copy
= gimple_build_debug_bind (var
, value
, stmt
);
1834 if (id
->reset_location
)
1835 gimple_set_location (copy
, input_location
);
1836 id
->debug_stmts
.safe_push (copy
);
1837 gimple_seq_add_stmt (&stmts
, copy
);
1840 if (gimple_debug_source_bind_p (stmt
))
1842 gdebug
*copy
= gimple_build_debug_source_bind
1843 (gimple_debug_source_bind_get_var (stmt
),
1844 gimple_debug_source_bind_get_value (stmt
),
1846 if (id
->reset_location
)
1847 gimple_set_location (copy
, input_location
);
1848 id
->debug_stmts
.safe_push (copy
);
1849 gimple_seq_add_stmt (&stmts
, copy
);
1852 if (gimple_debug_nonbind_marker_p (stmt
))
1854 /* If the inlined function has too many debug markers,
1856 if (id
->src_cfun
->debug_marker_count
1857 > param_max_debug_marker_count
1858 || id
->reset_location
)
1861 gdebug
*copy
= as_a
<gdebug
*> (gimple_copy (stmt
));
1862 id
->debug_stmts
.safe_push (copy
);
1863 gimple_seq_add_stmt (&stmts
, copy
);
1867 /* Create a new deep copy of the statement. */
1868 copy
= gimple_copy (stmt
);
1870 /* Clear flags that need revisiting. */
1871 if (gcall
*call_stmt
= dyn_cast
<gcall
*> (copy
))
1873 if (gimple_call_tail_p (call_stmt
))
1874 gimple_call_set_tail (call_stmt
, false);
1875 if (gimple_call_from_thunk_p (call_stmt
))
1876 gimple_call_set_from_thunk (call_stmt
, false);
1877 if (gimple_call_internal_p (call_stmt
))
1878 switch (gimple_call_internal_fn (call_stmt
))
1880 case IFN_GOMP_SIMD_LANE
:
1881 case IFN_GOMP_SIMD_VF
:
1882 case IFN_GOMP_SIMD_LAST_LANE
:
1883 case IFN_GOMP_SIMD_ORDERED_START
:
1884 case IFN_GOMP_SIMD_ORDERED_END
:
1885 DECL_STRUCT_FUNCTION (id
->dst_fn
)->has_simduid_loops
= true;
1892 /* Remap the region numbers for __builtin_eh_{pointer,filter},
1893 RESX and EH_DISPATCH. */
1895 switch (gimple_code (copy
))
1899 tree r
, fndecl
= gimple_call_fndecl (copy
);
1900 if (fndecl
&& fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
))
1901 switch (DECL_FUNCTION_CODE (fndecl
))
1903 case BUILT_IN_EH_COPY_VALUES
:
1904 r
= gimple_call_arg (copy
, 1);
1905 r
= remap_eh_region_tree_nr (r
, id
);
1906 gimple_call_set_arg (copy
, 1, r
);
1909 case BUILT_IN_EH_POINTER
:
1910 case BUILT_IN_EH_FILTER
:
1911 r
= gimple_call_arg (copy
, 0);
1912 r
= remap_eh_region_tree_nr (r
, id
);
1913 gimple_call_set_arg (copy
, 0, r
);
1920 /* Reset alias info if we didn't apply measures to
1921 keep it valid over inlining by setting DECL_PT_UID. */
1922 if (!id
->src_cfun
->gimple_df
1923 || !id
->src_cfun
->gimple_df
->ipa_pta
)
1924 gimple_call_reset_alias_info (as_a
<gcall
*> (copy
));
1930 gresx
*resx_stmt
= as_a
<gresx
*> (copy
);
1931 int r
= gimple_resx_region (resx_stmt
);
1932 r
= remap_eh_region_nr (r
, id
);
1933 gimple_resx_set_region (resx_stmt
, r
);
1937 case GIMPLE_EH_DISPATCH
:
1939 geh_dispatch
*eh_dispatch
= as_a
<geh_dispatch
*> (copy
);
1940 int r
= gimple_eh_dispatch_region (eh_dispatch
);
1941 r
= remap_eh_region_nr (r
, id
);
1942 gimple_eh_dispatch_set_region (eh_dispatch
, r
);
1951 /* If STMT has a block defined, map it to the newly constructed block. */
1952 if (tree block
= gimple_block (copy
))
1955 n
= id
->decl_map
->get (block
);
1957 gimple_set_block (copy
, *n
);
1959 if (id
->param_body_adjs
)
1961 gimple_seq extra_stmts
= NULL
;
1962 id
->param_body_adjs
->modify_gimple_stmt (©
, &extra_stmts
, stmt
);
1963 if (!gimple_seq_empty_p (extra_stmts
))
1965 memset (&wi
, 0, sizeof (wi
));
1967 for (gimple_stmt_iterator egsi
= gsi_start (extra_stmts
);
1970 walk_gimple_op (gsi_stmt (egsi
), remap_gimple_op_r
, &wi
);
1971 gimple_seq_add_seq (&stmts
, extra_stmts
);
1975 if (id
->reset_location
)
1976 gimple_set_location (copy
, input_location
);
1978 /* Debug statements ought to be rebuilt and not copied. */
1979 gcc_checking_assert (!is_gimple_debug (copy
));
1981 /* Remap all the operands in COPY. */
1982 memset (&wi
, 0, sizeof (wi
));
1985 walk_tree (gimple_op_ptr (copy
, 1), remap_gimple_op_r
, &wi
, NULL
);
1987 walk_gimple_op (copy
, remap_gimple_op_r
, &wi
);
1989 /* Clear the copied virtual operands. We are not remapping them here
1990 but are going to recreate them from scratch. */
1991 if (gimple_has_mem_ops (copy
))
1993 gimple_set_vdef (copy
, NULL_TREE
);
1994 gimple_set_vuse (copy
, NULL_TREE
);
1997 if (cfun
->can_throw_non_call_exceptions
)
1999 /* When inlining a function which does not have non-call exceptions
2000 enabled into a function that has (which only happens with
2001 always-inline) we have to fixup stmts that cannot throw. */
2002 if (gcond
*cond
= dyn_cast
<gcond
*> (copy
))
2003 if (gimple_could_trap_p (cond
))
2006 = gimple_build_assign (make_ssa_name (boolean_type_node
),
2007 gimple_cond_code (cond
),
2008 gimple_cond_lhs (cond
),
2009 gimple_cond_rhs (cond
));
2010 gimple_seq_add_stmt (&stmts
, cmp
);
2011 gimple_cond_set_code (cond
, NE_EXPR
);
2012 gimple_cond_set_lhs (cond
, gimple_assign_lhs (cmp
));
2013 gimple_cond_set_rhs (cond
, boolean_false_node
);
2017 gimple_seq_add_stmt (&stmts
, copy
);
2022 /* Copy basic block, scale profile accordingly. Edges will be taken care of
2026 copy_bb (copy_body_data
*id
, basic_block bb
,
2027 profile_count num
, profile_count den
)
2029 gimple_stmt_iterator gsi
, copy_gsi
, seq_gsi
;
2030 basic_block copy_basic_block
;
2034 profile_count::adjust_for_ipa_scaling (&num
, &den
);
2036 /* Search for previous copied basic block. */
2039 prev
= prev
->prev_bb
;
2041 /* create_basic_block() will append every new block to
2042 basic_block_info automatically. */
2043 copy_basic_block
= create_basic_block (NULL
, (basic_block
) prev
->aux
);
2044 copy_basic_block
->count
= bb
->count
.apply_scale (num
, den
);
2046 copy_gsi
= gsi_start_bb (copy_basic_block
);
2048 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2051 gimple
*stmt
= gsi_stmt (gsi
);
2052 gimple
*orig_stmt
= stmt
;
2053 gimple_stmt_iterator stmts_gsi
;
2054 bool stmt_added
= false;
2056 id
->regimplify
= false;
2057 stmts
= remap_gimple_stmt (stmt
, id
);
2059 if (gimple_seq_empty_p (stmts
))
2064 for (stmts_gsi
= gsi_start (stmts
);
2065 !gsi_end_p (stmts_gsi
); )
2067 stmt
= gsi_stmt (stmts_gsi
);
2069 /* Advance iterator now before stmt is moved to seq_gsi. */
2070 gsi_next (&stmts_gsi
);
2072 if (gimple_nop_p (stmt
))
2075 gimple_duplicate_stmt_histograms (cfun
, stmt
, id
->src_cfun
,
2078 /* With return slot optimization we can end up with
2079 non-gimple (foo *)&this->m, fix that here. */
2080 if (is_gimple_assign (stmt
)
2081 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
))
2082 && !is_gimple_val (gimple_assign_rhs1 (stmt
)))
2085 new_rhs
= force_gimple_operand_gsi (&seq_gsi
,
2086 gimple_assign_rhs1 (stmt
),
2088 GSI_CONTINUE_LINKING
);
2089 gimple_assign_set_rhs1 (stmt
, new_rhs
);
2090 id
->regimplify
= false;
2093 gsi_insert_after (&seq_gsi
, stmt
, GSI_NEW_STMT
);
2096 gimple_regimplify_operands (stmt
, &seq_gsi
);
2104 /* If copy_basic_block has been empty at the start of this iteration,
2105 call gsi_start_bb again to get at the newly added statements. */
2106 if (gsi_end_p (copy_gsi
))
2107 copy_gsi
= gsi_start_bb (copy_basic_block
);
2109 gsi_next (©_gsi
);
2111 /* Process the new statement. The call to gimple_regimplify_operands
2112 possibly turned the statement into multiple statements, we
2113 need to process all of them. */
2119 stmt
= gsi_stmt (copy_gsi
);
2120 call_stmt
= dyn_cast
<gcall
*> (stmt
);
2122 && gimple_call_va_arg_pack_p (call_stmt
)
2124 && ! gimple_call_va_arg_pack_p (id
->call_stmt
))
2126 /* __builtin_va_arg_pack () should be replaced by
2127 all arguments corresponding to ... in the caller. */
2131 size_t nargs_caller
= gimple_call_num_args (id
->call_stmt
);
2132 size_t nargs
= nargs_caller
;
2134 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
2136 /* Avoid crashing on invalid IL that doesn't have a
2137 varargs function or that passes not enough arguments. */
2143 /* Create the new array of arguments. */
2144 size_t nargs_callee
= gimple_call_num_args (call_stmt
);
2145 size_t n
= nargs
+ nargs_callee
;
2146 argarray
.create (n
);
2147 argarray
.safe_grow_cleared (n
, true);
2149 /* Copy all the arguments before '...' */
2151 memcpy (argarray
.address (),
2152 gimple_call_arg_ptr (call_stmt
, 0),
2153 nargs_callee
* sizeof (tree
));
2155 /* Append the arguments passed in '...' */
2157 memcpy (argarray
.address () + nargs_callee
,
2158 gimple_call_arg_ptr (id
->call_stmt
, 0)
2159 + (nargs_caller
- nargs
), nargs
* sizeof (tree
));
2161 new_call
= gimple_build_call_vec (gimple_call_fn (call_stmt
),
2164 argarray
.release ();
2166 /* Copy all GIMPLE_CALL flags, location and block, except
2167 GF_CALL_VA_ARG_PACK. */
2168 gimple_call_copy_flags (new_call
, call_stmt
);
2169 gimple_call_set_va_arg_pack (new_call
, false);
2170 gimple_call_set_fntype (new_call
, gimple_call_fntype (call_stmt
));
2171 /* location includes block. */
2172 gimple_set_location (new_call
, gimple_location (stmt
));
2173 gimple_call_set_lhs (new_call
, gimple_call_lhs (call_stmt
));
2175 gsi_replace (©_gsi
, new_call
, false);
2180 && (decl
= gimple_call_fndecl (stmt
))
2181 && fndecl_built_in_p (decl
, BUILT_IN_VA_ARG_PACK_LEN
))
2183 /* __builtin_va_arg_pack_len () should be replaced by
2184 the number of anonymous arguments. */
2185 size_t nargs
= gimple_call_num_args (id
->call_stmt
);
2189 for (p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
2192 if (!gimple_call_lhs (stmt
))
2194 /* Drop unused calls. */
2195 gsi_remove (©_gsi
, false);
2198 else if (!gimple_call_va_arg_pack_p (id
->call_stmt
))
2200 count
= build_int_cst (integer_type_node
, nargs
);
2201 new_stmt
= gimple_build_assign (gimple_call_lhs (stmt
), count
);
2202 gsi_replace (©_gsi
, new_stmt
, false);
2205 else if (nargs
!= 0)
2207 tree newlhs
= create_tmp_reg_or_ssa_name (integer_type_node
);
2208 count
= build_int_cst (integer_type_node
, nargs
);
2209 new_stmt
= gimple_build_assign (gimple_call_lhs (stmt
),
2210 PLUS_EXPR
, newlhs
, count
);
2211 gimple_call_set_lhs (stmt
, newlhs
);
2212 gsi_insert_after (©_gsi
, new_stmt
, GSI_NEW_STMT
);
2217 && gimple_call_internal_p (stmt
)
2218 && gimple_call_internal_fn (stmt
) == IFN_TSAN_FUNC_EXIT
)
2220 /* Drop TSAN_FUNC_EXIT () internal calls during inlining. */
2221 gsi_remove (©_gsi
, false);
2225 /* Statements produced by inlining can be unfolded, especially
2226 when we constant propagated some operands. We can't fold
2227 them right now for two reasons:
2228 1) folding require SSA_NAME_DEF_STMTs to be correct
2229 2) we can't change function calls to builtins.
2230 So we just mark statement for later folding. We mark
2231 all new statements, instead just statements that has changed
2232 by some nontrivial substitution so even statements made
2233 foldable indirectly are updated. If this turns out to be
2234 expensive, copy_body can be told to watch for nontrivial
2236 if (id
->statements_to_fold
)
2237 id
->statements_to_fold
->add (stmt
);
2239 /* We're duplicating a CALL_EXPR. Find any corresponding
2240 callgraph edges and update or duplicate them. */
2241 if (gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
))
2243 struct cgraph_edge
*edge
;
2245 switch (id
->transform_call_graph_edges
)
2247 case CB_CGE_DUPLICATE
:
2248 edge
= id
->src_node
->get_edge (orig_stmt
);
2251 struct cgraph_edge
*old_edge
= edge
;
2253 /* A speculative call is consist of multiple
2254 edges - indirect edge and one or more direct edges
2255 Duplicate the whole thing and distribute frequencies
2257 if (edge
->speculative
)
2260 profile_count direct_cnt
2261 = profile_count::zero ();
2263 /* First figure out the distribution of counts
2264 so we can re-scale BB profile accordingly. */
2265 for (cgraph_edge
*e
= old_edge
; e
;
2266 e
= e
->next_speculative_call_target ())
2267 direct_cnt
= direct_cnt
+ e
->count
;
2269 cgraph_edge
*indirect
2270 = old_edge
->speculative_call_indirect_edge ();
2271 profile_count indir_cnt
= indirect
->count
;
2273 /* Next iterate all direct edges, clone it and its
2274 corresponding reference and update profile. */
2275 for (cgraph_edge
*e
= old_edge
;
2277 e
= e
->next_speculative_call_target ())
2279 profile_count cnt
= e
->count
;
2281 id
->dst_node
->clone_reference
2282 (e
->speculative_call_target_ref (), stmt
);
2283 edge
= e
->clone (id
->dst_node
, call_stmt
,
2284 gimple_uid (stmt
), num
, den
,
2286 profile_probability prob
2287 = cnt
.probability_in (direct_cnt
2290 = copy_basic_block
->count
.apply_probability
2295 (indirect
->num_speculative_call_targets_p ()
2298 /* Duplicate the indirect edge after all direct edges
2300 indirect
= indirect
->clone (id
->dst_node
, call_stmt
,
2305 profile_probability prob
2306 = indir_cnt
.probability_in (direct_cnt
2309 = copy_basic_block
->count
.apply_probability (prob
);
2313 edge
= edge
->clone (id
->dst_node
, call_stmt
,
2317 edge
->count
= copy_basic_block
->count
;
2322 case CB_CGE_MOVE_CLONES
:
2323 id
->dst_node
->set_call_stmt_including_clones (orig_stmt
,
2325 edge
= id
->dst_node
->get_edge (stmt
);
2329 edge
= id
->dst_node
->get_edge (orig_stmt
);
2331 edge
= cgraph_edge::set_call_stmt (edge
, call_stmt
);
2338 /* Constant propagation on argument done during inlining
2339 may create new direct call. Produce an edge for it. */
2341 || (edge
->indirect_inlining_edge
2342 && id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
))
2343 && id
->dst_node
->definition
2344 && (fn
= gimple_call_fndecl (stmt
)) != NULL
)
2346 struct cgraph_node
*dest
= cgraph_node::get_create (fn
);
2348 /* We have missing edge in the callgraph. This can happen
2349 when previous inlining turned an indirect call into a
2350 direct call by constant propagating arguments or we are
2351 producing dead clone (for further cloning). In all
2352 other cases we hit a bug (incorrect node sharing is the
2353 most common reason for missing edges). */
2354 gcc_assert (!dest
->definition
2355 || dest
->address_taken
2356 || !id
->src_node
->definition
2357 || !id
->dst_node
->definition
);
2358 if (id
->transform_call_graph_edges
== CB_CGE_MOVE_CLONES
)
2359 id
->dst_node
->create_edge_including_clones
2360 (dest
, orig_stmt
, call_stmt
, bb
->count
,
2361 CIF_ORIGINALLY_INDIRECT_CALL
);
2363 id
->dst_node
->create_edge (dest
, call_stmt
,
2364 bb
->count
)->inline_failed
2365 = CIF_ORIGINALLY_INDIRECT_CALL
;
2368 fprintf (dump_file
, "Created new direct edge to %s\n",
2369 dest
->dump_name ());
2373 notice_special_calls (as_a
<gcall
*> (stmt
));
2376 maybe_duplicate_eh_stmt_fn (cfun
, stmt
, id
->src_cfun
, orig_stmt
,
2377 id
->eh_map
, id
->eh_lp_nr
);
2379 gsi_next (©_gsi
);
2381 while (!gsi_end_p (copy_gsi
));
2383 copy_gsi
= gsi_last_bb (copy_basic_block
);
2386 return copy_basic_block
;
2389 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
2390 form is quite easy, since dominator relationship for old basic blocks does
2393 There is however exception where inlining might change dominator relation
2394 across EH edges from basic block within inlined functions destinating
2395 to landing pads in function we inline into.
2397 The function fills in PHI_RESULTs of such PHI nodes if they refer
2398 to gimple regs. Otherwise, the function mark PHI_RESULT of such
2399 PHI nodes for renaming. For non-gimple regs, renaming is safe: the
2400 EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
2401 set, and this means that there will be no overlapping live ranges
2402 for the underlying symbol.
2404 This might change in future if we allow redirecting of EH edges and
2405 we might want to change way build CFG pre-inlining to include
2406 all the possible edges then. */
2408 update_ssa_across_abnormal_edges (basic_block bb
, basic_block ret_bb
,
2409 bool can_throw
, bool nonlocal_goto
)
2414 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
2416 || ((basic_block
)e
->dest
->aux
)->index
== ENTRY_BLOCK
)
2422 gcc_assert (e
->flags
& EDGE_EH
);
2425 gcc_assert (!(e
->flags
& EDGE_EH
));
2427 for (si
= gsi_start_phis (e
->dest
); !gsi_end_p (si
); gsi_next (&si
))
2433 /* For abnormal goto/call edges the receiver can be the
2434 ENTRY_BLOCK. Do not assert this cannot happen. */
2436 gcc_assert ((e
->flags
& EDGE_EH
)
2437 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi
)));
2439 re
= find_edge (ret_bb
, e
->dest
);
2440 gcc_checking_assert (re
);
2441 gcc_assert ((re
->flags
& (EDGE_EH
| EDGE_ABNORMAL
))
2442 == (e
->flags
& (EDGE_EH
| EDGE_ABNORMAL
)));
2444 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, e
),
2445 USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi
, re
)));
2450 /* Insert clobbers for automatic variables of inlined ID->src_fn
2451 function at the start of basic block ID->eh_landing_pad_dest. */
2454 add_clobbers_to_eh_landing_pad (copy_body_data
*id
)
2457 basic_block bb
= id
->eh_landing_pad_dest
;
2458 live_vars_map
*vars
= NULL
;
2459 unsigned int cnt
= 0;
2461 FOR_EACH_VEC_SAFE_ELT (id
->src_cfun
->local_decls
, i
, var
)
2463 && !DECL_HARD_REGISTER (var
)
2464 && !TREE_THIS_VOLATILE (var
)
2465 && !DECL_HAS_VALUE_EXPR_P (var
)
2466 && !is_gimple_reg (var
)
2467 && auto_var_in_fn_p (var
, id
->src_fn
)
2468 && !lookup_attribute ("omp simd array", DECL_ATTRIBUTES (var
)))
2470 tree
*t
= id
->decl_map
->get (var
);
2475 && !DECL_HARD_REGISTER (new_var
)
2476 && !TREE_THIS_VOLATILE (new_var
)
2477 && !DECL_HAS_VALUE_EXPR_P (new_var
)
2478 && !is_gimple_reg (new_var
)
2479 && auto_var_in_fn_p (new_var
, id
->dst_fn
))
2482 vars
= new live_vars_map
;
2483 vars
->put (DECL_UID (var
), cnt
++);
2489 vec
<bitmap_head
> live
= compute_live_vars (id
->src_cfun
, vars
);
2490 FOR_EACH_VEC_SAFE_ELT (id
->src_cfun
->local_decls
, i
, var
)
2495 bool needed
= false;
2496 unsigned int *v
= vars
->get (DECL_UID (var
));
2499 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
2500 if ((e
->flags
& EDGE_EH
) != 0
2501 && e
->src
->index
>= id
->add_clobbers_to_eh_landing_pads
)
2503 basic_block src_bb
= (basic_block
) e
->src
->aux
;
2505 if (bitmap_bit_p (&live
[src_bb
->index
], *v
))
2513 tree new_var
= *id
->decl_map
->get (var
);
2514 gimple_stmt_iterator gsi
= gsi_after_labels (bb
);
2515 tree clobber
= build_clobber (TREE_TYPE (new_var
));
2516 gimple
*clobber_stmt
= gimple_build_assign (new_var
, clobber
);
2517 gsi_insert_before (&gsi
, clobber_stmt
, GSI_NEW_STMT
);
2520 destroy_live_vars (live
);
2524 /* Copy edges from BB into its copy constructed earlier, scale profile
2525 accordingly. Edges will be taken care of later. Assume aux
2526 pointers to point to the copies of each BB. Return true if any
2527 debug stmts are left after a statement that must end the basic block. */
2530 copy_edges_for_bb (basic_block bb
, profile_count num
, profile_count den
,
2531 basic_block ret_bb
, basic_block abnormal_goto_dest
,
2534 basic_block new_bb
= (basic_block
) bb
->aux
;
2537 gimple_stmt_iterator si
;
2538 bool need_debug_cleanup
= false;
2540 /* Use the indices from the original blocks to create edges for the
2542 FOR_EACH_EDGE (old_edge
, ei
, bb
->succs
)
2543 if (!(old_edge
->flags
& EDGE_EH
))
2546 int flags
= old_edge
->flags
;
2547 location_t locus
= old_edge
->goto_locus
;
2549 /* Return edges do get a FALLTHRU flag when they get inlined. */
2550 if (old_edge
->dest
->index
== EXIT_BLOCK
2551 && !(flags
& (EDGE_TRUE_VALUE
|EDGE_FALSE_VALUE
|EDGE_FAKE
))
2552 && old_edge
->dest
->aux
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
2553 flags
|= EDGE_FALLTHRU
;
2556 = make_edge (new_bb
, (basic_block
) old_edge
->dest
->aux
, flags
);
2557 new_edge
->probability
= old_edge
->probability
;
2558 if (!id
->reset_location
)
2559 new_edge
->goto_locus
= remap_location (locus
, id
);
2562 if (bb
->index
== ENTRY_BLOCK
|| bb
->index
== EXIT_BLOCK
)
2565 /* When doing function splitting, we must decrease count of the return block
2566 which was previously reachable by block we did not copy. */
2567 if (single_succ_p (bb
) && single_succ_edge (bb
)->dest
->index
== EXIT_BLOCK
)
2568 FOR_EACH_EDGE (old_edge
, ei
, bb
->preds
)
2569 if (old_edge
->src
->index
!= ENTRY_BLOCK
2570 && !old_edge
->src
->aux
)
2571 new_bb
->count
-= old_edge
->count ().apply_scale (num
, den
);
2573 for (si
= gsi_start_bb (new_bb
); !gsi_end_p (si
);)
2576 bool can_throw
, nonlocal_goto
;
2578 copy_stmt
= gsi_stmt (si
);
2579 if (!is_gimple_debug (copy_stmt
))
2580 update_stmt (copy_stmt
);
2582 /* Do this before the possible split_block. */
2585 /* If this tree could throw an exception, there are two
2586 cases where we need to add abnormal edge(s): the
2587 tree wasn't in a region and there is a "current
2588 region" in the caller; or the original tree had
2589 EH edges. In both cases split the block after the tree,
2590 and add abnormal edge(s) as needed; we need both
2591 those from the callee and the caller.
2592 We check whether the copy can throw, because the const
2593 propagation can change an INDIRECT_REF which throws
2594 into a COMPONENT_REF which doesn't. If the copy
2595 can throw, the original could also throw. */
2596 can_throw
= stmt_can_throw_internal (cfun
, copy_stmt
);
2598 = (stmt_can_make_abnormal_goto (copy_stmt
)
2599 && !computed_goto_p (copy_stmt
));
2601 if (can_throw
|| nonlocal_goto
)
2603 if (!gsi_end_p (si
))
2605 while (!gsi_end_p (si
) && is_gimple_debug (gsi_stmt (si
)))
2608 need_debug_cleanup
= true;
2610 if (!gsi_end_p (si
))
2611 /* Note that bb's predecessor edges aren't necessarily
2612 right at this point; split_block doesn't care. */
2614 edge e
= split_block (new_bb
, copy_stmt
);
2617 new_bb
->aux
= e
->src
->aux
;
2618 si
= gsi_start_bb (new_bb
);
2622 bool update_probs
= false;
2624 if (gimple_code (copy_stmt
) == GIMPLE_EH_DISPATCH
)
2626 make_eh_dispatch_edges (as_a
<geh_dispatch
*> (copy_stmt
));
2627 update_probs
= true;
2631 make_eh_edges (copy_stmt
);
2632 update_probs
= true;
2635 /* EH edges may not match old edges. Copy as much as possible. */
2640 basic_block copy_stmt_bb
= gimple_bb (copy_stmt
);
2642 FOR_EACH_EDGE (old_edge
, ei
, bb
->succs
)
2643 if ((old_edge
->flags
& EDGE_EH
)
2644 && (e
= find_edge (copy_stmt_bb
,
2645 (basic_block
) old_edge
->dest
->aux
))
2646 && (e
->flags
& EDGE_EH
))
2647 e
->probability
= old_edge
->probability
;
2649 FOR_EACH_EDGE (e
, ei
, copy_stmt_bb
->succs
)
2650 if (e
->flags
& EDGE_EH
)
2652 if (!e
->probability
.initialized_p ())
2653 e
->probability
= profile_probability::never ();
2654 if (e
->dest
->index
< id
->add_clobbers_to_eh_landing_pads
)
2656 if (id
->eh_landing_pad_dest
== NULL
)
2657 id
->eh_landing_pad_dest
= e
->dest
;
2659 gcc_assert (id
->eh_landing_pad_dest
== e
->dest
);
2665 /* If the call we inline cannot make abnormal goto do not add
2666 additional abnormal edges but only retain those already present
2667 in the original function body. */
2668 if (abnormal_goto_dest
== NULL
)
2669 nonlocal_goto
= false;
2672 basic_block copy_stmt_bb
= gimple_bb (copy_stmt
);
2674 if (get_abnormal_succ_dispatcher (copy_stmt_bb
))
2675 nonlocal_goto
= false;
2676 /* ABNORMAL_DISPATCHER (1) is for longjmp/setjmp or nonlocal gotos
2677 in OpenMP regions which aren't allowed to be left abnormally.
2678 So, no need to add abnormal edge in that case. */
2679 else if (is_gimple_call (copy_stmt
)
2680 && gimple_call_internal_p (copy_stmt
)
2681 && (gimple_call_internal_fn (copy_stmt
)
2682 == IFN_ABNORMAL_DISPATCHER
)
2683 && gimple_call_arg (copy_stmt
, 0) == boolean_true_node
)
2684 nonlocal_goto
= false;
2686 make_single_succ_edge (copy_stmt_bb
, abnormal_goto_dest
,
2690 if ((can_throw
|| nonlocal_goto
)
2691 && gimple_in_ssa_p (cfun
))
2692 update_ssa_across_abnormal_edges (gimple_bb (copy_stmt
), ret_bb
,
2693 can_throw
, nonlocal_goto
);
2695 return need_debug_cleanup
;
2698 /* Copy the PHIs. All blocks and edges are copied, some blocks
2699 was possibly split and new outgoing EH edges inserted.
2700 BB points to the block of original function and AUX pointers links
2701 the original and newly copied blocks. */
2704 copy_phis_for_bb (basic_block bb
, copy_body_data
*id
)
2706 basic_block
const new_bb
= (basic_block
) bb
->aux
;
2711 bool inserted
= false;
2713 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
2719 res
= PHI_RESULT (phi
);
2721 if (!virtual_operand_p (res
)
2722 && (!id
->param_body_adjs
2723 || !id
->param_body_adjs
->m_dead_stmts
.contains (phi
)))
2725 walk_tree (&new_res
, copy_tree_body_r
, id
, NULL
);
2726 if (EDGE_COUNT (new_bb
->preds
) == 0)
2728 /* Technically we'd want a SSA_DEFAULT_DEF here... */
2729 SSA_NAME_DEF_STMT (new_res
) = gimple_build_nop ();
2733 new_phi
= create_phi_node (new_res
, new_bb
);
2734 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2736 edge old_edge
= find_edge ((basic_block
) new_edge
->src
->aux
,
2743 /* When doing partial cloning, we allow PHIs on the entry
2744 block as long as all the arguments are the same.
2745 Find any input edge to see argument to copy. */
2747 FOR_EACH_EDGE (old_edge
, ei2
, bb
->preds
)
2748 if (!old_edge
->src
->aux
)
2751 arg
= PHI_ARG_DEF_FROM_EDGE (phi
, old_edge
);
2753 walk_tree (&new_arg
, copy_tree_body_r
, id
, NULL
);
2754 gcc_assert (new_arg
);
2755 /* With return slot optimization we can end up with
2756 non-gimple (foo *)&this->m, fix that here. */
2757 if (TREE_CODE (new_arg
) != SSA_NAME
2758 && TREE_CODE (new_arg
) != FUNCTION_DECL
2759 && !is_gimple_val (new_arg
))
2761 gimple_seq stmts
= NULL
;
2762 new_arg
= force_gimple_operand (new_arg
, &stmts
, true,
2764 gsi_insert_seq_on_edge (new_edge
, stmts
);
2767 locus
= gimple_phi_arg_location_from_edge (phi
, old_edge
);
2768 if (id
->reset_location
)
2769 locus
= input_location
;
2771 locus
= remap_location (locus
, id
);
2772 add_phi_arg (new_phi
, new_arg
, new_edge
, locus
);
2778 /* Commit the delayed edge insertions. */
2780 FOR_EACH_EDGE (new_edge
, ei
, new_bb
->preds
)
2781 gsi_commit_one_edge_insert (new_edge
, NULL
);
2785 /* Wrapper for remap_decl so it can be used as a callback. */
2788 remap_decl_1 (tree decl
, void *data
)
2790 return remap_decl (decl
, (copy_body_data
*) data
);
2793 /* Build struct function and associated datastructures for the new clone
2794 NEW_FNDECL to be build. CALLEE_FNDECL is the original. Function changes
2795 the cfun to the function of new_fndecl (and current_function_decl too). */
2798 initialize_cfun (tree new_fndecl
, tree callee_fndecl
, profile_count count
)
2800 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
2802 if (!DECL_ARGUMENTS (new_fndecl
))
2803 DECL_ARGUMENTS (new_fndecl
) = DECL_ARGUMENTS (callee_fndecl
);
2804 if (!DECL_RESULT (new_fndecl
))
2805 DECL_RESULT (new_fndecl
) = DECL_RESULT (callee_fndecl
);
2807 /* Register specific tree functions. */
2808 gimple_register_cfg_hooks ();
2810 /* Get clean struct function. */
2811 push_struct_function (new_fndecl
);
2813 /* We will rebuild these, so just sanity check that they are empty. */
2814 gcc_assert (VALUE_HISTOGRAMS (cfun
) == NULL
);
2815 gcc_assert (cfun
->local_decls
== NULL
);
2816 gcc_assert (cfun
->cfg
== NULL
);
2817 gcc_assert (cfun
->decl
== new_fndecl
);
2819 /* Copy items we preserve during cloning. */
2820 cfun
->static_chain_decl
= src_cfun
->static_chain_decl
;
2821 cfun
->nonlocal_goto_save_area
= src_cfun
->nonlocal_goto_save_area
;
2822 cfun
->function_end_locus
= src_cfun
->function_end_locus
;
2823 cfun
->curr_properties
= src_cfun
->curr_properties
;
2824 cfun
->last_verified
= src_cfun
->last_verified
;
2825 cfun
->va_list_gpr_size
= src_cfun
->va_list_gpr_size
;
2826 cfun
->va_list_fpr_size
= src_cfun
->va_list_fpr_size
;
2827 cfun
->has_nonlocal_label
= src_cfun
->has_nonlocal_label
;
2828 cfun
->calls_eh_return
= src_cfun
->calls_eh_return
;
2829 cfun
->stdarg
= src_cfun
->stdarg
;
2830 cfun
->after_inlining
= src_cfun
->after_inlining
;
2831 cfun
->can_throw_non_call_exceptions
2832 = src_cfun
->can_throw_non_call_exceptions
;
2833 cfun
->can_delete_dead_exceptions
= src_cfun
->can_delete_dead_exceptions
;
2834 cfun
->returns_struct
= src_cfun
->returns_struct
;
2835 cfun
->returns_pcc_struct
= src_cfun
->returns_pcc_struct
;
2837 init_empty_tree_cfg ();
2839 profile_status_for_fn (cfun
) = profile_status_for_fn (src_cfun
);
2841 profile_count num
= count
;
2842 profile_count den
= ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
;
2843 profile_count::adjust_for_ipa_scaling (&num
, &den
);
2845 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
=
2846 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
.apply_scale (count
,
2847 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
);
2848 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
=
2849 EXIT_BLOCK_PTR_FOR_FN (src_cfun
)->count
.apply_scale (count
,
2850 ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
);
2852 init_eh_for_function ();
2854 if (src_cfun
->gimple_df
)
2856 init_tree_ssa (cfun
);
2857 cfun
->gimple_df
->in_ssa_p
= src_cfun
->gimple_df
->in_ssa_p
;
2858 if (cfun
->gimple_df
->in_ssa_p
)
2859 init_ssa_operands (cfun
);
2863 /* Helper function for copy_cfg_body. Move debug stmts from the end
2864 of NEW_BB to the beginning of successor basic blocks when needed. If the
2865 successor has multiple predecessors, reset them, otherwise keep
2869 maybe_move_debug_stmts_to_successors (copy_body_data
*id
, basic_block new_bb
)
2873 gimple_stmt_iterator si
= gsi_last_nondebug_bb (new_bb
);
2876 || gsi_one_before_end_p (si
)
2877 || !(stmt_can_throw_internal (cfun
, gsi_stmt (si
))
2878 || stmt_can_make_abnormal_goto (gsi_stmt (si
))))
2881 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
2883 gimple_stmt_iterator ssi
= gsi_last_bb (new_bb
);
2884 gimple_stmt_iterator dsi
= gsi_after_labels (e
->dest
);
2885 while (is_gimple_debug (gsi_stmt (ssi
)))
2887 gimple
*stmt
= gsi_stmt (ssi
);
2892 /* For the last edge move the debug stmts instead of copying
2894 if (ei_one_before_end_p (ei
))
2898 if (!single_pred_p (e
->dest
) && gimple_debug_bind_p (stmt
))
2900 gimple_debug_bind_reset_value (stmt
);
2901 gimple_set_location (stmt
, UNKNOWN_LOCATION
);
2903 gsi_remove (&si
, false);
2904 gsi_insert_before (&dsi
, stmt
, GSI_NEW_STMT
);
2908 if (gimple_debug_bind_p (stmt
))
2910 var
= gimple_debug_bind_get_var (stmt
);
2911 if (single_pred_p (e
->dest
))
2913 value
= gimple_debug_bind_get_value (stmt
);
2914 value
= unshare_expr (value
);
2915 new_stmt
= gimple_build_debug_bind (var
, value
, stmt
);
2918 new_stmt
= gimple_build_debug_bind (var
, NULL_TREE
, NULL
);
2920 else if (gimple_debug_source_bind_p (stmt
))
2922 var
= gimple_debug_source_bind_get_var (stmt
);
2923 value
= gimple_debug_source_bind_get_value (stmt
);
2924 new_stmt
= gimple_build_debug_source_bind (var
, value
, stmt
);
2926 else if (gimple_debug_nonbind_marker_p (stmt
))
2927 new_stmt
= as_a
<gdebug
*> (gimple_copy (stmt
));
2930 gsi_insert_before (&dsi
, new_stmt
, GSI_NEW_STMT
);
2931 id
->debug_stmts
.safe_push (new_stmt
);
2937 /* Make a copy of the sub-loops of SRC_PARENT and place them
2938 as siblings of DEST_PARENT. */
2941 copy_loops (copy_body_data
*id
,
2942 class loop
*dest_parent
, class loop
*src_parent
)
2944 class loop
*src_loop
= src_parent
->inner
;
2947 if (!id
->blocks_to_copy
2948 || bitmap_bit_p (id
->blocks_to_copy
, src_loop
->header
->index
))
2950 class loop
*dest_loop
= alloc_loop ();
2952 /* Assign the new loop its header and latch and associate
2953 those with the new loop. */
2954 dest_loop
->header
= (basic_block
)src_loop
->header
->aux
;
2955 dest_loop
->header
->loop_father
= dest_loop
;
2956 if (src_loop
->latch
!= NULL
)
2958 dest_loop
->latch
= (basic_block
)src_loop
->latch
->aux
;
2959 dest_loop
->latch
->loop_father
= dest_loop
;
2962 /* Copy loop meta-data. */
2963 copy_loop_info (src_loop
, dest_loop
);
2964 if (dest_loop
->unroll
)
2965 cfun
->has_unroll
= true;
2966 if (dest_loop
->force_vectorize
)
2967 cfun
->has_force_vectorize_loops
= true;
2968 if (id
->src_cfun
->last_clique
!= 0)
2969 dest_loop
->owned_clique
2970 = remap_dependence_clique (id
,
2971 src_loop
->owned_clique
2972 ? src_loop
->owned_clique
: 1);
2974 /* Finally place it into the loop array and the loop tree. */
2975 place_new_loop (cfun
, dest_loop
);
2976 flow_loop_tree_node_add (dest_parent
, dest_loop
);
2978 if (src_loop
->simduid
)
2980 dest_loop
->simduid
= remap_decl (src_loop
->simduid
, id
);
2981 cfun
->has_simduid_loops
= true;
2985 copy_loops (id
, dest_loop
, src_loop
);
2987 src_loop
= src_loop
->next
;
2991 /* Call redirect_call_stmt_to_callee on all calls in BB. */
2994 redirect_all_calls (copy_body_data
* id
, basic_block bb
)
2996 gimple_stmt_iterator si
;
2997 gimple
*last
= last_stmt (bb
);
2998 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
3000 gimple
*stmt
= gsi_stmt (si
);
3001 if (is_gimple_call (stmt
))
3003 tree old_lhs
= gimple_call_lhs (stmt
);
3004 struct cgraph_edge
*edge
= id
->dst_node
->get_edge (stmt
);
3008 = cgraph_edge::redirect_call_stmt_to_callee (edge
);
3009 /* If IPA-SRA transformation, run as part of edge redirection,
3010 removed the LHS because it is unused, save it to
3011 killed_new_ssa_names so that we can prune it from debug
3014 && TREE_CODE (old_lhs
) == SSA_NAME
3015 && !gimple_call_lhs (new_stmt
))
3017 if (!id
->killed_new_ssa_names
)
3018 id
->killed_new_ssa_names
= new hash_set
<tree
> (16);
3019 id
->killed_new_ssa_names
->add (old_lhs
);
3022 if (stmt
== last
&& id
->call_stmt
&& maybe_clean_eh_stmt (stmt
))
3023 gimple_purge_dead_eh_edges (bb
);
3029 /* Make a copy of the body of FN so that it can be inserted inline in
3030 another function. Walks FN via CFG, returns new fndecl. */
3033 copy_cfg_body (copy_body_data
* id
,
3034 basic_block entry_block_map
, basic_block exit_block_map
,
3035 basic_block new_entry
)
3037 tree callee_fndecl
= id
->src_fn
;
3038 /* Original cfun for the callee, doesn't change. */
3039 struct function
*src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
3040 struct function
*cfun_to_copy
;
3042 tree new_fndecl
= NULL
;
3043 bool need_debug_cleanup
= false;
3045 profile_count den
= ENTRY_BLOCK_PTR_FOR_FN (src_cfun
)->count
;
3046 profile_count num
= entry_block_map
->count
;
3048 cfun_to_copy
= id
->src_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
3050 /* Register specific tree functions. */
3051 gimple_register_cfg_hooks ();
3053 /* If we are inlining just region of the function, make sure to connect
3054 new entry to ENTRY_BLOCK_PTR_FOR_FN (cfun). Since new entry can be
3055 part of loop, we must compute frequency and probability of
3056 ENTRY_BLOCK_PTR_FOR_FN (cfun) based on the frequencies and
3057 probabilities of edges incoming from nonduplicated region. */
3062 den
= profile_count::zero ();
3064 FOR_EACH_EDGE (e
, ei
, new_entry
->preds
)
3067 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= den
;
3070 profile_count::adjust_for_ipa_scaling (&num
, &den
);
3072 /* Must have a CFG here at this point. */
3073 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN
3074 (DECL_STRUCT_FUNCTION (callee_fndecl
)));
3077 ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy
)->aux
= entry_block_map
;
3078 EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy
)->aux
= exit_block_map
;
3079 entry_block_map
->aux
= ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy
);
3080 exit_block_map
->aux
= EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy
);
3082 /* Duplicate any exception-handling regions. */
3084 id
->eh_map
= duplicate_eh_regions (cfun_to_copy
, NULL
, id
->eh_lp_nr
,
3087 /* Use aux pointers to map the original blocks to copy. */
3088 FOR_EACH_BB_FN (bb
, cfun_to_copy
)
3089 if (!id
->blocks_to_copy
|| bitmap_bit_p (id
->blocks_to_copy
, bb
->index
))
3091 basic_block new_bb
= copy_bb (id
, bb
, num
, den
);
3094 new_bb
->loop_father
= entry_block_map
->loop_father
;
3097 last
= last_basic_block_for_fn (cfun
);
3099 /* Now that we've duplicated the blocks, duplicate their edges. */
3100 basic_block abnormal_goto_dest
= NULL
;
3102 && stmt_can_make_abnormal_goto (id
->call_stmt
))
3104 gimple_stmt_iterator gsi
= gsi_for_stmt (id
->call_stmt
);
3106 bb
= gimple_bb (id
->call_stmt
);
3108 if (gsi_end_p (gsi
))
3109 abnormal_goto_dest
= get_abnormal_succ_dispatcher (bb
);
3111 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
3112 if (!id
->blocks_to_copy
3113 || (bb
->index
> 0 && bitmap_bit_p (id
->blocks_to_copy
, bb
->index
)))
3114 need_debug_cleanup
|= copy_edges_for_bb (bb
, num
, den
, exit_block_map
,
3115 abnormal_goto_dest
, id
);
3117 if (id
->eh_landing_pad_dest
)
3119 add_clobbers_to_eh_landing_pad (id
);
3120 id
->eh_landing_pad_dest
= NULL
;
3125 edge e
= make_edge (entry_block_map
, (basic_block
)new_entry
->aux
,
3127 e
->probability
= profile_probability::always ();
3130 /* Duplicate the loop tree, if available and wanted. */
3131 if (loops_for_fn (src_cfun
) != NULL
3132 && current_loops
!= NULL
)
3134 copy_loops (id
, entry_block_map
->loop_father
,
3135 get_loop (src_cfun
, 0));
3136 /* Defer to cfgcleanup to update loop-father fields of basic-blocks. */
3137 loops_state_set (LOOPS_NEED_FIXUP
);
3140 /* If the loop tree in the source function needed fixup, mark the
3141 destination loop tree for fixup, too. */
3142 if (loops_for_fn (src_cfun
)->state
& LOOPS_NEED_FIXUP
)
3143 loops_state_set (LOOPS_NEED_FIXUP
);
3145 if (gimple_in_ssa_p (cfun
))
3146 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
3147 if (!id
->blocks_to_copy
3148 || (bb
->index
> 0 && bitmap_bit_p (id
->blocks_to_copy
, bb
->index
)))
3149 copy_phis_for_bb (bb
, id
);
3151 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
3154 if (need_debug_cleanup
3155 && bb
->index
!= ENTRY_BLOCK
3156 && bb
->index
!= EXIT_BLOCK
)
3157 maybe_move_debug_stmts_to_successors (id
, (basic_block
) bb
->aux
);
3158 /* Update call edge destinations. This cannot be done before loop
3159 info is updated, because we may split basic blocks. */
3160 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
3161 && bb
->index
!= ENTRY_BLOCK
3162 && bb
->index
!= EXIT_BLOCK
)
3163 redirect_all_calls (id
, (basic_block
)bb
->aux
);
3164 ((basic_block
)bb
->aux
)->aux
= NULL
;
3168 /* Zero out AUX fields of newly created block during EH edge
3170 for (; last
< last_basic_block_for_fn (cfun
); last
++)
3172 if (need_debug_cleanup
)
3173 maybe_move_debug_stmts_to_successors (id
,
3174 BASIC_BLOCK_FOR_FN (cfun
, last
));
3175 BASIC_BLOCK_FOR_FN (cfun
, last
)->aux
= NULL
;
3176 /* Update call edge destinations. This cannot be done before loop
3177 info is updated, because we may split basic blocks. */
3178 if (id
->transform_call_graph_edges
== CB_CGE_DUPLICATE
)
3179 redirect_all_calls (id
, BASIC_BLOCK_FOR_FN (cfun
, last
));
3181 entry_block_map
->aux
= NULL
;
3182 exit_block_map
->aux
= NULL
;
3189 if (id
->dependence_map
)
3191 delete id
->dependence_map
;
3192 id
->dependence_map
= NULL
;
3198 /* Copy the debug STMT using ID. We deal with these statements in a
3199 special way: if any variable in their VALUE expression wasn't
3200 remapped yet, we won't remap it, because that would get decl uids
3201 out of sync, causing codegen differences between -g and -g0. If
3202 this arises, we drop the VALUE expression altogether. */
3205 copy_debug_stmt (gdebug
*stmt
, copy_body_data
*id
)
3208 struct walk_stmt_info wi
;
3210 if (tree block
= gimple_block (stmt
))
3212 n
= id
->decl_map
->get (block
);
3213 gimple_set_block (stmt
, n
? *n
: id
->block
);
3216 if (gimple_debug_nonbind_marker_p (stmt
))
3218 if (id
->call_stmt
&& !gimple_block (stmt
))
3220 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
3221 gsi_remove (&gsi
, true);
3226 /* Remap all the operands in COPY. */
3227 memset (&wi
, 0, sizeof (wi
));
3230 processing_debug_stmt
= 1;
3232 if (gimple_debug_source_bind_p (stmt
))
3233 t
= gimple_debug_source_bind_get_var (stmt
);
3234 else if (gimple_debug_bind_p (stmt
))
3235 t
= gimple_debug_bind_get_var (stmt
);
3239 if (TREE_CODE (t
) == PARM_DECL
3241 && (n
= id
->debug_map
->get (t
)))
3243 gcc_assert (VAR_P (*n
));
3246 else if (VAR_P (t
) && !is_global_var (t
) && !id
->decl_map
->get (t
))
3247 /* T is a non-localized variable. */;
3249 walk_tree (&t
, remap_gimple_op_r
, &wi
, NULL
);
3251 if (gimple_debug_bind_p (stmt
))
3253 gimple_debug_bind_set_var (stmt
, t
);
3255 if (gimple_debug_bind_has_value_p (stmt
))
3256 walk_tree (gimple_debug_bind_get_value_ptr (stmt
),
3257 remap_gimple_op_r
, &wi
, NULL
);
3259 /* Punt if any decl couldn't be remapped. */
3260 if (processing_debug_stmt
< 0)
3261 gimple_debug_bind_reset_value (stmt
);
3263 else if (gimple_debug_source_bind_p (stmt
))
3265 gimple_debug_source_bind_set_var (stmt
, t
);
3266 /* When inlining and source bind refers to one of the optimized
3267 away parameters, change the source bind into normal debug bind
3268 referring to the corresponding DEBUG_EXPR_DECL that should have
3269 been bound before the call stmt. */
3270 t
= gimple_debug_source_bind_get_value (stmt
);
3272 && TREE_CODE (t
) == PARM_DECL
3275 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (id
->src_fn
);
3277 if (debug_args
!= NULL
)
3279 for (i
= 0; i
< vec_safe_length (*debug_args
); i
+= 2)
3280 if ((**debug_args
)[i
] == DECL_ORIGIN (t
)
3281 && TREE_CODE ((**debug_args
)[i
+ 1]) == DEBUG_EXPR_DECL
)
3283 t
= (**debug_args
)[i
+ 1];
3284 stmt
->subcode
= GIMPLE_DEBUG_BIND
;
3285 gimple_debug_bind_set_value (stmt
, t
);
3290 if (gimple_debug_source_bind_p (stmt
))
3291 walk_tree (gimple_debug_source_bind_get_value_ptr (stmt
),
3292 remap_gimple_op_r
, &wi
, NULL
);
3295 processing_debug_stmt
= 0;
3300 /* Process deferred debug stmts. In order to give values better odds
3301 of being successfully remapped, we delay the processing of debug
3302 stmts until all other stmts that might require remapping are
3306 copy_debug_stmts (copy_body_data
*id
)
3308 if (!id
->debug_stmts
.exists ())
3311 for (gdebug
*stmt
: id
->debug_stmts
)
3312 copy_debug_stmt (stmt
, id
);
3314 id
->debug_stmts
.release ();
3317 /* Make a copy of the body of SRC_FN so that it can be inserted inline in
3318 another function. */
3321 copy_tree_body (copy_body_data
*id
)
3323 tree fndecl
= id
->src_fn
;
3324 tree body
= DECL_SAVED_TREE (fndecl
);
3326 walk_tree (&body
, copy_tree_body_r
, id
, NULL
);
3331 /* Make a copy of the body of FN so that it can be inserted inline in
3332 another function. */
3335 copy_body (copy_body_data
*id
,
3336 basic_block entry_block_map
, basic_block exit_block_map
,
3337 basic_block new_entry
)
3339 tree fndecl
= id
->src_fn
;
3342 /* If this body has a CFG, walk CFG and copy. */
3343 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (fndecl
)));
3344 body
= copy_cfg_body (id
, entry_block_map
, exit_block_map
,
3346 copy_debug_stmts (id
);
3347 delete id
->killed_new_ssa_names
;
3348 id
->killed_new_ssa_names
= NULL
;
3353 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
3354 defined in function FN, or of a data member thereof. */
3357 self_inlining_addr_expr (tree value
, tree fn
)
3361 if (TREE_CODE (value
) != ADDR_EXPR
)
3364 var
= get_base_address (TREE_OPERAND (value
, 0));
3366 return var
&& auto_var_in_fn_p (var
, fn
);
3369 /* Append to BB a debug annotation that binds VAR to VALUE, inheriting
3370 lexical block and line number information from base_stmt, if given,
3371 or from the last stmt of the block otherwise. */
3374 insert_init_debug_bind (copy_body_data
*id
,
3375 basic_block bb
, tree var
, tree value
,
3379 gimple_stmt_iterator gsi
;
3382 if (!gimple_in_ssa_p (id
->src_cfun
))
3385 if (!opt_for_fn (id
->dst_fn
, flag_var_tracking_assignments
))
3388 tracked_var
= target_for_debug_bind (var
);
3394 gsi
= gsi_last_bb (bb
);
3395 if (!base_stmt
&& !gsi_end_p (gsi
))
3396 base_stmt
= gsi_stmt (gsi
);
3399 note
= gimple_build_debug_bind (tracked_var
,
3400 value
== error_mark_node
3401 ? NULL_TREE
: unshare_expr (value
),
3406 if (!gsi_end_p (gsi
))
3407 gsi_insert_after (&gsi
, note
, GSI_SAME_STMT
);
3409 gsi_insert_before (&gsi
, note
, GSI_SAME_STMT
);
3416 insert_init_stmt (copy_body_data
*id
, basic_block bb
, gimple
*init_stmt
)
3418 /* If VAR represents a zero-sized variable, it's possible that the
3419 assignment statement may result in no gimple statements. */
3422 gimple_stmt_iterator si
= gsi_last_bb (bb
);
3424 /* We can end up with init statements that store to a non-register
3425 from a rhs with a conversion. Handle that here by forcing the
3426 rhs into a temporary. gimple_regimplify_operands is not
3427 prepared to do this for us. */
3428 if (!is_gimple_debug (init_stmt
)
3429 && !is_gimple_reg (gimple_assign_lhs (init_stmt
))
3430 && is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (init_stmt
)))
3431 && gimple_assign_rhs_class (init_stmt
) == GIMPLE_UNARY_RHS
)
3433 tree rhs
= build1 (gimple_assign_rhs_code (init_stmt
),
3434 TREE_TYPE (gimple_assign_lhs (init_stmt
)),
3435 gimple_assign_rhs1 (init_stmt
));
3436 rhs
= force_gimple_operand_gsi (&si
, rhs
, true, NULL_TREE
, false,
3438 gimple_assign_set_rhs_code (init_stmt
, TREE_CODE (rhs
));
3439 gimple_assign_set_rhs1 (init_stmt
, rhs
);
3441 gsi_insert_after (&si
, init_stmt
, GSI_NEW_STMT
);
3442 if (!is_gimple_debug (init_stmt
))
3444 gimple_regimplify_operands (init_stmt
, &si
);
3446 tree def
= gimple_assign_lhs (init_stmt
);
3447 insert_init_debug_bind (id
, bb
, def
, def
, init_stmt
);
3452 /* Deal with mismatched formal/actual parameters, in a rather brute-force way
3453 if need be (which should only be necessary for invalid programs). Attempt
3454 to convert VAL to TYPE and return the result if it is possible, just return
3455 a zero constant of the given type if it fails. */
3458 force_value_to_type (tree type
, tree value
)
3460 /* If we can match up types by promotion/demotion do so. */
3461 if (fold_convertible_p (type
, value
))
3462 return fold_convert (type
, value
);
3464 /* ??? For valid programs we should not end up here.
3465 Still if we end up with truly mismatched types here, fall back
3466 to using a VIEW_CONVERT_EXPR or a literal zero to not leak invalid
3467 GIMPLE to the following passes. */
3468 if (TREE_CODE (value
) == WITH_SIZE_EXPR
)
3469 return error_mark_node
;
3470 else if (!is_gimple_reg_type (TREE_TYPE (value
))
3471 || TYPE_SIZE (type
) == TYPE_SIZE (TREE_TYPE (value
)))
3472 return fold_build1 (VIEW_CONVERT_EXPR
, type
, value
);
3474 return build_zero_cst (type
);
3477 /* Initialize parameter P with VALUE. If needed, produce init statement
3478 at the end of BB. When BB is NULL, we return init statement to be
3481 setup_one_parameter (copy_body_data
*id
, tree p
, tree value
, tree fn
,
3482 basic_block bb
, tree
*vars
)
3484 gimple
*init_stmt
= NULL
;
3486 tree def
= (gimple_in_ssa_p (cfun
)
3487 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
3489 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
3490 here since the type of this decl must be visible to the calling
3492 var
= copy_decl_to_var (p
, id
);
3494 /* Declare this new variable. */
3495 DECL_CHAIN (var
) = *vars
;
3498 /* Make gimplifier happy about this variable. */
3499 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
3501 /* If the parameter is never assigned to, has no SSA_NAMEs created,
3502 we would not need to create a new variable here at all, if it
3503 weren't for debug info. Still, we can just use the argument
3505 if (TREE_READONLY (p
)
3506 && !TREE_ADDRESSABLE (p
)
3508 && !TREE_SIDE_EFFECTS (value
)
3511 /* We may produce non-gimple trees by adding NOPs or introduce invalid
3512 sharing when the value is not constant or DECL. And we need to make
3513 sure that it cannot be modified from another path in the callee. */
3514 if (((is_gimple_min_invariant (value
)
3515 /* When the parameter is used in a context that forces it to
3516 not be a GIMPLE register avoid substituting something that
3517 is not a decl there. */
3518 && ! DECL_NOT_GIMPLE_REG_P (p
))
3519 || (DECL_P (value
) && TREE_READONLY (value
))
3520 || (auto_var_in_fn_p (value
, id
->dst_fn
)
3521 && !TREE_ADDRESSABLE (value
)))
3522 && useless_type_conversion_p (TREE_TYPE (p
), TREE_TYPE (value
))
3523 /* We have to be very careful about ADDR_EXPR. Make sure
3524 the base variable isn't a local variable of the inlined
3525 function, e.g., when doing recursive inlining, direct or
3526 mutually-recursive or whatever, which is why we don't
3527 just test whether fn == current_function_decl. */
3528 && ! self_inlining_addr_expr (value
, fn
))
3530 insert_decl_map (id
, p
, value
);
3532 id
->debug_map
= new hash_map
<tree
, tree
>;
3533 id
->debug_map
->put (p
, var
);
3534 return insert_init_debug_bind (id
, bb
, var
, value
, NULL
);
3538 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
3539 that way, when the PARM_DECL is encountered, it will be
3540 automatically replaced by the VAR_DECL. */
3541 insert_decl_map (id
, p
, var
);
3543 /* Even if P was TREE_READONLY, the new VAR should not be. In the original
3544 code, we would have constructed a temporary, and then the function body
3545 would have never changed the value of P. However, now, we will be
3546 constructing VAR directly. Therefore, it must not be TREE_READONLY. */
3547 TREE_READONLY (var
) = 0;
3551 && value
!= error_mark_node
3552 && !useless_type_conversion_p (TREE_TYPE (p
), TREE_TYPE (value
)))
3553 rhs
= force_value_to_type (TREE_TYPE (p
), value
);
3555 /* If there is no setup required and we are in SSA, take the easy route
3556 replacing all SSA names representing the function parameter by the
3557 SSA name passed to function.
3559 We need to construct map for the variable anyway as it might be used
3560 in different SSA names when parameter is set in function.
3562 Do replacement at -O0 for const arguments replaced by constant.
3563 This is important for builtin_constant_p and other construct requiring
3564 constant argument to be visible in inlined function body. */
3565 if (gimple_in_ssa_p (cfun
) && rhs
&& def
&& is_gimple_reg (p
)
3567 || (TREE_READONLY (p
)
3568 && is_gimple_min_invariant (rhs
)))
3569 && (TREE_CODE (rhs
) == SSA_NAME
3570 || is_gimple_min_invariant (rhs
))
3571 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
3573 insert_decl_map (id
, def
, rhs
);
3574 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3577 /* If the value of argument is never used, don't care about initializing
3579 if (optimize
&& gimple_in_ssa_p (cfun
) && !def
&& is_gimple_reg (p
))
3581 gcc_assert (!value
|| !TREE_SIDE_EFFECTS (value
));
3582 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3585 /* Initialize this VAR_DECL from the equivalent argument. Convert
3586 the argument to the proper type in case it was promoted. */
3589 if (rhs
== error_mark_node
)
3591 insert_decl_map (id
, p
, var
);
3592 return insert_init_debug_bind (id
, bb
, var
, rhs
, NULL
);
3595 STRIP_USELESS_TYPE_CONVERSION (rhs
);
3597 /* If we are in SSA form properly remap the default definition
3598 or assign to a dummy SSA name if the parameter is unused and
3599 we are not optimizing. */
3600 if (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
))
3604 def
= remap_ssa_name (def
, id
);
3605 init_stmt
= gimple_build_assign (def
, rhs
);
3606 SSA_NAME_IS_DEFAULT_DEF (def
) = 0;
3607 set_ssa_default_def (cfun
, var
, NULL
);
3611 def
= make_ssa_name (var
);
3612 init_stmt
= gimple_build_assign (def
, rhs
);
3616 init_stmt
= gimple_build_assign (var
, rhs
);
3618 if (bb
&& init_stmt
)
3619 insert_init_stmt (id
, bb
, init_stmt
);
3624 /* Generate code to initialize the parameters of the function at the
3625 top of the stack in ID from the GIMPLE_CALL STMT. */
3628 initialize_inlined_parameters (copy_body_data
*id
, gimple
*stmt
,
3629 tree fn
, basic_block bb
)
3634 tree vars
= NULL_TREE
;
3635 tree static_chain
= gimple_call_chain (stmt
);
3637 /* Figure out what the parameters are. */
3638 parms
= DECL_ARGUMENTS (fn
);
3640 /* Loop through the parameter declarations, replacing each with an
3641 equivalent VAR_DECL, appropriately initialized. */
3642 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
3645 val
= i
< gimple_call_num_args (stmt
) ? gimple_call_arg (stmt
, i
) : NULL
;
3646 setup_one_parameter (id
, p
, val
, fn
, bb
, &vars
);
3648 /* After remapping parameters remap their types. This has to be done
3649 in a second loop over all parameters to appropriately remap
3650 variable sized arrays when the size is specified in a
3651 parameter following the array. */
3652 for (p
= parms
, i
= 0; p
; p
= DECL_CHAIN (p
), i
++)
3654 tree
*varp
= id
->decl_map
->get (p
);
3655 if (varp
&& VAR_P (*varp
))
3657 tree def
= (gimple_in_ssa_p (cfun
) && is_gimple_reg (p
)
3658 ? ssa_default_def (id
->src_cfun
, p
) : NULL
);
3660 TREE_TYPE (var
) = remap_type (TREE_TYPE (var
), id
);
3661 /* Also remap the default definition if it was remapped
3662 to the default definition of the parameter replacement
3663 by the parameter setup. */
3666 tree
*defp
= id
->decl_map
->get (def
);
3668 && TREE_CODE (*defp
) == SSA_NAME
3669 && SSA_NAME_VAR (*defp
) == var
)
3670 TREE_TYPE (*defp
) = TREE_TYPE (var
);
3675 /* Initialize the static chain. */
3676 p
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
3677 gcc_assert (fn
!= current_function_decl
);
3680 /* No static chain? Seems like a bug in tree-nested.c. */
3681 gcc_assert (static_chain
);
3683 setup_one_parameter (id
, p
, static_chain
, fn
, bb
, &vars
);
3686 declare_inline_vars (id
->block
, vars
);
3690 /* Declare a return variable to replace the RESULT_DECL for the
3691 function we are calling. An appropriate DECL_STMT is returned.
3692 The USE_STMT is filled to contain a use of the declaration to
3693 indicate the return value of the function.
3695 RETURN_SLOT, if non-null is place where to store the result. It
3696 is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null,
3697 was the LHS of the MODIFY_EXPR to which this call is the RHS.
3699 The return value is a (possibly null) value that holds the result
3700 as seen by the caller. */
3703 declare_return_variable (copy_body_data
*id
, tree return_slot
, tree modify_dest
,
3704 basic_block entry_bb
)
3706 tree callee
= id
->src_fn
;
3707 tree result
= DECL_RESULT (callee
);
3708 tree callee_type
= TREE_TYPE (result
);
3712 /* Handle type-mismatches in the function declaration return type
3713 vs. the call expression. */
3715 caller_type
= TREE_TYPE (modify_dest
);
3716 else if (return_slot
)
3717 caller_type
= TREE_TYPE (return_slot
);
3718 else /* No LHS on the call. */
3719 caller_type
= TREE_TYPE (TREE_TYPE (callee
));
3721 /* We don't need to do anything for functions that don't return anything. */
3722 if (VOID_TYPE_P (callee_type
))
3725 /* If there was a return slot, then the return value is the
3726 dereferenced address of that object. */
3729 /* The front end shouldn't have used both return_slot and
3730 a modify expression. */
3731 gcc_assert (!modify_dest
);
3732 if (DECL_BY_REFERENCE (result
))
3734 tree return_slot_addr
= build_fold_addr_expr (return_slot
);
3735 STRIP_USELESS_TYPE_CONVERSION (return_slot_addr
);
3737 /* We are going to construct *&return_slot and we can't do that
3738 for variables believed to be not addressable.
3740 FIXME: This check possibly can match, because values returned
3741 via return slot optimization are not believed to have address
3742 taken by alias analysis. */
3743 gcc_assert (TREE_CODE (return_slot
) != SSA_NAME
);
3744 var
= return_slot_addr
;
3745 mark_addressable (return_slot
);
3750 gcc_assert (TREE_CODE (var
) != SSA_NAME
);
3751 if (TREE_ADDRESSABLE (result
))
3752 mark_addressable (var
);
3754 if (DECL_NOT_GIMPLE_REG_P (result
)
3756 DECL_NOT_GIMPLE_REG_P (var
) = 1;
3758 if (!useless_type_conversion_p (callee_type
, caller_type
))
3759 var
= build1 (VIEW_CONVERT_EXPR
, callee_type
, var
);
3765 /* All types requiring non-trivial constructors should have been handled. */
3766 gcc_assert (!TREE_ADDRESSABLE (callee_type
));
3768 /* Attempt to avoid creating a new temporary variable. */
3770 && TREE_CODE (modify_dest
) != SSA_NAME
)
3772 bool use_it
= false;
3774 /* We can't use MODIFY_DEST if there's type promotion involved. */
3775 if (!useless_type_conversion_p (callee_type
, caller_type
))
3778 /* ??? If we're assigning to a variable sized type, then we must
3779 reuse the destination variable, because we've no good way to
3780 create variable sized temporaries at this point. */
3781 else if (!poly_int_tree_p (TYPE_SIZE_UNIT (caller_type
)))
3784 /* If the callee cannot possibly modify MODIFY_DEST, then we can
3785 reuse it as the result of the call directly. Don't do this if
3786 it would promote MODIFY_DEST to addressable. */
3787 else if (TREE_ADDRESSABLE (result
))
3791 tree base_m
= get_base_address (modify_dest
);
3793 /* If the base isn't a decl, then it's a pointer, and we don't
3794 know where that's going to go. */
3795 if (!DECL_P (base_m
))
3797 else if (is_global_var (base_m
))
3799 else if (DECL_NOT_GIMPLE_REG_P (result
)
3800 && !DECL_NOT_GIMPLE_REG_P (base_m
))
3802 else if (!TREE_ADDRESSABLE (base_m
))
3814 gcc_assert (poly_int_tree_p (TYPE_SIZE_UNIT (callee_type
)));
3816 var
= copy_result_decl_to_var (result
, id
);
3817 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
3819 /* Do not have the rest of GCC warn about this variable as it should
3820 not be visible to the user. */
3821 suppress_warning (var
/* OPT_Wuninitialized? */);
3823 declare_inline_vars (id
->block
, var
);
3825 /* Build the use expr. If the return type of the function was
3826 promoted, convert it back to the expected type. */
3828 if (!useless_type_conversion_p (caller_type
, TREE_TYPE (var
)))
3830 /* If we can match up types by promotion/demotion do so. */
3831 if (fold_convertible_p (caller_type
, var
))
3832 use
= fold_convert (caller_type
, var
);
3835 /* ??? For valid programs we should not end up here.
3836 Still if we end up with truly mismatched types here, fall back
3837 to using a MEM_REF to not leak invalid GIMPLE to the following
3839 /* Prevent var from being written into SSA form. */
3840 if (is_gimple_reg_type (TREE_TYPE (var
)))
3841 DECL_NOT_GIMPLE_REG_P (var
) = true;
3842 use
= fold_build2 (MEM_REF
, caller_type
,
3843 build_fold_addr_expr (var
),
3844 build_int_cst (ptr_type_node
, 0));
3848 STRIP_USELESS_TYPE_CONVERSION (use
);
3850 if (DECL_BY_REFERENCE (result
))
3852 TREE_ADDRESSABLE (var
) = 1;
3853 var
= build_fold_addr_expr (var
);
3857 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
3858 way, when the RESULT_DECL is encountered, it will be
3859 automatically replaced by the VAR_DECL.
3861 When returning by reference, ensure that RESULT_DECL remaps to
3863 if (DECL_BY_REFERENCE (result
)
3864 && !is_gimple_val (var
))
3866 tree temp
= create_tmp_var (TREE_TYPE (result
), "retvalptr");
3867 insert_decl_map (id
, result
, temp
);
3868 /* When RESULT_DECL is in SSA form, we need to remap and initialize
3869 it's default_def SSA_NAME. */
3870 if (gimple_in_ssa_p (id
->src_cfun
)
3871 && is_gimple_reg (result
))
3873 temp
= make_ssa_name (temp
);
3874 insert_decl_map (id
, ssa_default_def (id
->src_cfun
, result
), temp
);
3876 insert_init_stmt (id
, entry_bb
, gimple_build_assign (temp
, var
));
3879 insert_decl_map (id
, result
, var
);
3881 /* Remember this so we can ignore it in remap_decls. */
3886 /* Determine if the function can be copied. If so return NULL. If
3887 not return a string describng the reason for failure. */
3890 copy_forbidden (struct function
*fun
)
3892 const char *reason
= fun
->cannot_be_copied_reason
;
3894 /* Only examine the function once. */
3895 if (fun
->cannot_be_copied_set
)
3898 /* We cannot copy a function that receives a non-local goto
3899 because we cannot remap the destination label used in the
3900 function that is performing the non-local goto. */
3901 /* ??? Actually, this should be possible, if we work at it.
3902 No doubt there's just a handful of places that simply
3903 assume it doesn't happen and don't substitute properly. */
3904 if (fun
->has_nonlocal_label
)
3906 reason
= G_("function %q+F can never be copied "
3907 "because it receives a non-local goto");
3911 if (fun
->has_forced_label_in_static
)
3913 reason
= G_("function %q+F can never be copied because it saves "
3914 "address of local label in a static variable");
3919 fun
->cannot_be_copied_reason
= reason
;
3920 fun
->cannot_be_copied_set
= true;
3925 static const char *inline_forbidden_reason
;
3927 /* A callback for walk_gimple_seq to handle statements. Returns non-null
3928 iff a function cannot be inlined. Also sets the reason why. */
3931 inline_forbidden_p_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
3932 struct walk_stmt_info
*wip
)
3934 tree fn
= (tree
) wip
->info
;
3936 gimple
*stmt
= gsi_stmt (*gsi
);
3938 switch (gimple_code (stmt
))
3941 /* Refuse to inline alloca call unless user explicitly forced so as
3942 this may change program's memory overhead drastically when the
3943 function using alloca is called in loop. In GCC present in
3944 SPEC2000 inlining into schedule_block cause it to require 2GB of
3945 RAM instead of 256MB. Don't do so for alloca calls emitted for
3946 VLA objects as those can't cause unbounded growth (they're always
3947 wrapped inside stack_save/stack_restore regions. */
3948 if (gimple_maybe_alloca_call_p (stmt
)
3949 && !gimple_call_alloca_for_var_p (as_a
<gcall
*> (stmt
))
3950 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
3952 inline_forbidden_reason
3953 = G_("function %q+F can never be inlined because it uses "
3954 "alloca (override using the always_inline attribute)");
3955 *handled_ops_p
= true;
3959 t
= gimple_call_fndecl (stmt
);
3963 /* We cannot inline functions that call setjmp. */
3964 if (setjmp_call_p (t
))
3966 inline_forbidden_reason
3967 = G_("function %q+F can never be inlined because it uses setjmp");
3968 *handled_ops_p
= true;
3972 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
3973 switch (DECL_FUNCTION_CODE (t
))
3975 /* We cannot inline functions that take a variable number of
3977 case BUILT_IN_VA_START
:
3978 case BUILT_IN_NEXT_ARG
:
3979 case BUILT_IN_VA_END
:
3980 inline_forbidden_reason
3981 = G_("function %q+F can never be inlined because it "
3982 "uses variable argument lists");
3983 *handled_ops_p
= true;
3986 case BUILT_IN_LONGJMP
:
3987 /* We can't inline functions that call __builtin_longjmp at
3988 all. The non-local goto machinery really requires the
3989 destination be in a different function. If we allow the
3990 function calling __builtin_longjmp to be inlined into the
3991 function calling __builtin_setjmp, Things will Go Awry. */
3992 inline_forbidden_reason
3993 = G_("function %q+F can never be inlined because "
3994 "it uses setjmp-longjmp exception handling");
3995 *handled_ops_p
= true;
3998 case BUILT_IN_NONLOCAL_GOTO
:
4000 inline_forbidden_reason
4001 = G_("function %q+F can never be inlined because "
4002 "it uses non-local goto");
4003 *handled_ops_p
= true;
4006 case BUILT_IN_RETURN
:
4007 case BUILT_IN_APPLY_ARGS
:
4008 /* If a __builtin_apply_args caller would be inlined,
4009 it would be saving arguments of the function it has
4010 been inlined into. Similarly __builtin_return would
4011 return from the function the inline has been inlined into. */
4012 inline_forbidden_reason
4013 = G_("function %q+F can never be inlined because "
4014 "it uses %<__builtin_return%> or %<__builtin_apply_args%>");
4015 *handled_ops_p
= true;
4024 t
= gimple_goto_dest (stmt
);
4026 /* We will not inline a function which uses computed goto. The
4027 addresses of its local labels, which may be tucked into
4028 global storage, are of course not constant across
4029 instantiations, which causes unexpected behavior. */
4030 if (TREE_CODE (t
) != LABEL_DECL
)
4032 inline_forbidden_reason
4033 = G_("function %q+F can never be inlined "
4034 "because it contains a computed goto");
4035 *handled_ops_p
= true;
4044 *handled_ops_p
= false;
4048 /* Return true if FNDECL is a function that cannot be inlined into
4052 inline_forbidden_p (tree fndecl
)
4054 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
4055 struct walk_stmt_info wi
;
4057 bool forbidden_p
= false;
4059 /* First check for shared reasons not to copy the code. */
4060 inline_forbidden_reason
= copy_forbidden (fun
);
4061 if (inline_forbidden_reason
!= NULL
)
4064 /* Next, walk the statements of the function looking for
4065 constraucts we can't handle, or are non-optimal for inlining. */
4066 hash_set
<tree
> visited_nodes
;
4067 memset (&wi
, 0, sizeof (wi
));
4068 wi
.info
= (void *) fndecl
;
4069 wi
.pset
= &visited_nodes
;
4071 /* We cannot inline a function with a variable-sized parameter because we
4072 cannot materialize a temporary of such a type in the caller if need be.
4073 Note that the return case is not symmetrical because we can guarantee
4074 that a temporary is not needed by means of CALL_EXPR_RETURN_SLOT_OPT. */
4075 for (tree parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
4076 if (!poly_int_tree_p (DECL_SIZE (parm
)))
4078 inline_forbidden_reason
4079 = G_("function %q+F can never be inlined because "
4080 "it has a VLA argument");
4084 FOR_EACH_BB_FN (bb
, fun
)
4087 gimple_seq seq
= bb_seq (bb
);
4088 ret
= walk_gimple_seq (seq
, inline_forbidden_p_stmt
, NULL
, &wi
);
4089 forbidden_p
= (ret
!= NULL
);
4097 /* Return false if the function FNDECL cannot be inlined on account of its
4098 attributes, true otherwise. */
4100 function_attribute_inlinable_p (const_tree fndecl
)
4102 if (targetm
.attribute_table
)
4106 for (a
= DECL_ATTRIBUTES (fndecl
); a
; a
= TREE_CHAIN (a
))
4108 const_tree name
= get_attribute_name (a
);
4111 for (i
= 0; targetm
.attribute_table
[i
].name
!= NULL
; i
++)
4112 if (is_attribute_p (targetm
.attribute_table
[i
].name
, name
))
4113 return targetm
.function_attribute_inlinable_p (fndecl
);
4120 /* Returns nonzero if FN is a function that does not have any
4121 fundamental inline blocking properties. */
4124 tree_inlinable_function_p (tree fn
)
4126 bool inlinable
= true;
4130 /* If we've already decided this function shouldn't be inlined,
4131 there's no need to check again. */
4132 if (DECL_UNINLINABLE (fn
))
4135 /* We only warn for functions declared `inline' by the user. */
4136 do_warning
= (opt_for_fn (fn
, warn_inline
)
4137 && DECL_DECLARED_INLINE_P (fn
)
4138 && !DECL_NO_INLINE_WARNING_P (fn
)
4139 && !DECL_IN_SYSTEM_HEADER (fn
));
4141 always_inline
= lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
));
4144 && always_inline
== NULL
)
4147 warning (OPT_Winline
, "function %q+F can never be inlined because it "
4148 "is suppressed using %<-fno-inline%>", fn
);
4152 else if (!function_attribute_inlinable_p (fn
))
4155 warning (OPT_Winline
, "function %q+F can never be inlined because it "
4156 "uses attributes conflicting with inlining", fn
);
4160 else if (inline_forbidden_p (fn
))
4162 /* See if we should warn about uninlinable functions. Previously,
4163 some of these warnings would be issued while trying to expand
4164 the function inline, but that would cause multiple warnings
4165 about functions that would for example call alloca. But since
4166 this a property of the function, just one warning is enough.
4167 As a bonus we can now give more details about the reason why a
4168 function is not inlinable. */
4170 error (inline_forbidden_reason
, fn
);
4171 else if (do_warning
)
4172 warning (OPT_Winline
, inline_forbidden_reason
, fn
);
4177 /* Squirrel away the result so that we don't have to check again. */
4178 DECL_UNINLINABLE (fn
) = !inlinable
;
4183 /* Estimate the cost of a memory move of type TYPE. Use machine dependent
4184 word size and take possible memcpy call into account and return
4185 cost based on whether optimizing for size or speed according to SPEED_P. */
4188 estimate_move_cost (tree type
, bool ARG_UNUSED (speed_p
))
4192 gcc_assert (!VOID_TYPE_P (type
));
4194 if (TREE_CODE (type
) == VECTOR_TYPE
)
4196 scalar_mode inner
= SCALAR_TYPE_MODE (TREE_TYPE (type
));
4197 machine_mode simd
= targetm
.vectorize
.preferred_simd_mode (inner
);
4199 = estimated_poly_value (GET_MODE_SIZE (TYPE_MODE (type
)));
4200 int simd_mode_size
= estimated_poly_value (GET_MODE_SIZE (simd
));
4201 return ((orig_mode_size
+ simd_mode_size
- 1)
4205 size
= int_size_in_bytes (type
);
4207 if (size
< 0 || size
> MOVE_MAX_PIECES
* MOVE_RATIO (speed_p
))
4208 /* Cost of a memcpy call, 3 arguments and the call. */
4211 return ((size
+ MOVE_MAX_PIECES
- 1) / MOVE_MAX_PIECES
);
4214 /* Returns cost of operation CODE, according to WEIGHTS */
4217 estimate_operator_cost (enum tree_code code
, eni_weights
*weights
,
4218 tree op1 ATTRIBUTE_UNUSED
, tree op2
)
4222 /* These are "free" conversions, or their presumed cost
4223 is folded into other operations. */
4228 case VIEW_CONVERT_EXPR
:
4231 /* Assign cost of 1 to usual operations.
4232 ??? We may consider mapping RTL costs to this. */
4238 case POINTER_PLUS_EXPR
:
4239 case POINTER_DIFF_EXPR
:
4242 case MULT_HIGHPART_EXPR
:
4244 case ADDR_SPACE_CONVERT_EXPR
:
4245 case FIXED_CONVERT_EXPR
:
4246 case FIX_TRUNC_EXPR
:
4265 case TRUTH_ANDIF_EXPR
:
4266 case TRUTH_ORIF_EXPR
:
4267 case TRUTH_AND_EXPR
:
4269 case TRUTH_XOR_EXPR
:
4270 case TRUTH_NOT_EXPR
:
4279 case UNORDERED_EXPR
:
4290 case PREDECREMENT_EXPR
:
4291 case PREINCREMENT_EXPR
:
4292 case POSTDECREMENT_EXPR
:
4293 case POSTINCREMENT_EXPR
:
4295 case REALIGN_LOAD_EXPR
:
4297 case WIDEN_PLUS_EXPR
:
4298 case WIDEN_MINUS_EXPR
:
4299 case WIDEN_SUM_EXPR
:
4300 case WIDEN_MULT_EXPR
:
4303 case WIDEN_MULT_PLUS_EXPR
:
4304 case WIDEN_MULT_MINUS_EXPR
:
4305 case WIDEN_LSHIFT_EXPR
:
4307 case VEC_WIDEN_PLUS_HI_EXPR
:
4308 case VEC_WIDEN_PLUS_LO_EXPR
:
4309 case VEC_WIDEN_MINUS_HI_EXPR
:
4310 case VEC_WIDEN_MINUS_LO_EXPR
:
4311 case VEC_WIDEN_MULT_HI_EXPR
:
4312 case VEC_WIDEN_MULT_LO_EXPR
:
4313 case VEC_WIDEN_MULT_EVEN_EXPR
:
4314 case VEC_WIDEN_MULT_ODD_EXPR
:
4315 case VEC_UNPACK_HI_EXPR
:
4316 case VEC_UNPACK_LO_EXPR
:
4317 case VEC_UNPACK_FLOAT_HI_EXPR
:
4318 case VEC_UNPACK_FLOAT_LO_EXPR
:
4319 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
4320 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
4321 case VEC_PACK_TRUNC_EXPR
:
4322 case VEC_PACK_SAT_EXPR
:
4323 case VEC_PACK_FIX_TRUNC_EXPR
:
4324 case VEC_PACK_FLOAT_EXPR
:
4325 case VEC_WIDEN_LSHIFT_HI_EXPR
:
4326 case VEC_WIDEN_LSHIFT_LO_EXPR
:
4327 case VEC_DUPLICATE_EXPR
:
4328 case VEC_SERIES_EXPR
:
4332 /* Few special cases of expensive operations. This is useful
4333 to avoid inlining on functions having too many of these. */
4334 case TRUNC_DIV_EXPR
:
4336 case FLOOR_DIV_EXPR
:
4337 case ROUND_DIV_EXPR
:
4338 case EXACT_DIV_EXPR
:
4339 case TRUNC_MOD_EXPR
:
4341 case FLOOR_MOD_EXPR
:
4342 case ROUND_MOD_EXPR
:
4344 if (TREE_CODE (op2
) != INTEGER_CST
)
4345 return weights
->div_mod_cost
;
4348 /* Bit-field insertion needs several shift and mask operations. */
4349 case BIT_INSERT_EXPR
:
4353 /* We expect a copy assignment with no operator. */
4354 gcc_assert (get_gimple_rhs_class (code
) == GIMPLE_SINGLE_RHS
);
4360 /* Estimate number of instructions that will be created by expanding
4361 the statements in the statement sequence STMTS.
4362 WEIGHTS contains weights attributed to various constructs. */
4365 estimate_num_insns_seq (gimple_seq stmts
, eni_weights
*weights
)
4368 gimple_stmt_iterator gsi
;
4371 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4372 cost
+= estimate_num_insns (gsi_stmt (gsi
), weights
);
4378 /* Estimate number of instructions that will be created by expanding STMT.
4379 WEIGHTS contains weights attributed to various constructs. */
4382 estimate_num_insns (gimple
*stmt
, eni_weights
*weights
)
4385 enum gimple_code code
= gimple_code (stmt
);
4392 /* Try to estimate the cost of assignments. We have three cases to
4394 1) Simple assignments to registers;
4395 2) Stores to things that must live in memory. This includes
4396 "normal" stores to scalars, but also assignments of large
4397 structures, or constructors of big arrays;
4399 Let us look at the first two cases, assuming we have "a = b + C":
4400 <GIMPLE_ASSIGN <var_decl "a">
4401 <plus_expr <var_decl "b"> <constant C>>
4402 If "a" is a GIMPLE register, the assignment to it is free on almost
4403 any target, because "a" usually ends up in a real register. Hence
4404 the only cost of this expression comes from the PLUS_EXPR, and we
4405 can ignore the GIMPLE_ASSIGN.
4406 If "a" is not a GIMPLE register, the assignment to "a" will most
4407 likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost
4408 of moving something into "a", which we compute using the function
4409 estimate_move_cost. */
4410 if (gimple_clobber_p (stmt
))
4411 return 0; /* ={v} {CLOBBER} stmt expands to nothing. */
4413 lhs
= gimple_assign_lhs (stmt
);
4414 rhs
= gimple_assign_rhs1 (stmt
);
4418 /* Account for the cost of moving to / from memory. */
4419 if (gimple_store_p (stmt
))
4420 cost
+= estimate_move_cost (TREE_TYPE (lhs
), weights
->time_based
);
4421 if (gimple_assign_load_p (stmt
))
4422 cost
+= estimate_move_cost (TREE_TYPE (rhs
), weights
->time_based
);
4424 cost
+= estimate_operator_cost (gimple_assign_rhs_code (stmt
), weights
,
4425 gimple_assign_rhs1 (stmt
),
4426 get_gimple_rhs_class (gimple_assign_rhs_code (stmt
))
4427 == GIMPLE_BINARY_RHS
4428 ? gimple_assign_rhs2 (stmt
) : NULL
);
4432 cost
= 1 + estimate_operator_cost (gimple_cond_code (stmt
), weights
,
4433 gimple_op (stmt
, 0),
4434 gimple_op (stmt
, 1));
4439 gswitch
*switch_stmt
= as_a
<gswitch
*> (stmt
);
4440 /* Take into account cost of the switch + guess 2 conditional jumps for
4443 TODO: once the switch expansion logic is sufficiently separated, we can
4444 do better job on estimating cost of the switch. */
4445 if (weights
->time_based
)
4446 cost
= floor_log2 (gimple_switch_num_labels (switch_stmt
)) * 2;
4448 cost
= gimple_switch_num_labels (switch_stmt
) * 2;
4456 if (gimple_call_internal_p (stmt
))
4458 else if ((decl
= gimple_call_fndecl (stmt
))
4459 && fndecl_built_in_p (decl
))
4461 /* Do not special case builtins where we see the body.
4462 This just confuse inliner. */
4463 struct cgraph_node
*node
;
4464 if ((node
= cgraph_node::get (decl
))
4465 && node
->definition
)
4467 /* For buitins that are likely expanded to nothing or
4468 inlined do not account operand costs. */
4469 else if (is_simple_builtin (decl
))
4471 else if (is_inexpensive_builtin (decl
))
4472 return weights
->target_builtin_call_cost
;
4473 else if (gimple_call_builtin_p (stmt
, BUILT_IN_NORMAL
))
4475 /* We canonicalize x * x to pow (x, 2.0) with -ffast-math, so
4476 specialize the cheap expansion we do here.
4477 ??? This asks for a more general solution. */
4478 switch (DECL_FUNCTION_CODE (decl
))
4483 if (TREE_CODE (gimple_call_arg (stmt
, 1)) == REAL_CST
4485 (&TREE_REAL_CST (gimple_call_arg (stmt
, 1)),
4487 return estimate_operator_cost
4488 (MULT_EXPR
, weights
, gimple_call_arg (stmt
, 0),
4489 gimple_call_arg (stmt
, 0));
4498 cost
= decl
? weights
->call_cost
: weights
->indirect_call_cost
;
4499 if (gimple_call_lhs (stmt
))
4500 cost
+= estimate_move_cost (TREE_TYPE (gimple_call_lhs (stmt
)),
4501 weights
->time_based
);
4502 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
4504 tree arg
= gimple_call_arg (stmt
, i
);
4505 cost
+= estimate_move_cost (TREE_TYPE (arg
),
4506 weights
->time_based
);
4512 return weights
->return_cost
;
4518 case GIMPLE_PREDICT
:
4524 int count
= asm_str_count (gimple_asm_string (as_a
<gasm
*> (stmt
)));
4525 /* 1000 means infinity. This avoids overflows later
4526 with very long asm statements. */
4529 /* If this asm is asm inline, count anything as minimum size. */
4530 if (gimple_asm_inline_p (as_a
<gasm
*> (stmt
)))
4531 count
= MIN (1, count
);
4532 return MAX (1, count
);
4536 /* This is either going to be an external function call with one
4537 argument, or two register copy statements plus a goto. */
4540 case GIMPLE_EH_DISPATCH
:
4541 /* ??? This is going to turn into a switch statement. Ideally
4542 we'd have a look at the eh region and estimate the number of
4547 return estimate_num_insns_seq (
4548 gimple_bind_body (as_a
<gbind
*> (stmt
)),
4551 case GIMPLE_EH_FILTER
:
4552 return estimate_num_insns_seq (gimple_eh_filter_failure (stmt
), weights
);
4555 return estimate_num_insns_seq (gimple_catch_handler (
4556 as_a
<gcatch
*> (stmt
)),
4560 return (estimate_num_insns_seq (gimple_try_eval (stmt
), weights
)
4561 + estimate_num_insns_seq (gimple_try_cleanup (stmt
), weights
));
4563 /* OMP directives are generally very expensive. */
4565 case GIMPLE_OMP_RETURN
:
4566 case GIMPLE_OMP_SECTIONS_SWITCH
:
4567 case GIMPLE_OMP_ATOMIC_STORE
:
4568 case GIMPLE_OMP_CONTINUE
:
4569 /* ...except these, which are cheap. */
4572 case GIMPLE_OMP_ATOMIC_LOAD
:
4573 return weights
->omp_cost
;
4575 case GIMPLE_OMP_FOR
:
4576 return (weights
->omp_cost
4577 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
)
4578 + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt
), weights
));
4580 case GIMPLE_OMP_PARALLEL
:
4581 case GIMPLE_OMP_TASK
:
4582 case GIMPLE_OMP_CRITICAL
:
4583 case GIMPLE_OMP_MASTER
:
4584 case GIMPLE_OMP_MASKED
:
4585 case GIMPLE_OMP_SCOPE
:
4586 case GIMPLE_OMP_TASKGROUP
:
4587 case GIMPLE_OMP_ORDERED
:
4588 case GIMPLE_OMP_SCAN
:
4589 case GIMPLE_OMP_SECTION
:
4590 case GIMPLE_OMP_SECTIONS
:
4591 case GIMPLE_OMP_SINGLE
:
4592 case GIMPLE_OMP_TARGET
:
4593 case GIMPLE_OMP_TEAMS
:
4594 return (weights
->omp_cost
4595 + estimate_num_insns_seq (gimple_omp_body (stmt
), weights
));
4597 case GIMPLE_TRANSACTION
:
4598 return (weights
->tm_cost
4599 + estimate_num_insns_seq (gimple_transaction_body (
4600 as_a
<gtransaction
*> (stmt
)),
4610 /* Estimate number of instructions that will be created by expanding
4611 function FNDECL. WEIGHTS contains weights attributed to various
4615 estimate_num_insns_fn (tree fndecl
, eni_weights
*weights
)
4617 struct function
*my_function
= DECL_STRUCT_FUNCTION (fndecl
);
4618 gimple_stmt_iterator bsi
;
4622 gcc_assert (my_function
&& my_function
->cfg
);
4623 FOR_EACH_BB_FN (bb
, my_function
)
4625 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
4626 n
+= estimate_num_insns (gsi_stmt (bsi
), weights
);
4633 /* Initializes weights used by estimate_num_insns. */
4636 init_inline_once (void)
4638 eni_size_weights
.call_cost
= 1;
4639 eni_size_weights
.indirect_call_cost
= 3;
4640 eni_size_weights
.target_builtin_call_cost
= 1;
4641 eni_size_weights
.div_mod_cost
= 1;
4642 eni_size_weights
.omp_cost
= 40;
4643 eni_size_weights
.tm_cost
= 10;
4644 eni_size_weights
.time_based
= false;
4645 eni_size_weights
.return_cost
= 1;
4647 /* Estimating time for call is difficult, since we have no idea what the
4648 called function does. In the current uses of eni_time_weights,
4649 underestimating the cost does less harm than overestimating it, so
4650 we choose a rather small value here. */
4651 eni_time_weights
.call_cost
= 10;
4652 eni_time_weights
.indirect_call_cost
= 15;
4653 eni_time_weights
.target_builtin_call_cost
= 1;
4654 eni_time_weights
.div_mod_cost
= 10;
4655 eni_time_weights
.omp_cost
= 40;
4656 eni_time_weights
.tm_cost
= 40;
4657 eni_time_weights
.time_based
= true;
4658 eni_time_weights
.return_cost
= 2;
4662 /* Install new lexical TREE_BLOCK underneath 'current_block'. */
4665 prepend_lexical_block (tree current_block
, tree new_block
)
4667 BLOCK_CHAIN (new_block
) = BLOCK_SUBBLOCKS (current_block
);
4668 BLOCK_SUBBLOCKS (current_block
) = new_block
;
4669 BLOCK_SUPERCONTEXT (new_block
) = current_block
;
4672 /* Add local variables from CALLEE to CALLER. */
4675 add_local_variables (struct function
*callee
, struct function
*caller
,
4681 FOR_EACH_LOCAL_DECL (callee
, ix
, var
)
4682 if (!can_be_nonlocal (var
, id
))
4684 tree new_var
= remap_decl (var
, id
);
4686 /* Remap debug-expressions. */
4688 && DECL_HAS_DEBUG_EXPR_P (var
)
4691 tree tem
= DECL_DEBUG_EXPR (var
);
4692 bool old_regimplify
= id
->regimplify
;
4693 id
->remapping_type_depth
++;
4694 walk_tree (&tem
, copy_tree_body_r
, id
, NULL
);
4695 id
->remapping_type_depth
--;
4696 id
->regimplify
= old_regimplify
;
4697 SET_DECL_DEBUG_EXPR (new_var
, tem
);
4698 DECL_HAS_DEBUG_EXPR_P (new_var
) = 1;
4700 add_local_decl (caller
, new_var
);
4704 /* Add to BINDINGS a debug stmt resetting SRCVAR if inlining might
4705 have brought in or introduced any debug stmts for SRCVAR. */
4708 reset_debug_binding (copy_body_data
*id
, tree srcvar
, gimple_seq
*bindings
)
4710 tree
*remappedvarp
= id
->decl_map
->get (srcvar
);
4715 if (!VAR_P (*remappedvarp
))
4718 if (*remappedvarp
== id
->retvar
)
4721 tree tvar
= target_for_debug_bind (*remappedvarp
);
4725 gdebug
*stmt
= gimple_build_debug_bind (tvar
, NULL_TREE
,
4727 gimple_seq_add_stmt (bindings
, stmt
);
4730 /* For each inlined variable for which we may have debug bind stmts,
4731 add before GSI a final debug stmt resetting it, marking the end of
4732 its life, so that var-tracking knows it doesn't have to compute
4733 further locations for it. */
4736 reset_debug_bindings (copy_body_data
*id
, gimple_stmt_iterator gsi
)
4740 gimple_seq bindings
= NULL
;
4742 if (!gimple_in_ssa_p (id
->src_cfun
))
4745 if (!opt_for_fn (id
->dst_fn
, flag_var_tracking_assignments
))
4748 for (var
= DECL_ARGUMENTS (id
->src_fn
);
4749 var
; var
= DECL_CHAIN (var
))
4750 reset_debug_binding (id
, var
, &bindings
);
4752 FOR_EACH_LOCAL_DECL (id
->src_cfun
, ix
, var
)
4753 reset_debug_binding (id
, var
, &bindings
);
4755 gsi_insert_seq_before_without_update (&gsi
, bindings
, GSI_SAME_STMT
);
4758 /* If STMT is a GIMPLE_CALL, replace it with its inline expansion. */
4761 expand_call_inline (basic_block bb
, gimple
*stmt
, copy_body_data
*id
,
4766 hash_map
<tree
, tree
> *dst
;
4767 hash_map
<tree
, tree
> *st
= NULL
;
4770 struct cgraph_edge
*cg_edge
;
4771 cgraph_inline_failed_t reason
;
4772 basic_block return_block
;
4774 gimple_stmt_iterator gsi
, stmt_gsi
;
4775 bool successfully_inlined
= false;
4776 bool purge_dead_abnormal_edges
;
4778 unsigned int prop_mask
, src_properties
;
4779 struct function
*dst_cfun
;
4782 gimple
*simtenter_stmt
= NULL
;
4783 vec
<tree
> *simtvars_save
;
4785 /* The gimplifier uses input_location in too many places, such as
4786 internal_get_tmp_var (). */
4787 location_t saved_location
= input_location
;
4788 input_location
= gimple_location (stmt
);
4790 /* From here on, we're only interested in CALL_EXPRs. */
4791 call_stmt
= dyn_cast
<gcall
*> (stmt
);
4795 cg_edge
= id
->dst_node
->get_edge (stmt
);
4796 gcc_checking_assert (cg_edge
);
4797 /* First, see if we can figure out what function is being called.
4798 If we cannot, then there is no hope of inlining the function. */
4799 if (cg_edge
->indirect_unknown_callee
)
4801 fn
= cg_edge
->callee
->decl
;
4802 gcc_checking_assert (fn
);
4804 /* If FN is a declaration of a function in a nested scope that was
4805 globally declared inline, we don't set its DECL_INITIAL.
4806 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
4807 C++ front-end uses it for cdtors to refer to their internal
4808 declarations, that are not real functions. Fortunately those
4809 don't have trees to be saved, so we can tell by checking their
4811 if (!DECL_INITIAL (fn
)
4812 && DECL_ABSTRACT_ORIGIN (fn
)
4813 && gimple_has_body_p (DECL_ABSTRACT_ORIGIN (fn
)))
4814 fn
= DECL_ABSTRACT_ORIGIN (fn
);
4816 /* Don't try to inline functions that are not well-suited to inlining. */
4817 if (cg_edge
->inline_failed
)
4819 reason
= cg_edge
->inline_failed
;
4820 /* If this call was originally indirect, we do not want to emit any
4821 inlining related warnings or sorry messages because there are no
4822 guarantees regarding those. */
4823 if (cg_edge
->indirect_inlining_edge
)
4826 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
))
4827 /* For extern inline functions that get redefined we always
4828 silently ignored always_inline flag. Better behavior would
4829 be to be able to keep both bodies and use extern inline body
4830 for inlining, but we can't do that because frontends overwrite
4832 && !cg_edge
->callee
->redefined_extern_inline
4833 /* During early inline pass, report only when optimization is
4835 && (symtab
->global_info_ready
4837 || cgraph_inline_failed_type (reason
) == CIF_FINAL_ERROR
)
4838 /* PR 20090218-1_0.c. Body can be provided by another module. */
4839 && (reason
!= CIF_BODY_NOT_AVAILABLE
|| !flag_generate_lto
))
4841 error ("inlining failed in call to %<always_inline%> %q+F: %s", fn
,
4842 cgraph_inline_failed_string (reason
));
4843 if (gimple_location (stmt
) != UNKNOWN_LOCATION
)
4844 inform (gimple_location (stmt
), "called from here");
4845 else if (DECL_SOURCE_LOCATION (cfun
->decl
) != UNKNOWN_LOCATION
)
4846 inform (DECL_SOURCE_LOCATION (cfun
->decl
),
4847 "called from this function");
4849 else if (opt_for_fn (fn
, warn_inline
)
4850 && DECL_DECLARED_INLINE_P (fn
)
4851 && !DECL_NO_INLINE_WARNING_P (fn
)
4852 && !DECL_IN_SYSTEM_HEADER (fn
)
4853 && reason
!= CIF_UNSPECIFIED
4854 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn
))
4855 /* Do not warn about not inlined recursive calls. */
4856 && !cg_edge
->recursive_p ()
4857 /* Avoid warnings during early inline pass. */
4858 && symtab
->global_info_ready
)
4860 auto_diagnostic_group d
;
4861 if (warning (OPT_Winline
, "inlining failed in call to %q+F: %s",
4862 fn
, _(cgraph_inline_failed_string (reason
))))
4864 if (gimple_location (stmt
) != UNKNOWN_LOCATION
)
4865 inform (gimple_location (stmt
), "called from here");
4866 else if (DECL_SOURCE_LOCATION (cfun
->decl
) != UNKNOWN_LOCATION
)
4867 inform (DECL_SOURCE_LOCATION (cfun
->decl
),
4868 "called from this function");
4873 id
->src_node
= cg_edge
->callee
;
4875 /* If callee is thunk, all we need is to adjust the THIS pointer
4876 and redirect to function being thunked. */
4877 if (id
->src_node
->thunk
)
4880 tree virtual_offset
= NULL
;
4881 profile_count count
= cg_edge
->count
;
4883 gimple_stmt_iterator iter
= gsi_for_stmt (stmt
);
4884 thunk_info
*info
= thunk_info::get (id
->src_node
);
4886 cgraph_edge::remove (cg_edge
);
4887 edge
= id
->src_node
->callees
->clone (id
->dst_node
, call_stmt
,
4889 profile_count::one (),
4890 profile_count::one (),
4892 edge
->count
= count
;
4893 if (info
->virtual_offset_p
)
4894 virtual_offset
= size_int (info
->virtual_value
);
4895 op
= create_tmp_reg_fn (cfun
, TREE_TYPE (gimple_call_arg (stmt
, 0)),
4897 gsi_insert_before (&iter
, gimple_build_assign (op
,
4898 gimple_call_arg (stmt
, 0)),
4900 gcc_assert (info
->this_adjusting
);
4901 op
= thunk_adjust (&iter
, op
, 1, info
->fixed_offset
,
4902 virtual_offset
, info
->indirect_offset
);
4904 gimple_call_set_arg (stmt
, 0, op
);
4905 gimple_call_set_fndecl (stmt
, edge
->callee
->decl
);
4907 id
->src_node
->remove ();
4908 successfully_inlined
= expand_call_inline (bb
, stmt
, id
, to_purge
);
4909 maybe_remove_unused_call_args (cfun
, stmt
);
4910 /* This used to return true even though we do fail to inline in
4911 some cases. See PR98525. */
4914 fn
= cg_edge
->callee
->decl
;
4915 cg_edge
->callee
->get_untransformed_body ();
4917 if (flag_checking
&& cg_edge
->callee
->decl
!= id
->dst_node
->decl
)
4918 cg_edge
->callee
->verify ();
4920 /* We will be inlining this callee. */
4921 id
->eh_lp_nr
= lookup_stmt_eh_lp (stmt
);
4923 /* Update the callers EH personality. */
4924 if (DECL_FUNCTION_PERSONALITY (fn
))
4925 DECL_FUNCTION_PERSONALITY (cg_edge
->caller
->decl
)
4926 = DECL_FUNCTION_PERSONALITY (fn
);
4928 /* Split the block before the GIMPLE_CALL. */
4929 stmt_gsi
= gsi_for_stmt (stmt
);
4930 gsi_prev (&stmt_gsi
);
4931 e
= split_block (bb
, gsi_end_p (stmt_gsi
) ? NULL
: gsi_stmt (stmt_gsi
));
4933 return_block
= e
->dest
;
4936 /* If the GIMPLE_CALL was in the last statement of BB, it may have
4937 been the source of abnormal edges. In this case, schedule
4938 the removal of dead abnormal edges. */
4939 gsi
= gsi_start_bb (return_block
);
4941 purge_dead_abnormal_edges
= gsi_end_p (gsi
);
4943 stmt_gsi
= gsi_start_bb (return_block
);
4945 /* Build a block containing code to initialize the arguments, the
4946 actual inline expansion of the body, and a label for the return
4947 statements within the function to jump to. The type of the
4948 statement expression is the return type of the function call.
4949 ??? If the call does not have an associated block then we will
4950 remap all callee blocks to NULL, effectively dropping most of
4951 its debug information. This should only happen for calls to
4952 artificial decls inserted by the compiler itself. We need to
4953 either link the inlined blocks into the caller block tree or
4954 not refer to them in any way to not break GC for locations. */
4955 if (tree block
= gimple_block (stmt
))
4957 /* We do want to assign a not UNKNOWN_LOCATION BLOCK_SOURCE_LOCATION
4958 to make inlined_function_outer_scope_p return true on this BLOCK. */
4959 location_t loc
= LOCATION_LOCUS (gimple_location (stmt
));
4960 if (loc
== UNKNOWN_LOCATION
)
4961 loc
= LOCATION_LOCUS (DECL_SOURCE_LOCATION (fn
));
4962 if (loc
== UNKNOWN_LOCATION
)
4963 loc
= BUILTINS_LOCATION
;
4964 id
->block
= make_node (BLOCK
);
4965 BLOCK_ABSTRACT_ORIGIN (id
->block
) = DECL_ORIGIN (fn
);
4966 BLOCK_SOURCE_LOCATION (id
->block
) = loc
;
4967 prepend_lexical_block (block
, id
->block
);
4970 /* Local declarations will be replaced by their equivalents in this map. */
4972 id
->decl_map
= new hash_map
<tree
, tree
>;
4973 dst
= id
->debug_map
;
4974 id
->debug_map
= NULL
;
4975 if (flag_stack_reuse
!= SR_NONE
)
4976 id
->add_clobbers_to_eh_landing_pads
= last_basic_block_for_fn (cfun
);
4978 /* Record the function we are about to inline. */
4980 id
->src_cfun
= DECL_STRUCT_FUNCTION (fn
);
4981 id
->reset_location
= DECL_IGNORED_P (fn
);
4982 id
->call_stmt
= call_stmt
;
4984 /* When inlining into an OpenMP SIMD-on-SIMT loop, arrange for new automatic
4985 variables to be added to IFN_GOMP_SIMT_ENTER argument list. */
4986 dst_cfun
= DECL_STRUCT_FUNCTION (id
->dst_fn
);
4987 simtvars_save
= id
->dst_simt_vars
;
4988 if (!(dst_cfun
->curr_properties
& PROP_gimple_lomp_dev
)
4989 && (simduid
= bb
->loop_father
->simduid
) != NULL_TREE
4990 && (simduid
= ssa_default_def (dst_cfun
, simduid
)) != NULL_TREE
4991 && single_imm_use (simduid
, &use
, &simtenter_stmt
)
4992 && is_gimple_call (simtenter_stmt
)
4993 && gimple_call_internal_p (simtenter_stmt
, IFN_GOMP_SIMT_ENTER
))
4994 vec_alloc (id
->dst_simt_vars
, 0);
4996 id
->dst_simt_vars
= NULL
;
4998 if (profile_status_for_fn (id
->src_cfun
) == PROFILE_ABSENT
)
4999 profile_status_for_fn (dst_cfun
) = PROFILE_ABSENT
;
5001 /* If the src function contains an IFN_VA_ARG, then so will the dst
5002 function after inlining. Likewise for IFN_GOMP_USE_SIMT. */
5003 prop_mask
= PROP_gimple_lva
| PROP_gimple_lomp_dev
;
5004 src_properties
= id
->src_cfun
->curr_properties
& prop_mask
;
5005 if (src_properties
!= prop_mask
)
5006 dst_cfun
->curr_properties
&= src_properties
| ~prop_mask
;
5007 dst_cfun
->calls_eh_return
|= id
->src_cfun
->calls_eh_return
;
5008 id
->dst_node
->calls_declare_variant_alt
5009 |= id
->src_node
->calls_declare_variant_alt
;
5011 gcc_assert (!id
->src_cfun
->after_inlining
);
5014 if (lookup_attribute ("cold", DECL_ATTRIBUTES (fn
)))
5016 gimple_stmt_iterator si
= gsi_last_bb (bb
);
5017 gsi_insert_after (&si
, gimple_build_predict (PRED_COLD_FUNCTION
,
5021 initialize_inlined_parameters (id
, stmt
, fn
, bb
);
5022 if (debug_nonbind_markers_p
&& debug_inline_points
&& id
->block
5023 && inlined_function_outer_scope_p (id
->block
))
5025 gimple_stmt_iterator si
= gsi_last_bb (bb
);
5026 gsi_insert_after (&si
, gimple_build_debug_inline_entry
5027 (id
->block
, DECL_SOURCE_LOCATION (id
->src_fn
)),
5031 if (DECL_INITIAL (fn
))
5033 if (gimple_block (stmt
))
5037 prepend_lexical_block (id
->block
,
5038 remap_blocks (DECL_INITIAL (fn
), id
));
5039 gcc_checking_assert (BLOCK_SUBBLOCKS (id
->block
)
5040 && (BLOCK_CHAIN (BLOCK_SUBBLOCKS (id
->block
))
5042 /* Move vars for PARM_DECLs from DECL_INITIAL block to id->block,
5043 otherwise for DWARF DW_TAG_formal_parameter will not be children of
5044 DW_TAG_inlined_subroutine, but of a DW_TAG_lexical_block
5045 under it. The parameters can be then evaluated in the debugger,
5046 but don't show in backtraces. */
5047 for (var
= &BLOCK_VARS (BLOCK_SUBBLOCKS (id
->block
)); *var
; )
5048 if (TREE_CODE (DECL_ORIGIN (*var
)) == PARM_DECL
)
5051 *var
= TREE_CHAIN (v
);
5052 TREE_CHAIN (v
) = BLOCK_VARS (id
->block
);
5053 BLOCK_VARS (id
->block
) = v
;
5056 var
= &TREE_CHAIN (*var
);
5059 remap_blocks_to_null (DECL_INITIAL (fn
), id
);
5062 /* Return statements in the function body will be replaced by jumps
5063 to the RET_LABEL. */
5064 gcc_assert (DECL_INITIAL (fn
));
5065 gcc_assert (TREE_CODE (DECL_INITIAL (fn
)) == BLOCK
);
5067 /* Find the LHS to which the result of this call is assigned. */
5069 if (gimple_call_lhs (stmt
))
5071 modify_dest
= gimple_call_lhs (stmt
);
5073 /* The function which we are inlining might not return a value,
5074 in which case we should issue a warning that the function
5075 does not return a value. In that case the optimizers will
5076 see that the variable to which the value is assigned was not
5077 initialized. We do not want to issue a warning about that
5078 uninitialized variable. */
5079 if (DECL_P (modify_dest
))
5080 suppress_warning (modify_dest
, OPT_Wuninitialized
);
5082 if (gimple_call_return_slot_opt_p (call_stmt
))
5084 return_slot
= modify_dest
;
5091 /* If we are inlining a call to the C++ operator new, we don't want
5092 to use type based alias analysis on the return value. Otherwise
5093 we may get confused if the compiler sees that the inlined new
5094 function returns a pointer which was just deleted. See bug
5096 if (DECL_IS_OPERATOR_NEW_P (fn
))
5102 /* Declare the return variable for the function. */
5103 use_retvar
= declare_return_variable (id
, return_slot
, modify_dest
, bb
);
5105 /* Add local vars in this inlined callee to caller. */
5106 add_local_variables (id
->src_cfun
, cfun
, id
);
5108 if (dump_enabled_p ())
5111 snprintf (buf
, sizeof(buf
), "%4.2f",
5112 cg_edge
->sreal_frequency ().to_double ());
5113 dump_printf_loc (MSG_NOTE
| MSG_PRIORITY_INTERNALS
,
5115 "Inlining %C to %C with frequency %s\n",
5116 id
->src_node
, id
->dst_node
, buf
);
5117 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5119 id
->src_node
->dump (dump_file
);
5120 id
->dst_node
->dump (dump_file
);
5124 /* This is it. Duplicate the callee body. Assume callee is
5125 pre-gimplified. Note that we must not alter the caller
5126 function in any way before this point, as this CALL_EXPR may be
5127 a self-referential call; if we're calling ourselves, we need to
5128 duplicate our body before altering anything. */
5129 copy_body (id
, bb
, return_block
, NULL
);
5131 reset_debug_bindings (id
, stmt_gsi
);
5133 if (flag_stack_reuse
!= SR_NONE
)
5134 for (tree p
= DECL_ARGUMENTS (id
->src_fn
); p
; p
= DECL_CHAIN (p
))
5135 if (!TREE_THIS_VOLATILE (p
))
5137 /* The value associated with P is a local temporary only if
5138 there is no value associated with P in the debug map. */
5139 tree
*varp
= id
->decl_map
->get (p
);
5142 && !is_gimple_reg (*varp
)
5143 && !(id
->debug_map
&& id
->debug_map
->get (p
)))
5145 tree clobber
= build_clobber (TREE_TYPE (*varp
));
5146 gimple
*clobber_stmt
;
5147 clobber_stmt
= gimple_build_assign (*varp
, clobber
);
5148 gimple_set_location (clobber_stmt
, gimple_location (stmt
));
5149 gsi_insert_before (&stmt_gsi
, clobber_stmt
, GSI_SAME_STMT
);
5153 /* Reset the escaped solution. */
5154 if (cfun
->gimple_df
)
5155 pt_solution_reset (&cfun
->gimple_df
->escaped
);
5157 /* Add new automatic variables to IFN_GOMP_SIMT_ENTER arguments. */
5158 if (id
->dst_simt_vars
&& id
->dst_simt_vars
->length () > 0)
5160 size_t nargs
= gimple_call_num_args (simtenter_stmt
);
5161 vec
<tree
> *vars
= id
->dst_simt_vars
;
5162 auto_vec
<tree
> newargs (nargs
+ vars
->length ());
5163 for (size_t i
= 0; i
< nargs
; i
++)
5164 newargs
.quick_push (gimple_call_arg (simtenter_stmt
, i
));
5165 for (tree
*pvar
= vars
->begin (); pvar
!= vars
->end (); pvar
++)
5167 tree ptrtype
= build_pointer_type (TREE_TYPE (*pvar
));
5168 newargs
.quick_push (build1 (ADDR_EXPR
, ptrtype
, *pvar
));
5170 gcall
*g
= gimple_build_call_internal_vec (IFN_GOMP_SIMT_ENTER
, newargs
);
5171 gimple_call_set_lhs (g
, gimple_call_lhs (simtenter_stmt
));
5172 gimple_stmt_iterator gsi
= gsi_for_stmt (simtenter_stmt
);
5173 gsi_replace (&gsi
, g
, false);
5175 vec_free (id
->dst_simt_vars
);
5176 id
->dst_simt_vars
= simtvars_save
;
5181 delete id
->debug_map
;
5182 id
->debug_map
= dst
;
5184 delete id
->decl_map
;
5187 /* Unlink the calls virtual operands before replacing it. */
5188 unlink_stmt_vdef (stmt
);
5189 if (gimple_vdef (stmt
)
5190 && TREE_CODE (gimple_vdef (stmt
)) == SSA_NAME
)
5191 release_ssa_name (gimple_vdef (stmt
));
5193 /* If the inlined function returns a result that we care about,
5194 substitute the GIMPLE_CALL with an assignment of the return
5195 variable to the LHS of the call. That is, if STMT was
5196 'a = foo (...)', substitute the call with 'a = USE_RETVAR'. */
5197 if (use_retvar
&& gimple_call_lhs (stmt
))
5199 gimple
*old_stmt
= stmt
;
5200 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), use_retvar
);
5201 gimple_set_location (stmt
, gimple_location (old_stmt
));
5202 gsi_replace (&stmt_gsi
, stmt
, false);
5203 maybe_clean_or_replace_eh_stmt (old_stmt
, stmt
);
5204 /* Append a clobber for id->retvar if easily possible. */
5205 if (flag_stack_reuse
!= SR_NONE
5207 && VAR_P (id
->retvar
)
5208 && id
->retvar
!= return_slot
5209 && id
->retvar
!= modify_dest
5210 && !TREE_THIS_VOLATILE (id
->retvar
)
5211 && !is_gimple_reg (id
->retvar
)
5212 && !stmt_ends_bb_p (stmt
))
5214 tree clobber
= build_clobber (TREE_TYPE (id
->retvar
));
5215 gimple
*clobber_stmt
;
5216 clobber_stmt
= gimple_build_assign (id
->retvar
, clobber
);
5217 gimple_set_location (clobber_stmt
, gimple_location (old_stmt
));
5218 gsi_insert_after (&stmt_gsi
, clobber_stmt
, GSI_SAME_STMT
);
5223 /* Handle the case of inlining a function with no return
5224 statement, which causes the return value to become undefined. */
5225 if (gimple_call_lhs (stmt
)
5226 && TREE_CODE (gimple_call_lhs (stmt
)) == SSA_NAME
)
5228 tree name
= gimple_call_lhs (stmt
);
5229 tree var
= SSA_NAME_VAR (name
);
5230 tree def
= var
? ssa_default_def (cfun
, var
) : NULL
;
5234 /* If the variable is used undefined, make this name
5235 undefined via a move. */
5236 stmt
= gimple_build_assign (gimple_call_lhs (stmt
), def
);
5237 gsi_replace (&stmt_gsi
, stmt
, true);
5243 var
= create_tmp_reg_fn (cfun
, TREE_TYPE (name
), NULL
);
5244 SET_SSA_NAME_VAR_OR_IDENTIFIER (name
, var
);
5246 /* Otherwise make this variable undefined. */
5247 gsi_remove (&stmt_gsi
, true);
5248 set_ssa_default_def (cfun
, var
, name
);
5249 SSA_NAME_DEF_STMT (name
) = gimple_build_nop ();
5252 /* Replace with a clobber for id->retvar. */
5253 else if (flag_stack_reuse
!= SR_NONE
5255 && VAR_P (id
->retvar
)
5256 && id
->retvar
!= return_slot
5257 && id
->retvar
!= modify_dest
5258 && !TREE_THIS_VOLATILE (id
->retvar
)
5259 && !is_gimple_reg (id
->retvar
))
5261 tree clobber
= build_clobber (TREE_TYPE (id
->retvar
));
5262 gimple
*clobber_stmt
;
5263 clobber_stmt
= gimple_build_assign (id
->retvar
, clobber
);
5264 gimple_set_location (clobber_stmt
, gimple_location (stmt
));
5265 gsi_replace (&stmt_gsi
, clobber_stmt
, false);
5266 maybe_clean_or_replace_eh_stmt (stmt
, clobber_stmt
);
5269 gsi_remove (&stmt_gsi
, true);
5272 if (purge_dead_abnormal_edges
)
5273 bitmap_set_bit (to_purge
, return_block
->index
);
5275 /* If the value of the new expression is ignored, that's OK. We
5276 don't warn about this for CALL_EXPRs, so we shouldn't warn about
5277 the equivalent inlined version either. */
5278 if (is_gimple_assign (stmt
))
5280 gcc_assert (gimple_assign_single_p (stmt
)
5281 || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt
)));
5282 TREE_USED (gimple_assign_rhs1 (stmt
)) = 1;
5285 id
->add_clobbers_to_eh_landing_pads
= 0;
5287 /* Output the inlining info for this abstract function, since it has been
5288 inlined. If we don't do this now, we can lose the information about the
5289 variables in the function when the blocks get blown away as soon as we
5290 remove the cgraph node. */
5291 if (gimple_block (stmt
))
5292 (*debug_hooks
->outlining_inline_function
) (fn
);
5294 /* Update callgraph if needed. */
5295 cg_edge
->callee
->remove ();
5297 id
->block
= NULL_TREE
;
5298 id
->retvar
= NULL_TREE
;
5299 successfully_inlined
= true;
5302 input_location
= saved_location
;
5303 return successfully_inlined
;
5306 /* Expand call statements reachable from STMT_P.
5307 We can only have CALL_EXPRs as the "toplevel" tree code or nested
5308 in a MODIFY_EXPR. */
5311 gimple_expand_calls_inline (basic_block bb
, copy_body_data
*id
,
5314 gimple_stmt_iterator gsi
;
5315 bool inlined
= false;
5317 for (gsi
= gsi_last_bb (bb
); !gsi_end_p (gsi
);)
5319 gimple
*stmt
= gsi_stmt (gsi
);
5322 if (is_gimple_call (stmt
)
5323 && !gimple_call_internal_p (stmt
))
5324 inlined
|= expand_call_inline (bb
, stmt
, id
, to_purge
);
5331 /* Walk all basic blocks created after FIRST and try to fold every statement
5332 in the STATEMENTS pointer set. */
5335 fold_marked_statements (int first
, hash_set
<gimple
*> *statements
)
5337 auto_bitmap to_purge
;
5339 auto_vec
<edge
, 20> stack (n_basic_blocks_for_fn (cfun
) + 2);
5340 auto_sbitmap
visited (last_basic_block_for_fn (cfun
));
5341 bitmap_clear (visited
);
5343 stack
.quick_push (single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
5344 while (!stack
.is_empty ())
5346 /* Look at the edge on the top of the stack. */
5347 edge e
= stack
.pop ();
5348 basic_block dest
= e
->dest
;
5350 if (dest
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
5351 || bitmap_bit_p (visited
, dest
->index
))
5354 bitmap_set_bit (visited
, dest
->index
);
5356 if (dest
->index
>= first
)
5357 for (gimple_stmt_iterator gsi
= gsi_start_bb (dest
);
5358 !gsi_end_p (gsi
); gsi_next (&gsi
))
5360 if (!statements
->contains (gsi_stmt (gsi
)))
5363 gimple
*old_stmt
= gsi_stmt (gsi
);
5364 tree old_decl
= (is_gimple_call (old_stmt
)
5365 ? gimple_call_fndecl (old_stmt
) : 0);
5366 if (old_decl
&& fndecl_built_in_p (old_decl
))
5368 /* Folding builtins can create multiple instructions,
5369 we need to look at all of them. */
5370 gimple_stmt_iterator i2
= gsi
;
5372 if (fold_stmt (&gsi
))
5375 /* If a builtin at the end of a bb folded into nothing,
5376 the following loop won't work. */
5377 if (gsi_end_p (gsi
))
5379 cgraph_update_edges_for_call_stmt (old_stmt
,
5384 i2
= gsi_start_bb (dest
);
5389 new_stmt
= gsi_stmt (i2
);
5390 update_stmt (new_stmt
);
5391 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
5394 if (new_stmt
== gsi_stmt (gsi
))
5396 /* It is okay to check only for the very last
5397 of these statements. If it is a throwing
5398 statement nothing will change. If it isn't
5399 this can remove EH edges. If that weren't
5400 correct then because some intermediate stmts
5401 throw, but not the last one. That would mean
5402 we'd have to split the block, which we can't
5403 here and we'd loose anyway. And as builtins
5404 probably never throw, this all
5406 if (maybe_clean_or_replace_eh_stmt (old_stmt
,
5408 bitmap_set_bit (to_purge
, dest
->index
);
5415 else if (fold_stmt (&gsi
))
5417 /* Re-read the statement from GSI as fold_stmt() may
5419 gimple
*new_stmt
= gsi_stmt (gsi
);
5420 update_stmt (new_stmt
);
5422 if (is_gimple_call (old_stmt
)
5423 || is_gimple_call (new_stmt
))
5424 cgraph_update_edges_for_call_stmt (old_stmt
, old_decl
,
5427 if (maybe_clean_or_replace_eh_stmt (old_stmt
, new_stmt
))
5428 bitmap_set_bit (to_purge
, dest
->index
);
5432 if (EDGE_COUNT (dest
->succs
) > 0)
5434 /* Avoid warnings emitted from folding statements that
5435 became unreachable because of inlined function parameter
5437 e
= find_taken_edge (dest
, NULL_TREE
);
5439 stack
.quick_push (e
);
5443 FOR_EACH_EDGE (e
, ei
, dest
->succs
)
5444 stack
.safe_push (e
);
5449 gimple_purge_all_dead_eh_edges (to_purge
);
5452 /* Expand calls to inline functions in the body of FN. */
5455 optimize_inline_calls (tree fn
)
5459 int last
= n_basic_blocks_for_fn (cfun
);
5460 bool inlined_p
= false;
5463 memset (&id
, 0, sizeof (id
));
5465 id
.src_node
= id
.dst_node
= cgraph_node::get (fn
);
5466 gcc_assert (id
.dst_node
->definition
);
5468 /* Or any functions that aren't finished yet. */
5469 if (current_function_decl
)
5470 id
.dst_fn
= current_function_decl
;
5472 id
.copy_decl
= copy_decl_maybe_to_var
;
5473 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5474 id
.transform_new_cfg
= false;
5475 id
.transform_return_to_modify
= true;
5476 id
.transform_parameter
= true;
5477 id
.transform_lang_insert_block
= NULL
;
5478 id
.statements_to_fold
= new hash_set
<gimple
*>;
5480 push_gimplify_context ();
5482 /* We make no attempts to keep dominance info up-to-date. */
5483 free_dominance_info (CDI_DOMINATORS
);
5484 free_dominance_info (CDI_POST_DOMINATORS
);
5486 /* Register specific gimple functions. */
5487 gimple_register_cfg_hooks ();
5489 /* Reach the trees by walking over the CFG, and note the
5490 enclosing basic-blocks in the call edges. */
5491 /* We walk the blocks going forward, because inlined function bodies
5492 will split id->current_basic_block, and the new blocks will
5493 follow it; we'll trudge through them, processing their CALL_EXPRs
5495 auto_bitmap to_purge
;
5496 FOR_EACH_BB_FN (bb
, cfun
)
5497 inlined_p
|= gimple_expand_calls_inline (bb
, &id
, to_purge
);
5499 pop_gimplify_context (NULL
);
5503 struct cgraph_edge
*e
;
5505 id
.dst_node
->verify ();
5507 /* Double check that we inlined everything we are supposed to inline. */
5508 for (e
= id
.dst_node
->callees
; e
; e
= e
->next_callee
)
5509 gcc_assert (e
->inline_failed
);
5512 /* If we didn't inline into the function there is nothing to do. */
5515 delete id
.statements_to_fold
;
5519 /* Fold queued statements. */
5520 update_max_bb_count ();
5521 fold_marked_statements (last
, id
.statements_to_fold
);
5522 delete id
.statements_to_fold
;
5524 /* Finally purge EH and abnormal edges from the call stmts we inlined.
5525 We need to do this after fold_marked_statements since that may walk
5526 the SSA use-def chain. */
5529 EXECUTE_IF_SET_IN_BITMAP (to_purge
, 0, i
, bi
)
5531 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
5534 gimple_purge_dead_eh_edges (bb
);
5535 gimple_purge_dead_abnormal_call_edges (bb
);
5539 gcc_assert (!id
.debug_stmts
.exists ());
5541 /* Renumber the lexical scoping (non-code) blocks consecutively. */
5544 delete_unreachable_blocks_update_callgraph (id
.dst_node
, false);
5545 id
.dst_node
->calls_comdat_local
= id
.dst_node
->check_calls_comdat_local_p ();
5548 id
.dst_node
->verify ();
5550 /* It would be nice to check SSA/CFG/statement consistency here, but it is
5551 not possible yet - the IPA passes might make various functions to not
5552 throw and they don't care to proactively update local EH info. This is
5553 done later in fixup_cfg pass that also execute the verification. */
5554 return (TODO_update_ssa
5556 | (gimple_in_ssa_p (cfun
) ? TODO_remove_unused_locals
: 0)
5557 | (gimple_in_ssa_p (cfun
) ? TODO_update_address_taken
: 0)
5558 | (profile_status_for_fn (cfun
) != PROFILE_ABSENT
5559 ? TODO_rebuild_frequencies
: 0));
5562 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
5565 copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
5567 enum tree_code code
= TREE_CODE (*tp
);
5568 enum tree_code_class cl
= TREE_CODE_CLASS (code
);
5570 /* We make copies of most nodes. */
5571 if (IS_EXPR_CODE_CLASS (cl
)
5572 || code
== TREE_LIST
5574 || code
== TYPE_DECL
5575 || code
== OMP_CLAUSE
)
5577 /* Because the chain gets clobbered when we make a copy, we save it
5579 tree chain
= NULL_TREE
, new_tree
;
5581 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
5582 chain
= TREE_CHAIN (*tp
);
5584 /* Copy the node. */
5585 new_tree
= copy_node (*tp
);
5589 /* Now, restore the chain, if appropriate. That will cause
5590 walk_tree to walk into the chain as well. */
5591 if (code
== PARM_DECL
5592 || code
== TREE_LIST
5593 || code
== OMP_CLAUSE
)
5594 TREE_CHAIN (*tp
) = chain
;
5596 /* For now, we don't update BLOCKs when we make copies. So, we
5597 have to nullify all BIND_EXPRs. */
5598 if (TREE_CODE (*tp
) == BIND_EXPR
)
5599 BIND_EXPR_BLOCK (*tp
) = NULL_TREE
;
5601 else if (code
== CONSTRUCTOR
)
5603 /* CONSTRUCTOR nodes need special handling because
5604 we need to duplicate the vector of elements. */
5607 new_tree
= copy_node (*tp
);
5608 CONSTRUCTOR_ELTS (new_tree
) = vec_safe_copy (CONSTRUCTOR_ELTS (*tp
));
5611 else if (code
== STATEMENT_LIST
)
5612 /* We used to just abort on STATEMENT_LIST, but we can run into them
5613 with statement-expressions (c++/40975). */
5614 copy_statement_list (tp
);
5615 else if (TREE_CODE_CLASS (code
) == tcc_type
)
5617 else if (TREE_CODE_CLASS (code
) == tcc_declaration
)
5619 else if (TREE_CODE_CLASS (code
) == tcc_constant
)
5624 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
5625 information indicating to what new SAVE_EXPR this one should be mapped,
5626 use that one. Otherwise, create a new node and enter it in ST. FN is
5627 the function into which the copy will be placed. */
5630 remap_save_expr (tree
*tp
, hash_map
<tree
, tree
> *st
, int *walk_subtrees
)
5635 /* See if we already encountered this SAVE_EXPR. */
5638 /* If we didn't already remap this SAVE_EXPR, do so now. */
5641 t
= copy_node (*tp
);
5643 /* Remember this SAVE_EXPR. */
5645 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
5650 /* We've already walked into this SAVE_EXPR; don't do it again. */
5655 /* Replace this SAVE_EXPR with the copy. */
5659 /* Called via walk_gimple_seq. If *GSIP points to a GIMPLE_LABEL for a local
5660 label, copies the declaration and enters it in the splay_tree in DATA (which
5661 is really a 'copy_body_data *'. */
5664 mark_local_labels_stmt (gimple_stmt_iterator
*gsip
,
5665 bool *handled_ops_p ATTRIBUTE_UNUSED
,
5666 struct walk_stmt_info
*wi
)
5668 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
5669 glabel
*stmt
= dyn_cast
<glabel
*> (gsi_stmt (*gsip
));
5673 tree decl
= gimple_label_label (stmt
);
5675 /* Copy the decl and remember the copy. */
5676 insert_decl_map (id
, decl
, id
->copy_decl (decl
, id
));
5682 static gimple_seq
duplicate_remap_omp_clause_seq (gimple_seq seq
,
5683 struct walk_stmt_info
*wi
);
5685 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
5686 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
5687 remaps all local declarations to appropriate replacements in gimple
5691 replace_locals_op (tree
*tp
, int *walk_subtrees
, void *data
)
5693 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
5694 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
5695 hash_map
<tree
, tree
> *st
= id
->decl_map
;
5699 /* For recursive invocations this is no longer the LHS itself. */
5700 bool is_lhs
= wi
->is_lhs
;
5703 if (TREE_CODE (expr
) == SSA_NAME
)
5705 *tp
= remap_ssa_name (*tp
, id
);
5708 SSA_NAME_DEF_STMT (*tp
) = gsi_stmt (wi
->gsi
);
5710 /* Only a local declaration (variable or label). */
5711 else if ((VAR_P (expr
) && !TREE_STATIC (expr
))
5712 || TREE_CODE (expr
) == LABEL_DECL
)
5714 /* Lookup the declaration. */
5717 /* If it's there, remap it. */
5722 else if (TREE_CODE (expr
) == STATEMENT_LIST
5723 || TREE_CODE (expr
) == BIND_EXPR
5724 || TREE_CODE (expr
) == SAVE_EXPR
)
5726 else if (TREE_CODE (expr
) == TARGET_EXPR
)
5728 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
5729 It's OK for this to happen if it was part of a subtree that
5730 isn't immediately expanded, such as operand 2 of another
5732 if (!TREE_OPERAND (expr
, 1))
5734 TREE_OPERAND (expr
, 1) = TREE_OPERAND (expr
, 3);
5735 TREE_OPERAND (expr
, 3) = NULL_TREE
;
5738 else if (TREE_CODE (expr
) == OMP_CLAUSE
)
5740 /* Before the omplower pass completes, some OMP clauses can contain
5741 sequences that are neither copied by gimple_seq_copy nor walked by
5742 walk_gimple_seq. To make copy_gimple_seq_and_replace_locals work even
5743 in those situations, we have to copy and process them explicitely. */
5745 if (OMP_CLAUSE_CODE (expr
) == OMP_CLAUSE_LASTPRIVATE
)
5747 gimple_seq seq
= OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (expr
);
5748 seq
= duplicate_remap_omp_clause_seq (seq
, wi
);
5749 OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (expr
) = seq
;
5751 else if (OMP_CLAUSE_CODE (expr
) == OMP_CLAUSE_LINEAR
)
5753 gimple_seq seq
= OMP_CLAUSE_LINEAR_GIMPLE_SEQ (expr
);
5754 seq
= duplicate_remap_omp_clause_seq (seq
, wi
);
5755 OMP_CLAUSE_LINEAR_GIMPLE_SEQ (expr
) = seq
;
5757 else if (OMP_CLAUSE_CODE (expr
) == OMP_CLAUSE_REDUCTION
)
5759 gimple_seq seq
= OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr
);
5760 seq
= duplicate_remap_omp_clause_seq (seq
, wi
);
5761 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr
) = seq
;
5762 seq
= OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr
);
5763 seq
= duplicate_remap_omp_clause_seq (seq
, wi
);
5764 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr
) = seq
;
5768 /* Keep iterating. */
5773 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
5774 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
5775 remaps all local declarations to appropriate replacements in gimple
5779 replace_locals_stmt (gimple_stmt_iterator
*gsip
,
5780 bool *handled_ops_p ATTRIBUTE_UNUSED
,
5781 struct walk_stmt_info
*wi
)
5783 copy_body_data
*id
= (copy_body_data
*) wi
->info
;
5784 gimple
*gs
= gsi_stmt (*gsip
);
5786 if (gbind
*stmt
= dyn_cast
<gbind
*> (gs
))
5788 tree block
= gimple_bind_block (stmt
);
5792 remap_block (&block
, id
);
5793 gimple_bind_set_block (stmt
, block
);
5796 /* This will remap a lot of the same decls again, but this should be
5798 if (gimple_bind_vars (stmt
))
5800 tree old_var
, decls
= gimple_bind_vars (stmt
);
5802 for (old_var
= decls
; old_var
; old_var
= DECL_CHAIN (old_var
))
5803 if (!can_be_nonlocal (old_var
, id
)
5804 && ! variably_modified_type_p (TREE_TYPE (old_var
), id
->src_fn
))
5805 remap_decl (old_var
, id
);
5807 gcc_checking_assert (!id
->prevent_decl_creation_for_types
);
5808 id
->prevent_decl_creation_for_types
= true;
5809 gimple_bind_set_vars (stmt
, remap_decls (decls
, NULL
, id
));
5810 id
->prevent_decl_creation_for_types
= false;
5814 /* Keep iterating. */
5818 /* Create a copy of SEQ and remap all decls in it. */
5821 duplicate_remap_omp_clause_seq (gimple_seq seq
, struct walk_stmt_info
*wi
)
5826 /* If there are any labels in OMP sequences, they can be only referred to in
5827 the sequence itself and therefore we can do both here. */
5828 walk_gimple_seq (seq
, mark_local_labels_stmt
, NULL
, wi
);
5829 gimple_seq copy
= gimple_seq_copy (seq
);
5830 walk_gimple_seq (copy
, replace_locals_stmt
, replace_locals_op
, wi
);
5834 /* Copies everything in SEQ and replaces variables and labels local to
5835 current_function_decl. */
5838 copy_gimple_seq_and_replace_locals (gimple_seq seq
)
5841 struct walk_stmt_info wi
;
5844 /* There's nothing to do for NULL_TREE. */
5849 memset (&id
, 0, sizeof (id
));
5850 id
.src_fn
= current_function_decl
;
5851 id
.dst_fn
= current_function_decl
;
5853 id
.decl_map
= new hash_map
<tree
, tree
>;
5854 id
.debug_map
= NULL
;
5856 id
.copy_decl
= copy_decl_no_change
;
5857 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5858 id
.transform_new_cfg
= false;
5859 id
.transform_return_to_modify
= false;
5860 id
.transform_parameter
= false;
5861 id
.transform_lang_insert_block
= NULL
;
5863 /* Walk the tree once to find local labels. */
5864 memset (&wi
, 0, sizeof (wi
));
5865 hash_set
<tree
> visited
;
5868 walk_gimple_seq (seq
, mark_local_labels_stmt
, NULL
, &wi
);
5870 copy
= gimple_seq_copy (seq
);
5872 /* Walk the copy, remapping decls. */
5873 memset (&wi
, 0, sizeof (wi
));
5875 walk_gimple_seq (copy
, replace_locals_stmt
, replace_locals_op
, &wi
);
5880 delete id
.debug_map
;
5881 if (id
.dependence_map
)
5883 delete id
.dependence_map
;
5884 id
.dependence_map
= NULL
;
5891 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
5894 debug_find_tree_1 (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
, void *data
)
5903 debug_find_tree (tree top
, tree search
)
5905 return walk_tree_without_duplicates (&top
, debug_find_tree_1
, search
) != 0;
5909 /* Declare the variables created by the inliner. Add all the variables in
5910 VARS to BIND_EXPR. */
5913 declare_inline_vars (tree block
, tree vars
)
5916 for (t
= vars
; t
; t
= DECL_CHAIN (t
))
5918 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
5919 gcc_assert (!TREE_STATIC (t
) && !TREE_ASM_WRITTEN (t
));
5920 add_local_decl (cfun
, t
);
5924 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), vars
);
5927 /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN,
5928 but now it will be in the TO_FN. PARM_TO_VAR means enable PARM_DECL to
5929 VAR_DECL translation. */
5932 copy_decl_for_dup_finish (copy_body_data
*id
, tree decl
, tree copy
)
5934 /* Don't generate debug information for the copy if we wouldn't have
5935 generated it for the copy either. */
5936 DECL_ARTIFICIAL (copy
) = DECL_ARTIFICIAL (decl
);
5937 DECL_IGNORED_P (copy
) = DECL_IGNORED_P (decl
);
5939 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
5940 declaration inspired this copy. */
5941 DECL_ABSTRACT_ORIGIN (copy
) = DECL_ORIGIN (decl
);
5943 /* The new variable/label has no RTL, yet. */
5944 if (CODE_CONTAINS_STRUCT (TREE_CODE (copy
), TS_DECL_WRTL
)
5945 && !TREE_STATIC (copy
) && !DECL_EXTERNAL (copy
))
5946 SET_DECL_RTL (copy
, 0);
5947 /* For vector typed decls make sure to update DECL_MODE according
5948 to the new function context. */
5949 if (VECTOR_TYPE_P (TREE_TYPE (copy
)))
5950 SET_DECL_MODE (copy
, TYPE_MODE (TREE_TYPE (copy
)));
5952 /* These args would always appear unused, if not for this. */
5953 TREE_USED (copy
) = 1;
5955 /* Set the context for the new declaration. */
5956 if (!DECL_CONTEXT (decl
))
5957 /* Globals stay global. */
5959 else if (DECL_CONTEXT (decl
) != id
->src_fn
)
5960 /* Things that weren't in the scope of the function we're inlining
5961 from aren't in the scope we're inlining to, either. */
5963 else if (TREE_STATIC (decl
))
5964 /* Function-scoped static variables should stay in the original
5969 /* Ordinary automatic local variables are now in the scope of the
5971 DECL_CONTEXT (copy
) = id
->dst_fn
;
5972 if (VAR_P (copy
) && id
->dst_simt_vars
&& !is_gimple_reg (copy
))
5974 if (!lookup_attribute ("omp simt private", DECL_ATTRIBUTES (copy
)))
5975 DECL_ATTRIBUTES (copy
)
5976 = tree_cons (get_identifier ("omp simt private"), NULL
,
5977 DECL_ATTRIBUTES (copy
));
5978 id
->dst_simt_vars
->safe_push (copy
);
5985 /* Create a new VAR_DECL that is indentical in all respect to DECL except that
5986 DECL can be either a VAR_DECL, a PARM_DECL or RESULT_DECL. The original
5987 DECL must come from ID->src_fn and the copy will be part of ID->dst_fn. */
5990 copy_decl_to_var (tree decl
, copy_body_data
*id
)
5994 gcc_assert (TREE_CODE (decl
) == PARM_DECL
5995 || TREE_CODE (decl
) == RESULT_DECL
);
5997 type
= TREE_TYPE (decl
);
5999 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
6000 VAR_DECL
, DECL_NAME (decl
), type
);
6001 if (DECL_PT_UID_SET_P (decl
))
6002 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
6003 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
6004 TREE_READONLY (copy
) = TREE_READONLY (decl
);
6005 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
6006 DECL_NOT_GIMPLE_REG_P (copy
) = DECL_NOT_GIMPLE_REG_P (decl
);
6007 DECL_BY_REFERENCE (copy
) = DECL_BY_REFERENCE (decl
);
6009 return copy_decl_for_dup_finish (id
, decl
, copy
);
6012 /* Like copy_decl_to_var, but create a return slot object instead of a
6013 pointer variable for return by invisible reference. */
6016 copy_result_decl_to_var (tree decl
, copy_body_data
*id
)
6020 gcc_assert (TREE_CODE (decl
) == PARM_DECL
6021 || TREE_CODE (decl
) == RESULT_DECL
);
6023 type
= TREE_TYPE (decl
);
6024 if (DECL_BY_REFERENCE (decl
))
6025 type
= TREE_TYPE (type
);
6027 copy
= build_decl (DECL_SOURCE_LOCATION (id
->dst_fn
),
6028 VAR_DECL
, DECL_NAME (decl
), type
);
6029 if (DECL_PT_UID_SET_P (decl
))
6030 SET_DECL_PT_UID (copy
, DECL_PT_UID (decl
));
6031 TREE_READONLY (copy
) = TREE_READONLY (decl
);
6032 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (decl
);
6033 if (!DECL_BY_REFERENCE (decl
))
6035 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (decl
);
6036 DECL_NOT_GIMPLE_REG_P (copy
)
6037 = (DECL_NOT_GIMPLE_REG_P (decl
)
6038 /* RESULT_DECLs are treated special by needs_to_live_in_memory,
6039 mirror that to the created VAR_DECL. */
6040 || (TREE_CODE (decl
) == RESULT_DECL
6041 && aggregate_value_p (decl
, id
->src_fn
)));
6044 return copy_decl_for_dup_finish (id
, decl
, copy
);
6048 copy_decl_no_change (tree decl
, copy_body_data
*id
)
6052 copy
= copy_node (decl
);
6054 /* The COPY is not abstract; it will be generated in DST_FN. */
6055 DECL_ABSTRACT_P (copy
) = false;
6056 lang_hooks
.dup_lang_specific_decl (copy
);
6058 /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
6059 been taken; it's for internal bookkeeping in expand_goto_internal. */
6060 if (TREE_CODE (copy
) == LABEL_DECL
)
6062 TREE_ADDRESSABLE (copy
) = 0;
6063 LABEL_DECL_UID (copy
) = -1;
6066 return copy_decl_for_dup_finish (id
, decl
, copy
);
6070 copy_decl_maybe_to_var (tree decl
, copy_body_data
*id
)
6072 if (TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
)
6073 return copy_decl_to_var (decl
, id
);
6075 return copy_decl_no_change (decl
, id
);
6078 /* Return a copy of the function's argument tree without any modifications. */
6081 copy_arguments_nochange (tree orig_parm
, copy_body_data
* id
)
6084 tree new_parm
= NULL
;
6087 for (arg
= orig_parm
; arg
; arg
= DECL_CHAIN (arg
))
6089 tree new_tree
= remap_decl (arg
, id
);
6090 if (TREE_CODE (new_tree
) != PARM_DECL
)
6091 new_tree
= id
->copy_decl (arg
, id
);
6092 lang_hooks
.dup_lang_specific_decl (new_tree
);
6094 parg
= &DECL_CHAIN (new_tree
);
6099 /* Return a copy of the function's static chain. */
6101 copy_static_chain (tree static_chain
, copy_body_data
* id
)
6103 tree
*chain_copy
, *pvar
;
6105 chain_copy
= &static_chain
;
6106 for (pvar
= chain_copy
; *pvar
; pvar
= &DECL_CHAIN (*pvar
))
6108 tree new_tree
= remap_decl (*pvar
, id
);
6109 lang_hooks
.dup_lang_specific_decl (new_tree
);
6110 DECL_CHAIN (new_tree
) = DECL_CHAIN (*pvar
);
6113 return static_chain
;
6116 /* Return true if the function is allowed to be versioned.
6117 This is a guard for the versioning functionality. */
6120 tree_versionable_function_p (tree fndecl
)
6122 return (!lookup_attribute ("noclone", DECL_ATTRIBUTES (fndecl
))
6123 && copy_forbidden (DECL_STRUCT_FUNCTION (fndecl
)) == NULL
);
6126 /* Update clone info after duplication. */
6129 update_clone_info (copy_body_data
* id
)
6131 struct cgraph_node
*this_node
= id
->dst_node
;
6132 if (!this_node
->clones
)
6134 for (cgraph_node
*node
= this_node
->clones
; node
!= this_node
;)
6136 /* First update replace maps to match the new body. */
6137 clone_info
*info
= clone_info::get (node
);
6138 if (info
&& info
->tree_map
)
6141 for (i
= 0; i
< vec_safe_length (info
->tree_map
); i
++)
6143 struct ipa_replace_map
*replace_info
;
6144 replace_info
= (*info
->tree_map
)[i
];
6145 walk_tree (&replace_info
->new_tree
, copy_tree_body_r
, id
, NULL
);
6150 node
= node
->clones
;
6151 else if (node
->next_sibling_clone
)
6152 node
= node
->next_sibling_clone
;
6155 while (node
!= id
->dst_node
&& !node
->next_sibling_clone
)
6156 node
= node
->clone_of
;
6157 if (node
!= id
->dst_node
)
6158 node
= node
->next_sibling_clone
;
6163 /* Create a copy of a function's tree.
6164 OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
6165 of the original function and the new copied function
6166 respectively. In case we want to replace a DECL
6167 tree with another tree while duplicating the function's
6168 body, TREE_MAP represents the mapping between these
6169 trees. If UPDATE_CLONES is set, the call_stmt fields
6170 of edges of clones of the function will be updated.
6172 If non-NULL PARAM_ADJUSTMENTS determines how function prototype (i.e. the
6173 function parameters and return value) should be modified).
6174 If non-NULL BLOCKS_TO_COPY determine what basic blocks to copy.
6175 If non_NULL NEW_ENTRY determine new entry BB of the clone.
6178 tree_function_versioning (tree old_decl
, tree new_decl
,
6179 vec
<ipa_replace_map
*, va_gc
> *tree_map
,
6180 ipa_param_adjustments
*param_adjustments
,
6181 bool update_clones
, bitmap blocks_to_copy
,
6182 basic_block new_entry
)
6184 struct cgraph_node
*old_version_node
;
6185 struct cgraph_node
*new_version_node
;
6189 struct ipa_replace_map
*replace_info
;
6190 basic_block old_entry_block
, bb
;
6191 auto_vec
<gimple
*, 10> init_stmts
;
6192 tree vars
= NULL_TREE
;
6194 /* We can get called recursively from expand_call_inline via clone
6195 materialization. While expand_call_inline maintains input_location
6196 we cannot tolerate it to leak into the materialized clone. */
6197 location_t saved_location
= input_location
;
6198 input_location
= UNKNOWN_LOCATION
;
6200 gcc_assert (TREE_CODE (old_decl
) == FUNCTION_DECL
6201 && TREE_CODE (new_decl
) == FUNCTION_DECL
);
6202 DECL_POSSIBLY_INLINED (old_decl
) = 1;
6204 old_version_node
= cgraph_node::get (old_decl
);
6205 gcc_checking_assert (old_version_node
);
6206 new_version_node
= cgraph_node::get (new_decl
);
6207 gcc_checking_assert (new_version_node
);
6209 /* Copy over debug args. */
6210 if (DECL_HAS_DEBUG_ARGS_P (old_decl
))
6212 vec
<tree
, va_gc
> **new_debug_args
, **old_debug_args
;
6213 gcc_checking_assert (decl_debug_args_lookup (new_decl
) == NULL
);
6214 DECL_HAS_DEBUG_ARGS_P (new_decl
) = 0;
6215 old_debug_args
= decl_debug_args_lookup (old_decl
);
6218 new_debug_args
= decl_debug_args_insert (new_decl
);
6219 *new_debug_args
= vec_safe_copy (*old_debug_args
);
6223 /* Output the inlining info for this abstract function, since it has been
6224 inlined. If we don't do this now, we can lose the information about the
6225 variables in the function when the blocks get blown away as soon as we
6226 remove the cgraph node. */
6227 (*debug_hooks
->outlining_inline_function
) (old_decl
);
6229 DECL_ARTIFICIAL (new_decl
) = 1;
6230 DECL_ABSTRACT_ORIGIN (new_decl
) = DECL_ORIGIN (old_decl
);
6231 if (DECL_ORIGIN (old_decl
) == old_decl
)
6232 old_version_node
->used_as_abstract_origin
= true;
6233 DECL_FUNCTION_PERSONALITY (new_decl
) = DECL_FUNCTION_PERSONALITY (old_decl
);
6235 /* Prepare the data structures for the tree copy. */
6236 memset (&id
, 0, sizeof (id
));
6238 /* Generate a new name for the new version. */
6239 id
.statements_to_fold
= new hash_set
<gimple
*>;
6241 id
.decl_map
= new hash_map
<tree
, tree
>;
6242 id
.debug_map
= NULL
;
6243 id
.src_fn
= old_decl
;
6244 id
.dst_fn
= new_decl
;
6245 id
.src_node
= old_version_node
;
6246 id
.dst_node
= new_version_node
;
6247 id
.src_cfun
= DECL_STRUCT_FUNCTION (old_decl
);
6248 id
.blocks_to_copy
= blocks_to_copy
;
6250 id
.copy_decl
= copy_decl_no_change
;
6251 id
.transform_call_graph_edges
6252 = update_clones
? CB_CGE_MOVE_CLONES
: CB_CGE_MOVE
;
6253 id
.transform_new_cfg
= true;
6254 id
.transform_return_to_modify
= false;
6255 id
.transform_parameter
= false;
6256 id
.transform_lang_insert_block
= NULL
;
6258 old_entry_block
= ENTRY_BLOCK_PTR_FOR_FN
6259 (DECL_STRUCT_FUNCTION (old_decl
));
6260 DECL_RESULT (new_decl
) = DECL_RESULT (old_decl
);
6261 DECL_ARGUMENTS (new_decl
) = DECL_ARGUMENTS (old_decl
);
6262 initialize_cfun (new_decl
, old_decl
,
6263 new_entry
? new_entry
->count
: old_entry_block
->count
);
6264 new_version_node
->calls_declare_variant_alt
6265 = old_version_node
->calls_declare_variant_alt
;
6266 if (DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
)
6267 DECL_STRUCT_FUNCTION (new_decl
)->gimple_df
->ipa_pta
6268 = id
.src_cfun
->gimple_df
->ipa_pta
;
6270 /* Copy the function's static chain. */
6271 p
= DECL_STRUCT_FUNCTION (old_decl
)->static_chain_decl
;
6273 DECL_STRUCT_FUNCTION (new_decl
)->static_chain_decl
6274 = copy_static_chain (p
, &id
);
6276 auto_vec
<int, 16> new_param_indices
;
6277 clone_info
*info
= clone_info::get (old_version_node
);
6278 ipa_param_adjustments
*old_param_adjustments
6279 = info
? info
->param_adjustments
: NULL
;
6280 if (old_param_adjustments
)
6281 old_param_adjustments
->get_updated_indices (&new_param_indices
);
6283 /* If there's a tree_map, prepare for substitution. */
6285 for (i
= 0; i
< tree_map
->length (); i
++)
6288 replace_info
= (*tree_map
)[i
];
6290 int p
= replace_info
->parm_num
;
6291 if (old_param_adjustments
)
6292 p
= new_param_indices
[p
];
6295 for (parm
= DECL_ARGUMENTS (old_decl
); p
;
6296 parm
= DECL_CHAIN (parm
))
6299 init
= setup_one_parameter (&id
, parm
, replace_info
->new_tree
,
6300 id
.src_fn
, NULL
, &vars
);
6302 init_stmts
.safe_push (init
);
6305 ipa_param_body_adjustments
*param_body_adjs
= NULL
;
6306 if (param_adjustments
)
6308 param_body_adjs
= new ipa_param_body_adjustments (param_adjustments
,
6310 &id
, &vars
, tree_map
);
6311 id
.param_body_adjs
= param_body_adjs
;
6312 DECL_ARGUMENTS (new_decl
) = param_body_adjs
->get_new_param_chain ();
6314 else if (DECL_ARGUMENTS (old_decl
) != NULL_TREE
)
6315 DECL_ARGUMENTS (new_decl
)
6316 = copy_arguments_nochange (DECL_ARGUMENTS (old_decl
), &id
);
6318 DECL_INITIAL (new_decl
) = remap_blocks (DECL_INITIAL (id
.src_fn
), &id
);
6319 BLOCK_SUPERCONTEXT (DECL_INITIAL (new_decl
)) = new_decl
;
6321 declare_inline_vars (DECL_INITIAL (new_decl
), vars
);
6323 if (!vec_safe_is_empty (DECL_STRUCT_FUNCTION (old_decl
)->local_decls
))
6324 /* Add local vars. */
6325 add_local_variables (DECL_STRUCT_FUNCTION (old_decl
), cfun
, &id
);
6327 if (DECL_RESULT (old_decl
) == NULL_TREE
)
6329 else if (param_adjustments
&& param_adjustments
->m_skip_return
6330 && !VOID_TYPE_P (TREE_TYPE (DECL_RESULT (old_decl
))))
6332 tree resdecl_repl
= copy_result_decl_to_var (DECL_RESULT (old_decl
),
6334 declare_inline_vars (NULL
, resdecl_repl
);
6335 if (DECL_BY_REFERENCE (DECL_RESULT (old_decl
)))
6336 resdecl_repl
= build_fold_addr_expr (resdecl_repl
);
6337 insert_decl_map (&id
, DECL_RESULT (old_decl
), resdecl_repl
);
6339 DECL_RESULT (new_decl
)
6340 = build_decl (DECL_SOURCE_LOCATION (DECL_RESULT (old_decl
)),
6341 RESULT_DECL
, NULL_TREE
, void_type_node
);
6342 DECL_CONTEXT (DECL_RESULT (new_decl
)) = new_decl
;
6343 DECL_IS_MALLOC (new_decl
) = false;
6344 cfun
->returns_struct
= 0;
6345 cfun
->returns_pcc_struct
= 0;
6350 DECL_RESULT (new_decl
) = remap_decl (DECL_RESULT (old_decl
), &id
);
6351 lang_hooks
.dup_lang_specific_decl (DECL_RESULT (new_decl
));
6352 if (gimple_in_ssa_p (id
.src_cfun
)
6353 && DECL_BY_REFERENCE (DECL_RESULT (old_decl
))
6354 && (old_name
= ssa_default_def (id
.src_cfun
, DECL_RESULT (old_decl
))))
6356 tree new_name
= make_ssa_name (DECL_RESULT (new_decl
));
6357 insert_decl_map (&id
, old_name
, new_name
);
6358 SSA_NAME_DEF_STMT (new_name
) = gimple_build_nop ();
6359 set_ssa_default_def (cfun
, DECL_RESULT (new_decl
), new_name
);
6363 /* Set up the destination functions loop tree. */
6364 if (loops_for_fn (DECL_STRUCT_FUNCTION (old_decl
)) != NULL
)
6366 cfun
->curr_properties
&= ~PROP_loops
;
6367 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
6368 cfun
->curr_properties
|= PROP_loops
;
6371 /* Copy the Function's body. */
6372 copy_body (&id
, ENTRY_BLOCK_PTR_FOR_FN (cfun
), EXIT_BLOCK_PTR_FOR_FN (cfun
),
6375 /* Renumber the lexical scoping (non-code) blocks consecutively. */
6376 number_blocks (new_decl
);
6378 /* We want to create the BB unconditionally, so that the addition of
6379 debug stmts doesn't affect BB count, which may in the end cause
6380 codegen differences. */
6381 bb
= split_edge (single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
6382 while (init_stmts
.length ())
6383 insert_init_stmt (&id
, bb
, init_stmts
.pop ());
6384 update_clone_info (&id
);
6386 /* Remap the nonlocal_goto_save_area, if any. */
6387 if (cfun
->nonlocal_goto_save_area
)
6389 struct walk_stmt_info wi
;
6391 memset (&wi
, 0, sizeof (wi
));
6393 walk_tree (&cfun
->nonlocal_goto_save_area
, remap_gimple_op_r
, &wi
, NULL
);
6399 delete id
.debug_map
;
6400 free_dominance_info (CDI_DOMINATORS
);
6401 free_dominance_info (CDI_POST_DOMINATORS
);
6403 update_max_bb_count ();
6404 fold_marked_statements (0, id
.statements_to_fold
);
6405 delete id
.statements_to_fold
;
6406 delete_unreachable_blocks_update_callgraph (id
.dst_node
, update_clones
);
6407 if (id
.dst_node
->definition
)
6408 cgraph_edge::rebuild_references ();
6409 if (loops_state_satisfies_p (LOOPS_NEED_FIXUP
))
6411 calculate_dominance_info (CDI_DOMINATORS
);
6412 fix_loop_structure (NULL
);
6414 update_ssa (TODO_update_ssa
);
6416 /* After partial cloning we need to rescale frequencies, so they are
6417 within proper range in the cloned function. */
6420 struct cgraph_edge
*e
;
6421 rebuild_frequencies ();
6423 new_version_node
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
6424 for (e
= new_version_node
->callees
; e
; e
= e
->next_callee
)
6426 basic_block bb
= gimple_bb (e
->call_stmt
);
6427 e
->count
= bb
->count
;
6429 for (e
= new_version_node
->indirect_calls
; e
; e
= e
->next_callee
)
6431 basic_block bb
= gimple_bb (e
->call_stmt
);
6432 e
->count
= bb
->count
;
6436 if (param_body_adjs
&& MAY_HAVE_DEBUG_BIND_STMTS
)
6438 vec
<tree
, va_gc
> **debug_args
= NULL
;
6439 unsigned int len
= 0;
6440 unsigned reset_len
= param_body_adjs
->m_reset_debug_decls
.length ();
6442 for (i
= 0; i
< reset_len
; i
++)
6444 tree parm
= param_body_adjs
->m_reset_debug_decls
[i
];
6445 gcc_assert (is_gimple_reg (parm
));
6448 if (debug_args
== NULL
)
6450 debug_args
= decl_debug_args_insert (new_decl
);
6451 len
= vec_safe_length (*debug_args
);
6453 ddecl
= make_node (DEBUG_EXPR_DECL
);
6454 DECL_ARTIFICIAL (ddecl
) = 1;
6455 TREE_TYPE (ddecl
) = TREE_TYPE (parm
);
6456 SET_DECL_MODE (ddecl
, DECL_MODE (parm
));
6457 vec_safe_push (*debug_args
, DECL_ORIGIN (parm
));
6458 vec_safe_push (*debug_args
, ddecl
);
6460 if (debug_args
!= NULL
)
6462 /* On the callee side, add
6465 stmts to the first bb where var is a VAR_DECL created for the
6466 optimized away parameter in DECL_INITIAL block. This hints
6467 in the debug info that var (whole DECL_ORIGIN is the parm
6468 PARM_DECL) is optimized away, but could be looked up at the
6469 call site as value of D#X there. */
6470 gimple_stmt_iterator cgsi
6471 = gsi_after_labels (single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
6474 i
= vec_safe_length (*debug_args
);
6477 tree vexpr
= NULL_TREE
;
6479 while (var
!= NULL_TREE
6480 && DECL_ABSTRACT_ORIGIN (var
) != (**debug_args
)[i
])
6481 var
= TREE_CHAIN (var
);
6482 if (var
== NULL_TREE
)
6484 tree parm
= (**debug_args
)[i
];
6485 if (tree parm_ddef
= ssa_default_def (id
.src_cfun
, parm
))
6487 = param_body_adjs
->m_dead_ssa_debug_equiv
.get (parm_ddef
))
6491 vexpr
= make_node (DEBUG_EXPR_DECL
);
6492 DECL_ARTIFICIAL (vexpr
) = 1;
6493 TREE_TYPE (vexpr
) = TREE_TYPE (parm
);
6494 SET_DECL_MODE (vexpr
, DECL_MODE (parm
));
6496 def_temp
= gimple_build_debug_bind (var
, vexpr
, NULL
);
6497 gsi_insert_before (&cgsi
, def_temp
, GSI_NEW_STMT
);
6498 def_temp
= gimple_build_debug_source_bind (vexpr
, parm
, NULL
);
6499 gsi_insert_before (&cgsi
, def_temp
, GSI_NEW_STMT
);
6504 delete param_body_adjs
;
6505 free_dominance_info (CDI_DOMINATORS
);
6506 free_dominance_info (CDI_POST_DOMINATORS
);
6508 gcc_assert (!id
.debug_stmts
.exists ());
6510 input_location
= saved_location
;
6514 /* EXP is CALL_EXPR present in a GENERIC expression tree. Try to integrate
6515 the callee and return the inlined body on success. */
6518 maybe_inline_call_in_expr (tree exp
)
6520 tree fn
= get_callee_fndecl (exp
);
6522 /* We can only try to inline "const" functions. */
6523 if (fn
&& TREE_READONLY (fn
) && DECL_SAVED_TREE (fn
))
6525 call_expr_arg_iterator iter
;
6528 hash_map
<tree
, tree
> decl_map
;
6530 /* Remap the parameters. */
6531 for (param
= DECL_ARGUMENTS (fn
), arg
= first_call_expr_arg (exp
, &iter
);
6533 param
= DECL_CHAIN (param
), arg
= next_call_expr_arg (&iter
))
6534 decl_map
.put (param
, arg
);
6536 memset (&id
, 0, sizeof (id
));
6538 id
.dst_fn
= current_function_decl
;
6539 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
6540 id
.decl_map
= &decl_map
;
6542 id
.copy_decl
= copy_decl_no_change
;
6543 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
6544 id
.transform_new_cfg
= false;
6545 id
.transform_return_to_modify
= true;
6546 id
.transform_parameter
= true;
6547 id
.transform_lang_insert_block
= NULL
;
6549 /* Make sure not to unshare trees behind the front-end's back
6550 since front-end specific mechanisms may rely on sharing. */
6551 id
.regimplify
= false;
6552 id
.do_not_unshare
= true;
6554 /* We're not inside any EH region. */
6557 t
= copy_tree_body (&id
);
6559 /* We can only return something suitable for use in a GENERIC
6561 if (TREE_CODE (t
) == MODIFY_EXPR
)
6562 return TREE_OPERAND (t
, 1);
6568 /* Duplicate a type, fields and all. */
6571 build_duplicate_type (tree type
)
6573 struct copy_body_data id
;
6575 memset (&id
, 0, sizeof (id
));
6576 id
.src_fn
= current_function_decl
;
6577 id
.dst_fn
= current_function_decl
;
6579 id
.decl_map
= new hash_map
<tree
, tree
>;
6580 id
.debug_map
= NULL
;
6581 id
.copy_decl
= copy_decl_no_change
;
6583 type
= remap_type_1 (type
, &id
);
6587 delete id
.debug_map
;
6589 TYPE_CANONICAL (type
) = type
;
6594 /* Unshare the entire DECL_SAVED_TREE of FN and return the remapped
6595 parameters and RESULT_DECL in PARMS and RESULT. Used by C++ constexpr
6599 copy_fn (tree fn
, tree
& parms
, tree
& result
)
6603 hash_map
<tree
, tree
> decl_map
;
6608 memset (&id
, 0, sizeof (id
));
6610 id
.dst_fn
= current_function_decl
;
6611 id
.src_cfun
= DECL_STRUCT_FUNCTION (fn
);
6612 id
.decl_map
= &decl_map
;
6614 id
.copy_decl
= copy_decl_no_change
;
6615 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
6616 id
.transform_new_cfg
= false;
6617 id
.transform_return_to_modify
= false;
6618 id
.transform_parameter
= true;
6619 id
.transform_lang_insert_block
= NULL
;
6621 /* Make sure not to unshare trees behind the front-end's back
6622 since front-end specific mechanisms may rely on sharing. */
6623 id
.regimplify
= false;
6624 id
.do_not_unshare
= true;
6625 id
.do_not_fold
= true;
6627 /* We're not inside any EH region. */
6630 /* Remap the parameters and result and return them to the caller. */
6631 for (param
= DECL_ARGUMENTS (fn
);
6633 param
= DECL_CHAIN (param
))
6635 *p
= remap_decl (param
, &id
);
6636 p
= &DECL_CHAIN (*p
);
6639 if (DECL_RESULT (fn
))
6640 result
= remap_decl (DECL_RESULT (fn
), &id
);
6644 return copy_tree_body (&id
);