* cgraphclones.c (cgraph_edge::clone): Rename gcov_count to prof_count.
[official-gcc.git] / gcc / tree-inline.c
blob6af2079b8375bfc258144bb294cd79f809290ee3
1 /* Tree inlining.
2 Copyright (C) 2001-2017 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)
10 any later version.
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/>. */
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "backend.h"
25 #include "target.h"
26 #include "rtl.h"
27 #include "tree.h"
28 #include "gimple.h"
29 #include "cfghooks.h"
30 #include "tree-pass.h"
31 #include "ssa.h"
32 #include "cgraph.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"
38 #include "calls.h"
39 #include "tree-inline.h"
40 #include "langhooks.h"
41 #include "cfganal.h"
42 #include "tree-iterator.h"
43 #include "intl.h"
44 #include "gimple-fold.h"
45 #include "tree-eh.h"
46 #include "gimplify.h"
47 #include "gimple-iterator.h"
48 #include "gimplify-me.h"
49 #include "gimple-walk.h"
50 #include "tree-cfg.h"
51 #include "tree-into-ssa.h"
52 #include "tree-dfa.h"
53 #include "tree-ssa.h"
54 #include "except.h"
55 #include "debug.h"
56 #include "value-prof.h"
57 #include "cfgloop.h"
58 #include "builtins.h"
59 #include "tree-chkp.h"
60 #include "stringpool.h"
61 #include "attribs.h"
62 #include "sreal.h"
64 /* I'm not real happy about this, but we need to handle gimple and
65 non-gimple trees. */
67 /* Inlining, Cloning, Versioning, Parallelization
69 Inlining: a function body is duplicated, but the PARM_DECLs are
70 remapped into VAR_DECLs, and non-void RETURN_EXPRs become
71 MODIFY_EXPRs that store to a dedicated returned-value variable.
72 The duplicated eh_region info of the copy will later be appended
73 to the info for the caller; the eh_region info in copied throwing
74 statements and RESX statements are adjusted accordingly.
76 Cloning: (only in C++) We have one body for a con/de/structor, and
77 multiple function decls, each with a unique parameter list.
78 Duplicate the body, using the given splay tree; some parameters
79 will become constants (like 0 or 1).
81 Versioning: a function body is duplicated and the result is a new
82 function rather than into blocks of an existing function as with
83 inlining. Some parameters will become constants.
85 Parallelization: a region of a function is duplicated resulting in
86 a new function. Variables may be replaced with complex expressions
87 to enable shared variable semantics.
89 All of these will simultaneously lookup any callgraph edges. If
90 we're going to inline the duplicated function body, and the given
91 function has some cloned callgraph nodes (one for each place this
92 function will be inlined) those callgraph edges will be duplicated.
93 If we're cloning the body, those callgraph edges will be
94 updated to point into the new body. (Note that the original
95 callgraph node and edge list will not be altered.)
97 See the CALL_EXPR handling case in copy_tree_body_r (). */
99 /* To Do:
101 o In order to make inlining-on-trees work, we pessimized
102 function-local static constants. In particular, they are now
103 always output, even when not addressed. Fix this by treating
104 function-local static constants just like global static
105 constants; the back-end already knows not to output them if they
106 are not needed.
108 o Provide heuristics to clamp inlining of recursive template
109 calls? */
112 /* Weights that estimate_num_insns uses to estimate the size of the
113 produced code. */
115 eni_weights eni_size_weights;
117 /* Weights that estimate_num_insns uses to estimate the time necessary
118 to execute the produced code. */
120 eni_weights eni_time_weights;
122 /* Prototypes. */
124 static tree declare_return_variable (copy_body_data *, tree, tree, tree,
125 basic_block);
126 static void remap_block (tree *, copy_body_data *);
127 static void copy_bind_expr (tree *, int *, copy_body_data *);
128 static void declare_inline_vars (tree, tree);
129 static void remap_save_expr (tree *, hash_map<tree, tree> *, int *);
130 static void prepend_lexical_block (tree current_block, tree new_block);
131 static tree copy_decl_to_var (tree, copy_body_data *);
132 static tree copy_result_decl_to_var (tree, copy_body_data *);
133 static tree copy_decl_maybe_to_var (tree, copy_body_data *);
134 static gimple_seq remap_gimple_stmt (gimple *, copy_body_data *);
135 static bool delete_unreachable_blocks_update_callgraph (copy_body_data *id);
136 static void insert_init_stmt (copy_body_data *, basic_block, gimple *);
138 /* Insert a tree->tree mapping for ID. Despite the name suggests
139 that the trees should be variables, it is used for more than that. */
141 void
142 insert_decl_map (copy_body_data *id, tree key, tree value)
144 id->decl_map->put (key, value);
146 /* Always insert an identity map as well. If we see this same new
147 node again, we won't want to duplicate it a second time. */
148 if (key != value)
149 id->decl_map->put (value, value);
152 /* Insert a tree->tree mapping for ID. This is only used for
153 variables. */
155 static void
156 insert_debug_decl_map (copy_body_data *id, tree key, tree value)
158 if (!gimple_in_ssa_p (id->src_cfun))
159 return;
161 if (!opt_for_fn (id->dst_fn, flag_var_tracking_assignments))
162 return;
164 if (!target_for_debug_bind (key))
165 return;
167 gcc_assert (TREE_CODE (key) == PARM_DECL);
168 gcc_assert (VAR_P (value));
170 if (!id->debug_map)
171 id->debug_map = new hash_map<tree, tree>;
173 id->debug_map->put (key, value);
176 /* If nonzero, we're remapping the contents of inlined debug
177 statements. If negative, an error has occurred, such as a
178 reference to a variable that isn't available in the inlined
179 context. */
180 static int processing_debug_stmt = 0;
182 /* Construct new SSA name for old NAME. ID is the inline context. */
184 static tree
185 remap_ssa_name (tree name, copy_body_data *id)
187 tree new_tree, var;
188 tree *n;
190 gcc_assert (TREE_CODE (name) == SSA_NAME);
192 n = id->decl_map->get (name);
193 if (n)
194 return unshare_expr (*n);
196 if (processing_debug_stmt)
198 if (SSA_NAME_IS_DEFAULT_DEF (name)
199 && TREE_CODE (SSA_NAME_VAR (name)) == PARM_DECL
200 && id->entry_bb == NULL
201 && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (cfun)))
203 tree vexpr = make_node (DEBUG_EXPR_DECL);
204 gimple *def_temp;
205 gimple_stmt_iterator gsi;
206 tree val = SSA_NAME_VAR (name);
208 n = id->decl_map->get (val);
209 if (n != NULL)
210 val = *n;
211 if (TREE_CODE (val) != PARM_DECL)
213 processing_debug_stmt = -1;
214 return name;
216 def_temp = gimple_build_debug_source_bind (vexpr, val, NULL);
217 DECL_ARTIFICIAL (vexpr) = 1;
218 TREE_TYPE (vexpr) = TREE_TYPE (name);
219 SET_DECL_MODE (vexpr, DECL_MODE (SSA_NAME_VAR (name)));
220 gsi = gsi_after_labels (single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun)));
221 gsi_insert_before (&gsi, def_temp, GSI_SAME_STMT);
222 return vexpr;
225 processing_debug_stmt = -1;
226 return name;
229 /* Remap anonymous SSA names or SSA names of anonymous decls. */
230 var = SSA_NAME_VAR (name);
231 if (!var
232 || (!SSA_NAME_IS_DEFAULT_DEF (name)
233 && VAR_P (var)
234 && !VAR_DECL_IS_VIRTUAL_OPERAND (var)
235 && DECL_ARTIFICIAL (var)
236 && DECL_IGNORED_P (var)
237 && !DECL_NAME (var)))
239 struct ptr_info_def *pi;
240 new_tree = make_ssa_name (remap_type (TREE_TYPE (name), id));
241 if (!var && SSA_NAME_IDENTIFIER (name))
242 SET_SSA_NAME_VAR_OR_IDENTIFIER (new_tree, SSA_NAME_IDENTIFIER (name));
243 insert_decl_map (id, name, new_tree);
244 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree)
245 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name);
246 /* At least IPA points-to info can be directly transferred. */
247 if (id->src_cfun->gimple_df
248 && id->src_cfun->gimple_df->ipa_pta
249 && POINTER_TYPE_P (TREE_TYPE (name))
250 && (pi = SSA_NAME_PTR_INFO (name))
251 && !pi->pt.anything)
253 struct ptr_info_def *new_pi = get_ptr_info (new_tree);
254 new_pi->pt = pi->pt;
256 return new_tree;
259 /* Do not set DEF_STMT yet as statement is not copied yet. We do that
260 in copy_bb. */
261 new_tree = remap_decl (var, id);
263 /* We might've substituted constant or another SSA_NAME for
264 the variable.
266 Replace the SSA name representing RESULT_DECL by variable during
267 inlining: this saves us from need to introduce PHI node in a case
268 return value is just partly initialized. */
269 if ((VAR_P (new_tree) || TREE_CODE (new_tree) == PARM_DECL)
270 && (!SSA_NAME_VAR (name)
271 || TREE_CODE (SSA_NAME_VAR (name)) != RESULT_DECL
272 || !id->transform_return_to_modify))
274 struct ptr_info_def *pi;
275 new_tree = make_ssa_name (new_tree);
276 insert_decl_map (id, name, new_tree);
277 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree)
278 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name);
279 /* At least IPA points-to info can be directly transferred. */
280 if (id->src_cfun->gimple_df
281 && id->src_cfun->gimple_df->ipa_pta
282 && POINTER_TYPE_P (TREE_TYPE (name))
283 && (pi = SSA_NAME_PTR_INFO (name))
284 && !pi->pt.anything)
286 struct ptr_info_def *new_pi = get_ptr_info (new_tree);
287 new_pi->pt = pi->pt;
289 if (SSA_NAME_IS_DEFAULT_DEF (name))
291 /* By inlining function having uninitialized variable, we might
292 extend the lifetime (variable might get reused). This cause
293 ICE in the case we end up extending lifetime of SSA name across
294 abnormal edge, but also increase register pressure.
296 We simply initialize all uninitialized vars by 0 except
297 for case we are inlining to very first BB. We can avoid
298 this for all BBs that are not inside strongly connected
299 regions of the CFG, but this is expensive to test. */
300 if (id->entry_bb
301 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name)
302 && (!SSA_NAME_VAR (name)
303 || TREE_CODE (SSA_NAME_VAR (name)) != PARM_DECL)
304 && (id->entry_bb != EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun),
305 0)->dest
306 || EDGE_COUNT (id->entry_bb->preds) != 1))
308 gimple_stmt_iterator gsi = gsi_last_bb (id->entry_bb);
309 gimple *init_stmt;
310 tree zero = build_zero_cst (TREE_TYPE (new_tree));
312 init_stmt = gimple_build_assign (new_tree, zero);
313 gsi_insert_after (&gsi, init_stmt, GSI_NEW_STMT);
314 SSA_NAME_IS_DEFAULT_DEF (new_tree) = 0;
316 else
318 SSA_NAME_DEF_STMT (new_tree) = gimple_build_nop ();
319 set_ssa_default_def (cfun, SSA_NAME_VAR (new_tree), new_tree);
323 else
324 insert_decl_map (id, name, new_tree);
325 return new_tree;
328 /* Remap DECL during the copying of the BLOCK tree for the function. */
330 tree
331 remap_decl (tree decl, copy_body_data *id)
333 tree *n;
335 /* We only remap local variables in the current function. */
337 /* See if we have remapped this declaration. */
339 n = id->decl_map->get (decl);
341 if (!n && processing_debug_stmt)
343 processing_debug_stmt = -1;
344 return decl;
347 /* When remapping a type within copy_gimple_seq_and_replace_locals, all
348 necessary DECLs have already been remapped and we do not want to duplicate
349 a decl coming from outside of the sequence we are copying. */
350 if (!n
351 && id->prevent_decl_creation_for_types
352 && id->remapping_type_depth > 0
353 && (VAR_P (decl) || TREE_CODE (decl) == PARM_DECL))
354 return decl;
356 /* If we didn't already have an equivalent for this declaration, create one
357 now. */
358 if (!n)
360 /* Make a copy of the variable or label. */
361 tree t = id->copy_decl (decl, id);
363 /* Remember it, so that if we encounter this local entity again
364 we can reuse this copy. Do this early because remap_type may
365 need this decl for TYPE_STUB_DECL. */
366 insert_decl_map (id, decl, t);
368 if (!DECL_P (t))
369 return t;
371 /* Remap types, if necessary. */
372 TREE_TYPE (t) = remap_type (TREE_TYPE (t), id);
373 if (TREE_CODE (t) == TYPE_DECL)
375 DECL_ORIGINAL_TYPE (t) = remap_type (DECL_ORIGINAL_TYPE (t), id);
377 /* Preserve the invariant that DECL_ORIGINAL_TYPE != TREE_TYPE,
378 which is enforced in gen_typedef_die when DECL_ABSTRACT_ORIGIN
379 is not set on the TYPE_DECL, for example in LTO mode. */
380 if (DECL_ORIGINAL_TYPE (t) == TREE_TYPE (t))
382 tree x = build_variant_type_copy (TREE_TYPE (t));
383 TYPE_STUB_DECL (x) = TYPE_STUB_DECL (TREE_TYPE (t));
384 TYPE_NAME (x) = TYPE_NAME (TREE_TYPE (t));
385 DECL_ORIGINAL_TYPE (t) = x;
389 /* Remap sizes as necessary. */
390 walk_tree (&DECL_SIZE (t), copy_tree_body_r, id, NULL);
391 walk_tree (&DECL_SIZE_UNIT (t), copy_tree_body_r, id, NULL);
393 /* If fields, do likewise for offset and qualifier. */
394 if (TREE_CODE (t) == FIELD_DECL)
396 walk_tree (&DECL_FIELD_OFFSET (t), copy_tree_body_r, id, NULL);
397 if (TREE_CODE (DECL_CONTEXT (t)) == QUAL_UNION_TYPE)
398 walk_tree (&DECL_QUALIFIER (t), copy_tree_body_r, id, NULL);
401 return t;
404 if (id->do_not_unshare)
405 return *n;
406 else
407 return unshare_expr (*n);
410 static tree
411 remap_type_1 (tree type, copy_body_data *id)
413 tree new_tree, t;
415 /* We do need a copy. build and register it now. If this is a pointer or
416 reference type, remap the designated type and make a new pointer or
417 reference type. */
418 if (TREE_CODE (type) == POINTER_TYPE)
420 new_tree = build_pointer_type_for_mode (remap_type (TREE_TYPE (type), id),
421 TYPE_MODE (type),
422 TYPE_REF_CAN_ALIAS_ALL (type));
423 if (TYPE_ATTRIBUTES (type) || TYPE_QUALS (type))
424 new_tree = build_type_attribute_qual_variant (new_tree,
425 TYPE_ATTRIBUTES (type),
426 TYPE_QUALS (type));
427 insert_decl_map (id, type, new_tree);
428 return new_tree;
430 else if (TREE_CODE (type) == REFERENCE_TYPE)
432 new_tree = build_reference_type_for_mode (remap_type (TREE_TYPE (type), id),
433 TYPE_MODE (type),
434 TYPE_REF_CAN_ALIAS_ALL (type));
435 if (TYPE_ATTRIBUTES (type) || TYPE_QUALS (type))
436 new_tree = build_type_attribute_qual_variant (new_tree,
437 TYPE_ATTRIBUTES (type),
438 TYPE_QUALS (type));
439 insert_decl_map (id, type, new_tree);
440 return new_tree;
442 else
443 new_tree = copy_node (type);
445 insert_decl_map (id, type, new_tree);
447 /* This is a new type, not a copy of an old type. Need to reassociate
448 variants. We can handle everything except the main variant lazily. */
449 t = TYPE_MAIN_VARIANT (type);
450 if (type != t)
452 t = remap_type (t, id);
453 TYPE_MAIN_VARIANT (new_tree) = t;
454 TYPE_NEXT_VARIANT (new_tree) = TYPE_NEXT_VARIANT (t);
455 TYPE_NEXT_VARIANT (t) = new_tree;
457 else
459 TYPE_MAIN_VARIANT (new_tree) = new_tree;
460 TYPE_NEXT_VARIANT (new_tree) = NULL;
463 if (TYPE_STUB_DECL (type))
464 TYPE_STUB_DECL (new_tree) = remap_decl (TYPE_STUB_DECL (type), id);
466 /* Lazily create pointer and reference types. */
467 TYPE_POINTER_TO (new_tree) = NULL;
468 TYPE_REFERENCE_TO (new_tree) = NULL;
470 /* Copy all types that may contain references to local variables; be sure to
471 preserve sharing in between type and its main variant when possible. */
472 switch (TREE_CODE (new_tree))
474 case INTEGER_TYPE:
475 case REAL_TYPE:
476 case FIXED_POINT_TYPE:
477 case ENUMERAL_TYPE:
478 case BOOLEAN_TYPE:
479 if (TYPE_MAIN_VARIANT (new_tree) != new_tree)
481 gcc_checking_assert (TYPE_MIN_VALUE (type) == TYPE_MIN_VALUE (TYPE_MAIN_VARIANT (type)));
482 gcc_checking_assert (TYPE_MAX_VALUE (type) == TYPE_MAX_VALUE (TYPE_MAIN_VARIANT (type)));
484 TYPE_MIN_VALUE (new_tree) = TYPE_MIN_VALUE (TYPE_MAIN_VARIANT (new_tree));
485 TYPE_MAX_VALUE (new_tree) = TYPE_MAX_VALUE (TYPE_MAIN_VARIANT (new_tree));
487 else
489 t = TYPE_MIN_VALUE (new_tree);
490 if (t && TREE_CODE (t) != INTEGER_CST)
491 walk_tree (&TYPE_MIN_VALUE (new_tree), copy_tree_body_r, id, NULL);
493 t = TYPE_MAX_VALUE (new_tree);
494 if (t && TREE_CODE (t) != INTEGER_CST)
495 walk_tree (&TYPE_MAX_VALUE (new_tree), copy_tree_body_r, id, NULL);
497 return new_tree;
499 case FUNCTION_TYPE:
500 if (TYPE_MAIN_VARIANT (new_tree) != new_tree
501 && TREE_TYPE (type) == TREE_TYPE (TYPE_MAIN_VARIANT (type)))
502 TREE_TYPE (new_tree) = TREE_TYPE (TYPE_MAIN_VARIANT (new_tree));
503 else
504 TREE_TYPE (new_tree) = remap_type (TREE_TYPE (new_tree), id);
505 if (TYPE_MAIN_VARIANT (new_tree) != new_tree
506 && TYPE_ARG_TYPES (type) == TYPE_ARG_TYPES (TYPE_MAIN_VARIANT (type)))
507 TYPE_ARG_TYPES (new_tree) = TYPE_ARG_TYPES (TYPE_MAIN_VARIANT (new_tree));
508 else
509 walk_tree (&TYPE_ARG_TYPES (new_tree), copy_tree_body_r, id, NULL);
510 return new_tree;
512 case ARRAY_TYPE:
513 if (TYPE_MAIN_VARIANT (new_tree) != new_tree
514 && TREE_TYPE (type) == TREE_TYPE (TYPE_MAIN_VARIANT (type)))
515 TREE_TYPE (new_tree) = TREE_TYPE (TYPE_MAIN_VARIANT (new_tree));
516 else
517 TREE_TYPE (new_tree) = remap_type (TREE_TYPE (new_tree), id);
519 if (TYPE_MAIN_VARIANT (new_tree) != new_tree)
521 gcc_checking_assert (TYPE_DOMAIN (type) == TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)));
522 TYPE_DOMAIN (new_tree) = TYPE_DOMAIN (TYPE_MAIN_VARIANT (new_tree));
524 else
525 TYPE_DOMAIN (new_tree) = remap_type (TYPE_DOMAIN (new_tree), id);
526 break;
528 case RECORD_TYPE:
529 case UNION_TYPE:
530 case QUAL_UNION_TYPE:
531 if (TYPE_MAIN_VARIANT (type) != type
532 && TYPE_FIELDS (type) == TYPE_FIELDS (TYPE_MAIN_VARIANT (type)))
533 TYPE_FIELDS (new_tree) = TYPE_FIELDS (TYPE_MAIN_VARIANT (new_tree));
534 else
536 tree f, nf = NULL;
538 for (f = TYPE_FIELDS (new_tree); f ; f = DECL_CHAIN (f))
540 t = remap_decl (f, id);
541 DECL_CONTEXT (t) = new_tree;
542 DECL_CHAIN (t) = nf;
543 nf = t;
545 TYPE_FIELDS (new_tree) = nreverse (nf);
547 break;
549 case OFFSET_TYPE:
550 default:
551 /* Shouldn't have been thought variable sized. */
552 gcc_unreachable ();
555 /* All variants of type share the same size, so use the already remaped data. */
556 if (TYPE_MAIN_VARIANT (new_tree) != new_tree)
558 tree s = TYPE_SIZE (type);
559 tree mvs = TYPE_SIZE (TYPE_MAIN_VARIANT (type));
560 tree su = TYPE_SIZE_UNIT (type);
561 tree mvsu = TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type));
562 gcc_checking_assert ((TREE_CODE (s) == PLACEHOLDER_EXPR
563 && (TREE_CODE (mvs) == PLACEHOLDER_EXPR))
564 || s == mvs);
565 gcc_checking_assert ((TREE_CODE (su) == PLACEHOLDER_EXPR
566 && (TREE_CODE (mvsu) == PLACEHOLDER_EXPR))
567 || su == mvsu);
568 TYPE_SIZE (new_tree) = TYPE_SIZE (TYPE_MAIN_VARIANT (new_tree));
569 TYPE_SIZE_UNIT (new_tree) = TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (new_tree));
571 else
573 walk_tree (&TYPE_SIZE (new_tree), copy_tree_body_r, id, NULL);
574 walk_tree (&TYPE_SIZE_UNIT (new_tree), copy_tree_body_r, id, NULL);
577 return new_tree;
580 tree
581 remap_type (tree type, copy_body_data *id)
583 tree *node;
584 tree tmp;
586 if (type == NULL)
587 return type;
589 /* See if we have remapped this type. */
590 node = id->decl_map->get (type);
591 if (node)
592 return *node;
594 /* The type only needs remapping if it's variably modified. */
595 if (! variably_modified_type_p (type, id->src_fn))
597 insert_decl_map (id, type, type);
598 return type;
601 id->remapping_type_depth++;
602 tmp = remap_type_1 (type, id);
603 id->remapping_type_depth--;
605 return tmp;
608 /* Decide if DECL can be put into BLOCK_NONLOCAL_VARs. */
610 static bool
611 can_be_nonlocal (tree decl, copy_body_data *id)
613 /* We can not duplicate function decls. */
614 if (TREE_CODE (decl) == FUNCTION_DECL)
615 return true;
617 /* Local static vars must be non-local or we get multiple declaration
618 problems. */
619 if (VAR_P (decl) && !auto_var_in_fn_p (decl, id->src_fn))
620 return true;
622 return false;
625 static tree
626 remap_decls (tree decls, vec<tree, va_gc> **nonlocalized_list,
627 copy_body_data *id)
629 tree old_var;
630 tree new_decls = NULL_TREE;
632 /* Remap its variables. */
633 for (old_var = decls; old_var; old_var = DECL_CHAIN (old_var))
635 tree new_var;
637 if (can_be_nonlocal (old_var, id))
639 /* We need to add this variable to the local decls as otherwise
640 nothing else will do so. */
641 if (VAR_P (old_var) && ! DECL_EXTERNAL (old_var) && cfun)
642 add_local_decl (cfun, old_var);
643 if ((!optimize || debug_info_level > DINFO_LEVEL_TERSE)
644 && !DECL_IGNORED_P (old_var)
645 && nonlocalized_list)
646 vec_safe_push (*nonlocalized_list, old_var);
647 continue;
650 /* Remap the variable. */
651 new_var = remap_decl (old_var, id);
653 /* If we didn't remap this variable, we can't mess with its
654 TREE_CHAIN. If we remapped this variable to the return slot, it's
655 already declared somewhere else, so don't declare it here. */
657 if (new_var == id->retvar)
659 else if (!new_var)
661 if ((!optimize || debug_info_level > DINFO_LEVEL_TERSE)
662 && !DECL_IGNORED_P (old_var)
663 && nonlocalized_list)
664 vec_safe_push (*nonlocalized_list, old_var);
666 else
668 gcc_assert (DECL_P (new_var));
669 DECL_CHAIN (new_var) = new_decls;
670 new_decls = new_var;
672 /* Also copy value-expressions. */
673 if (VAR_P (new_var) && DECL_HAS_VALUE_EXPR_P (new_var))
675 tree tem = DECL_VALUE_EXPR (new_var);
676 bool old_regimplify = id->regimplify;
677 id->remapping_type_depth++;
678 walk_tree (&tem, copy_tree_body_r, id, NULL);
679 id->remapping_type_depth--;
680 id->regimplify = old_regimplify;
681 SET_DECL_VALUE_EXPR (new_var, tem);
686 return nreverse (new_decls);
689 /* Copy the BLOCK to contain remapped versions of the variables
690 therein. And hook the new block into the block-tree. */
692 static void
693 remap_block (tree *block, copy_body_data *id)
695 tree old_block;
696 tree new_block;
698 /* Make the new block. */
699 old_block = *block;
700 new_block = make_node (BLOCK);
701 TREE_USED (new_block) = TREE_USED (old_block);
702 BLOCK_ABSTRACT_ORIGIN (new_block) = old_block;
703 BLOCK_SOURCE_LOCATION (new_block) = BLOCK_SOURCE_LOCATION (old_block);
704 BLOCK_NONLOCALIZED_VARS (new_block)
705 = vec_safe_copy (BLOCK_NONLOCALIZED_VARS (old_block));
706 *block = new_block;
708 /* Remap its variables. */
709 BLOCK_VARS (new_block) = remap_decls (BLOCK_VARS (old_block),
710 &BLOCK_NONLOCALIZED_VARS (new_block),
711 id);
713 if (id->transform_lang_insert_block)
714 id->transform_lang_insert_block (new_block);
716 /* Remember the remapped block. */
717 insert_decl_map (id, old_block, new_block);
720 /* Copy the whole block tree and root it in id->block. */
721 static tree
722 remap_blocks (tree block, copy_body_data *id)
724 tree t;
725 tree new_tree = block;
727 if (!block)
728 return NULL;
730 remap_block (&new_tree, id);
731 gcc_assert (new_tree != block);
732 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
733 prepend_lexical_block (new_tree, remap_blocks (t, id));
734 /* Blocks are in arbitrary order, but make things slightly prettier and do
735 not swap order when producing a copy. */
736 BLOCK_SUBBLOCKS (new_tree) = blocks_nreverse (BLOCK_SUBBLOCKS (new_tree));
737 return new_tree;
740 /* Remap the block tree rooted at BLOCK to nothing. */
741 static void
742 remap_blocks_to_null (tree block, copy_body_data *id)
744 tree t;
745 insert_decl_map (id, block, NULL_TREE);
746 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
747 remap_blocks_to_null (t, id);
750 static void
751 copy_statement_list (tree *tp)
753 tree_stmt_iterator oi, ni;
754 tree new_tree;
756 new_tree = alloc_stmt_list ();
757 ni = tsi_start (new_tree);
758 oi = tsi_start (*tp);
759 TREE_TYPE (new_tree) = TREE_TYPE (*tp);
760 *tp = new_tree;
762 for (; !tsi_end_p (oi); tsi_next (&oi))
764 tree stmt = tsi_stmt (oi);
765 if (TREE_CODE (stmt) == STATEMENT_LIST)
766 /* This copy is not redundant; tsi_link_after will smash this
767 STATEMENT_LIST into the end of the one we're building, and we
768 don't want to do that with the original. */
769 copy_statement_list (&stmt);
770 tsi_link_after (&ni, stmt, TSI_CONTINUE_LINKING);
774 static void
775 copy_bind_expr (tree *tp, int *walk_subtrees, copy_body_data *id)
777 tree block = BIND_EXPR_BLOCK (*tp);
778 /* Copy (and replace) the statement. */
779 copy_tree_r (tp, walk_subtrees, NULL);
780 if (block)
782 remap_block (&block, id);
783 BIND_EXPR_BLOCK (*tp) = block;
786 if (BIND_EXPR_VARS (*tp))
787 /* This will remap a lot of the same decls again, but this should be
788 harmless. */
789 BIND_EXPR_VARS (*tp) = remap_decls (BIND_EXPR_VARS (*tp), NULL, id);
793 /* Create a new gimple_seq by remapping all the statements in BODY
794 using the inlining information in ID. */
796 static gimple_seq
797 remap_gimple_seq (gimple_seq body, copy_body_data *id)
799 gimple_stmt_iterator si;
800 gimple_seq new_body = NULL;
802 for (si = gsi_start (body); !gsi_end_p (si); gsi_next (&si))
804 gimple_seq new_stmts = remap_gimple_stmt (gsi_stmt (si), id);
805 gimple_seq_add_seq (&new_body, new_stmts);
808 return new_body;
812 /* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its
813 block using the mapping information in ID. */
815 static gimple *
816 copy_gimple_bind (gbind *stmt, copy_body_data *id)
818 gimple *new_bind;
819 tree new_block, new_vars;
820 gimple_seq body, new_body;
822 /* Copy the statement. Note that we purposely don't use copy_stmt
823 here because we need to remap statements as we copy. */
824 body = gimple_bind_body (stmt);
825 new_body = remap_gimple_seq (body, id);
827 new_block = gimple_bind_block (stmt);
828 if (new_block)
829 remap_block (&new_block, id);
831 /* This will remap a lot of the same decls again, but this should be
832 harmless. */
833 new_vars = gimple_bind_vars (stmt);
834 if (new_vars)
835 new_vars = remap_decls (new_vars, NULL, id);
837 new_bind = gimple_build_bind (new_vars, new_body, new_block);
839 return new_bind;
842 /* Return true if DECL is a parameter or a SSA_NAME for a parameter. */
844 static bool
845 is_parm (tree decl)
847 if (TREE_CODE (decl) == SSA_NAME)
849 decl = SSA_NAME_VAR (decl);
850 if (!decl)
851 return false;
854 return (TREE_CODE (decl) == PARM_DECL);
857 /* Remap the dependence CLIQUE from the source to the destination function
858 as specified in ID. */
860 static unsigned short
861 remap_dependence_clique (copy_body_data *id, unsigned short clique)
863 if (clique == 0 || processing_debug_stmt)
864 return 0;
865 if (!id->dependence_map)
866 id->dependence_map = new hash_map<dependence_hash, unsigned short>;
867 bool existed;
868 unsigned short &newc = id->dependence_map->get_or_insert (clique, &existed);
869 if (!existed)
870 newc = ++cfun->last_clique;
871 return newc;
874 /* Remap the GIMPLE operand pointed to by *TP. DATA is really a
875 'struct walk_stmt_info *'. DATA->INFO is a 'copy_body_data *'.
876 WALK_SUBTREES is used to indicate walk_gimple_op whether to keep
877 recursing into the children nodes of *TP. */
879 static tree
880 remap_gimple_op_r (tree *tp, int *walk_subtrees, void *data)
882 struct walk_stmt_info *wi_p = (struct walk_stmt_info *) data;
883 copy_body_data *id = (copy_body_data *) wi_p->info;
884 tree fn = id->src_fn;
886 /* For recursive invocations this is no longer the LHS itself. */
887 bool is_lhs = wi_p->is_lhs;
888 wi_p->is_lhs = false;
890 if (TREE_CODE (*tp) == SSA_NAME)
892 *tp = remap_ssa_name (*tp, id);
893 *walk_subtrees = 0;
894 if (is_lhs)
895 SSA_NAME_DEF_STMT (*tp) = wi_p->stmt;
896 return NULL;
898 else if (auto_var_in_fn_p (*tp, fn))
900 /* Local variables and labels need to be replaced by equivalent
901 variables. We don't want to copy static variables; there's
902 only one of those, no matter how many times we inline the
903 containing function. Similarly for globals from an outer
904 function. */
905 tree new_decl;
907 /* Remap the declaration. */
908 new_decl = remap_decl (*tp, id);
909 gcc_assert (new_decl);
910 /* Replace this variable with the copy. */
911 STRIP_TYPE_NOPS (new_decl);
912 /* ??? The C++ frontend uses void * pointer zero to initialize
913 any other type. This confuses the middle-end type verification.
914 As cloned bodies do not go through gimplification again the fixup
915 there doesn't trigger. */
916 if (TREE_CODE (new_decl) == INTEGER_CST
917 && !useless_type_conversion_p (TREE_TYPE (*tp), TREE_TYPE (new_decl)))
918 new_decl = fold_convert (TREE_TYPE (*tp), new_decl);
919 *tp = new_decl;
920 *walk_subtrees = 0;
922 else if (TREE_CODE (*tp) == STATEMENT_LIST)
923 gcc_unreachable ();
924 else if (TREE_CODE (*tp) == SAVE_EXPR)
925 gcc_unreachable ();
926 else if (TREE_CODE (*tp) == LABEL_DECL
927 && (!DECL_CONTEXT (*tp)
928 || decl_function_context (*tp) == id->src_fn))
929 /* These may need to be remapped for EH handling. */
930 *tp = remap_decl (*tp, id);
931 else if (TREE_CODE (*tp) == FIELD_DECL)
933 /* If the enclosing record type is variably_modified_type_p, the field
934 has already been remapped. Otherwise, it need not be. */
935 tree *n = id->decl_map->get (*tp);
936 if (n)
937 *tp = *n;
938 *walk_subtrees = 0;
940 else if (TYPE_P (*tp))
941 /* Types may need remapping as well. */
942 *tp = remap_type (*tp, id);
943 else if (CONSTANT_CLASS_P (*tp))
945 /* If this is a constant, we have to copy the node iff the type
946 will be remapped. copy_tree_r will not copy a constant. */
947 tree new_type = remap_type (TREE_TYPE (*tp), id);
949 if (new_type == TREE_TYPE (*tp))
950 *walk_subtrees = 0;
952 else if (TREE_CODE (*tp) == INTEGER_CST)
953 *tp = wide_int_to_tree (new_type, wi::to_wide (*tp));
954 else
956 *tp = copy_node (*tp);
957 TREE_TYPE (*tp) = new_type;
960 else
962 /* Otherwise, just copy the node. Note that copy_tree_r already
963 knows not to copy VAR_DECLs, etc., so this is safe. */
965 if (TREE_CODE (*tp) == MEM_REF)
967 /* We need to re-canonicalize MEM_REFs from inline substitutions
968 that can happen when a pointer argument is an ADDR_EXPR.
969 Recurse here manually to allow that. */
970 tree ptr = TREE_OPERAND (*tp, 0);
971 tree type = remap_type (TREE_TYPE (*tp), id);
972 tree old = *tp;
973 walk_tree (&ptr, remap_gimple_op_r, data, NULL);
974 *tp = fold_build2 (MEM_REF, type, ptr, TREE_OPERAND (*tp, 1));
975 TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old);
976 TREE_SIDE_EFFECTS (*tp) = TREE_SIDE_EFFECTS (old);
977 TREE_NO_WARNING (*tp) = TREE_NO_WARNING (old);
978 if (MR_DEPENDENCE_CLIQUE (old) != 0)
980 MR_DEPENDENCE_CLIQUE (*tp)
981 = remap_dependence_clique (id, MR_DEPENDENCE_CLIQUE (old));
982 MR_DEPENDENCE_BASE (*tp) = MR_DEPENDENCE_BASE (old);
984 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
985 remapped a parameter as the property might be valid only
986 for the parameter itself. */
987 if (TREE_THIS_NOTRAP (old)
988 && (!is_parm (TREE_OPERAND (old, 0))
989 || (!id->transform_parameter && is_parm (ptr))))
990 TREE_THIS_NOTRAP (*tp) = 1;
991 REF_REVERSE_STORAGE_ORDER (*tp) = REF_REVERSE_STORAGE_ORDER (old);
992 *walk_subtrees = 0;
993 return NULL;
996 /* Here is the "usual case". Copy this tree node, and then
997 tweak some special cases. */
998 copy_tree_r (tp, walk_subtrees, NULL);
1000 if (TREE_CODE (*tp) != OMP_CLAUSE)
1001 TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id);
1003 if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3))
1005 /* The copied TARGET_EXPR has never been expanded, even if the
1006 original node was expanded already. */
1007 TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
1008 TREE_OPERAND (*tp, 3) = NULL_TREE;
1010 else if (TREE_CODE (*tp) == ADDR_EXPR)
1012 /* Variable substitution need not be simple. In particular,
1013 the MEM_REF substitution above. Make sure that
1014 TREE_CONSTANT and friends are up-to-date. */
1015 int invariant = is_gimple_min_invariant (*tp);
1016 walk_tree (&TREE_OPERAND (*tp, 0), remap_gimple_op_r, data, NULL);
1017 recompute_tree_invariant_for_addr_expr (*tp);
1019 /* If this used to be invariant, but is not any longer,
1020 then regimplification is probably needed. */
1021 if (invariant && !is_gimple_min_invariant (*tp))
1022 id->regimplify = true;
1024 *walk_subtrees = 0;
1028 /* Update the TREE_BLOCK for the cloned expr. */
1029 if (EXPR_P (*tp))
1031 tree new_block = id->remapping_type_depth == 0 ? id->block : NULL;
1032 tree old_block = TREE_BLOCK (*tp);
1033 if (old_block)
1035 tree *n;
1036 n = id->decl_map->get (TREE_BLOCK (*tp));
1037 if (n)
1038 new_block = *n;
1040 TREE_SET_BLOCK (*tp, new_block);
1043 /* Keep iterating. */
1044 return NULL_TREE;
1048 /* Called from copy_body_id via walk_tree. DATA is really a
1049 `copy_body_data *'. */
1051 tree
1052 copy_tree_body_r (tree *tp, int *walk_subtrees, void *data)
1054 copy_body_data *id = (copy_body_data *) data;
1055 tree fn = id->src_fn;
1056 tree new_block;
1058 /* Begin by recognizing trees that we'll completely rewrite for the
1059 inlining context. Our output for these trees is completely
1060 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1061 into an edge). Further down, we'll handle trees that get
1062 duplicated and/or tweaked. */
1064 /* When requested, RETURN_EXPRs should be transformed to just the
1065 contained MODIFY_EXPR. The branch semantics of the return will
1066 be handled elsewhere by manipulating the CFG rather than a statement. */
1067 if (TREE_CODE (*tp) == RETURN_EXPR && id->transform_return_to_modify)
1069 tree assignment = TREE_OPERAND (*tp, 0);
1071 /* If we're returning something, just turn that into an
1072 assignment into the equivalent of the original RESULT_DECL.
1073 If the "assignment" is just the result decl, the result
1074 decl has already been set (e.g. a recent "foo (&result_decl,
1075 ...)"); just toss the entire RETURN_EXPR. */
1076 if (assignment && TREE_CODE (assignment) == MODIFY_EXPR)
1078 /* Replace the RETURN_EXPR with (a copy of) the
1079 MODIFY_EXPR hanging underneath. */
1080 *tp = copy_node (assignment);
1082 else /* Else the RETURN_EXPR returns no value. */
1084 *tp = NULL;
1085 return (tree) (void *)1;
1088 else if (TREE_CODE (*tp) == SSA_NAME)
1090 *tp = remap_ssa_name (*tp, id);
1091 *walk_subtrees = 0;
1092 return NULL;
1095 /* Local variables and labels need to be replaced by equivalent
1096 variables. We don't want to copy static variables; there's only
1097 one of those, no matter how many times we inline the containing
1098 function. Similarly for globals from an outer function. */
1099 else if (auto_var_in_fn_p (*tp, fn))
1101 tree new_decl;
1103 /* Remap the declaration. */
1104 new_decl = remap_decl (*tp, id);
1105 gcc_assert (new_decl);
1106 /* Replace this variable with the copy. */
1107 STRIP_TYPE_NOPS (new_decl);
1108 *tp = new_decl;
1109 *walk_subtrees = 0;
1111 else if (TREE_CODE (*tp) == STATEMENT_LIST)
1112 copy_statement_list (tp);
1113 else if (TREE_CODE (*tp) == SAVE_EXPR
1114 || TREE_CODE (*tp) == TARGET_EXPR)
1115 remap_save_expr (tp, id->decl_map, walk_subtrees);
1116 else if (TREE_CODE (*tp) == LABEL_DECL
1117 && (! DECL_CONTEXT (*tp)
1118 || decl_function_context (*tp) == id->src_fn))
1119 /* These may need to be remapped for EH handling. */
1120 *tp = remap_decl (*tp, id);
1121 else if (TREE_CODE (*tp) == BIND_EXPR)
1122 copy_bind_expr (tp, walk_subtrees, id);
1123 /* Types may need remapping as well. */
1124 else if (TYPE_P (*tp))
1125 *tp = remap_type (*tp, id);
1127 /* If this is a constant, we have to copy the node iff the type will be
1128 remapped. copy_tree_r will not copy a constant. */
1129 else if (CONSTANT_CLASS_P (*tp))
1131 tree new_type = remap_type (TREE_TYPE (*tp), id);
1133 if (new_type == TREE_TYPE (*tp))
1134 *walk_subtrees = 0;
1136 else if (TREE_CODE (*tp) == INTEGER_CST)
1137 *tp = wide_int_to_tree (new_type, wi::to_wide (*tp));
1138 else
1140 *tp = copy_node (*tp);
1141 TREE_TYPE (*tp) = new_type;
1145 /* Otherwise, just copy the node. Note that copy_tree_r already
1146 knows not to copy VAR_DECLs, etc., so this is safe. */
1147 else
1149 /* Here we handle trees that are not completely rewritten.
1150 First we detect some inlining-induced bogosities for
1151 discarding. */
1152 if (TREE_CODE (*tp) == MODIFY_EXPR
1153 && TREE_OPERAND (*tp, 0) == TREE_OPERAND (*tp, 1)
1154 && (auto_var_in_fn_p (TREE_OPERAND (*tp, 0), fn)))
1156 /* Some assignments VAR = VAR; don't generate any rtl code
1157 and thus don't count as variable modification. Avoid
1158 keeping bogosities like 0 = 0. */
1159 tree decl = TREE_OPERAND (*tp, 0), value;
1160 tree *n;
1162 n = id->decl_map->get (decl);
1163 if (n)
1165 value = *n;
1166 STRIP_TYPE_NOPS (value);
1167 if (TREE_CONSTANT (value) || TREE_READONLY (value))
1169 *tp = build_empty_stmt (EXPR_LOCATION (*tp));
1170 return copy_tree_body_r (tp, walk_subtrees, data);
1174 else if (TREE_CODE (*tp) == INDIRECT_REF)
1176 /* Get rid of *& from inline substitutions that can happen when a
1177 pointer argument is an ADDR_EXPR. */
1178 tree decl = TREE_OPERAND (*tp, 0);
1179 tree *n = id->decl_map->get (decl);
1180 if (n)
1182 /* If we happen to get an ADDR_EXPR in n->value, strip
1183 it manually here as we'll eventually get ADDR_EXPRs
1184 which lie about their types pointed to. In this case
1185 build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
1186 but we absolutely rely on that. As fold_indirect_ref
1187 does other useful transformations, try that first, though. */
1188 tree type = TREE_TYPE (*tp);
1189 tree ptr = id->do_not_unshare ? *n : unshare_expr (*n);
1190 tree old = *tp;
1191 *tp = gimple_fold_indirect_ref (ptr);
1192 if (! *tp)
1194 if (TREE_CODE (ptr) == ADDR_EXPR)
1197 = fold_indirect_ref_1 (EXPR_LOCATION (ptr), type, ptr);
1198 /* ??? We should either assert here or build
1199 a VIEW_CONVERT_EXPR instead of blindly leaking
1200 incompatible types to our IL. */
1201 if (! *tp)
1202 *tp = TREE_OPERAND (ptr, 0);
1204 else
1206 *tp = build1 (INDIRECT_REF, type, ptr);
1207 TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old);
1208 TREE_SIDE_EFFECTS (*tp) = TREE_SIDE_EFFECTS (old);
1209 TREE_READONLY (*tp) = TREE_READONLY (old);
1210 /* We cannot propagate the TREE_THIS_NOTRAP flag if we
1211 have remapped a parameter as the property might be
1212 valid only for the parameter itself. */
1213 if (TREE_THIS_NOTRAP (old)
1214 && (!is_parm (TREE_OPERAND (old, 0))
1215 || (!id->transform_parameter && is_parm (ptr))))
1216 TREE_THIS_NOTRAP (*tp) = 1;
1219 *walk_subtrees = 0;
1220 return NULL;
1223 else if (TREE_CODE (*tp) == MEM_REF)
1225 /* We need to re-canonicalize MEM_REFs from inline substitutions
1226 that can happen when a pointer argument is an ADDR_EXPR.
1227 Recurse here manually to allow that. */
1228 tree ptr = TREE_OPERAND (*tp, 0);
1229 tree type = remap_type (TREE_TYPE (*tp), id);
1230 tree old = *tp;
1231 walk_tree (&ptr, copy_tree_body_r, data, NULL);
1232 *tp = fold_build2 (MEM_REF, type, ptr, TREE_OPERAND (*tp, 1));
1233 TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old);
1234 TREE_SIDE_EFFECTS (*tp) = TREE_SIDE_EFFECTS (old);
1235 TREE_NO_WARNING (*tp) = TREE_NO_WARNING (old);
1236 if (MR_DEPENDENCE_CLIQUE (old) != 0)
1238 MR_DEPENDENCE_CLIQUE (*tp)
1239 = remap_dependence_clique (id, MR_DEPENDENCE_CLIQUE (old));
1240 MR_DEPENDENCE_BASE (*tp) = MR_DEPENDENCE_BASE (old);
1242 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
1243 remapped a parameter as the property might be valid only
1244 for the parameter itself. */
1245 if (TREE_THIS_NOTRAP (old)
1246 && (!is_parm (TREE_OPERAND (old, 0))
1247 || (!id->transform_parameter && is_parm (ptr))))
1248 TREE_THIS_NOTRAP (*tp) = 1;
1249 REF_REVERSE_STORAGE_ORDER (*tp) = REF_REVERSE_STORAGE_ORDER (old);
1250 *walk_subtrees = 0;
1251 return NULL;
1254 /* Here is the "usual case". Copy this tree node, and then
1255 tweak some special cases. */
1256 copy_tree_r (tp, walk_subtrees, NULL);
1258 /* If EXPR has block defined, map it to newly constructed block.
1259 When inlining we want EXPRs without block appear in the block
1260 of function call if we are not remapping a type. */
1261 if (EXPR_P (*tp))
1263 new_block = id->remapping_type_depth == 0 ? id->block : NULL;
1264 if (TREE_BLOCK (*tp))
1266 tree *n;
1267 n = id->decl_map->get (TREE_BLOCK (*tp));
1268 if (n)
1269 new_block = *n;
1271 TREE_SET_BLOCK (*tp, new_block);
1274 if (TREE_CODE (*tp) != OMP_CLAUSE)
1275 TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id);
1277 /* The copied TARGET_EXPR has never been expanded, even if the
1278 original node was expanded already. */
1279 if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3))
1281 TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
1282 TREE_OPERAND (*tp, 3) = NULL_TREE;
1285 /* Variable substitution need not be simple. In particular, the
1286 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
1287 and friends are up-to-date. */
1288 else if (TREE_CODE (*tp) == ADDR_EXPR)
1290 int invariant = is_gimple_min_invariant (*tp);
1291 walk_tree (&TREE_OPERAND (*tp, 0), copy_tree_body_r, id, NULL);
1293 /* Handle the case where we substituted an INDIRECT_REF
1294 into the operand of the ADDR_EXPR. */
1295 if (TREE_CODE (TREE_OPERAND (*tp, 0)) == INDIRECT_REF)
1297 tree t = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0);
1298 if (TREE_TYPE (t) != TREE_TYPE (*tp))
1299 t = fold_convert (remap_type (TREE_TYPE (*tp), id), t);
1300 *tp = t;
1302 else
1303 recompute_tree_invariant_for_addr_expr (*tp);
1305 /* If this used to be invariant, but is not any longer,
1306 then regimplification is probably needed. */
1307 if (invariant && !is_gimple_min_invariant (*tp))
1308 id->regimplify = true;
1310 *walk_subtrees = 0;
1314 /* Keep iterating. */
1315 return NULL_TREE;
1318 /* Helper for remap_gimple_stmt. Given an EH region number for the
1319 source function, map that to the duplicate EH region number in
1320 the destination function. */
1322 static int
1323 remap_eh_region_nr (int old_nr, copy_body_data *id)
1325 eh_region old_r, new_r;
1327 old_r = get_eh_region_from_number_fn (id->src_cfun, old_nr);
1328 new_r = static_cast<eh_region> (*id->eh_map->get (old_r));
1330 return new_r->index;
1333 /* Similar, but operate on INTEGER_CSTs. */
1335 static tree
1336 remap_eh_region_tree_nr (tree old_t_nr, copy_body_data *id)
1338 int old_nr, new_nr;
1340 old_nr = tree_to_shwi (old_t_nr);
1341 new_nr = remap_eh_region_nr (old_nr, id);
1343 return build_int_cst (integer_type_node, new_nr);
1346 /* Helper for copy_bb. Remap statement STMT using the inlining
1347 information in ID. Return the new statement copy. */
1349 static gimple_seq
1350 remap_gimple_stmt (gimple *stmt, copy_body_data *id)
1352 gimple *copy = NULL;
1353 struct walk_stmt_info wi;
1354 bool skip_first = false;
1355 gimple_seq stmts = NULL;
1357 if (is_gimple_debug (stmt)
1358 && !opt_for_fn (id->dst_fn, flag_var_tracking_assignments))
1359 return stmts;
1361 /* Begin by recognizing trees that we'll completely rewrite for the
1362 inlining context. Our output for these trees is completely
1363 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1364 into an edge). Further down, we'll handle trees that get
1365 duplicated and/or tweaked. */
1367 /* When requested, GIMPLE_RETURNs should be transformed to just the
1368 contained GIMPLE_ASSIGN. The branch semantics of the return will
1369 be handled elsewhere by manipulating the CFG rather than the
1370 statement. */
1371 if (gimple_code (stmt) == GIMPLE_RETURN && id->transform_return_to_modify)
1373 tree retval = gimple_return_retval (as_a <greturn *> (stmt));
1374 tree retbnd = gimple_return_retbnd (stmt);
1375 tree bndslot = id->retbnd;
1377 if (retbnd && bndslot)
1379 gimple *bndcopy = gimple_build_assign (bndslot, retbnd);
1380 memset (&wi, 0, sizeof (wi));
1381 wi.info = id;
1382 walk_gimple_op (bndcopy, remap_gimple_op_r, &wi);
1383 gimple_seq_add_stmt (&stmts, bndcopy);
1386 /* If we're returning something, just turn that into an
1387 assignment into the equivalent of the original RESULT_DECL.
1388 If RETVAL is just the result decl, the result decl has
1389 already been set (e.g. a recent "foo (&result_decl, ...)");
1390 just toss the entire GIMPLE_RETURN. */
1391 if (retval
1392 && (TREE_CODE (retval) != RESULT_DECL
1393 && (TREE_CODE (retval) != SSA_NAME
1394 || ! SSA_NAME_VAR (retval)
1395 || TREE_CODE (SSA_NAME_VAR (retval)) != RESULT_DECL)))
1397 copy = gimple_build_assign (id->do_not_unshare
1398 ? id->retvar : unshare_expr (id->retvar),
1399 retval);
1400 /* id->retvar is already substituted. Skip it on later remapping. */
1401 skip_first = true;
1403 /* We need to copy bounds if return structure with pointers into
1404 instrumented function. */
1405 if (chkp_function_instrumented_p (id->dst_fn)
1406 && !bndslot
1407 && !BOUNDED_P (id->retvar)
1408 && chkp_type_has_pointer (TREE_TYPE (id->retvar)))
1409 id->assign_stmts.safe_push (copy);
1412 else
1413 return stmts;
1415 else if (gimple_has_substatements (stmt))
1417 gimple_seq s1, s2;
1419 /* When cloning bodies from the C++ front end, we will be handed bodies
1420 in High GIMPLE form. Handle here all the High GIMPLE statements that
1421 have embedded statements. */
1422 switch (gimple_code (stmt))
1424 case GIMPLE_BIND:
1425 copy = copy_gimple_bind (as_a <gbind *> (stmt), id);
1426 break;
1428 case GIMPLE_CATCH:
1430 gcatch *catch_stmt = as_a <gcatch *> (stmt);
1431 s1 = remap_gimple_seq (gimple_catch_handler (catch_stmt), id);
1432 copy = gimple_build_catch (gimple_catch_types (catch_stmt), s1);
1434 break;
1436 case GIMPLE_EH_FILTER:
1437 s1 = remap_gimple_seq (gimple_eh_filter_failure (stmt), id);
1438 copy = gimple_build_eh_filter (gimple_eh_filter_types (stmt), s1);
1439 break;
1441 case GIMPLE_TRY:
1442 s1 = remap_gimple_seq (gimple_try_eval (stmt), id);
1443 s2 = remap_gimple_seq (gimple_try_cleanup (stmt), id);
1444 copy = gimple_build_try (s1, s2, gimple_try_kind (stmt));
1445 break;
1447 case GIMPLE_WITH_CLEANUP_EXPR:
1448 s1 = remap_gimple_seq (gimple_wce_cleanup (stmt), id);
1449 copy = gimple_build_wce (s1);
1450 break;
1452 case GIMPLE_OMP_PARALLEL:
1454 gomp_parallel *omp_par_stmt = as_a <gomp_parallel *> (stmt);
1455 s1 = remap_gimple_seq (gimple_omp_body (omp_par_stmt), id);
1456 copy = gimple_build_omp_parallel
1457 (s1,
1458 gimple_omp_parallel_clauses (omp_par_stmt),
1459 gimple_omp_parallel_child_fn (omp_par_stmt),
1460 gimple_omp_parallel_data_arg (omp_par_stmt));
1462 break;
1464 case GIMPLE_OMP_TASK:
1465 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1466 copy = gimple_build_omp_task
1467 (s1,
1468 gimple_omp_task_clauses (stmt),
1469 gimple_omp_task_child_fn (stmt),
1470 gimple_omp_task_data_arg (stmt),
1471 gimple_omp_task_copy_fn (stmt),
1472 gimple_omp_task_arg_size (stmt),
1473 gimple_omp_task_arg_align (stmt));
1474 break;
1476 case GIMPLE_OMP_FOR:
1477 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1478 s2 = remap_gimple_seq (gimple_omp_for_pre_body (stmt), id);
1479 copy = gimple_build_omp_for (s1, gimple_omp_for_kind (stmt),
1480 gimple_omp_for_clauses (stmt),
1481 gimple_omp_for_collapse (stmt), s2);
1483 size_t i;
1484 for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
1486 gimple_omp_for_set_index (copy, i,
1487 gimple_omp_for_index (stmt, i));
1488 gimple_omp_for_set_initial (copy, i,
1489 gimple_omp_for_initial (stmt, i));
1490 gimple_omp_for_set_final (copy, i,
1491 gimple_omp_for_final (stmt, i));
1492 gimple_omp_for_set_incr (copy, i,
1493 gimple_omp_for_incr (stmt, i));
1494 gimple_omp_for_set_cond (copy, i,
1495 gimple_omp_for_cond (stmt, i));
1498 break;
1500 case GIMPLE_OMP_MASTER:
1501 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1502 copy = gimple_build_omp_master (s1);
1503 break;
1505 case GIMPLE_OMP_TASKGROUP:
1506 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1507 copy = gimple_build_omp_taskgroup (s1);
1508 break;
1510 case GIMPLE_OMP_ORDERED:
1511 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1512 copy = gimple_build_omp_ordered
1513 (s1,
1514 gimple_omp_ordered_clauses (as_a <gomp_ordered *> (stmt)));
1515 break;
1517 case GIMPLE_OMP_SECTION:
1518 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1519 copy = gimple_build_omp_section (s1);
1520 break;
1522 case GIMPLE_OMP_SECTIONS:
1523 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1524 copy = gimple_build_omp_sections
1525 (s1, gimple_omp_sections_clauses (stmt));
1526 break;
1528 case GIMPLE_OMP_SINGLE:
1529 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1530 copy = gimple_build_omp_single
1531 (s1, gimple_omp_single_clauses (stmt));
1532 break;
1534 case GIMPLE_OMP_TARGET:
1535 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1536 copy = gimple_build_omp_target
1537 (s1, gimple_omp_target_kind (stmt),
1538 gimple_omp_target_clauses (stmt));
1539 break;
1541 case GIMPLE_OMP_TEAMS:
1542 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1543 copy = gimple_build_omp_teams
1544 (s1, gimple_omp_teams_clauses (stmt));
1545 break;
1547 case GIMPLE_OMP_CRITICAL:
1548 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1549 copy = gimple_build_omp_critical (s1,
1550 gimple_omp_critical_name
1551 (as_a <gomp_critical *> (stmt)),
1552 gimple_omp_critical_clauses
1553 (as_a <gomp_critical *> (stmt)));
1554 break;
1556 case GIMPLE_TRANSACTION:
1558 gtransaction *old_trans_stmt = as_a <gtransaction *> (stmt);
1559 gtransaction *new_trans_stmt;
1560 s1 = remap_gimple_seq (gimple_transaction_body (old_trans_stmt),
1561 id);
1562 copy = new_trans_stmt = gimple_build_transaction (s1);
1563 gimple_transaction_set_subcode (new_trans_stmt,
1564 gimple_transaction_subcode (old_trans_stmt));
1565 gimple_transaction_set_label_norm (new_trans_stmt,
1566 gimple_transaction_label_norm (old_trans_stmt));
1567 gimple_transaction_set_label_uninst (new_trans_stmt,
1568 gimple_transaction_label_uninst (old_trans_stmt));
1569 gimple_transaction_set_label_over (new_trans_stmt,
1570 gimple_transaction_label_over (old_trans_stmt));
1572 break;
1574 default:
1575 gcc_unreachable ();
1578 else
1580 if (gimple_assign_copy_p (stmt)
1581 && gimple_assign_lhs (stmt) == gimple_assign_rhs1 (stmt)
1582 && auto_var_in_fn_p (gimple_assign_lhs (stmt), id->src_fn))
1584 /* Here we handle statements that are not completely rewritten.
1585 First we detect some inlining-induced bogosities for
1586 discarding. */
1588 /* Some assignments VAR = VAR; don't generate any rtl code
1589 and thus don't count as variable modification. Avoid
1590 keeping bogosities like 0 = 0. */
1591 tree decl = gimple_assign_lhs (stmt), value;
1592 tree *n;
1594 n = id->decl_map->get (decl);
1595 if (n)
1597 value = *n;
1598 STRIP_TYPE_NOPS (value);
1599 if (TREE_CONSTANT (value) || TREE_READONLY (value))
1600 return NULL;
1604 /* For *ptr_N ={v} {CLOBBER}, if ptr_N is SSA_NAME defined
1605 in a block that we aren't copying during tree_function_versioning,
1606 just drop the clobber stmt. */
1607 if (id->blocks_to_copy && gimple_clobber_p (stmt))
1609 tree lhs = gimple_assign_lhs (stmt);
1610 if (TREE_CODE (lhs) == MEM_REF
1611 && TREE_CODE (TREE_OPERAND (lhs, 0)) == SSA_NAME)
1613 gimple *def_stmt = SSA_NAME_DEF_STMT (TREE_OPERAND (lhs, 0));
1614 if (gimple_bb (def_stmt)
1615 && !bitmap_bit_p (id->blocks_to_copy,
1616 gimple_bb (def_stmt)->index))
1617 return NULL;
1621 if (gimple_debug_bind_p (stmt))
1623 gdebug *copy
1624 = gimple_build_debug_bind (gimple_debug_bind_get_var (stmt),
1625 gimple_debug_bind_get_value (stmt),
1626 stmt);
1627 id->debug_stmts.safe_push (copy);
1628 gimple_seq_add_stmt (&stmts, copy);
1629 return stmts;
1631 if (gimple_debug_source_bind_p (stmt))
1633 gdebug *copy = gimple_build_debug_source_bind
1634 (gimple_debug_source_bind_get_var (stmt),
1635 gimple_debug_source_bind_get_value (stmt),
1636 stmt);
1637 id->debug_stmts.safe_push (copy);
1638 gimple_seq_add_stmt (&stmts, copy);
1639 return stmts;
1642 /* Create a new deep copy of the statement. */
1643 copy = gimple_copy (stmt);
1645 /* Clear flags that need revisiting. */
1646 if (gcall *call_stmt = dyn_cast <gcall *> (copy))
1648 if (gimple_call_tail_p (call_stmt))
1649 gimple_call_set_tail (call_stmt, false);
1650 if (gimple_call_from_thunk_p (call_stmt))
1651 gimple_call_set_from_thunk (call_stmt, false);
1652 if (gimple_call_internal_p (call_stmt))
1653 switch (gimple_call_internal_fn (call_stmt))
1655 case IFN_GOMP_SIMD_LANE:
1656 case IFN_GOMP_SIMD_VF:
1657 case IFN_GOMP_SIMD_LAST_LANE:
1658 case IFN_GOMP_SIMD_ORDERED_START:
1659 case IFN_GOMP_SIMD_ORDERED_END:
1660 DECL_STRUCT_FUNCTION (id->dst_fn)->has_simduid_loops = true;
1661 break;
1662 default:
1663 break;
1667 /* Remap the region numbers for __builtin_eh_{pointer,filter},
1668 RESX and EH_DISPATCH. */
1669 if (id->eh_map)
1670 switch (gimple_code (copy))
1672 case GIMPLE_CALL:
1674 tree r, fndecl = gimple_call_fndecl (copy);
1675 if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
1676 switch (DECL_FUNCTION_CODE (fndecl))
1678 case BUILT_IN_EH_COPY_VALUES:
1679 r = gimple_call_arg (copy, 1);
1680 r = remap_eh_region_tree_nr (r, id);
1681 gimple_call_set_arg (copy, 1, r);
1682 /* FALLTHRU */
1684 case BUILT_IN_EH_POINTER:
1685 case BUILT_IN_EH_FILTER:
1686 r = gimple_call_arg (copy, 0);
1687 r = remap_eh_region_tree_nr (r, id);
1688 gimple_call_set_arg (copy, 0, r);
1689 break;
1691 default:
1692 break;
1695 /* Reset alias info if we didn't apply measures to
1696 keep it valid over inlining by setting DECL_PT_UID. */
1697 if (!id->src_cfun->gimple_df
1698 || !id->src_cfun->gimple_df->ipa_pta)
1699 gimple_call_reset_alias_info (as_a <gcall *> (copy));
1701 break;
1703 case GIMPLE_RESX:
1705 gresx *resx_stmt = as_a <gresx *> (copy);
1706 int r = gimple_resx_region (resx_stmt);
1707 r = remap_eh_region_nr (r, id);
1708 gimple_resx_set_region (resx_stmt, r);
1710 break;
1712 case GIMPLE_EH_DISPATCH:
1714 geh_dispatch *eh_dispatch = as_a <geh_dispatch *> (copy);
1715 int r = gimple_eh_dispatch_region (eh_dispatch);
1716 r = remap_eh_region_nr (r, id);
1717 gimple_eh_dispatch_set_region (eh_dispatch, r);
1719 break;
1721 default:
1722 break;
1726 /* If STMT has a block defined, map it to the newly constructed
1727 block. */
1728 if (gimple_block (copy))
1730 tree *n;
1731 n = id->decl_map->get (gimple_block (copy));
1732 gcc_assert (n);
1733 gimple_set_block (copy, *n);
1736 if (gimple_debug_bind_p (copy) || gimple_debug_source_bind_p (copy))
1738 gimple_seq_add_stmt (&stmts, copy);
1739 return stmts;
1742 /* Remap all the operands in COPY. */
1743 memset (&wi, 0, sizeof (wi));
1744 wi.info = id;
1745 if (skip_first)
1746 walk_tree (gimple_op_ptr (copy, 1), remap_gimple_op_r, &wi, NULL);
1747 else
1748 walk_gimple_op (copy, remap_gimple_op_r, &wi);
1750 /* Clear the copied virtual operands. We are not remapping them here
1751 but are going to recreate them from scratch. */
1752 if (gimple_has_mem_ops (copy))
1754 gimple_set_vdef (copy, NULL_TREE);
1755 gimple_set_vuse (copy, NULL_TREE);
1758 gimple_seq_add_stmt (&stmts, copy);
1759 return stmts;
1763 /* Copy basic block, scale profile accordingly. Edges will be taken care of
1764 later */
1766 static basic_block
1767 copy_bb (copy_body_data *id, basic_block bb,
1768 profile_count num, profile_count den)
1770 gimple_stmt_iterator gsi, copy_gsi, seq_gsi;
1771 basic_block copy_basic_block;
1772 tree decl;
1773 basic_block prev;
1775 profile_count::adjust_for_ipa_scaling (&num, &den);
1777 /* Search for previous copied basic block. */
1778 prev = bb->prev_bb;
1779 while (!prev->aux)
1780 prev = prev->prev_bb;
1782 /* create_basic_block() will append every new block to
1783 basic_block_info automatically. */
1784 copy_basic_block = create_basic_block (NULL, (basic_block) prev->aux);
1785 copy_basic_block->count = bb->count.apply_scale (num, den);
1787 copy_gsi = gsi_start_bb (copy_basic_block);
1789 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1791 gimple_seq stmts;
1792 gimple *stmt = gsi_stmt (gsi);
1793 gimple *orig_stmt = stmt;
1794 gimple_stmt_iterator stmts_gsi;
1795 bool stmt_added = false;
1797 id->regimplify = false;
1798 stmts = remap_gimple_stmt (stmt, id);
1800 if (gimple_seq_empty_p (stmts))
1801 continue;
1803 seq_gsi = copy_gsi;
1805 for (stmts_gsi = gsi_start (stmts);
1806 !gsi_end_p (stmts_gsi); )
1808 stmt = gsi_stmt (stmts_gsi);
1810 /* Advance iterator now before stmt is moved to seq_gsi. */
1811 gsi_next (&stmts_gsi);
1813 if (gimple_nop_p (stmt))
1814 continue;
1816 gimple_duplicate_stmt_histograms (cfun, stmt, id->src_cfun,
1817 orig_stmt);
1819 /* With return slot optimization we can end up with
1820 non-gimple (foo *)&this->m, fix that here. */
1821 if (is_gimple_assign (stmt)
1822 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt))
1823 && !is_gimple_val (gimple_assign_rhs1 (stmt)))
1825 tree new_rhs;
1826 new_rhs = force_gimple_operand_gsi (&seq_gsi,
1827 gimple_assign_rhs1 (stmt),
1828 true, NULL, false,
1829 GSI_CONTINUE_LINKING);
1830 gimple_assign_set_rhs1 (stmt, new_rhs);
1831 id->regimplify = false;
1834 gsi_insert_after (&seq_gsi, stmt, GSI_NEW_STMT);
1836 if (id->regimplify)
1837 gimple_regimplify_operands (stmt, &seq_gsi);
1839 stmt_added = true;
1842 if (!stmt_added)
1843 continue;
1845 /* If copy_basic_block has been empty at the start of this iteration,
1846 call gsi_start_bb again to get at the newly added statements. */
1847 if (gsi_end_p (copy_gsi))
1848 copy_gsi = gsi_start_bb (copy_basic_block);
1849 else
1850 gsi_next (&copy_gsi);
1852 /* Process the new statement. The call to gimple_regimplify_operands
1853 possibly turned the statement into multiple statements, we
1854 need to process all of them. */
1857 tree fn;
1858 gcall *call_stmt;
1860 stmt = gsi_stmt (copy_gsi);
1861 call_stmt = dyn_cast <gcall *> (stmt);
1862 if (call_stmt
1863 && gimple_call_va_arg_pack_p (call_stmt)
1864 && id->call_stmt
1865 && ! gimple_call_va_arg_pack_p (id->call_stmt))
1867 /* __builtin_va_arg_pack () should be replaced by
1868 all arguments corresponding to ... in the caller. */
1869 tree p;
1870 gcall *new_call;
1871 vec<tree> argarray;
1872 size_t nargs = gimple_call_num_args (id->call_stmt);
1873 size_t n, i, nargs_to_copy;
1874 bool remove_bounds = false;
1876 for (p = DECL_ARGUMENTS (id->src_fn); p; p = DECL_CHAIN (p))
1877 nargs--;
1879 /* Bounds should be removed from arg pack in case
1880 we handle not instrumented call in instrumented
1881 function. */
1882 nargs_to_copy = nargs;
1883 if (gimple_call_with_bounds_p (id->call_stmt)
1884 && !gimple_call_with_bounds_p (stmt))
1886 for (i = gimple_call_num_args (id->call_stmt) - nargs;
1887 i < gimple_call_num_args (id->call_stmt);
1888 i++)
1889 if (POINTER_BOUNDS_P (gimple_call_arg (id->call_stmt, i)))
1890 nargs_to_copy--;
1891 remove_bounds = true;
1894 /* Create the new array of arguments. */
1895 n = nargs_to_copy + gimple_call_num_args (call_stmt);
1896 argarray.create (n);
1897 argarray.safe_grow_cleared (n);
1899 /* Copy all the arguments before '...' */
1900 memcpy (argarray.address (),
1901 gimple_call_arg_ptr (call_stmt, 0),
1902 gimple_call_num_args (call_stmt) * sizeof (tree));
1904 if (remove_bounds)
1906 /* Append the rest of arguments removing bounds. */
1907 unsigned cur = gimple_call_num_args (call_stmt);
1908 i = gimple_call_num_args (id->call_stmt) - nargs;
1909 for (i = gimple_call_num_args (id->call_stmt) - nargs;
1910 i < gimple_call_num_args (id->call_stmt);
1911 i++)
1912 if (!POINTER_BOUNDS_P (gimple_call_arg (id->call_stmt, i)))
1913 argarray[cur++] = gimple_call_arg (id->call_stmt, i);
1914 gcc_assert (cur == n);
1916 else
1918 /* Append the arguments passed in '...' */
1919 memcpy (argarray.address () + gimple_call_num_args (call_stmt),
1920 gimple_call_arg_ptr (id->call_stmt, 0)
1921 + (gimple_call_num_args (id->call_stmt) - nargs),
1922 nargs * sizeof (tree));
1925 new_call = gimple_build_call_vec (gimple_call_fn (call_stmt),
1926 argarray);
1928 argarray.release ();
1930 /* Copy all GIMPLE_CALL flags, location and block, except
1931 GF_CALL_VA_ARG_PACK. */
1932 gimple_call_copy_flags (new_call, call_stmt);
1933 gimple_call_set_va_arg_pack (new_call, false);
1934 gimple_set_location (new_call, gimple_location (stmt));
1935 gimple_set_block (new_call, gimple_block (stmt));
1936 gimple_call_set_lhs (new_call, gimple_call_lhs (call_stmt));
1938 gsi_replace (&copy_gsi, new_call, false);
1939 stmt = new_call;
1941 else if (call_stmt
1942 && id->call_stmt
1943 && (decl = gimple_call_fndecl (stmt))
1944 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
1945 && DECL_FUNCTION_CODE (decl) == BUILT_IN_VA_ARG_PACK_LEN
1946 && ! gimple_call_va_arg_pack_p (id->call_stmt))
1948 /* __builtin_va_arg_pack_len () should be replaced by
1949 the number of anonymous arguments. */
1950 size_t nargs = gimple_call_num_args (id->call_stmt), i;
1951 tree count, p;
1952 gimple *new_stmt;
1954 for (p = DECL_ARGUMENTS (id->src_fn); p; p = DECL_CHAIN (p))
1955 nargs--;
1957 /* For instrumented calls we should ignore bounds. */
1958 for (i = gimple_call_num_args (id->call_stmt) - nargs;
1959 i < gimple_call_num_args (id->call_stmt);
1960 i++)
1961 if (POINTER_BOUNDS_P (gimple_call_arg (id->call_stmt, i)))
1962 nargs--;
1964 count = build_int_cst (integer_type_node, nargs);
1965 new_stmt = gimple_build_assign (gimple_call_lhs (stmt), count);
1966 gsi_replace (&copy_gsi, new_stmt, false);
1967 stmt = new_stmt;
1969 else if (call_stmt
1970 && id->call_stmt
1971 && gimple_call_internal_p (stmt)
1972 && gimple_call_internal_fn (stmt) == IFN_TSAN_FUNC_EXIT)
1974 /* Drop TSAN_FUNC_EXIT () internal calls during inlining. */
1975 gsi_remove (&copy_gsi, false);
1976 continue;
1979 /* Statements produced by inlining can be unfolded, especially
1980 when we constant propagated some operands. We can't fold
1981 them right now for two reasons:
1982 1) folding require SSA_NAME_DEF_STMTs to be correct
1983 2) we can't change function calls to builtins.
1984 So we just mark statement for later folding. We mark
1985 all new statements, instead just statements that has changed
1986 by some nontrivial substitution so even statements made
1987 foldable indirectly are updated. If this turns out to be
1988 expensive, copy_body can be told to watch for nontrivial
1989 changes. */
1990 if (id->statements_to_fold)
1991 id->statements_to_fold->add (stmt);
1993 /* We're duplicating a CALL_EXPR. Find any corresponding
1994 callgraph edges and update or duplicate them. */
1995 if (gcall *call_stmt = dyn_cast <gcall *> (stmt))
1997 struct cgraph_edge *edge;
1999 switch (id->transform_call_graph_edges)
2001 case CB_CGE_DUPLICATE:
2002 edge = id->src_node->get_edge (orig_stmt);
2003 if (edge)
2005 struct cgraph_edge *old_edge = edge;
2006 profile_count old_cnt = edge->count;
2007 edge = edge->clone (id->dst_node, call_stmt,
2008 gimple_uid (stmt),
2009 num, den,
2010 true);
2012 /* Speculative calls consist of two edges - direct and
2013 indirect. Duplicate the whole thing and distribute
2014 frequencies accordingly. */
2015 if (edge->speculative)
2017 struct cgraph_edge *direct, *indirect;
2018 struct ipa_ref *ref;
2020 gcc_assert (!edge->indirect_unknown_callee);
2021 old_edge->speculative_call_info (direct, indirect, ref);
2023 profile_count indir_cnt = indirect->count;
2024 indirect = indirect->clone (id->dst_node, call_stmt,
2025 gimple_uid (stmt),
2026 num, den,
2027 true);
2029 profile_probability prob
2030 = indir_cnt.probability_in (old_cnt + indir_cnt);
2031 indirect->count
2032 = copy_basic_block->count.apply_probability (prob);
2033 edge->count = copy_basic_block->count - indirect->count;
2034 id->dst_node->clone_reference (ref, stmt);
2036 else
2037 edge->count = copy_basic_block->count;
2039 break;
2041 case CB_CGE_MOVE_CLONES:
2042 id->dst_node->set_call_stmt_including_clones (orig_stmt,
2043 call_stmt);
2044 edge = id->dst_node->get_edge (stmt);
2045 break;
2047 case CB_CGE_MOVE:
2048 edge = id->dst_node->get_edge (orig_stmt);
2049 if (edge)
2050 edge->set_call_stmt (call_stmt);
2051 break;
2053 default:
2054 gcc_unreachable ();
2057 /* Constant propagation on argument done during inlining
2058 may create new direct call. Produce an edge for it. */
2059 if ((!edge
2060 || (edge->indirect_inlining_edge
2061 && id->transform_call_graph_edges == CB_CGE_MOVE_CLONES))
2062 && id->dst_node->definition
2063 && (fn = gimple_call_fndecl (stmt)) != NULL)
2065 struct cgraph_node *dest = cgraph_node::get_create (fn);
2067 /* We have missing edge in the callgraph. This can happen
2068 when previous inlining turned an indirect call into a
2069 direct call by constant propagating arguments or we are
2070 producing dead clone (for further cloning). In all
2071 other cases we hit a bug (incorrect node sharing is the
2072 most common reason for missing edges). */
2073 gcc_assert (!dest->definition
2074 || dest->address_taken
2075 || !id->src_node->definition
2076 || !id->dst_node->definition);
2077 if (id->transform_call_graph_edges == CB_CGE_MOVE_CLONES)
2078 id->dst_node->create_edge_including_clones
2079 (dest, orig_stmt, call_stmt, bb->count,
2080 CIF_ORIGINALLY_INDIRECT_CALL);
2081 else
2082 id->dst_node->create_edge (dest, call_stmt,
2083 bb->count)->inline_failed
2084 = CIF_ORIGINALLY_INDIRECT_CALL;
2085 if (dump_file)
2087 fprintf (dump_file, "Created new direct edge to %s\n",
2088 dest->name ());
2092 notice_special_calls (as_a <gcall *> (stmt));
2095 maybe_duplicate_eh_stmt_fn (cfun, stmt, id->src_cfun, orig_stmt,
2096 id->eh_map, id->eh_lp_nr);
2098 gsi_next (&copy_gsi);
2100 while (!gsi_end_p (copy_gsi));
2102 copy_gsi = gsi_last_bb (copy_basic_block);
2105 return copy_basic_block;
2108 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
2109 form is quite easy, since dominator relationship for old basic blocks does
2110 not change.
2112 There is however exception where inlining might change dominator relation
2113 across EH edges from basic block within inlined functions destinating
2114 to landing pads in function we inline into.
2116 The function fills in PHI_RESULTs of such PHI nodes if they refer
2117 to gimple regs. Otherwise, the function mark PHI_RESULT of such
2118 PHI nodes for renaming. For non-gimple regs, renaming is safe: the
2119 EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
2120 set, and this means that there will be no overlapping live ranges
2121 for the underlying symbol.
2123 This might change in future if we allow redirecting of EH edges and
2124 we might want to change way build CFG pre-inlining to include
2125 all the possible edges then. */
2126 static void
2127 update_ssa_across_abnormal_edges (basic_block bb, basic_block ret_bb,
2128 bool can_throw, bool nonlocal_goto)
2130 edge e;
2131 edge_iterator ei;
2133 FOR_EACH_EDGE (e, ei, bb->succs)
2134 if (!e->dest->aux
2135 || ((basic_block)e->dest->aux)->index == ENTRY_BLOCK)
2137 gphi *phi;
2138 gphi_iterator si;
2140 if (!nonlocal_goto)
2141 gcc_assert (e->flags & EDGE_EH);
2143 if (!can_throw)
2144 gcc_assert (!(e->flags & EDGE_EH));
2146 for (si = gsi_start_phis (e->dest); !gsi_end_p (si); gsi_next (&si))
2148 edge re;
2150 phi = si.phi ();
2152 /* For abnormal goto/call edges the receiver can be the
2153 ENTRY_BLOCK. Do not assert this cannot happen. */
2155 gcc_assert ((e->flags & EDGE_EH)
2156 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi)));
2158 re = find_edge (ret_bb, e->dest);
2159 gcc_checking_assert (re);
2160 gcc_assert ((re->flags & (EDGE_EH | EDGE_ABNORMAL))
2161 == (e->flags & (EDGE_EH | EDGE_ABNORMAL)));
2163 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi, e),
2164 USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi, re)));
2170 /* Copy edges from BB into its copy constructed earlier, scale profile
2171 accordingly. Edges will be taken care of later. Assume aux
2172 pointers to point to the copies of each BB. Return true if any
2173 debug stmts are left after a statement that must end the basic block. */
2175 static bool
2176 copy_edges_for_bb (basic_block bb, profile_count num, profile_count den,
2177 basic_block ret_bb, basic_block abnormal_goto_dest)
2179 basic_block new_bb = (basic_block) bb->aux;
2180 edge_iterator ei;
2181 edge old_edge;
2182 gimple_stmt_iterator si;
2183 int flags;
2184 bool need_debug_cleanup = false;
2186 /* Use the indices from the original blocks to create edges for the
2187 new ones. */
2188 FOR_EACH_EDGE (old_edge, ei, bb->succs)
2189 if (!(old_edge->flags & EDGE_EH))
2191 edge new_edge;
2193 flags = old_edge->flags;
2195 /* Return edges do get a FALLTHRU flag when the get inlined. */
2196 if (old_edge->dest->index == EXIT_BLOCK
2197 && !(old_edge->flags & (EDGE_TRUE_VALUE|EDGE_FALSE_VALUE|EDGE_FAKE))
2198 && old_edge->dest->aux != EXIT_BLOCK_PTR_FOR_FN (cfun))
2199 flags |= EDGE_FALLTHRU;
2200 new_edge = make_edge (new_bb, (basic_block) old_edge->dest->aux, flags);
2201 new_edge->probability = old_edge->probability;
2204 if (bb->index == ENTRY_BLOCK || bb->index == EXIT_BLOCK)
2205 return false;
2207 /* When doing function splitting, we must decreate count of the return block
2208 which was previously reachable by block we did not copy. */
2209 if (single_succ_p (bb) && single_succ_edge (bb)->dest->index == EXIT_BLOCK)
2210 FOR_EACH_EDGE (old_edge, ei, bb->preds)
2211 if (old_edge->src->index != ENTRY_BLOCK
2212 && !old_edge->src->aux)
2213 new_bb->count -= old_edge->count ().apply_scale (num, den);
2215 for (si = gsi_start_bb (new_bb); !gsi_end_p (si);)
2217 gimple *copy_stmt;
2218 bool can_throw, nonlocal_goto;
2220 copy_stmt = gsi_stmt (si);
2221 if (!is_gimple_debug (copy_stmt))
2222 update_stmt (copy_stmt);
2224 /* Do this before the possible split_block. */
2225 gsi_next (&si);
2227 /* If this tree could throw an exception, there are two
2228 cases where we need to add abnormal edge(s): the
2229 tree wasn't in a region and there is a "current
2230 region" in the caller; or the original tree had
2231 EH edges. In both cases split the block after the tree,
2232 and add abnormal edge(s) as needed; we need both
2233 those from the callee and the caller.
2234 We check whether the copy can throw, because the const
2235 propagation can change an INDIRECT_REF which throws
2236 into a COMPONENT_REF which doesn't. If the copy
2237 can throw, the original could also throw. */
2238 can_throw = stmt_can_throw_internal (copy_stmt);
2239 nonlocal_goto
2240 = (stmt_can_make_abnormal_goto (copy_stmt)
2241 && !computed_goto_p (copy_stmt));
2243 if (can_throw || nonlocal_goto)
2245 if (!gsi_end_p (si))
2247 while (!gsi_end_p (si) && is_gimple_debug (gsi_stmt (si)))
2248 gsi_next (&si);
2249 if (gsi_end_p (si))
2250 need_debug_cleanup = true;
2252 if (!gsi_end_p (si))
2253 /* Note that bb's predecessor edges aren't necessarily
2254 right at this point; split_block doesn't care. */
2256 edge e = split_block (new_bb, copy_stmt);
2258 new_bb = e->dest;
2259 new_bb->aux = e->src->aux;
2260 si = gsi_start_bb (new_bb);
2264 bool update_probs = false;
2266 if (gimple_code (copy_stmt) == GIMPLE_EH_DISPATCH)
2268 make_eh_dispatch_edges (as_a <geh_dispatch *> (copy_stmt));
2269 update_probs = true;
2271 else if (can_throw)
2273 make_eh_edges (copy_stmt);
2274 update_probs = true;
2277 /* EH edges may not match old edges. Copy as much as possible. */
2278 if (update_probs)
2280 edge e;
2281 edge_iterator ei;
2282 basic_block copy_stmt_bb = gimple_bb (copy_stmt);
2284 FOR_EACH_EDGE (old_edge, ei, bb->succs)
2285 if ((old_edge->flags & EDGE_EH)
2286 && (e = find_edge (copy_stmt_bb,
2287 (basic_block) old_edge->dest->aux))
2288 && (e->flags & EDGE_EH))
2289 e->probability = old_edge->probability;
2291 FOR_EACH_EDGE (e, ei, copy_stmt_bb->succs)
2292 if ((e->flags & EDGE_EH) && !e->probability.initialized_p ())
2293 e->probability = profile_probability::never ();
2297 /* If the call we inline cannot make abnormal goto do not add
2298 additional abnormal edges but only retain those already present
2299 in the original function body. */
2300 if (abnormal_goto_dest == NULL)
2301 nonlocal_goto = false;
2302 if (nonlocal_goto)
2304 basic_block copy_stmt_bb = gimple_bb (copy_stmt);
2306 if (get_abnormal_succ_dispatcher (copy_stmt_bb))
2307 nonlocal_goto = false;
2308 /* ABNORMAL_DISPATCHER (1) is for longjmp/setjmp or nonlocal gotos
2309 in OpenMP regions which aren't allowed to be left abnormally.
2310 So, no need to add abnormal edge in that case. */
2311 else if (is_gimple_call (copy_stmt)
2312 && gimple_call_internal_p (copy_stmt)
2313 && (gimple_call_internal_fn (copy_stmt)
2314 == IFN_ABNORMAL_DISPATCHER)
2315 && gimple_call_arg (copy_stmt, 0) == boolean_true_node)
2316 nonlocal_goto = false;
2317 else
2318 make_single_succ_edge (copy_stmt_bb, abnormal_goto_dest,
2319 EDGE_ABNORMAL);
2322 if ((can_throw || nonlocal_goto)
2323 && gimple_in_ssa_p (cfun))
2324 update_ssa_across_abnormal_edges (gimple_bb (copy_stmt), ret_bb,
2325 can_throw, nonlocal_goto);
2327 return need_debug_cleanup;
2330 /* Copy the PHIs. All blocks and edges are copied, some blocks
2331 was possibly split and new outgoing EH edges inserted.
2332 BB points to the block of original function and AUX pointers links
2333 the original and newly copied blocks. */
2335 static void
2336 copy_phis_for_bb (basic_block bb, copy_body_data *id)
2338 basic_block const new_bb = (basic_block) bb->aux;
2339 edge_iterator ei;
2340 gphi *phi;
2341 gphi_iterator si;
2342 edge new_edge;
2343 bool inserted = false;
2345 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
2347 tree res, new_res;
2348 gphi *new_phi;
2350 phi = si.phi ();
2351 res = PHI_RESULT (phi);
2352 new_res = res;
2353 if (!virtual_operand_p (res))
2355 walk_tree (&new_res, copy_tree_body_r, id, NULL);
2356 if (EDGE_COUNT (new_bb->preds) == 0)
2358 /* Technically we'd want a SSA_DEFAULT_DEF here... */
2359 SSA_NAME_DEF_STMT (new_res) = gimple_build_nop ();
2361 else
2363 new_phi = create_phi_node (new_res, new_bb);
2364 FOR_EACH_EDGE (new_edge, ei, new_bb->preds)
2366 edge old_edge = find_edge ((basic_block) new_edge->src->aux,
2367 bb);
2368 tree arg;
2369 tree new_arg;
2370 edge_iterator ei2;
2371 location_t locus;
2373 /* When doing partial cloning, we allow PHIs on the entry
2374 block as long as all the arguments are the same.
2375 Find any input edge to see argument to copy. */
2376 if (!old_edge)
2377 FOR_EACH_EDGE (old_edge, ei2, bb->preds)
2378 if (!old_edge->src->aux)
2379 break;
2381 arg = PHI_ARG_DEF_FROM_EDGE (phi, old_edge);
2382 new_arg = arg;
2383 walk_tree (&new_arg, copy_tree_body_r, id, NULL);
2384 gcc_assert (new_arg);
2385 /* With return slot optimization we can end up with
2386 non-gimple (foo *)&this->m, fix that here. */
2387 if (TREE_CODE (new_arg) != SSA_NAME
2388 && TREE_CODE (new_arg) != FUNCTION_DECL
2389 && !is_gimple_val (new_arg))
2391 gimple_seq stmts = NULL;
2392 new_arg = force_gimple_operand (new_arg, &stmts, true,
2393 NULL);
2394 gsi_insert_seq_on_edge (new_edge, stmts);
2395 inserted = true;
2397 locus = gimple_phi_arg_location_from_edge (phi, old_edge);
2398 if (LOCATION_BLOCK (locus))
2400 tree *n;
2401 n = id->decl_map->get (LOCATION_BLOCK (locus));
2402 gcc_assert (n);
2403 locus = set_block (locus, *n);
2405 else
2406 locus = LOCATION_LOCUS (locus);
2408 add_phi_arg (new_phi, new_arg, new_edge, locus);
2414 /* Commit the delayed edge insertions. */
2415 if (inserted)
2416 FOR_EACH_EDGE (new_edge, ei, new_bb->preds)
2417 gsi_commit_one_edge_insert (new_edge, NULL);
2421 /* Wrapper for remap_decl so it can be used as a callback. */
2423 static tree
2424 remap_decl_1 (tree decl, void *data)
2426 return remap_decl (decl, (copy_body_data *) data);
2429 /* Build struct function and associated datastructures for the new clone
2430 NEW_FNDECL to be build. CALLEE_FNDECL is the original. Function changes
2431 the cfun to the function of new_fndecl (and current_function_decl too). */
2433 static void
2434 initialize_cfun (tree new_fndecl, tree callee_fndecl, profile_count count)
2436 struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
2438 if (!DECL_ARGUMENTS (new_fndecl))
2439 DECL_ARGUMENTS (new_fndecl) = DECL_ARGUMENTS (callee_fndecl);
2440 if (!DECL_RESULT (new_fndecl))
2441 DECL_RESULT (new_fndecl) = DECL_RESULT (callee_fndecl);
2443 /* Register specific tree functions. */
2444 gimple_register_cfg_hooks ();
2446 /* Get clean struct function. */
2447 push_struct_function (new_fndecl);
2449 /* We will rebuild these, so just sanity check that they are empty. */
2450 gcc_assert (VALUE_HISTOGRAMS (cfun) == NULL);
2451 gcc_assert (cfun->local_decls == NULL);
2452 gcc_assert (cfun->cfg == NULL);
2453 gcc_assert (cfun->decl == new_fndecl);
2455 /* Copy items we preserve during cloning. */
2456 cfun->static_chain_decl = src_cfun->static_chain_decl;
2457 cfun->nonlocal_goto_save_area = src_cfun->nonlocal_goto_save_area;
2458 cfun->function_end_locus = src_cfun->function_end_locus;
2459 cfun->curr_properties = src_cfun->curr_properties;
2460 cfun->last_verified = src_cfun->last_verified;
2461 cfun->va_list_gpr_size = src_cfun->va_list_gpr_size;
2462 cfun->va_list_fpr_size = src_cfun->va_list_fpr_size;
2463 cfun->has_nonlocal_label = src_cfun->has_nonlocal_label;
2464 cfun->stdarg = src_cfun->stdarg;
2465 cfun->after_inlining = src_cfun->after_inlining;
2466 cfun->can_throw_non_call_exceptions
2467 = src_cfun->can_throw_non_call_exceptions;
2468 cfun->can_delete_dead_exceptions = src_cfun->can_delete_dead_exceptions;
2469 cfun->returns_struct = src_cfun->returns_struct;
2470 cfun->returns_pcc_struct = src_cfun->returns_pcc_struct;
2472 init_empty_tree_cfg ();
2474 profile_status_for_fn (cfun) = profile_status_for_fn (src_cfun);
2476 profile_count num = count;
2477 profile_count den = ENTRY_BLOCK_PTR_FOR_FN (src_cfun)->count;
2478 profile_count::adjust_for_ipa_scaling (&num, &den);
2480 ENTRY_BLOCK_PTR_FOR_FN (cfun)->count =
2481 ENTRY_BLOCK_PTR_FOR_FN (src_cfun)->count.apply_scale (count,
2482 ENTRY_BLOCK_PTR_FOR_FN (src_cfun)->count);
2483 EXIT_BLOCK_PTR_FOR_FN (cfun)->count =
2484 EXIT_BLOCK_PTR_FOR_FN (src_cfun)->count.apply_scale (count,
2485 ENTRY_BLOCK_PTR_FOR_FN (src_cfun)->count);
2486 if (src_cfun->eh)
2487 init_eh_for_function ();
2489 if (src_cfun->gimple_df)
2491 init_tree_ssa (cfun);
2492 cfun->gimple_df->in_ssa_p = src_cfun->gimple_df->in_ssa_p;
2493 if (cfun->gimple_df->in_ssa_p)
2494 init_ssa_operands (cfun);
2498 /* Helper function for copy_cfg_body. Move debug stmts from the end
2499 of NEW_BB to the beginning of successor basic blocks when needed. If the
2500 successor has multiple predecessors, reset them, otherwise keep
2501 their value. */
2503 static void
2504 maybe_move_debug_stmts_to_successors (copy_body_data *id, basic_block new_bb)
2506 edge e;
2507 edge_iterator ei;
2508 gimple_stmt_iterator si = gsi_last_nondebug_bb (new_bb);
2510 if (gsi_end_p (si)
2511 || gsi_one_before_end_p (si)
2512 || !(stmt_can_throw_internal (gsi_stmt (si))
2513 || stmt_can_make_abnormal_goto (gsi_stmt (si))))
2514 return;
2516 FOR_EACH_EDGE (e, ei, new_bb->succs)
2518 gimple_stmt_iterator ssi = gsi_last_bb (new_bb);
2519 gimple_stmt_iterator dsi = gsi_after_labels (e->dest);
2520 while (is_gimple_debug (gsi_stmt (ssi)))
2522 gimple *stmt = gsi_stmt (ssi);
2523 gdebug *new_stmt;
2524 tree var;
2525 tree value;
2527 /* For the last edge move the debug stmts instead of copying
2528 them. */
2529 if (ei_one_before_end_p (ei))
2531 si = ssi;
2532 gsi_prev (&ssi);
2533 if (!single_pred_p (e->dest) && gimple_debug_bind_p (stmt))
2534 gimple_debug_bind_reset_value (stmt);
2535 gsi_remove (&si, false);
2536 gsi_insert_before (&dsi, stmt, GSI_SAME_STMT);
2537 continue;
2540 if (gimple_debug_bind_p (stmt))
2542 var = gimple_debug_bind_get_var (stmt);
2543 if (single_pred_p (e->dest))
2545 value = gimple_debug_bind_get_value (stmt);
2546 value = unshare_expr (value);
2548 else
2549 value = NULL_TREE;
2550 new_stmt = gimple_build_debug_bind (var, value, stmt);
2552 else if (gimple_debug_source_bind_p (stmt))
2554 var = gimple_debug_source_bind_get_var (stmt);
2555 value = gimple_debug_source_bind_get_value (stmt);
2556 new_stmt = gimple_build_debug_source_bind (var, value, stmt);
2558 else
2559 gcc_unreachable ();
2560 gsi_insert_before (&dsi, new_stmt, GSI_SAME_STMT);
2561 id->debug_stmts.safe_push (new_stmt);
2562 gsi_prev (&ssi);
2567 /* Make a copy of the sub-loops of SRC_PARENT and place them
2568 as siblings of DEST_PARENT. */
2570 static void
2571 copy_loops (copy_body_data *id,
2572 struct loop *dest_parent, struct loop *src_parent)
2574 struct loop *src_loop = src_parent->inner;
2575 while (src_loop)
2577 if (!id->blocks_to_copy
2578 || bitmap_bit_p (id->blocks_to_copy, src_loop->header->index))
2580 struct loop *dest_loop = alloc_loop ();
2582 /* Assign the new loop its header and latch and associate
2583 those with the new loop. */
2584 dest_loop->header = (basic_block)src_loop->header->aux;
2585 dest_loop->header->loop_father = dest_loop;
2586 if (src_loop->latch != NULL)
2588 dest_loop->latch = (basic_block)src_loop->latch->aux;
2589 dest_loop->latch->loop_father = dest_loop;
2592 /* Copy loop meta-data. */
2593 copy_loop_info (src_loop, dest_loop);
2595 /* Finally place it into the loop array and the loop tree. */
2596 place_new_loop (cfun, dest_loop);
2597 flow_loop_tree_node_add (dest_parent, dest_loop);
2599 dest_loop->safelen = src_loop->safelen;
2600 dest_loop->dont_vectorize = src_loop->dont_vectorize;
2601 if (src_loop->force_vectorize)
2603 dest_loop->force_vectorize = true;
2604 cfun->has_force_vectorize_loops = true;
2606 if (src_loop->simduid)
2608 dest_loop->simduid = remap_decl (src_loop->simduid, id);
2609 cfun->has_simduid_loops = true;
2612 /* Recurse. */
2613 copy_loops (id, dest_loop, src_loop);
2615 src_loop = src_loop->next;
2619 /* Call cgraph_redirect_edge_call_stmt_to_callee on all calls in BB */
2621 void
2622 redirect_all_calls (copy_body_data * id, basic_block bb)
2624 gimple_stmt_iterator si;
2625 gimple *last = last_stmt (bb);
2626 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
2628 gimple *stmt = gsi_stmt (si);
2629 if (is_gimple_call (stmt))
2631 struct cgraph_edge *edge = id->dst_node->get_edge (stmt);
2632 if (edge)
2634 edge->redirect_call_stmt_to_callee ();
2635 if (stmt == last && id->call_stmt && maybe_clean_eh_stmt (stmt))
2636 gimple_purge_dead_eh_edges (bb);
2642 /* Make a copy of the body of FN so that it can be inserted inline in
2643 another function. Walks FN via CFG, returns new fndecl. */
2645 static tree
2646 copy_cfg_body (copy_body_data * id,
2647 basic_block entry_block_map, basic_block exit_block_map,
2648 basic_block new_entry)
2650 tree callee_fndecl = id->src_fn;
2651 /* Original cfun for the callee, doesn't change. */
2652 struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
2653 struct function *cfun_to_copy;
2654 basic_block bb;
2655 tree new_fndecl = NULL;
2656 bool need_debug_cleanup = false;
2657 int last;
2658 profile_count den = ENTRY_BLOCK_PTR_FOR_FN (src_cfun)->count;
2659 profile_count num = entry_block_map->count;
2661 profile_count::adjust_for_ipa_scaling (&num, &den);
2663 cfun_to_copy = id->src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
2665 /* Register specific tree functions. */
2666 gimple_register_cfg_hooks ();
2668 /* If we are inlining just region of the function, make sure to connect
2669 new entry to ENTRY_BLOCK_PTR_FOR_FN (cfun). Since new entry can be
2670 part of loop, we must compute frequency and probability of
2671 ENTRY_BLOCK_PTR_FOR_FN (cfun) based on the frequencies and
2672 probabilities of edges incoming from nonduplicated region. */
2673 if (new_entry)
2675 edge e;
2676 edge_iterator ei;
2677 den = profile_count::zero ();
2679 FOR_EACH_EDGE (e, ei, new_entry->preds)
2680 if (!e->src->aux)
2681 den += e->count ();
2682 ENTRY_BLOCK_PTR_FOR_FN (cfun)->count = den;
2685 /* Must have a CFG here at this point. */
2686 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN
2687 (DECL_STRUCT_FUNCTION (callee_fndecl)));
2690 ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy)->aux = entry_block_map;
2691 EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy)->aux = exit_block_map;
2692 entry_block_map->aux = ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy);
2693 exit_block_map->aux = EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy);
2695 /* Duplicate any exception-handling regions. */
2696 if (cfun->eh)
2697 id->eh_map = duplicate_eh_regions (cfun_to_copy, NULL, id->eh_lp_nr,
2698 remap_decl_1, id);
2700 /* Use aux pointers to map the original blocks to copy. */
2701 FOR_EACH_BB_FN (bb, cfun_to_copy)
2702 if (!id->blocks_to_copy || bitmap_bit_p (id->blocks_to_copy, bb->index))
2704 basic_block new_bb = copy_bb (id, bb, num, den);
2705 bb->aux = new_bb;
2706 new_bb->aux = bb;
2707 new_bb->loop_father = entry_block_map->loop_father;
2710 last = last_basic_block_for_fn (cfun);
2712 /* Now that we've duplicated the blocks, duplicate their edges. */
2713 basic_block abnormal_goto_dest = NULL;
2714 if (id->call_stmt
2715 && stmt_can_make_abnormal_goto (id->call_stmt))
2717 gimple_stmt_iterator gsi = gsi_for_stmt (id->call_stmt);
2719 bb = gimple_bb (id->call_stmt);
2720 gsi_next (&gsi);
2721 if (gsi_end_p (gsi))
2722 abnormal_goto_dest = get_abnormal_succ_dispatcher (bb);
2724 FOR_ALL_BB_FN (bb, cfun_to_copy)
2725 if (!id->blocks_to_copy
2726 || (bb->index > 0 && bitmap_bit_p (id->blocks_to_copy, bb->index)))
2727 need_debug_cleanup |= copy_edges_for_bb (bb, num, den, exit_block_map,
2728 abnormal_goto_dest);
2730 if (new_entry)
2732 edge e = make_edge (entry_block_map, (basic_block)new_entry->aux,
2733 EDGE_FALLTHRU);
2734 e->probability = profile_probability::always ();
2737 /* Duplicate the loop tree, if available and wanted. */
2738 if (loops_for_fn (src_cfun) != NULL
2739 && current_loops != NULL)
2741 copy_loops (id, entry_block_map->loop_father,
2742 get_loop (src_cfun, 0));
2743 /* Defer to cfgcleanup to update loop-father fields of basic-blocks. */
2744 loops_state_set (LOOPS_NEED_FIXUP);
2747 /* If the loop tree in the source function needed fixup, mark the
2748 destination loop tree for fixup, too. */
2749 if (loops_for_fn (src_cfun)->state & LOOPS_NEED_FIXUP)
2750 loops_state_set (LOOPS_NEED_FIXUP);
2752 if (gimple_in_ssa_p (cfun))
2753 FOR_ALL_BB_FN (bb, cfun_to_copy)
2754 if (!id->blocks_to_copy
2755 || (bb->index > 0 && bitmap_bit_p (id->blocks_to_copy, bb->index)))
2756 copy_phis_for_bb (bb, id);
2758 FOR_ALL_BB_FN (bb, cfun_to_copy)
2759 if (bb->aux)
2761 if (need_debug_cleanup
2762 && bb->index != ENTRY_BLOCK
2763 && bb->index != EXIT_BLOCK)
2764 maybe_move_debug_stmts_to_successors (id, (basic_block) bb->aux);
2765 /* Update call edge destinations. This can not be done before loop
2766 info is updated, because we may split basic blocks. */
2767 if (id->transform_call_graph_edges == CB_CGE_DUPLICATE
2768 && bb->index != ENTRY_BLOCK
2769 && bb->index != EXIT_BLOCK)
2770 redirect_all_calls (id, (basic_block)bb->aux);
2771 ((basic_block)bb->aux)->aux = NULL;
2772 bb->aux = NULL;
2775 /* Zero out AUX fields of newly created block during EH edge
2776 insertion. */
2777 for (; last < last_basic_block_for_fn (cfun); last++)
2779 if (need_debug_cleanup)
2780 maybe_move_debug_stmts_to_successors (id,
2781 BASIC_BLOCK_FOR_FN (cfun, last));
2782 BASIC_BLOCK_FOR_FN (cfun, last)->aux = NULL;
2783 /* Update call edge destinations. This can not be done before loop
2784 info is updated, because we may split basic blocks. */
2785 if (id->transform_call_graph_edges == CB_CGE_DUPLICATE)
2786 redirect_all_calls (id, BASIC_BLOCK_FOR_FN (cfun, last));
2788 entry_block_map->aux = NULL;
2789 exit_block_map->aux = NULL;
2791 if (id->eh_map)
2793 delete id->eh_map;
2794 id->eh_map = NULL;
2796 if (id->dependence_map)
2798 delete id->dependence_map;
2799 id->dependence_map = NULL;
2802 return new_fndecl;
2805 /* Copy the debug STMT using ID. We deal with these statements in a
2806 special way: if any variable in their VALUE expression wasn't
2807 remapped yet, we won't remap it, because that would get decl uids
2808 out of sync, causing codegen differences between -g and -g0. If
2809 this arises, we drop the VALUE expression altogether. */
2811 static void
2812 copy_debug_stmt (gdebug *stmt, copy_body_data *id)
2814 tree t, *n;
2815 struct walk_stmt_info wi;
2817 if (gimple_block (stmt))
2819 n = id->decl_map->get (gimple_block (stmt));
2820 gimple_set_block (stmt, n ? *n : id->block);
2823 /* Remap all the operands in COPY. */
2824 memset (&wi, 0, sizeof (wi));
2825 wi.info = id;
2827 processing_debug_stmt = 1;
2829 if (gimple_debug_source_bind_p (stmt))
2830 t = gimple_debug_source_bind_get_var (stmt);
2831 else
2832 t = gimple_debug_bind_get_var (stmt);
2834 if (TREE_CODE (t) == PARM_DECL && id->debug_map
2835 && (n = id->debug_map->get (t)))
2837 gcc_assert (VAR_P (*n));
2838 t = *n;
2840 else if (VAR_P (t) && !is_global_var (t) && !id->decl_map->get (t))
2841 /* T is a non-localized variable. */;
2842 else
2843 walk_tree (&t, remap_gimple_op_r, &wi, NULL);
2845 if (gimple_debug_bind_p (stmt))
2847 gimple_debug_bind_set_var (stmt, t);
2849 if (gimple_debug_bind_has_value_p (stmt))
2850 walk_tree (gimple_debug_bind_get_value_ptr (stmt),
2851 remap_gimple_op_r, &wi, NULL);
2853 /* Punt if any decl couldn't be remapped. */
2854 if (processing_debug_stmt < 0)
2855 gimple_debug_bind_reset_value (stmt);
2857 else if (gimple_debug_source_bind_p (stmt))
2859 gimple_debug_source_bind_set_var (stmt, t);
2860 /* When inlining and source bind refers to one of the optimized
2861 away parameters, change the source bind into normal debug bind
2862 referring to the corresponding DEBUG_EXPR_DECL that should have
2863 been bound before the call stmt. */
2864 t = gimple_debug_source_bind_get_value (stmt);
2865 if (t != NULL_TREE
2866 && TREE_CODE (t) == PARM_DECL
2867 && id->call_stmt)
2869 vec<tree, va_gc> **debug_args = decl_debug_args_lookup (id->src_fn);
2870 unsigned int i;
2871 if (debug_args != NULL)
2873 for (i = 0; i < vec_safe_length (*debug_args); i += 2)
2874 if ((**debug_args)[i] == DECL_ORIGIN (t)
2875 && TREE_CODE ((**debug_args)[i + 1]) == DEBUG_EXPR_DECL)
2877 t = (**debug_args)[i + 1];
2878 stmt->subcode = GIMPLE_DEBUG_BIND;
2879 gimple_debug_bind_set_value (stmt, t);
2880 break;
2884 if (gimple_debug_source_bind_p (stmt))
2885 walk_tree (gimple_debug_source_bind_get_value_ptr (stmt),
2886 remap_gimple_op_r, &wi, NULL);
2889 processing_debug_stmt = 0;
2891 update_stmt (stmt);
2894 /* Process deferred debug stmts. In order to give values better odds
2895 of being successfully remapped, we delay the processing of debug
2896 stmts until all other stmts that might require remapping are
2897 processed. */
2899 static void
2900 copy_debug_stmts (copy_body_data *id)
2902 size_t i;
2903 gdebug *stmt;
2905 if (!id->debug_stmts.exists ())
2906 return;
2908 FOR_EACH_VEC_ELT (id->debug_stmts, i, stmt)
2909 copy_debug_stmt (stmt, id);
2911 id->debug_stmts.release ();
2914 /* Make a copy of the body of SRC_FN so that it can be inserted inline in
2915 another function. */
2917 static tree
2918 copy_tree_body (copy_body_data *id)
2920 tree fndecl = id->src_fn;
2921 tree body = DECL_SAVED_TREE (fndecl);
2923 walk_tree (&body, copy_tree_body_r, id, NULL);
2925 return body;
2928 /* Make a copy of the body of FN so that it can be inserted inline in
2929 another function. */
2931 static tree
2932 copy_body (copy_body_data *id,
2933 basic_block entry_block_map, basic_block exit_block_map,
2934 basic_block new_entry)
2936 tree fndecl = id->src_fn;
2937 tree body;
2939 /* If this body has a CFG, walk CFG and copy. */
2940 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (fndecl)));
2941 body = copy_cfg_body (id, entry_block_map, exit_block_map,
2942 new_entry);
2943 copy_debug_stmts (id);
2945 return body;
2948 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
2949 defined in function FN, or of a data member thereof. */
2951 static bool
2952 self_inlining_addr_expr (tree value, tree fn)
2954 tree var;
2956 if (TREE_CODE (value) != ADDR_EXPR)
2957 return false;
2959 var = get_base_address (TREE_OPERAND (value, 0));
2961 return var && auto_var_in_fn_p (var, fn);
2964 /* Append to BB a debug annotation that binds VAR to VALUE, inheriting
2965 lexical block and line number information from base_stmt, if given,
2966 or from the last stmt of the block otherwise. */
2968 static gimple *
2969 insert_init_debug_bind (copy_body_data *id,
2970 basic_block bb, tree var, tree value,
2971 gimple *base_stmt)
2973 gimple *note;
2974 gimple_stmt_iterator gsi;
2975 tree tracked_var;
2977 if (!gimple_in_ssa_p (id->src_cfun))
2978 return NULL;
2980 if (!opt_for_fn (id->dst_fn, flag_var_tracking_assignments))
2981 return NULL;
2983 tracked_var = target_for_debug_bind (var);
2984 if (!tracked_var)
2985 return NULL;
2987 if (bb)
2989 gsi = gsi_last_bb (bb);
2990 if (!base_stmt && !gsi_end_p (gsi))
2991 base_stmt = gsi_stmt (gsi);
2994 note = gimple_build_debug_bind (tracked_var, unshare_expr (value), base_stmt);
2996 if (bb)
2998 if (!gsi_end_p (gsi))
2999 gsi_insert_after (&gsi, note, GSI_SAME_STMT);
3000 else
3001 gsi_insert_before (&gsi, note, GSI_SAME_STMT);
3004 return note;
3007 static void
3008 insert_init_stmt (copy_body_data *id, basic_block bb, gimple *init_stmt)
3010 /* If VAR represents a zero-sized variable, it's possible that the
3011 assignment statement may result in no gimple statements. */
3012 if (init_stmt)
3014 gimple_stmt_iterator si = gsi_last_bb (bb);
3016 /* We can end up with init statements that store to a non-register
3017 from a rhs with a conversion. Handle that here by forcing the
3018 rhs into a temporary. gimple_regimplify_operands is not
3019 prepared to do this for us. */
3020 if (!is_gimple_debug (init_stmt)
3021 && !is_gimple_reg (gimple_assign_lhs (init_stmt))
3022 && is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (init_stmt)))
3023 && gimple_assign_rhs_class (init_stmt) == GIMPLE_UNARY_RHS)
3025 tree rhs = build1 (gimple_assign_rhs_code (init_stmt),
3026 gimple_expr_type (init_stmt),
3027 gimple_assign_rhs1 (init_stmt));
3028 rhs = force_gimple_operand_gsi (&si, rhs, true, NULL_TREE, false,
3029 GSI_NEW_STMT);
3030 gimple_assign_set_rhs_code (init_stmt, TREE_CODE (rhs));
3031 gimple_assign_set_rhs1 (init_stmt, rhs);
3033 gsi_insert_after (&si, init_stmt, GSI_NEW_STMT);
3034 gimple_regimplify_operands (init_stmt, &si);
3036 if (!is_gimple_debug (init_stmt))
3038 tree def = gimple_assign_lhs (init_stmt);
3039 insert_init_debug_bind (id, bb, def, def, init_stmt);
3044 /* Initialize parameter P with VALUE. If needed, produce init statement
3045 at the end of BB. When BB is NULL, we return init statement to be
3046 output later. */
3047 static gimple *
3048 setup_one_parameter (copy_body_data *id, tree p, tree value, tree fn,
3049 basic_block bb, tree *vars)
3051 gimple *init_stmt = NULL;
3052 tree var;
3053 tree rhs = value;
3054 tree def = (gimple_in_ssa_p (cfun)
3055 ? ssa_default_def (id->src_cfun, p) : NULL);
3057 if (value
3058 && value != error_mark_node
3059 && !useless_type_conversion_p (TREE_TYPE (p), TREE_TYPE (value)))
3061 /* If we can match up types by promotion/demotion do so. */
3062 if (fold_convertible_p (TREE_TYPE (p), value))
3063 rhs = fold_convert (TREE_TYPE (p), value);
3064 else
3066 /* ??? For valid programs we should not end up here.
3067 Still if we end up with truly mismatched types here, fall back
3068 to using a VIEW_CONVERT_EXPR or a literal zero to not leak invalid
3069 GIMPLE to the following passes. */
3070 if (!is_gimple_reg_type (TREE_TYPE (value))
3071 || TYPE_SIZE (TREE_TYPE (p)) == TYPE_SIZE (TREE_TYPE (value)))
3072 rhs = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (p), value);
3073 else
3074 rhs = build_zero_cst (TREE_TYPE (p));
3078 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
3079 here since the type of this decl must be visible to the calling
3080 function. */
3081 var = copy_decl_to_var (p, id);
3083 /* Declare this new variable. */
3084 DECL_CHAIN (var) = *vars;
3085 *vars = var;
3087 /* Make gimplifier happy about this variable. */
3088 DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
3090 /* If the parameter is never assigned to, has no SSA_NAMEs created,
3091 we would not need to create a new variable here at all, if it
3092 weren't for debug info. Still, we can just use the argument
3093 value. */
3094 if (TREE_READONLY (p)
3095 && !TREE_ADDRESSABLE (p)
3096 && value && !TREE_SIDE_EFFECTS (value)
3097 && !def)
3099 /* We may produce non-gimple trees by adding NOPs or introduce
3100 invalid sharing when operand is not really constant.
3101 It is not big deal to prohibit constant propagation here as
3102 we will constant propagate in DOM1 pass anyway. */
3103 if (is_gimple_min_invariant (value)
3104 && useless_type_conversion_p (TREE_TYPE (p),
3105 TREE_TYPE (value))
3106 /* We have to be very careful about ADDR_EXPR. Make sure
3107 the base variable isn't a local variable of the inlined
3108 function, e.g., when doing recursive inlining, direct or
3109 mutually-recursive or whatever, which is why we don't
3110 just test whether fn == current_function_decl. */
3111 && ! self_inlining_addr_expr (value, fn))
3113 insert_decl_map (id, p, value);
3114 insert_debug_decl_map (id, p, var);
3115 return insert_init_debug_bind (id, bb, var, value, NULL);
3119 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
3120 that way, when the PARM_DECL is encountered, it will be
3121 automatically replaced by the VAR_DECL. */
3122 insert_decl_map (id, p, var);
3124 /* Even if P was TREE_READONLY, the new VAR should not be.
3125 In the original code, we would have constructed a
3126 temporary, and then the function body would have never
3127 changed the value of P. However, now, we will be
3128 constructing VAR directly. The constructor body may
3129 change its value multiple times as it is being
3130 constructed. Therefore, it must not be TREE_READONLY;
3131 the back-end assumes that TREE_READONLY variable is
3132 assigned to only once. */
3133 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p)))
3134 TREE_READONLY (var) = 0;
3136 /* If there is no setup required and we are in SSA, take the easy route
3137 replacing all SSA names representing the function parameter by the
3138 SSA name passed to function.
3140 We need to construct map for the variable anyway as it might be used
3141 in different SSA names when parameter is set in function.
3143 Do replacement at -O0 for const arguments replaced by constant.
3144 This is important for builtin_constant_p and other construct requiring
3145 constant argument to be visible in inlined function body. */
3146 if (gimple_in_ssa_p (cfun) && rhs && def && is_gimple_reg (p)
3147 && (optimize
3148 || (TREE_READONLY (p)
3149 && is_gimple_min_invariant (rhs)))
3150 && (TREE_CODE (rhs) == SSA_NAME
3151 || is_gimple_min_invariant (rhs))
3152 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def))
3154 insert_decl_map (id, def, rhs);
3155 return insert_init_debug_bind (id, bb, var, rhs, NULL);
3158 /* If the value of argument is never used, don't care about initializing
3159 it. */
3160 if (optimize && gimple_in_ssa_p (cfun) && !def && is_gimple_reg (p))
3162 gcc_assert (!value || !TREE_SIDE_EFFECTS (value));
3163 return insert_init_debug_bind (id, bb, var, rhs, NULL);
3166 /* Initialize this VAR_DECL from the equivalent argument. Convert
3167 the argument to the proper type in case it was promoted. */
3168 if (value)
3170 if (rhs == error_mark_node)
3172 insert_decl_map (id, p, var);
3173 return insert_init_debug_bind (id, bb, var, rhs, NULL);
3176 STRIP_USELESS_TYPE_CONVERSION (rhs);
3178 /* If we are in SSA form properly remap the default definition
3179 or assign to a dummy SSA name if the parameter is unused and
3180 we are not optimizing. */
3181 if (gimple_in_ssa_p (cfun) && is_gimple_reg (p))
3183 if (def)
3185 def = remap_ssa_name (def, id);
3186 init_stmt = gimple_build_assign (def, rhs);
3187 SSA_NAME_IS_DEFAULT_DEF (def) = 0;
3188 set_ssa_default_def (cfun, var, NULL);
3190 else if (!optimize)
3192 def = make_ssa_name (var);
3193 init_stmt = gimple_build_assign (def, rhs);
3196 else
3197 init_stmt = gimple_build_assign (var, rhs);
3199 if (bb && init_stmt)
3200 insert_init_stmt (id, bb, init_stmt);
3202 return init_stmt;
3205 /* Generate code to initialize the parameters of the function at the
3206 top of the stack in ID from the GIMPLE_CALL STMT. */
3208 static void
3209 initialize_inlined_parameters (copy_body_data *id, gimple *stmt,
3210 tree fn, basic_block bb)
3212 tree parms;
3213 size_t i;
3214 tree p;
3215 tree vars = NULL_TREE;
3216 tree static_chain = gimple_call_chain (stmt);
3218 /* Figure out what the parameters are. */
3219 parms = DECL_ARGUMENTS (fn);
3221 /* Loop through the parameter declarations, replacing each with an
3222 equivalent VAR_DECL, appropriately initialized. */
3223 for (p = parms, i = 0; p; p = DECL_CHAIN (p), i++)
3225 tree val;
3226 val = i < gimple_call_num_args (stmt) ? gimple_call_arg (stmt, i) : NULL;
3227 setup_one_parameter (id, p, val, fn, bb, &vars);
3229 /* After remapping parameters remap their types. This has to be done
3230 in a second loop over all parameters to appropriately remap
3231 variable sized arrays when the size is specified in a
3232 parameter following the array. */
3233 for (p = parms, i = 0; p; p = DECL_CHAIN (p), i++)
3235 tree *varp = id->decl_map->get (p);
3236 if (varp && VAR_P (*varp))
3238 tree def = (gimple_in_ssa_p (cfun) && is_gimple_reg (p)
3239 ? ssa_default_def (id->src_cfun, p) : NULL);
3240 tree var = *varp;
3241 TREE_TYPE (var) = remap_type (TREE_TYPE (var), id);
3242 /* Also remap the default definition if it was remapped
3243 to the default definition of the parameter replacement
3244 by the parameter setup. */
3245 if (def)
3247 tree *defp = id->decl_map->get (def);
3248 if (defp
3249 && TREE_CODE (*defp) == SSA_NAME
3250 && SSA_NAME_VAR (*defp) == var)
3251 TREE_TYPE (*defp) = TREE_TYPE (var);
3256 /* Initialize the static chain. */
3257 p = DECL_STRUCT_FUNCTION (fn)->static_chain_decl;
3258 gcc_assert (fn != current_function_decl);
3259 if (p)
3261 /* No static chain? Seems like a bug in tree-nested.c. */
3262 gcc_assert (static_chain);
3264 setup_one_parameter (id, p, static_chain, fn, bb, &vars);
3267 declare_inline_vars (id->block, vars);
3271 /* Declare a return variable to replace the RESULT_DECL for the
3272 function we are calling. An appropriate DECL_STMT is returned.
3273 The USE_STMT is filled to contain a use of the declaration to
3274 indicate the return value of the function.
3276 RETURN_SLOT, if non-null is place where to store the result. It
3277 is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null,
3278 was the LHS of the MODIFY_EXPR to which this call is the RHS.
3280 RETURN_BOUNDS holds a destination for returned bounds.
3282 The return value is a (possibly null) value that holds the result
3283 as seen by the caller. */
3285 static tree
3286 declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest,
3287 tree return_bounds, basic_block entry_bb)
3289 tree callee = id->src_fn;
3290 tree result = DECL_RESULT (callee);
3291 tree callee_type = TREE_TYPE (result);
3292 tree caller_type;
3293 tree var, use;
3295 /* Handle type-mismatches in the function declaration return type
3296 vs. the call expression. */
3297 if (modify_dest)
3298 caller_type = TREE_TYPE (modify_dest);
3299 else
3300 caller_type = TREE_TYPE (TREE_TYPE (callee));
3302 /* We don't need to do anything for functions that don't return anything. */
3303 if (VOID_TYPE_P (callee_type))
3304 return NULL_TREE;
3306 /* If there was a return slot, then the return value is the
3307 dereferenced address of that object. */
3308 if (return_slot)
3310 /* The front end shouldn't have used both return_slot and
3311 a modify expression. */
3312 gcc_assert (!modify_dest);
3313 if (DECL_BY_REFERENCE (result))
3315 tree return_slot_addr = build_fold_addr_expr (return_slot);
3316 STRIP_USELESS_TYPE_CONVERSION (return_slot_addr);
3318 /* We are going to construct *&return_slot and we can't do that
3319 for variables believed to be not addressable.
3321 FIXME: This check possibly can match, because values returned
3322 via return slot optimization are not believed to have address
3323 taken by alias analysis. */
3324 gcc_assert (TREE_CODE (return_slot) != SSA_NAME);
3325 var = return_slot_addr;
3327 else
3329 var = return_slot;
3330 gcc_assert (TREE_CODE (var) != SSA_NAME);
3331 if (TREE_ADDRESSABLE (result))
3332 mark_addressable (var);
3334 if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
3335 || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
3336 && !DECL_GIMPLE_REG_P (result)
3337 && DECL_P (var))
3338 DECL_GIMPLE_REG_P (var) = 0;
3339 use = NULL;
3340 goto done;
3343 /* All types requiring non-trivial constructors should have been handled. */
3344 gcc_assert (!TREE_ADDRESSABLE (callee_type));
3346 /* Attempt to avoid creating a new temporary variable. */
3347 if (modify_dest
3348 && TREE_CODE (modify_dest) != SSA_NAME)
3350 bool use_it = false;
3352 /* We can't use MODIFY_DEST if there's type promotion involved. */
3353 if (!useless_type_conversion_p (callee_type, caller_type))
3354 use_it = false;
3356 /* ??? If we're assigning to a variable sized type, then we must
3357 reuse the destination variable, because we've no good way to
3358 create variable sized temporaries at this point. */
3359 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type)) != INTEGER_CST)
3360 use_it = true;
3362 /* If the callee cannot possibly modify MODIFY_DEST, then we can
3363 reuse it as the result of the call directly. Don't do this if
3364 it would promote MODIFY_DEST to addressable. */
3365 else if (TREE_ADDRESSABLE (result))
3366 use_it = false;
3367 else
3369 tree base_m = get_base_address (modify_dest);
3371 /* If the base isn't a decl, then it's a pointer, and we don't
3372 know where that's going to go. */
3373 if (!DECL_P (base_m))
3374 use_it = false;
3375 else if (is_global_var (base_m))
3376 use_it = false;
3377 else if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
3378 || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
3379 && !DECL_GIMPLE_REG_P (result)
3380 && DECL_GIMPLE_REG_P (base_m))
3381 use_it = false;
3382 else if (!TREE_ADDRESSABLE (base_m))
3383 use_it = true;
3386 if (use_it)
3388 var = modify_dest;
3389 use = NULL;
3390 goto done;
3394 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type)) == INTEGER_CST);
3396 var = copy_result_decl_to_var (result, id);
3397 DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
3399 /* Do not have the rest of GCC warn about this variable as it should
3400 not be visible to the user. */
3401 TREE_NO_WARNING (var) = 1;
3403 declare_inline_vars (id->block, var);
3405 /* Build the use expr. If the return type of the function was
3406 promoted, convert it back to the expected type. */
3407 use = var;
3408 if (!useless_type_conversion_p (caller_type, TREE_TYPE (var)))
3410 /* If we can match up types by promotion/demotion do so. */
3411 if (fold_convertible_p (caller_type, var))
3412 use = fold_convert (caller_type, var);
3413 else
3415 /* ??? For valid programs we should not end up here.
3416 Still if we end up with truly mismatched types here, fall back
3417 to using a MEM_REF to not leak invalid GIMPLE to the following
3418 passes. */
3419 /* Prevent var from being written into SSA form. */
3420 if (TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE
3421 || TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE)
3422 DECL_GIMPLE_REG_P (var) = false;
3423 else if (is_gimple_reg_type (TREE_TYPE (var)))
3424 TREE_ADDRESSABLE (var) = true;
3425 use = fold_build2 (MEM_REF, caller_type,
3426 build_fold_addr_expr (var),
3427 build_int_cst (ptr_type_node, 0));
3431 STRIP_USELESS_TYPE_CONVERSION (use);
3433 if (DECL_BY_REFERENCE (result))
3435 TREE_ADDRESSABLE (var) = 1;
3436 var = build_fold_addr_expr (var);
3439 done:
3440 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
3441 way, when the RESULT_DECL is encountered, it will be
3442 automatically replaced by the VAR_DECL.
3444 When returning by reference, ensure that RESULT_DECL remaps to
3445 gimple_val. */
3446 if (DECL_BY_REFERENCE (result)
3447 && !is_gimple_val (var))
3449 tree temp = create_tmp_var (TREE_TYPE (result), "retvalptr");
3450 insert_decl_map (id, result, temp);
3451 /* When RESULT_DECL is in SSA form, we need to remap and initialize
3452 it's default_def SSA_NAME. */
3453 if (gimple_in_ssa_p (id->src_cfun)
3454 && is_gimple_reg (result))
3456 temp = make_ssa_name (temp);
3457 insert_decl_map (id, ssa_default_def (id->src_cfun, result), temp);
3459 insert_init_stmt (id, entry_bb, gimple_build_assign (temp, var));
3461 else
3462 insert_decl_map (id, result, var);
3464 /* Remember this so we can ignore it in remap_decls. */
3465 id->retvar = var;
3467 /* If returned bounds are used, then make var for them. */
3468 if (return_bounds)
3470 tree bndtemp = create_tmp_var (pointer_bounds_type_node, "retbnd");
3471 DECL_SEEN_IN_BIND_EXPR_P (bndtemp) = 1;
3472 TREE_NO_WARNING (bndtemp) = 1;
3473 declare_inline_vars (id->block, bndtemp);
3475 id->retbnd = bndtemp;
3476 insert_init_stmt (id, entry_bb,
3477 gimple_build_assign (bndtemp, chkp_get_zero_bounds_var ()));
3480 return use;
3483 /* Determine if the function can be copied. If so return NULL. If
3484 not return a string describng the reason for failure. */
3486 const char *
3487 copy_forbidden (struct function *fun)
3489 const char *reason = fun->cannot_be_copied_reason;
3491 /* Only examine the function once. */
3492 if (fun->cannot_be_copied_set)
3493 return reason;
3495 /* We cannot copy a function that receives a non-local goto
3496 because we cannot remap the destination label used in the
3497 function that is performing the non-local goto. */
3498 /* ??? Actually, this should be possible, if we work at it.
3499 No doubt there's just a handful of places that simply
3500 assume it doesn't happen and don't substitute properly. */
3501 if (fun->has_nonlocal_label)
3503 reason = G_("function %q+F can never be copied "
3504 "because it receives a non-local goto");
3505 goto fail;
3508 if (fun->has_forced_label_in_static)
3510 reason = G_("function %q+F can never be copied because it saves "
3511 "address of local label in a static variable");
3512 goto fail;
3515 fail:
3516 fun->cannot_be_copied_reason = reason;
3517 fun->cannot_be_copied_set = true;
3518 return reason;
3522 static const char *inline_forbidden_reason;
3524 /* A callback for walk_gimple_seq to handle statements. Returns non-null
3525 iff a function can not be inlined. Also sets the reason why. */
3527 static tree
3528 inline_forbidden_p_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
3529 struct walk_stmt_info *wip)
3531 tree fn = (tree) wip->info;
3532 tree t;
3533 gimple *stmt = gsi_stmt (*gsi);
3535 switch (gimple_code (stmt))
3537 case GIMPLE_CALL:
3538 /* Refuse to inline alloca call unless user explicitly forced so as
3539 this may change program's memory overhead drastically when the
3540 function using alloca is called in loop. In GCC present in
3541 SPEC2000 inlining into schedule_block cause it to require 2GB of
3542 RAM instead of 256MB. Don't do so for alloca calls emitted for
3543 VLA objects as those can't cause unbounded growth (they're always
3544 wrapped inside stack_save/stack_restore regions. */
3545 if (gimple_maybe_alloca_call_p (stmt)
3546 && !gimple_call_alloca_for_var_p (as_a <gcall *> (stmt))
3547 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
3549 inline_forbidden_reason
3550 = G_("function %q+F can never be inlined because it uses "
3551 "alloca (override using the always_inline attribute)");
3552 *handled_ops_p = true;
3553 return fn;
3556 t = gimple_call_fndecl (stmt);
3557 if (t == NULL_TREE)
3558 break;
3560 /* We cannot inline functions that call setjmp. */
3561 if (setjmp_call_p (t))
3563 inline_forbidden_reason
3564 = G_("function %q+F can never be inlined because it uses setjmp");
3565 *handled_ops_p = true;
3566 return t;
3569 if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL)
3570 switch (DECL_FUNCTION_CODE (t))
3572 /* We cannot inline functions that take a variable number of
3573 arguments. */
3574 case BUILT_IN_VA_START:
3575 case BUILT_IN_NEXT_ARG:
3576 case BUILT_IN_VA_END:
3577 inline_forbidden_reason
3578 = G_("function %q+F can never be inlined because it "
3579 "uses variable argument lists");
3580 *handled_ops_p = true;
3581 return t;
3583 case BUILT_IN_LONGJMP:
3584 /* We can't inline functions that call __builtin_longjmp at
3585 all. The non-local goto machinery really requires the
3586 destination be in a different function. If we allow the
3587 function calling __builtin_longjmp to be inlined into the
3588 function calling __builtin_setjmp, Things will Go Awry. */
3589 inline_forbidden_reason
3590 = G_("function %q+F can never be inlined because "
3591 "it uses setjmp-longjmp exception handling");
3592 *handled_ops_p = true;
3593 return t;
3595 case BUILT_IN_NONLOCAL_GOTO:
3596 /* Similarly. */
3597 inline_forbidden_reason
3598 = G_("function %q+F can never be inlined because "
3599 "it uses non-local goto");
3600 *handled_ops_p = true;
3601 return t;
3603 case BUILT_IN_RETURN:
3604 case BUILT_IN_APPLY_ARGS:
3605 /* If a __builtin_apply_args caller would be inlined,
3606 it would be saving arguments of the function it has
3607 been inlined into. Similarly __builtin_return would
3608 return from the function the inline has been inlined into. */
3609 inline_forbidden_reason
3610 = G_("function %q+F can never be inlined because "
3611 "it uses __builtin_return or __builtin_apply_args");
3612 *handled_ops_p = true;
3613 return t;
3615 default:
3616 break;
3618 break;
3620 case GIMPLE_GOTO:
3621 t = gimple_goto_dest (stmt);
3623 /* We will not inline a function which uses computed goto. The
3624 addresses of its local labels, which may be tucked into
3625 global storage, are of course not constant across
3626 instantiations, which causes unexpected behavior. */
3627 if (TREE_CODE (t) != LABEL_DECL)
3629 inline_forbidden_reason
3630 = G_("function %q+F can never be inlined "
3631 "because it contains a computed goto");
3632 *handled_ops_p = true;
3633 return t;
3635 break;
3637 default:
3638 break;
3641 *handled_ops_p = false;
3642 return NULL_TREE;
3645 /* Return true if FNDECL is a function that cannot be inlined into
3646 another one. */
3648 static bool
3649 inline_forbidden_p (tree fndecl)
3651 struct function *fun = DECL_STRUCT_FUNCTION (fndecl);
3652 struct walk_stmt_info wi;
3653 basic_block bb;
3654 bool forbidden_p = false;
3656 /* First check for shared reasons not to copy the code. */
3657 inline_forbidden_reason = copy_forbidden (fun);
3658 if (inline_forbidden_reason != NULL)
3659 return true;
3661 /* Next, walk the statements of the function looking for
3662 constraucts we can't handle, or are non-optimal for inlining. */
3663 hash_set<tree> visited_nodes;
3664 memset (&wi, 0, sizeof (wi));
3665 wi.info = (void *) fndecl;
3666 wi.pset = &visited_nodes;
3668 FOR_EACH_BB_FN (bb, fun)
3670 gimple *ret;
3671 gimple_seq seq = bb_seq (bb);
3672 ret = walk_gimple_seq (seq, inline_forbidden_p_stmt, NULL, &wi);
3673 forbidden_p = (ret != NULL);
3674 if (forbidden_p)
3675 break;
3678 return forbidden_p;
3681 /* Return false if the function FNDECL cannot be inlined on account of its
3682 attributes, true otherwise. */
3683 static bool
3684 function_attribute_inlinable_p (const_tree fndecl)
3686 if (targetm.attribute_table)
3688 const_tree a;
3690 for (a = DECL_ATTRIBUTES (fndecl); a; a = TREE_CHAIN (a))
3692 const_tree name = TREE_PURPOSE (a);
3693 int i;
3695 for (i = 0; targetm.attribute_table[i].name != NULL; i++)
3696 if (is_attribute_p (targetm.attribute_table[i].name, name))
3697 return targetm.function_attribute_inlinable_p (fndecl);
3701 return true;
3704 /* Returns nonzero if FN is a function that does not have any
3705 fundamental inline blocking properties. */
3707 bool
3708 tree_inlinable_function_p (tree fn)
3710 bool inlinable = true;
3711 bool do_warning;
3712 tree always_inline;
3714 /* If we've already decided this function shouldn't be inlined,
3715 there's no need to check again. */
3716 if (DECL_UNINLINABLE (fn))
3717 return false;
3719 /* We only warn for functions declared `inline' by the user. */
3720 do_warning = (warn_inline
3721 && DECL_DECLARED_INLINE_P (fn)
3722 && !DECL_NO_INLINE_WARNING_P (fn)
3723 && !DECL_IN_SYSTEM_HEADER (fn));
3725 always_inline = lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn));
3727 if (flag_no_inline
3728 && always_inline == NULL)
3730 if (do_warning)
3731 warning (OPT_Winline, "function %q+F can never be inlined because it "
3732 "is suppressed using -fno-inline", fn);
3733 inlinable = false;
3736 else if (!function_attribute_inlinable_p (fn))
3738 if (do_warning)
3739 warning (OPT_Winline, "function %q+F can never be inlined because it "
3740 "uses attributes conflicting with inlining", fn);
3741 inlinable = false;
3744 else if (inline_forbidden_p (fn))
3746 /* See if we should warn about uninlinable functions. Previously,
3747 some of these warnings would be issued while trying to expand
3748 the function inline, but that would cause multiple warnings
3749 about functions that would for example call alloca. But since
3750 this a property of the function, just one warning is enough.
3751 As a bonus we can now give more details about the reason why a
3752 function is not inlinable. */
3753 if (always_inline)
3754 error (inline_forbidden_reason, fn);
3755 else if (do_warning)
3756 warning (OPT_Winline, inline_forbidden_reason, fn);
3758 inlinable = false;
3761 /* Squirrel away the result so that we don't have to check again. */
3762 DECL_UNINLINABLE (fn) = !inlinable;
3764 return inlinable;
3767 /* Estimate the cost of a memory move of type TYPE. Use machine dependent
3768 word size and take possible memcpy call into account and return
3769 cost based on whether optimizing for size or speed according to SPEED_P. */
3772 estimate_move_cost (tree type, bool ARG_UNUSED (speed_p))
3774 HOST_WIDE_INT size;
3776 gcc_assert (!VOID_TYPE_P (type));
3778 if (TREE_CODE (type) == VECTOR_TYPE)
3780 scalar_mode inner = SCALAR_TYPE_MODE (TREE_TYPE (type));
3781 machine_mode simd
3782 = targetm.vectorize.preferred_simd_mode (inner);
3783 int simd_mode_size = GET_MODE_SIZE (simd);
3784 return ((GET_MODE_SIZE (TYPE_MODE (type)) + simd_mode_size - 1)
3785 / simd_mode_size);
3788 size = int_size_in_bytes (type);
3790 if (size < 0 || size > MOVE_MAX_PIECES * MOVE_RATIO (speed_p))
3791 /* Cost of a memcpy call, 3 arguments and the call. */
3792 return 4;
3793 else
3794 return ((size + MOVE_MAX_PIECES - 1) / MOVE_MAX_PIECES);
3797 /* Returns cost of operation CODE, according to WEIGHTS */
3799 static int
3800 estimate_operator_cost (enum tree_code code, eni_weights *weights,
3801 tree op1 ATTRIBUTE_UNUSED, tree op2)
3803 switch (code)
3805 /* These are "free" conversions, or their presumed cost
3806 is folded into other operations. */
3807 case RANGE_EXPR:
3808 CASE_CONVERT:
3809 case COMPLEX_EXPR:
3810 case PAREN_EXPR:
3811 case VIEW_CONVERT_EXPR:
3812 return 0;
3814 /* Assign cost of 1 to usual operations.
3815 ??? We may consider mapping RTL costs to this. */
3816 case COND_EXPR:
3817 case VEC_COND_EXPR:
3818 case VEC_PERM_EXPR:
3820 case PLUS_EXPR:
3821 case POINTER_PLUS_EXPR:
3822 case MINUS_EXPR:
3823 case MULT_EXPR:
3824 case MULT_HIGHPART_EXPR:
3825 case FMA_EXPR:
3827 case ADDR_SPACE_CONVERT_EXPR:
3828 case FIXED_CONVERT_EXPR:
3829 case FIX_TRUNC_EXPR:
3831 case NEGATE_EXPR:
3832 case FLOAT_EXPR:
3833 case MIN_EXPR:
3834 case MAX_EXPR:
3835 case ABS_EXPR:
3837 case LSHIFT_EXPR:
3838 case RSHIFT_EXPR:
3839 case LROTATE_EXPR:
3840 case RROTATE_EXPR:
3842 case BIT_IOR_EXPR:
3843 case BIT_XOR_EXPR:
3844 case BIT_AND_EXPR:
3845 case BIT_NOT_EXPR:
3847 case TRUTH_ANDIF_EXPR:
3848 case TRUTH_ORIF_EXPR:
3849 case TRUTH_AND_EXPR:
3850 case TRUTH_OR_EXPR:
3851 case TRUTH_XOR_EXPR:
3852 case TRUTH_NOT_EXPR:
3854 case LT_EXPR:
3855 case LE_EXPR:
3856 case GT_EXPR:
3857 case GE_EXPR:
3858 case EQ_EXPR:
3859 case NE_EXPR:
3860 case ORDERED_EXPR:
3861 case UNORDERED_EXPR:
3863 case UNLT_EXPR:
3864 case UNLE_EXPR:
3865 case UNGT_EXPR:
3866 case UNGE_EXPR:
3867 case UNEQ_EXPR:
3868 case LTGT_EXPR:
3870 case CONJ_EXPR:
3872 case PREDECREMENT_EXPR:
3873 case PREINCREMENT_EXPR:
3874 case POSTDECREMENT_EXPR:
3875 case POSTINCREMENT_EXPR:
3877 case REALIGN_LOAD_EXPR:
3879 case REDUC_MAX_EXPR:
3880 case REDUC_MIN_EXPR:
3881 case REDUC_PLUS_EXPR:
3882 case WIDEN_SUM_EXPR:
3883 case WIDEN_MULT_EXPR:
3884 case DOT_PROD_EXPR:
3885 case SAD_EXPR:
3886 case WIDEN_MULT_PLUS_EXPR:
3887 case WIDEN_MULT_MINUS_EXPR:
3888 case WIDEN_LSHIFT_EXPR:
3890 case VEC_WIDEN_MULT_HI_EXPR:
3891 case VEC_WIDEN_MULT_LO_EXPR:
3892 case VEC_WIDEN_MULT_EVEN_EXPR:
3893 case VEC_WIDEN_MULT_ODD_EXPR:
3894 case VEC_UNPACK_HI_EXPR:
3895 case VEC_UNPACK_LO_EXPR:
3896 case VEC_UNPACK_FLOAT_HI_EXPR:
3897 case VEC_UNPACK_FLOAT_LO_EXPR:
3898 case VEC_PACK_TRUNC_EXPR:
3899 case VEC_PACK_SAT_EXPR:
3900 case VEC_PACK_FIX_TRUNC_EXPR:
3901 case VEC_WIDEN_LSHIFT_HI_EXPR:
3902 case VEC_WIDEN_LSHIFT_LO_EXPR:
3904 return 1;
3906 /* Few special cases of expensive operations. This is useful
3907 to avoid inlining on functions having too many of these. */
3908 case TRUNC_DIV_EXPR:
3909 case CEIL_DIV_EXPR:
3910 case FLOOR_DIV_EXPR:
3911 case ROUND_DIV_EXPR:
3912 case EXACT_DIV_EXPR:
3913 case TRUNC_MOD_EXPR:
3914 case CEIL_MOD_EXPR:
3915 case FLOOR_MOD_EXPR:
3916 case ROUND_MOD_EXPR:
3917 case RDIV_EXPR:
3918 if (TREE_CODE (op2) != INTEGER_CST)
3919 return weights->div_mod_cost;
3920 return 1;
3922 /* Bit-field insertion needs several shift and mask operations. */
3923 case BIT_INSERT_EXPR:
3924 return 3;
3926 default:
3927 /* We expect a copy assignment with no operator. */
3928 gcc_assert (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS);
3929 return 0;
3934 /* Estimate number of instructions that will be created by expanding