1 /* Function splitting pass
2 Copyright (C) 2010-2013 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka <jh@suse.cz>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
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 /* The purpose of this pass is to split function bodies to improve
22 inlining. I.e. for function of the form:
47 When func becomes inlinable and when cheap_test is often true, inlining func,
48 but not fund.part leads to performance improvement similar as inlining
49 original func while the code size growth is smaller.
51 The pass is organized in three stages:
52 1) Collect local info about basic block into BB_INFO structure and
53 compute function body estimated size and time.
54 2) Via DFS walk find all possible basic blocks where we can split
56 3) If split point is found, split at the specified BB by creating a clone
57 and updating function to call it.
59 The decisions what functions to split are in execute_split_functions
62 There are several possible future improvements for this pass including:
64 1) Splitting to break up large functions
65 2) Splitting to reduce stack frame usage
66 3) Allow split part of function to use values computed in the header part.
67 The values needs to be passed to split function, perhaps via same
68 interface as for nested functions or as argument.
69 4) Support for simple rematerialization. I.e. when split part use
70 value computed in header from function parameter in very cheap way, we
71 can just recompute it.
72 5) Support splitting of nested functions.
73 6) Support non-SSA arguments.
74 7) There is nothing preventing us from producing multiple parts of single function
75 when needed or splitting also the parts. */
79 #include "coretypes.h"
81 #include "basic-block.h"
82 #include "tree-ssa-alias.h"
83 #include "internal-fn.h"
84 #include "gimple-expr.h"
87 #include "stringpool.h"
91 #include "gimple-iterator.h"
92 #include "gimplify-me.h"
93 #include "gimple-walk.h"
96 #include "gimple-ssa.h"
98 #include "tree-phinodes.h"
99 #include "ssa-iterators.h"
100 #include "stringpool.h"
101 #include "tree-ssanames.h"
102 #include "tree-into-ssa.h"
103 #include "tree-dfa.h"
104 #include "tree-pass.h"
106 #include "diagnostic.h"
107 #include "tree-dump.h"
108 #include "tree-inline.h"
110 #include "gimple-pretty-print.h"
111 #include "ipa-inline.h"
114 /* Per basic block info. */
122 static vec
<bb_info
> bb_info_vec
;
124 /* Description of split point. */
128 /* Size of the partitions. */
129 unsigned int header_time
, header_size
, split_time
, split_size
;
131 /* SSA names that need to be passed into spit function. */
132 bitmap ssa_names_to_pass
;
134 /* Basic block where we split (that will become entry point of new function. */
135 basic_block entry_bb
;
137 /* Basic blocks we are splitting away. */
140 /* True when return value is computed on split part and thus it needs
142 bool split_part_set_retval
;
145 /* Best split point found. */
147 struct split_point best_split_point
;
149 /* Set of basic blocks that are not allowed to dominate a split point. */
151 static bitmap forbidden_dominators
;
153 static tree
find_retval (basic_block return_bb
);
155 /* Callback for walk_stmt_load_store_addr_ops. If T is non-SSA automatic
156 variable, check it if it is present in bitmap passed via DATA. */
159 test_nonssa_use (gimple stmt ATTRIBUTE_UNUSED
, tree t
, void *data
)
161 t
= get_base_address (t
);
163 if (!t
|| is_gimple_reg (t
))
166 if (TREE_CODE (t
) == PARM_DECL
167 || (TREE_CODE (t
) == VAR_DECL
168 && auto_var_in_fn_p (t
, current_function_decl
))
169 || TREE_CODE (t
) == RESULT_DECL
170 || TREE_CODE (t
) == LABEL_DECL
)
171 return bitmap_bit_p ((bitmap
)data
, DECL_UID (t
));
173 /* For DECL_BY_REFERENCE, the return value is actually a pointer. We want
174 to pretend that the value pointed to is actual result decl. */
175 if ((TREE_CODE (t
) == MEM_REF
|| INDIRECT_REF_P (t
))
176 && TREE_CODE (TREE_OPERAND (t
, 0)) == SSA_NAME
177 && SSA_NAME_VAR (TREE_OPERAND (t
, 0))
178 && TREE_CODE (SSA_NAME_VAR (TREE_OPERAND (t
, 0))) == RESULT_DECL
179 && DECL_BY_REFERENCE (DECL_RESULT (current_function_decl
)))
181 bitmap_bit_p ((bitmap
)data
,
182 DECL_UID (DECL_RESULT (current_function_decl
)));
187 /* Dump split point CURRENT. */
190 dump_split_point (FILE * file
, struct split_point
*current
)
193 "Split point at BB %i\n"
194 " header time: %i header size: %i\n"
195 " split time: %i split size: %i\n bbs: ",
196 current
->entry_bb
->index
, current
->header_time
,
197 current
->header_size
, current
->split_time
, current
->split_size
);
198 dump_bitmap (file
, current
->split_bbs
);
199 fprintf (file
, " SSA names to pass: ");
200 dump_bitmap (file
, current
->ssa_names_to_pass
);
203 /* Look for all BBs in header that might lead to the split part and verify
204 that they are not defining any non-SSA var used by the split part.
205 Parameters are the same as for consider_split. */
208 verify_non_ssa_vars (struct split_point
*current
, bitmap non_ssa_vars
,
209 basic_block return_bb
)
211 bitmap seen
= BITMAP_ALLOC (NULL
);
212 vec
<basic_block
> worklist
= vNULL
;
217 FOR_EACH_EDGE (e
, ei
, current
->entry_bb
->preds
)
218 if (e
->src
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)
219 && !bitmap_bit_p (current
->split_bbs
, e
->src
->index
))
221 worklist
.safe_push (e
->src
);
222 bitmap_set_bit (seen
, e
->src
->index
);
225 while (!worklist
.is_empty ())
227 gimple_stmt_iterator bsi
;
228 basic_block bb
= worklist
.pop ();
230 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
231 if (e
->src
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)
232 && bitmap_set_bit (seen
, e
->src
->index
))
234 gcc_checking_assert (!bitmap_bit_p (current
->split_bbs
,
236 worklist
.safe_push (e
->src
);
238 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
240 gimple stmt
= gsi_stmt (bsi
);
241 if (is_gimple_debug (stmt
))
243 if (walk_stmt_load_store_addr_ops
244 (stmt
, non_ssa_vars
, test_nonssa_use
, test_nonssa_use
,
250 if (gimple_code (stmt
) == GIMPLE_LABEL
251 && test_nonssa_use (stmt
, gimple_label_label (stmt
),
258 for (bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
260 if (walk_stmt_load_store_addr_ops
261 (gsi_stmt (bsi
), non_ssa_vars
, test_nonssa_use
, test_nonssa_use
,
268 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
270 if (e
->dest
!= return_bb
)
272 for (bsi
= gsi_start_phis (return_bb
); !gsi_end_p (bsi
);
275 gimple stmt
= gsi_stmt (bsi
);
276 tree op
= gimple_phi_arg_def (stmt
, e
->dest_idx
);
278 if (virtual_operand_p (gimple_phi_result (stmt
)))
280 if (TREE_CODE (op
) != SSA_NAME
281 && test_nonssa_use (stmt
, op
, non_ssa_vars
))
295 /* If STMT is a call, check the callee against a list of forbidden
296 predicate functions. If a match is found, look for uses of the
297 call result in condition statements that compare against zero.
298 For each such use, find the block targeted by the condition
299 statement for the nonzero result, and set the bit for this block
300 in the forbidden dominators bitmap. The purpose of this is to avoid
301 selecting a split point where we are likely to lose the chance
302 to optimize away an unused function call. */
305 check_forbidden_calls (gimple stmt
)
307 imm_use_iterator use_iter
;
311 /* At the moment, __builtin_constant_p is the only forbidden
312 predicate function call (see PR49642). */
313 if (!gimple_call_builtin_p (stmt
, BUILT_IN_CONSTANT_P
))
316 lhs
= gimple_call_lhs (stmt
);
318 if (!lhs
|| TREE_CODE (lhs
) != SSA_NAME
)
321 FOR_EACH_IMM_USE_FAST (use_p
, use_iter
, lhs
)
324 basic_block use_bb
, forbidden_bb
;
326 edge true_edge
, false_edge
;
327 gimple use_stmt
= USE_STMT (use_p
);
329 if (gimple_code (use_stmt
) != GIMPLE_COND
)
332 /* Assuming canonical form for GIMPLE_COND here, with constant
333 in second position. */
334 op1
= gimple_cond_rhs (use_stmt
);
335 code
= gimple_cond_code (use_stmt
);
336 use_bb
= gimple_bb (use_stmt
);
338 extract_true_false_edges_from_block (use_bb
, &true_edge
, &false_edge
);
340 /* We're only interested in comparisons that distinguish
341 unambiguously from zero. */
342 if (!integer_zerop (op1
) || code
== LE_EXPR
|| code
== GE_EXPR
)
346 forbidden_bb
= false_edge
->dest
;
348 forbidden_bb
= true_edge
->dest
;
350 bitmap_set_bit (forbidden_dominators
, forbidden_bb
->index
);
354 /* If BB is dominated by any block in the forbidden dominators set,
355 return TRUE; else FALSE. */
358 dominated_by_forbidden (basic_block bb
)
363 EXECUTE_IF_SET_IN_BITMAP (forbidden_dominators
, 1, dom_bb
, bi
)
365 if (dominated_by_p (CDI_DOMINATORS
, bb
,
366 BASIC_BLOCK_FOR_FN (cfun
, dom_bb
)))
373 /* We found an split_point CURRENT. NON_SSA_VARS is bitmap of all non ssa
374 variables used and RETURN_BB is return basic block.
375 See if we can split function here. */
378 consider_split (struct split_point
*current
, bitmap non_ssa_vars
,
379 basic_block return_bb
)
382 unsigned int num_args
= 0;
383 unsigned int call_overhead
;
386 gimple_stmt_iterator bsi
;
388 int incoming_freq
= 0;
390 bool back_edge
= false;
392 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
393 dump_split_point (dump_file
, current
);
395 FOR_EACH_EDGE (e
, ei
, current
->entry_bb
->preds
)
397 if (e
->flags
& EDGE_DFS_BACK
)
399 if (!bitmap_bit_p (current
->split_bbs
, e
->src
->index
))
400 incoming_freq
+= EDGE_FREQUENCY (e
);
403 /* Do not split when we would end up calling function anyway. */
405 >= (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
406 * PARAM_VALUE (PARAM_PARTIAL_INLINING_ENTRY_PROBABILITY
) / 100))
408 /* When profile is guessed, we can not expect it to give us
409 realistic estimate on likelyness of function taking the
410 complex path. As a special case, when tail of the function is
411 a loop, enable splitting since inlining code skipping the loop
412 is likely noticeable win. */
414 && profile_status_for_fn (cfun
) != PROFILE_READ
415 && incoming_freq
< ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
)
417 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
419 " Split before loop, accepting despite low frequencies %i %i.\n",
421 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
);
425 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
427 " Refused: incoming frequency is too large.\n");
432 if (!current
->header_size
)
434 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
435 fprintf (dump_file
, " Refused: header empty\n");
439 /* Verify that PHI args on entry are either virtual or all their operands
440 incoming from header are the same. */
441 for (bsi
= gsi_start_phis (current
->entry_bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
443 gimple stmt
= gsi_stmt (bsi
);
446 if (virtual_operand_p (gimple_phi_result (stmt
)))
448 for (i
= 0; i
< gimple_phi_num_args (stmt
); i
++)
450 edge e
= gimple_phi_arg_edge (stmt
, i
);
451 if (!bitmap_bit_p (current
->split_bbs
, e
->src
->index
))
453 tree edge_val
= gimple_phi_arg_def (stmt
, i
);
454 if (val
&& edge_val
!= val
)
456 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
458 " Refused: entry BB has PHI with multiple variants\n");
467 /* See what argument we will pass to the split function and compute
469 call_overhead
= eni_size_weights
.call_cost
;
470 for (parm
= DECL_ARGUMENTS (current_function_decl
); parm
;
471 parm
= DECL_CHAIN (parm
))
473 if (!is_gimple_reg (parm
))
475 if (bitmap_bit_p (non_ssa_vars
, DECL_UID (parm
)))
477 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
479 " Refused: need to pass non-ssa param values\n");
485 tree ddef
= ssa_default_def (cfun
, parm
);
487 && bitmap_bit_p (current
->ssa_names_to_pass
,
488 SSA_NAME_VERSION (ddef
)))
490 if (!VOID_TYPE_P (TREE_TYPE (parm
)))
491 call_overhead
+= estimate_move_cost (TREE_TYPE (parm
));
496 if (!VOID_TYPE_P (TREE_TYPE (current_function_decl
)))
497 call_overhead
+= estimate_move_cost (TREE_TYPE (current_function_decl
));
499 if (current
->split_size
<= call_overhead
)
501 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
503 " Refused: split size is smaller than call overhead\n");
506 if (current
->header_size
+ call_overhead
507 >= (unsigned int)(DECL_DECLARED_INLINE_P (current_function_decl
)
508 ? MAX_INLINE_INSNS_SINGLE
509 : MAX_INLINE_INSNS_AUTO
))
511 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
513 " Refused: header size is too large for inline candidate\n");
517 /* FIXME: we currently can pass only SSA function parameters to the split
518 arguments. Once parm_adjustment infrastructure is supported by cloning,
519 we can pass more than that. */
520 if (num_args
!= bitmap_count_bits (current
->ssa_names_to_pass
))
523 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
525 " Refused: need to pass non-param values\n");
529 /* When there are non-ssa vars used in the split region, see if they
530 are used in the header region. If so, reject the split.
531 FIXME: we can use nested function support to access both. */
532 if (!bitmap_empty_p (non_ssa_vars
)
533 && !verify_non_ssa_vars (current
, non_ssa_vars
, return_bb
))
535 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
537 " Refused: split part has non-ssa uses\n");
541 /* If the split point is dominated by a forbidden block, reject
543 if (!bitmap_empty_p (forbidden_dominators
)
544 && dominated_by_forbidden (current
->entry_bb
))
546 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
548 " Refused: split point dominated by forbidden block\n");
552 /* See if retval used by return bb is computed by header or split part.
553 When it is computed by split part, we need to produce return statement
554 in the split part and add code to header to pass it around.
556 This is bit tricky to test:
557 1) When there is no return_bb or no return value, we always pass
559 2) Invariants are always computed by caller.
560 3) For SSA we need to look if defining statement is in header or split part
561 4) For non-SSA we need to look where the var is computed. */
562 retval
= find_retval (return_bb
);
564 current
->split_part_set_retval
= true;
565 else if (is_gimple_min_invariant (retval
))
566 current
->split_part_set_retval
= false;
567 /* Special case is value returned by reference we record as if it was non-ssa
568 set to result_decl. */
569 else if (TREE_CODE (retval
) == SSA_NAME
570 && SSA_NAME_VAR (retval
)
571 && TREE_CODE (SSA_NAME_VAR (retval
)) == RESULT_DECL
572 && DECL_BY_REFERENCE (DECL_RESULT (current_function_decl
)))
573 current
->split_part_set_retval
574 = bitmap_bit_p (non_ssa_vars
, DECL_UID (SSA_NAME_VAR (retval
)));
575 else if (TREE_CODE (retval
) == SSA_NAME
)
576 current
->split_part_set_retval
577 = (!SSA_NAME_IS_DEFAULT_DEF (retval
)
578 && (bitmap_bit_p (current
->split_bbs
,
579 gimple_bb (SSA_NAME_DEF_STMT (retval
))->index
)
580 || gimple_bb (SSA_NAME_DEF_STMT (retval
)) == return_bb
));
581 else if (TREE_CODE (retval
) == PARM_DECL
)
582 current
->split_part_set_retval
= false;
583 else if (TREE_CODE (retval
) == VAR_DECL
584 || TREE_CODE (retval
) == RESULT_DECL
)
585 current
->split_part_set_retval
586 = bitmap_bit_p (non_ssa_vars
, DECL_UID (retval
));
588 current
->split_part_set_retval
= true;
590 /* split_function fixes up at most one PHI non-virtual PHI node in return_bb,
591 for the return value. If there are other PHIs, give up. */
592 if (return_bb
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
594 gimple_stmt_iterator psi
;
596 for (psi
= gsi_start_phis (return_bb
); !gsi_end_p (psi
); gsi_next (&psi
))
597 if (!virtual_operand_p (gimple_phi_result (gsi_stmt (psi
)))
599 && current
->split_part_set_retval
600 && TREE_CODE (retval
) == SSA_NAME
601 && !DECL_BY_REFERENCE (DECL_RESULT (current_function_decl
))
602 && SSA_NAME_DEF_STMT (retval
) == gsi_stmt (psi
)))
604 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
606 " Refused: return bb has extra PHIs\n");
611 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
612 fprintf (dump_file
, " Accepted!\n");
614 /* At the moment chose split point with lowest frequency and that leaves
615 out smallest size of header.
616 In future we might re-consider this heuristics. */
617 if (!best_split_point
.split_bbs
618 || best_split_point
.entry_bb
->frequency
> current
->entry_bb
->frequency
619 || (best_split_point
.entry_bb
->frequency
== current
->entry_bb
->frequency
620 && best_split_point
.split_size
< current
->split_size
))
623 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
624 fprintf (dump_file
, " New best split point!\n");
625 if (best_split_point
.ssa_names_to_pass
)
627 BITMAP_FREE (best_split_point
.ssa_names_to_pass
);
628 BITMAP_FREE (best_split_point
.split_bbs
);
630 best_split_point
= *current
;
631 best_split_point
.ssa_names_to_pass
= BITMAP_ALLOC (NULL
);
632 bitmap_copy (best_split_point
.ssa_names_to_pass
,
633 current
->ssa_names_to_pass
);
634 best_split_point
.split_bbs
= BITMAP_ALLOC (NULL
);
635 bitmap_copy (best_split_point
.split_bbs
, current
->split_bbs
);
639 /* Return basic block containing RETURN statement. We allow basic blocks
643 but return_bb can not be more complex than this.
644 If nothing is found, return the exit block.
646 When there are multiple RETURN statement, chose one with return value,
647 since that one is more likely shared by multiple code paths.
649 Return BB is special, because for function splitting it is the only
650 basic block that is duplicated in between header and split part of the
653 TODO: We might support multiple return blocks. */
656 find_return_bb (void)
659 basic_block return_bb
= EXIT_BLOCK_PTR_FOR_FN (cfun
);
660 gimple_stmt_iterator bsi
;
661 bool found_return
= false;
662 tree retval
= NULL_TREE
;
664 if (!single_pred_p (EXIT_BLOCK_PTR_FOR_FN (cfun
)))
667 e
= single_pred_edge (EXIT_BLOCK_PTR_FOR_FN (cfun
));
668 for (bsi
= gsi_last_bb (e
->src
); !gsi_end_p (bsi
); gsi_prev (&bsi
))
670 gimple stmt
= gsi_stmt (bsi
);
671 if (gimple_code (stmt
) == GIMPLE_LABEL
672 || is_gimple_debug (stmt
)
673 || gimple_clobber_p (stmt
))
675 else if (gimple_code (stmt
) == GIMPLE_ASSIGN
677 && gimple_assign_single_p (stmt
)
678 && (auto_var_in_fn_p (gimple_assign_rhs1 (stmt
),
679 current_function_decl
)
680 || is_gimple_min_invariant (gimple_assign_rhs1 (stmt
)))
681 && retval
== gimple_assign_lhs (stmt
))
683 else if (gimple_code (stmt
) == GIMPLE_RETURN
)
686 retval
= gimple_return_retval (stmt
);
691 if (gsi_end_p (bsi
) && found_return
)
697 /* Given return basic block RETURN_BB, see where return value is really
700 find_retval (basic_block return_bb
)
702 gimple_stmt_iterator bsi
;
703 for (bsi
= gsi_start_bb (return_bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
704 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_RETURN
)
705 return gimple_return_retval (gsi_stmt (bsi
));
706 else if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_ASSIGN
707 && !gimple_clobber_p (gsi_stmt (bsi
)))
708 return gimple_assign_rhs1 (gsi_stmt (bsi
));
712 /* Callback for walk_stmt_load_store_addr_ops. If T is non-SSA automatic
713 variable, mark it as used in bitmap passed via DATA.
714 Return true when access to T prevents splitting the function. */
717 mark_nonssa_use (gimple stmt ATTRIBUTE_UNUSED
, tree t
, void *data
)
719 t
= get_base_address (t
);
721 if (!t
|| is_gimple_reg (t
))
724 /* At present we can't pass non-SSA arguments to split function.
725 FIXME: this can be relaxed by passing references to arguments. */
726 if (TREE_CODE (t
) == PARM_DECL
)
728 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
730 "Cannot split: use of non-ssa function parameter.\n");
734 if ((TREE_CODE (t
) == VAR_DECL
735 && auto_var_in_fn_p (t
, current_function_decl
))
736 || TREE_CODE (t
) == RESULT_DECL
737 || TREE_CODE (t
) == LABEL_DECL
)
738 bitmap_set_bit ((bitmap
)data
, DECL_UID (t
));
740 /* For DECL_BY_REFERENCE, the return value is actually a pointer. We want
741 to pretend that the value pointed to is actual result decl. */
742 if ((TREE_CODE (t
) == MEM_REF
|| INDIRECT_REF_P (t
))
743 && TREE_CODE (TREE_OPERAND (t
, 0)) == SSA_NAME
744 && SSA_NAME_VAR (TREE_OPERAND (t
, 0))
745 && TREE_CODE (SSA_NAME_VAR (TREE_OPERAND (t
, 0))) == RESULT_DECL
746 && DECL_BY_REFERENCE (DECL_RESULT (current_function_decl
)))
748 bitmap_bit_p ((bitmap
)data
,
749 DECL_UID (DECL_RESULT (current_function_decl
)));
754 /* Compute local properties of basic block BB we collect when looking for
755 split points. We look for ssa defs and store them in SET_SSA_NAMES,
756 for ssa uses and store them in USED_SSA_NAMES and for any non-SSA automatic
757 vars stored in NON_SSA_VARS.
759 When BB has edge to RETURN_BB, collect uses in RETURN_BB too.
761 Return false when BB contains something that prevents it from being put into
765 visit_bb (basic_block bb
, basic_block return_bb
,
766 bitmap set_ssa_names
, bitmap used_ssa_names
,
769 gimple_stmt_iterator bsi
;
772 bool can_split
= true;
774 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
776 gimple stmt
= gsi_stmt (bsi
);
781 if (is_gimple_debug (stmt
))
784 if (gimple_clobber_p (stmt
))
787 /* FIXME: We can split regions containing EH. We can not however
788 split RESX, EH_DISPATCH and EH_POINTER referring to same region
789 into different partitions. This would require tracking of
790 EH regions and checking in consider_split_point if they
791 are not used elsewhere. */
792 if (gimple_code (stmt
) == GIMPLE_RESX
)
794 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
795 fprintf (dump_file
, "Cannot split: resx.\n");
798 if (gimple_code (stmt
) == GIMPLE_EH_DISPATCH
)
800 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
801 fprintf (dump_file
, "Cannot split: eh dispatch.\n");
805 /* Check builtins that prevent splitting. */
806 if (gimple_code (stmt
) == GIMPLE_CALL
807 && (decl
= gimple_call_fndecl (stmt
)) != NULL_TREE
808 && DECL_BUILT_IN (decl
)
809 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
810 switch (DECL_FUNCTION_CODE (decl
))
812 /* FIXME: once we will allow passing non-parm values to split part,
813 we need to be sure to handle correct builtin_stack_save and
814 builtin_stack_restore. At the moment we are safe; there is no
815 way to store builtin_stack_save result in non-SSA variable
816 since all calls to those are compiler generated. */
818 case BUILT_IN_APPLY_ARGS
:
819 case BUILT_IN_VA_START
:
820 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
822 "Cannot split: builtin_apply and va_start.\n");
825 case BUILT_IN_EH_POINTER
:
826 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
827 fprintf (dump_file
, "Cannot split: builtin_eh_pointer.\n");
834 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_DEF
)
835 bitmap_set_bit (set_ssa_names
, SSA_NAME_VERSION (op
));
836 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
837 bitmap_set_bit (used_ssa_names
, SSA_NAME_VERSION (op
));
838 can_split
&= !walk_stmt_load_store_addr_ops (stmt
, non_ssa_vars
,
843 for (bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
845 gimple stmt
= gsi_stmt (bsi
);
848 if (virtual_operand_p (gimple_phi_result (stmt
)))
850 bitmap_set_bit (set_ssa_names
,
851 SSA_NAME_VERSION (gimple_phi_result (stmt
)));
852 for (i
= 0; i
< gimple_phi_num_args (stmt
); i
++)
854 tree op
= gimple_phi_arg_def (stmt
, i
);
855 if (TREE_CODE (op
) == SSA_NAME
)
856 bitmap_set_bit (used_ssa_names
, SSA_NAME_VERSION (op
));
858 can_split
&= !walk_stmt_load_store_addr_ops (stmt
, non_ssa_vars
,
863 /* Record also uses coming from PHI operand in return BB. */
864 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
865 if (e
->dest
== return_bb
)
867 for (bsi
= gsi_start_phis (return_bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
869 gimple stmt
= gsi_stmt (bsi
);
870 tree op
= gimple_phi_arg_def (stmt
, e
->dest_idx
);
872 if (virtual_operand_p (gimple_phi_result (stmt
)))
874 if (TREE_CODE (op
) == SSA_NAME
)
875 bitmap_set_bit (used_ssa_names
, SSA_NAME_VERSION (op
));
877 can_split
&= !mark_nonssa_use (stmt
, op
, non_ssa_vars
);
883 /* Stack entry for recursive DFS walk in find_split_point. */
887 /* Basic block we are examining. */
890 /* SSA names set and used by the BB and all BBs reachable
891 from it via DFS walk. */
892 bitmap set_ssa_names
, used_ssa_names
;
895 /* All BBS visited from this BB via DFS walk. */
898 /* Last examined edge in DFS walk. Since we walk unoriented graph,
899 the value is up to sum of incoming and outgoing edges of BB. */
900 unsigned int edge_num
;
902 /* Stack entry index of earliest BB reachable from current BB
903 or any BB visited later in DFS walk. */
906 /* Overall time and size of all BBs reached from this BB in DFS walk. */
907 int overall_time
, overall_size
;
909 /* When false we can not split on this BB. */
914 /* Find all articulations and call consider_split on them.
915 OVERALL_TIME and OVERALL_SIZE is time and size of the function.
917 We perform basic algorithm for finding an articulation in a graph
918 created from CFG by considering it to be an unoriented graph.
920 The articulation is discovered via DFS walk. We collect earliest
921 basic block on stack that is reachable via backward edge. Articulation
922 is any basic block such that there is no backward edge bypassing it.
923 To reduce stack usage we maintain heap allocated stack in STACK vector.
924 AUX pointer of BB is set to index it appears in the stack or -1 once
925 it is visited and popped off the stack.
927 The algorithm finds articulation after visiting the whole component
928 reachable by it. This makes it convenient to collect information about
929 the component used by consider_split. */
932 find_split_points (int overall_time
, int overall_size
)
935 vec
<stack_entry
> stack
= vNULL
;
937 basic_block return_bb
= find_return_bb ();
938 struct split_point current
;
940 current
.header_time
= overall_time
;
941 current
.header_size
= overall_size
;
942 current
.split_time
= 0;
943 current
.split_size
= 0;
944 current
.ssa_names_to_pass
= BITMAP_ALLOC (NULL
);
946 first
.bb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
948 first
.overall_time
= 0;
949 first
.overall_size
= 0;
950 first
.earliest
= INT_MAX
;
951 first
.set_ssa_names
= 0;
952 first
.used_ssa_names
= 0;
953 first
.bbs_visited
= 0;
954 stack
.safe_push (first
);
955 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->aux
= (void *)(intptr_t)-1;
957 while (!stack
.is_empty ())
959 stack_entry
*entry
= &stack
.last ();
961 /* We are walking an acyclic graph, so edge_num counts
962 succ and pred edges together. However when considering
963 articulation, we want to have processed everything reachable
964 from articulation but nothing that reaches into it. */
965 if (entry
->edge_num
== EDGE_COUNT (entry
->bb
->succs
)
966 && entry
->bb
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
))
968 int pos
= stack
.length ();
969 entry
->can_split
&= visit_bb (entry
->bb
, return_bb
,
970 entry
->set_ssa_names
,
971 entry
->used_ssa_names
,
972 entry
->non_ssa_vars
);
973 if (pos
<= entry
->earliest
&& !entry
->can_split
974 && dump_file
&& (dump_flags
& TDF_DETAILS
))
976 "found articulation at bb %i but can not split\n",
978 if (pos
<= entry
->earliest
&& entry
->can_split
)
980 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
981 fprintf (dump_file
, "found articulation at bb %i\n",
983 current
.entry_bb
= entry
->bb
;
984 current
.ssa_names_to_pass
= BITMAP_ALLOC (NULL
);
985 bitmap_and_compl (current
.ssa_names_to_pass
,
986 entry
->used_ssa_names
, entry
->set_ssa_names
);
987 current
.header_time
= overall_time
- entry
->overall_time
;
988 current
.header_size
= overall_size
- entry
->overall_size
;
989 current
.split_time
= entry
->overall_time
;
990 current
.split_size
= entry
->overall_size
;
991 current
.split_bbs
= entry
->bbs_visited
;
992 consider_split (¤t
, entry
->non_ssa_vars
, return_bb
);
993 BITMAP_FREE (current
.ssa_names_to_pass
);
996 /* Do actual DFS walk. */
998 < (EDGE_COUNT (entry
->bb
->succs
)
999 + EDGE_COUNT (entry
->bb
->preds
)))
1003 if (entry
->edge_num
< EDGE_COUNT (entry
->bb
->succs
))
1005 e
= EDGE_SUCC (entry
->bb
, entry
->edge_num
);
1010 e
= EDGE_PRED (entry
->bb
, entry
->edge_num
1011 - EDGE_COUNT (entry
->bb
->succs
));
1017 /* New BB to visit, push it to the stack. */
1018 if (dest
!= return_bb
&& dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
)
1021 stack_entry new_entry
;
1023 new_entry
.bb
= dest
;
1024 new_entry
.edge_num
= 0;
1025 new_entry
.overall_time
1026 = bb_info_vec
[dest
->index
].time
;
1027 new_entry
.overall_size
1028 = bb_info_vec
[dest
->index
].size
;
1029 new_entry
.earliest
= INT_MAX
;
1030 new_entry
.set_ssa_names
= BITMAP_ALLOC (NULL
);
1031 new_entry
.used_ssa_names
= BITMAP_ALLOC (NULL
);
1032 new_entry
.bbs_visited
= BITMAP_ALLOC (NULL
);
1033 new_entry
.non_ssa_vars
= BITMAP_ALLOC (NULL
);
1034 new_entry
.can_split
= true;
1035 bitmap_set_bit (new_entry
.bbs_visited
, dest
->index
);
1036 stack
.safe_push (new_entry
);
1037 dest
->aux
= (void *)(intptr_t)stack
.length ();
1039 /* Back edge found, record the earliest point. */
1040 else if ((intptr_t)dest
->aux
> 0
1041 && (intptr_t)dest
->aux
< entry
->earliest
)
1042 entry
->earliest
= (intptr_t)dest
->aux
;
1044 /* We are done with examining the edges. Pop off the value from stack
1045 and merge stuff we accumulate during the walk. */
1046 else if (entry
->bb
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
))
1048 stack_entry
*prev
= &stack
[stack
.length () - 2];
1050 entry
->bb
->aux
= (void *)(intptr_t)-1;
1051 prev
->can_split
&= entry
->can_split
;
1052 if (prev
->set_ssa_names
)
1054 bitmap_ior_into (prev
->set_ssa_names
, entry
->set_ssa_names
);
1055 bitmap_ior_into (prev
->used_ssa_names
, entry
->used_ssa_names
);
1056 bitmap_ior_into (prev
->bbs_visited
, entry
->bbs_visited
);
1057 bitmap_ior_into (prev
->non_ssa_vars
, entry
->non_ssa_vars
);
1059 if (prev
->earliest
> entry
->earliest
)
1060 prev
->earliest
= entry
->earliest
;
1061 prev
->overall_time
+= entry
->overall_time
;
1062 prev
->overall_size
+= entry
->overall_size
;
1063 BITMAP_FREE (entry
->set_ssa_names
);
1064 BITMAP_FREE (entry
->used_ssa_names
);
1065 BITMAP_FREE (entry
->bbs_visited
);
1066 BITMAP_FREE (entry
->non_ssa_vars
);
1072 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->aux
= NULL
;
1076 BITMAP_FREE (current
.ssa_names_to_pass
);
1079 /* Split function at SPLIT_POINT. */
1082 split_function (struct split_point
*split_point
)
1084 vec
<tree
> args_to_pass
= vNULL
;
1085 bitmap args_to_skip
;
1088 struct cgraph_node
*node
, *cur_node
= cgraph_get_node (current_function_decl
);
1089 basic_block return_bb
= find_return_bb ();
1090 basic_block call_bb
;
1091 gimple_stmt_iterator gsi
;
1095 tree retval
= NULL
, real_retval
= NULL
;
1096 bool split_part_return_p
= false;
1097 gimple last_stmt
= NULL
;
1100 vec
<tree
, va_gc
> **debug_args
= NULL
;
1104 fprintf (dump_file
, "\n\nSplitting function at:\n");
1105 dump_split_point (dump_file
, split_point
);
1108 if (cur_node
->local
.can_change_signature
)
1109 args_to_skip
= BITMAP_ALLOC (NULL
);
1111 args_to_skip
= NULL
;
1113 /* Collect the parameters of new function and args_to_skip bitmap. */
1114 for (parm
= DECL_ARGUMENTS (current_function_decl
);
1115 parm
; parm
= DECL_CHAIN (parm
), num
++)
1117 && (!is_gimple_reg (parm
)
1118 || (ddef
= ssa_default_def (cfun
, parm
)) == NULL_TREE
1119 || !bitmap_bit_p (split_point
->ssa_names_to_pass
,
1120 SSA_NAME_VERSION (ddef
))))
1121 bitmap_set_bit (args_to_skip
, num
);
1124 /* This parm might not have been used up to now, but is going to be
1125 used, hence register it. */
1126 if (is_gimple_reg (parm
))
1127 arg
= get_or_create_ssa_default_def (cfun
, parm
);
1131 if (!useless_type_conversion_p (DECL_ARG_TYPE (parm
), TREE_TYPE (arg
)))
1132 arg
= fold_convert (DECL_ARG_TYPE (parm
), arg
);
1133 args_to_pass
.safe_push (arg
);
1136 /* See if the split function will return. */
1137 FOR_EACH_EDGE (e
, ei
, return_bb
->preds
)
1138 if (bitmap_bit_p (split_point
->split_bbs
, e
->src
->index
))
1141 split_part_return_p
= true;
1143 /* Add return block to what will become the split function.
1144 We do not return; no return block is needed. */
1145 if (!split_part_return_p
)
1147 /* We have no return block, so nothing is needed. */
1148 else if (return_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
1150 /* When we do not want to return value, we need to construct
1151 new return block with empty return statement.
1152 FIXME: Once we are able to change return type, we should change function
1153 to return void instead of just outputting function with undefined return
1154 value. For structures this affects quality of codegen. */
1155 else if (!split_point
->split_part_set_retval
1156 && find_retval (return_bb
))
1158 bool redirected
= true;
1159 basic_block new_return_bb
= create_basic_block (NULL
, 0, return_bb
);
1160 gimple_stmt_iterator gsi
= gsi_start_bb (new_return_bb
);
1161 gsi_insert_after (&gsi
, gimple_build_return (NULL
), GSI_NEW_STMT
);
1165 FOR_EACH_EDGE (e
, ei
, return_bb
->preds
)
1166 if (bitmap_bit_p (split_point
->split_bbs
, e
->src
->index
))
1168 new_return_bb
->count
+= e
->count
;
1169 new_return_bb
->frequency
+= EDGE_FREQUENCY (e
);
1170 redirect_edge_and_branch (e
, new_return_bb
);
1175 e
= make_edge (new_return_bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
1176 e
->probability
= REG_BR_PROB_BASE
;
1177 e
->count
= new_return_bb
->count
;
1179 add_bb_to_loop (new_return_bb
, current_loops
->tree_root
);
1180 bitmap_set_bit (split_point
->split_bbs
, new_return_bb
->index
);
1182 /* When we pass around the value, use existing return block. */
1184 bitmap_set_bit (split_point
->split_bbs
, return_bb
->index
);
1186 /* If RETURN_BB has virtual operand PHIs, they must be removed and the
1187 virtual operand marked for renaming as we change the CFG in a way that
1188 tree-inline is not able to compensate for.
1190 Note this can happen whether or not we have a return value. If we have
1191 a return value, then RETURN_BB may have PHIs for real operands too. */
1192 if (return_bb
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
1195 for (gsi
= gsi_start_phis (return_bb
); !gsi_end_p (gsi
);)
1197 gimple stmt
= gsi_stmt (gsi
);
1198 if (!virtual_operand_p (gimple_phi_result (stmt
)))
1203 mark_virtual_phi_result_for_renaming (stmt
);
1204 remove_phi_node (&gsi
, true);
1207 /* In reality we have to rename the reaching definition of the
1208 virtual operand at return_bb as we will eventually release it
1209 when we remove the code region we outlined.
1210 So we have to rename all immediate virtual uses of that region
1211 if we didn't see a PHI definition yet. */
1212 /* ??? In real reality we want to set the reaching vdef of the
1213 entry of the SESE region as the vuse of the call and the reaching
1214 vdef of the exit of the SESE region as the vdef of the call. */
1216 for (gsi
= gsi_start_bb (return_bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1218 gimple stmt
= gsi_stmt (gsi
);
1219 if (gimple_vuse (stmt
))
1221 gimple_set_vuse (stmt
, NULL_TREE
);
1224 if (gimple_vdef (stmt
))
1229 /* Now create the actual clone. */
1230 rebuild_cgraph_edges ();
1231 node
= cgraph_function_versioning (cur_node
, vNULL
,
1234 !split_part_return_p
,
1235 split_point
->split_bbs
,
1236 split_point
->entry_bb
, "part");
1237 /* For usual cloning it is enough to clear builtin only when signature
1238 changes. For partial inlining we however can not expect the part
1239 of builtin implementation to have same semantic as the whole. */
1240 if (DECL_BUILT_IN (node
->decl
))
1242 DECL_BUILT_IN_CLASS (node
->decl
) = NOT_BUILT_IN
;
1243 DECL_FUNCTION_CODE (node
->decl
) = (enum built_in_function
) 0;
1245 /* If the original function is declared inline, there is no point in issuing
1246 a warning for the non-inlinable part. */
1247 DECL_NO_INLINE_WARNING_P (node
->decl
) = 1;
1248 cgraph_node_remove_callees (cur_node
);
1249 ipa_remove_all_references (&cur_node
->ref_list
);
1250 if (!split_part_return_p
)
1251 TREE_THIS_VOLATILE (node
->decl
) = 1;
1253 dump_function_to_file (node
->decl
, dump_file
, dump_flags
);
1255 /* Create the basic block we place call into. It is the entry basic block
1256 split after last label. */
1257 call_bb
= split_point
->entry_bb
;
1258 for (gsi
= gsi_start_bb (call_bb
); !gsi_end_p (gsi
);)
1259 if (gimple_code (gsi_stmt (gsi
)) == GIMPLE_LABEL
)
1261 last_stmt
= gsi_stmt (gsi
);
1266 e
= split_block (split_point
->entry_bb
, last_stmt
);
1269 /* Produce the call statement. */
1270 gsi
= gsi_last_bb (call_bb
);
1271 FOR_EACH_VEC_ELT (args_to_pass
, i
, arg
)
1272 if (!is_gimple_val (arg
))
1274 arg
= force_gimple_operand_gsi (&gsi
, arg
, true, NULL_TREE
,
1275 false, GSI_CONTINUE_LINKING
);
1276 args_to_pass
[i
] = arg
;
1278 call
= gimple_build_call_vec (node
->decl
, args_to_pass
);
1279 gimple_set_block (call
, DECL_INITIAL (current_function_decl
));
1280 args_to_pass
.release ();
1282 /* For optimized away parameters, add on the caller side
1284 DEBUG D#X => parm_Y(D)
1285 stmts and associate D#X with parm in decl_debug_args_lookup
1286 vector to say for debug info that if parameter parm had been passed,
1287 it would have value parm_Y(D). */
1289 for (parm
= DECL_ARGUMENTS (current_function_decl
), num
= 0;
1290 parm
; parm
= DECL_CHAIN (parm
), num
++)
1291 if (bitmap_bit_p (args_to_skip
, num
)
1292 && is_gimple_reg (parm
))
1297 /* This needs to be done even without MAY_HAVE_DEBUG_STMTS,
1298 otherwise if it didn't exist before, we'd end up with
1299 different SSA_NAME_VERSIONs between -g and -g0. */
1300 arg
= get_or_create_ssa_default_def (cfun
, parm
);
1301 if (!MAY_HAVE_DEBUG_STMTS
)
1304 if (debug_args
== NULL
)
1305 debug_args
= decl_debug_args_insert (node
->decl
);
1306 ddecl
= make_node (DEBUG_EXPR_DECL
);
1307 DECL_ARTIFICIAL (ddecl
) = 1;
1308 TREE_TYPE (ddecl
) = TREE_TYPE (parm
);
1309 DECL_MODE (ddecl
) = DECL_MODE (parm
);
1310 vec_safe_push (*debug_args
, DECL_ORIGIN (parm
));
1311 vec_safe_push (*debug_args
, ddecl
);
1312 def_temp
= gimple_build_debug_bind (ddecl
, unshare_expr (arg
),
1314 gsi_insert_after (&gsi
, def_temp
, GSI_NEW_STMT
);
1316 /* And on the callee side, add
1319 stmts to the first bb where var is a VAR_DECL created for the
1320 optimized away parameter in DECL_INITIAL block. This hints
1321 in the debug info that var (whole DECL_ORIGIN is the parm PARM_DECL)
1322 is optimized away, but could be looked up at the call site
1323 as value of D#X there. */
1324 if (debug_args
!= NULL
)
1328 gimple_stmt_iterator cgsi
;
1331 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
1332 var
= BLOCK_VARS (DECL_INITIAL (node
->decl
));
1333 i
= vec_safe_length (*debug_args
);
1334 cgsi
= gsi_after_labels (single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
1338 while (var
!= NULL_TREE
1339 && DECL_ABSTRACT_ORIGIN (var
) != (**debug_args
)[i
])
1340 var
= TREE_CHAIN (var
);
1341 if (var
== NULL_TREE
)
1343 vexpr
= make_node (DEBUG_EXPR_DECL
);
1344 parm
= (**debug_args
)[i
];
1345 DECL_ARTIFICIAL (vexpr
) = 1;
1346 TREE_TYPE (vexpr
) = TREE_TYPE (parm
);
1347 DECL_MODE (vexpr
) = DECL_MODE (parm
);
1348 def_temp
= gimple_build_debug_source_bind (vexpr
, parm
,
1350 gsi_insert_before (&cgsi
, def_temp
, GSI_SAME_STMT
);
1351 def_temp
= gimple_build_debug_bind (var
, vexpr
, NULL
);
1352 gsi_insert_before (&cgsi
, def_temp
, GSI_SAME_STMT
);
1358 /* We avoid address being taken on any variable used by split part,
1359 so return slot optimization is always possible. Moreover this is
1360 required to make DECL_BY_REFERENCE work. */
1361 if (aggregate_value_p (DECL_RESULT (current_function_decl
),
1362 TREE_TYPE (current_function_decl
))
1363 && (!is_gimple_reg_type (TREE_TYPE (DECL_RESULT (current_function_decl
)))
1364 || DECL_BY_REFERENCE (DECL_RESULT (current_function_decl
))))
1365 gimple_call_set_return_slot_opt (call
, true);
1367 /* Update return value. This is bit tricky. When we do not return,
1368 do nothing. When we return we might need to update return_bb
1369 or produce a new return statement. */
1370 if (!split_part_return_p
)
1371 gsi_insert_after (&gsi
, call
, GSI_NEW_STMT
);
1374 e
= make_edge (call_bb
, return_bb
,
1375 return_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
1376 ? 0 : EDGE_FALLTHRU
);
1377 e
->count
= call_bb
->count
;
1378 e
->probability
= REG_BR_PROB_BASE
;
1380 /* If there is return basic block, see what value we need to store
1381 return value into and put call just before it. */
1382 if (return_bb
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
1384 real_retval
= retval
= find_retval (return_bb
);
1386 if (real_retval
&& split_point
->split_part_set_retval
)
1388 gimple_stmt_iterator psi
;
1390 /* See if we need new SSA_NAME for the result.
1391 When DECL_BY_REFERENCE is true, retval is actually pointer to
1392 return value and it is constant in whole function. */
1393 if (TREE_CODE (retval
) == SSA_NAME
1394 && !DECL_BY_REFERENCE (DECL_RESULT (current_function_decl
)))
1396 retval
= copy_ssa_name (retval
, call
);
1398 /* See if there is PHI defining return value. */
1399 for (psi
= gsi_start_phis (return_bb
);
1400 !gsi_end_p (psi
); gsi_next (&psi
))
1401 if (!virtual_operand_p (gimple_phi_result (gsi_stmt (psi
))))
1404 /* When there is PHI, just update its value. */
1405 if (TREE_CODE (retval
) == SSA_NAME
1406 && !gsi_end_p (psi
))
1407 add_phi_arg (gsi_stmt (psi
), retval
, e
, UNKNOWN_LOCATION
);
1408 /* Otherwise update the return BB itself.
1409 find_return_bb allows at most one assignment to return value,
1410 so update first statement. */
1413 gimple_stmt_iterator bsi
;
1414 for (bsi
= gsi_start_bb (return_bb
); !gsi_end_p (bsi
);
1416 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_RETURN
)
1418 gimple_return_set_retval (gsi_stmt (bsi
), retval
);
1421 else if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_ASSIGN
1422 && !gimple_clobber_p (gsi_stmt (bsi
)))
1424 gimple_assign_set_rhs1 (gsi_stmt (bsi
), retval
);
1427 update_stmt (gsi_stmt (bsi
));
1430 if (DECL_BY_REFERENCE (DECL_RESULT (current_function_decl
)))
1432 gimple_call_set_lhs (call
, build_simple_mem_ref (retval
));
1433 gsi_insert_after (&gsi
, call
, GSI_NEW_STMT
);
1438 restype
= TREE_TYPE (DECL_RESULT (current_function_decl
));
1439 gsi_insert_after (&gsi
, call
, GSI_NEW_STMT
);
1440 if (!useless_type_conversion_p (TREE_TYPE (retval
), restype
))
1443 tree tem
= create_tmp_reg (restype
, NULL
);
1444 tem
= make_ssa_name (tem
, call
);
1445 cpy
= gimple_build_assign_with_ops (NOP_EXPR
, retval
,
1447 gsi_insert_after (&gsi
, cpy
, GSI_NEW_STMT
);
1450 gimple_call_set_lhs (call
, retval
);
1455 gsi_insert_after (&gsi
, call
, GSI_NEW_STMT
);
1457 /* We don't use return block (there is either no return in function or
1458 multiple of them). So create new basic block with return statement.
1463 if (split_point
->split_part_set_retval
1464 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
))))
1466 retval
= DECL_RESULT (current_function_decl
);
1468 /* We use temporary register to hold value when aggregate_value_p
1469 is false. Similarly for DECL_BY_REFERENCE we must avoid extra
1471 if (!aggregate_value_p (retval
, TREE_TYPE (current_function_decl
))
1472 && !DECL_BY_REFERENCE (retval
))
1473 retval
= create_tmp_reg (TREE_TYPE (retval
), NULL
);
1474 if (is_gimple_reg (retval
))
1476 /* When returning by reference, there is only one SSA name
1477 assigned to RESULT_DECL (that is pointer to return value).
1478 Look it up or create new one if it is missing. */
1479 if (DECL_BY_REFERENCE (retval
))
1480 retval
= get_or_create_ssa_default_def (cfun
, retval
);
1481 /* Otherwise produce new SSA name for return value. */
1483 retval
= make_ssa_name (retval
, call
);
1485 if (DECL_BY_REFERENCE (DECL_RESULT (current_function_decl
)))
1486 gimple_call_set_lhs (call
, build_simple_mem_ref (retval
));
1488 gimple_call_set_lhs (call
, retval
);
1490 gsi_insert_after (&gsi
, call
, GSI_NEW_STMT
);
1491 ret
= gimple_build_return (retval
);
1492 gsi_insert_after (&gsi
, ret
, GSI_NEW_STMT
);
1495 free_dominance_info (CDI_DOMINATORS
);
1496 free_dominance_info (CDI_POST_DOMINATORS
);
1497 compute_inline_parameters (node
, true);
1500 /* Execute function splitting pass. */
1503 execute_split_functions (void)
1505 gimple_stmt_iterator bsi
;
1507 int overall_time
= 0, overall_size
= 0;
1509 struct cgraph_node
*node
= cgraph_get_node (current_function_decl
);
1511 if (flags_from_decl_or_type (current_function_decl
)
1512 & (ECF_NORETURN
|ECF_MALLOC
))
1515 fprintf (dump_file
, "Not splitting: noreturn/malloc function.\n");
1518 if (MAIN_NAME_P (DECL_NAME (current_function_decl
)))
1521 fprintf (dump_file
, "Not splitting: main function.\n");
1524 /* This can be relaxed; function might become inlinable after splitting
1525 away the uninlinable part. */
1526 if (inline_edge_summary_vec
.exists ()
1527 && !inline_summary (node
)->inlinable
)
1530 fprintf (dump_file
, "Not splitting: not inlinable.\n");
1533 if (DECL_DISREGARD_INLINE_LIMITS (node
->decl
))
1536 fprintf (dump_file
, "Not splitting: disregarding inline limits.\n");
1539 /* This can be relaxed; most of versioning tests actually prevents
1541 if (!tree_versionable_function_p (current_function_decl
))
1544 fprintf (dump_file
, "Not splitting: not versionable.\n");
1547 /* FIXME: we could support this. */
1548 if (DECL_STRUCT_FUNCTION (current_function_decl
)->static_chain_decl
)
1551 fprintf (dump_file
, "Not splitting: nested function.\n");
1555 /* See if it makes sense to try to split.
1556 It makes sense to split if we inline, that is if we have direct calls to
1557 handle or direct calls are possibly going to appear as result of indirect
1558 inlining or LTO. Also handle -fprofile-generate as LTO to allow non-LTO
1559 training for LTO -fprofile-use build.
1561 Note that we are not completely conservative about disqualifying functions
1562 called once. It is possible that the caller is called more then once and
1563 then inlining would still benefit. */
1565 /* Local functions called once will be completely inlined most of time. */
1566 || (!node
->callers
->next_caller
&& node
->local
.local
))
1567 && !node
->address_taken
1568 && (!flag_lto
|| !node
->externally_visible
))
1571 fprintf (dump_file
, "Not splitting: not called directly "
1572 "or called once.\n");
1576 /* FIXME: We can actually split if splitting reduces call overhead. */
1577 if (!flag_inline_small_functions
1578 && !DECL_DECLARED_INLINE_P (current_function_decl
))
1581 fprintf (dump_file
, "Not splitting: not autoinlining and function"
1582 " is not inline.\n");
1586 /* We enforce splitting after loop headers when profile info is not
1588 if (profile_status_for_fn (cfun
) != PROFILE_READ
)
1589 mark_dfs_back_edges ();
1591 /* Initialize bitmap to track forbidden calls. */
1592 forbidden_dominators
= BITMAP_ALLOC (NULL
);
1593 calculate_dominance_info (CDI_DOMINATORS
);
1595 /* Compute local info about basic blocks and determine function size/time. */
1596 bb_info_vec
.safe_grow_cleared (last_basic_block_for_fn (cfun
) + 1);
1597 memset (&best_split_point
, 0, sizeof (best_split_point
));
1602 int freq
= compute_call_stmt_bb_frequency (current_function_decl
, bb
);
1604 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1605 fprintf (dump_file
, "Basic block %i\n", bb
->index
);
1607 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
1609 int this_time
, this_size
;
1610 gimple stmt
= gsi_stmt (bsi
);
1612 this_size
= estimate_num_insns (stmt
, &eni_size_weights
);
1613 this_time
= estimate_num_insns (stmt
, &eni_time_weights
) * freq
;
1616 check_forbidden_calls (stmt
);
1618 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1620 fprintf (dump_file
, " freq:%6i size:%3i time:%3i ",
1621 freq
, this_size
, this_time
);
1622 print_gimple_stmt (dump_file
, stmt
, 0, 0);
1625 overall_time
+= time
;
1626 overall_size
+= size
;
1627 bb_info_vec
[bb
->index
].time
= time
;
1628 bb_info_vec
[bb
->index
].size
= size
;
1630 find_split_points (overall_time
, overall_size
);
1631 if (best_split_point
.split_bbs
)
1633 split_function (&best_split_point
);
1634 BITMAP_FREE (best_split_point
.ssa_names_to_pass
);
1635 BITMAP_FREE (best_split_point
.split_bbs
);
1636 todo
= TODO_update_ssa
| TODO_cleanup_cfg
;
1638 BITMAP_FREE (forbidden_dominators
);
1639 bb_info_vec
.release ();
1643 /* Gate function splitting pass. When doing profile feedback, we want
1644 to execute the pass after profiling is read. So disable one in
1645 early optimization. */
1648 gate_split_functions (void)
1650 return (flag_partial_inlining
1651 && !profile_arc_flag
&& !flag_branch_probabilities
);
1656 const pass_data pass_data_split_functions
=
1658 GIMPLE_PASS
, /* type */
1659 "fnsplit", /* name */
1660 OPTGROUP_NONE
, /* optinfo_flags */
1661 true, /* has_gate */
1662 true, /* has_execute */
1663 TV_IPA_FNSPLIT
, /* tv_id */
1664 PROP_cfg
, /* properties_required */
1665 0, /* properties_provided */
1666 0, /* properties_destroyed */
1667 0, /* todo_flags_start */
1668 TODO_verify_all
, /* todo_flags_finish */
1671 class pass_split_functions
: public gimple_opt_pass
1674 pass_split_functions (gcc::context
*ctxt
)
1675 : gimple_opt_pass (pass_data_split_functions
, ctxt
)
1678 /* opt_pass methods: */
1679 bool gate () { return gate_split_functions (); }
1680 unsigned int execute () { return execute_split_functions (); }
1682 }; // class pass_split_functions
1687 make_pass_split_functions (gcc::context
*ctxt
)
1689 return new pass_split_functions (ctxt
);
1692 /* Gate feedback driven function splitting pass.
1693 We don't need to split when profiling at all, we are producing
1694 lousy code anyway. */
1697 gate_feedback_split_functions (void)
1699 return (flag_partial_inlining
1700 && flag_branch_probabilities
);
1703 /* Execute function splitting pass. */
1706 execute_feedback_split_functions (void)
1708 unsigned int retval
= execute_split_functions ();
1710 retval
|= TODO_rebuild_cgraph_edges
;
1716 const pass_data pass_data_feedback_split_functions
=
1718 GIMPLE_PASS
, /* type */
1719 "feedback_fnsplit", /* name */
1720 OPTGROUP_NONE
, /* optinfo_flags */
1721 true, /* has_gate */
1722 true, /* has_execute */
1723 TV_IPA_FNSPLIT
, /* tv_id */
1724 PROP_cfg
, /* properties_required */
1725 0, /* properties_provided */
1726 0, /* properties_destroyed */
1727 0, /* todo_flags_start */
1728 TODO_verify_all
, /* todo_flags_finish */
1731 class pass_feedback_split_functions
: public gimple_opt_pass
1734 pass_feedback_split_functions (gcc::context
*ctxt
)
1735 : gimple_opt_pass (pass_data_feedback_split_functions
, ctxt
)
1738 /* opt_pass methods: */
1739 bool gate () { return gate_feedback_split_functions (); }
1740 unsigned int execute () { return execute_feedback_split_functions (); }
1742 }; // class pass_feedback_split_functions
1747 make_pass_feedback_split_functions (gcc::context
*ctxt
)
1749 return new pass_feedback_split_functions (ctxt
);