Update gcc-50 to SVN version 221572
[dragonfly.git] / contrib / gcc-5.0 / gcc / ipa-split.c
CommitLineData
dda118e3
JM
1/* Function splitting pass
2 Copyright (C) 2010-2015 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka <jh@suse.cz>
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3. If not see
19<http://www.gnu.org/licenses/>. */
20
21/* The purpose of this pass is to split function bodies to improve
22 inlining. I.e. for function of the form:
23
24 func (...)
25 {
26 if (cheap_test)
27 something_small
28 else
29 something_big
30 }
31
32 Produce:
33
34 func.part (...)
35 {
36 something_big
37 }
38
39 func (...)
40 {
41 if (cheap_test)
42 something_small
43 else
44 func.part (...);
45 }
46
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.
50
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
55 and chose best one.
56 3) If split point is found, split at the specified BB by creating a clone
57 and updating function to call it.
58
59 The decisions what functions to split are in execute_split_functions
60 and consider_split.
61
62 There are several possible future improvements for this pass including:
63
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. */
76
77#include "config.h"
78#include "system.h"
79#include "coretypes.h"
80#include "hash-set.h"
81#include "machmode.h"
82#include "vec.h"
83#include "double-int.h"
84#include "input.h"
85#include "alias.h"
86#include "symtab.h"
87#include "options.h"
88#include "wide-int.h"
89#include "inchash.h"
90#include "tree.h"
91#include "fold-const.h"
92#include "predict.h"
93#include "tm.h"
94#include "hard-reg-set.h"
95#include "function.h"
96#include "dominance.h"
97#include "cfg.h"
98#include "cfganal.h"
99#include "basic-block.h"
100#include "tree-ssa-alias.h"
101#include "internal-fn.h"
102#include "gimple-expr.h"
103#include "is-a.h"
104#include "gimple.h"
105#include "stringpool.h"
106#include "hashtab.h"
107#include "rtl.h"
108#include "flags.h"
109#include "statistics.h"
110#include "real.h"
111#include "fixed-value.h"
112#include "insn-config.h"
113#include "expmed.h"
114#include "dojump.h"
115#include "explow.h"
116#include "calls.h"
117#include "emit-rtl.h"
118#include "varasm.h"
119#include "stmt.h"
120#include "expr.h"
121#include "gimplify.h"
122#include "gimple-iterator.h"
123#include "gimplify-me.h"
124#include "gimple-walk.h"
125#include "target.h"
126#include "hash-map.h"
127#include "plugin-api.h"
128#include "ipa-ref.h"
129#include "cgraph.h"
130#include "alloc-pool.h"
131#include "symbol-summary.h"
132#include "ipa-prop.h"
133#include "gimple-ssa.h"
134#include "tree-cfg.h"
135#include "tree-phinodes.h"
136#include "ssa-iterators.h"
137#include "tree-ssanames.h"
138#include "tree-into-ssa.h"
139#include "tree-dfa.h"
140#include "tree-pass.h"
141#include "diagnostic.h"
142#include "tree-dump.h"
143#include "tree-inline.h"
144#include "params.h"
145#include "gimple-pretty-print.h"
146#include "ipa-inline.h"
147#include "cfgloop.h"
148#include "tree-chkp.h"
149
150/* Per basic block info. */
151
152typedef struct
153{
154 unsigned int size;
155 unsigned int time;
156} split_bb_info;
157
158static vec<split_bb_info> bb_info_vec;
159
160/* Description of split point. */
161
162struct split_point
163{
164 /* Size of the partitions. */
165 unsigned int header_time, header_size, split_time, split_size;
166
167 /* SSA names that need to be passed into spit function. */
168 bitmap ssa_names_to_pass;
169
170 /* Basic block where we split (that will become entry point of new function. */
171 basic_block entry_bb;
172
173 /* Basic blocks we are splitting away. */
174 bitmap split_bbs;
175
176 /* True when return value is computed on split part and thus it needs
177 to be returned. */
178 bool split_part_set_retval;
179};
180
181/* Best split point found. */
182
183struct split_point best_split_point;
184
185/* Set of basic blocks that are not allowed to dominate a split point. */
186
187static bitmap forbidden_dominators;
188
189static tree find_retval (basic_block return_bb);
190static tree find_retbnd (basic_block return_bb);
191
192/* Callback for walk_stmt_load_store_addr_ops. If T is non-SSA automatic
193 variable, check it if it is present in bitmap passed via DATA. */
194
195static bool
196test_nonssa_use (gimple, tree t, tree, void *data)
197{
198 t = get_base_address (t);
199
200 if (!t || is_gimple_reg (t))
201 return false;
202
203 if (TREE_CODE (t) == PARM_DECL
204 || (TREE_CODE (t) == VAR_DECL
205 && auto_var_in_fn_p (t, current_function_decl))
206 || TREE_CODE (t) == RESULT_DECL
207 /* Normal labels are part of CFG and will be handled gratefuly.
208 Forced labels however can be used directly by statements and
209 need to stay in one partition along with their uses. */
210 || (TREE_CODE (t) == LABEL_DECL
211 && FORCED_LABEL (t)))
212 return bitmap_bit_p ((bitmap)data, DECL_UID (t));
213
214 /* For DECL_BY_REFERENCE, the return value is actually a pointer. We want
215 to pretend that the value pointed to is actual result decl. */
216 if ((TREE_CODE (t) == MEM_REF || INDIRECT_REF_P (t))
217 && TREE_CODE (TREE_OPERAND (t, 0)) == SSA_NAME
218 && SSA_NAME_VAR (TREE_OPERAND (t, 0))
219 && TREE_CODE (SSA_NAME_VAR (TREE_OPERAND (t, 0))) == RESULT_DECL
220 && DECL_BY_REFERENCE (DECL_RESULT (current_function_decl)))
221 return
222 bitmap_bit_p ((bitmap)data,
223 DECL_UID (DECL_RESULT (current_function_decl)));
224
225 return false;
226}
227
228/* Dump split point CURRENT. */
229
230static void
231dump_split_point (FILE * file, struct split_point *current)
232{
233 fprintf (file,
234 "Split point at BB %i\n"
235 " header time: %i header size: %i\n"
236 " split time: %i split size: %i\n bbs: ",
237 current->entry_bb->index, current->header_time,
238 current->header_size, current->split_time, current->split_size);
239 dump_bitmap (file, current->split_bbs);
240 fprintf (file, " SSA names to pass: ");
241 dump_bitmap (file, current->ssa_names_to_pass);
242}
243
244/* Look for all BBs in header that might lead to the split part and verify
245 that they are not defining any non-SSA var used by the split part.
246 Parameters are the same as for consider_split. */
247
248static bool
249verify_non_ssa_vars (struct split_point *current, bitmap non_ssa_vars,
250 basic_block return_bb)
251{
252 bitmap seen = BITMAP_ALLOC (NULL);
253 vec<basic_block> worklist = vNULL;
254 edge e;
255 edge_iterator ei;
256 bool ok = true;
257 basic_block bb;
258
259 FOR_EACH_EDGE (e, ei, current->entry_bb->preds)
260 if (e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)
261 && !bitmap_bit_p (current->split_bbs, e->src->index))
262 {
263 worklist.safe_push (e->src);
264 bitmap_set_bit (seen, e->src->index);
265 }
266
267 while (!worklist.is_empty ())
268 {
269 bb = worklist.pop ();
270 FOR_EACH_EDGE (e, ei, bb->preds)
271 if (e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)
272 && bitmap_set_bit (seen, e->src->index))
273 {
274 gcc_checking_assert (!bitmap_bit_p (current->split_bbs,
275 e->src->index));
276 worklist.safe_push (e->src);
277 }
278 for (gimple_stmt_iterator bsi = gsi_start_bb (bb); !gsi_end_p (bsi);
279 gsi_next (&bsi))
280 {
281 gimple stmt = gsi_stmt (bsi);
282 if (is_gimple_debug (stmt))
283 continue;
284 if (walk_stmt_load_store_addr_ops
285 (stmt, non_ssa_vars, test_nonssa_use, test_nonssa_use,
286 test_nonssa_use))
287 {
288 ok = false;
289 goto done;
290 }
291 if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
292 if (test_nonssa_use (stmt, gimple_label_label (label_stmt),
293 NULL_TREE, non_ssa_vars))
294 {
295 ok = false;
296 goto done;
297 }
298 }
299 for (gphi_iterator bsi = gsi_start_phis (bb); !gsi_end_p (bsi);
300 gsi_next (&bsi))
301 {
302 if (walk_stmt_load_store_addr_ops
303 (gsi_stmt (bsi), non_ssa_vars, test_nonssa_use, test_nonssa_use,
304 test_nonssa_use))
305 {
306 ok = false;
307 goto done;
308 }
309 }
310 FOR_EACH_EDGE (e, ei, bb->succs)
311 {
312 if (e->dest != return_bb)
313 continue;
314 for (gphi_iterator bsi = gsi_start_phis (return_bb);
315 !gsi_end_p (bsi);
316 gsi_next (&bsi))
317 {
318 gphi *stmt = bsi.phi ();
319 tree op = gimple_phi_arg_def (stmt, e->dest_idx);
320
321 if (virtual_operand_p (gimple_phi_result (stmt)))
322 continue;
323 if (TREE_CODE (op) != SSA_NAME
324 && test_nonssa_use (stmt, op, op, non_ssa_vars))
325 {
326 ok = false;
327 goto done;
328 }
329 }
330 }
331 }
332
333 /* Verify that the rest of function does not define any label
334 used by the split part. */
335 FOR_EACH_BB_FN (bb, cfun)
336 if (!bitmap_bit_p (current->split_bbs, bb->index)
337 && !bitmap_bit_p (seen, bb->index))
338 {
339 gimple_stmt_iterator bsi;
340 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
341 if (glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (bsi)))
342 {
343 if (test_nonssa_use (label_stmt,
344 gimple_label_label (label_stmt),
345 NULL_TREE, non_ssa_vars))
346 {
347 ok = false;
348 goto done;
349 }
350 }
351 else
352 break;
353 }
354
355done:
356 BITMAP_FREE (seen);
357 worklist.release ();
358 return ok;
359}
360
361/* If STMT is a call, check the callee against a list of forbidden
362 predicate functions. If a match is found, look for uses of the
363 call result in condition statements that compare against zero.
364 For each such use, find the block targeted by the condition
365 statement for the nonzero result, and set the bit for this block
366 in the forbidden dominators bitmap. The purpose of this is to avoid
367 selecting a split point where we are likely to lose the chance
368 to optimize away an unused function call. */
369
370static void
371check_forbidden_calls (gimple stmt)
372{
373 imm_use_iterator use_iter;
374 use_operand_p use_p;
375 tree lhs;
376
377 /* At the moment, __builtin_constant_p is the only forbidden
378 predicate function call (see PR49642). */
379 if (!gimple_call_builtin_p (stmt, BUILT_IN_CONSTANT_P))
380 return;
381
382 lhs = gimple_call_lhs (stmt);
383
384 if (!lhs || TREE_CODE (lhs) != SSA_NAME)
385 return;
386
387 FOR_EACH_IMM_USE_FAST (use_p, use_iter, lhs)
388 {
389 tree op1;
390 basic_block use_bb, forbidden_bb;
391 enum tree_code code;
392 edge true_edge, false_edge;
393 gcond *use_stmt;
394
395 use_stmt = dyn_cast <gcond *> (USE_STMT (use_p));
396 if (!use_stmt)
397 continue;
398
399 /* Assuming canonical form for GIMPLE_COND here, with constant
400 in second position. */
401 op1 = gimple_cond_rhs (use_stmt);
402 code = gimple_cond_code (use_stmt);
403 use_bb = gimple_bb (use_stmt);
404
405 extract_true_false_edges_from_block (use_bb, &true_edge, &false_edge);
406
407 /* We're only interested in comparisons that distinguish
408 unambiguously from zero. */
409 if (!integer_zerop (op1) || code == LE_EXPR || code == GE_EXPR)
410 continue;
411
412 if (code == EQ_EXPR)
413 forbidden_bb = false_edge->dest;
414 else
415 forbidden_bb = true_edge->dest;
416
417 bitmap_set_bit (forbidden_dominators, forbidden_bb->index);
418 }
419}
420
421/* If BB is dominated by any block in the forbidden dominators set,
422 return TRUE; else FALSE. */
423
424static bool
425dominated_by_forbidden (basic_block bb)
426{
427 unsigned dom_bb;
428 bitmap_iterator bi;
429
430 EXECUTE_IF_SET_IN_BITMAP (forbidden_dominators, 1, dom_bb, bi)
431 {
432 if (dominated_by_p (CDI_DOMINATORS, bb,
433 BASIC_BLOCK_FOR_FN (cfun, dom_bb)))
434 return true;
435 }
436
437 return false;
438}
439
440/* For give split point CURRENT and return block RETURN_BB return 1
441 if ssa name VAL is set by split part and 0 otherwise. */
442static bool
443split_part_set_ssa_name_p (tree val, struct split_point *current,
444 basic_block return_bb)
445{
446 if (TREE_CODE (val) != SSA_NAME)
447 return false;
448
449 return (!SSA_NAME_IS_DEFAULT_DEF (val)
450 && (bitmap_bit_p (current->split_bbs,
451 gimple_bb (SSA_NAME_DEF_STMT (val))->index)
452 || gimple_bb (SSA_NAME_DEF_STMT (val)) == return_bb));
453}
454
455/* We found an split_point CURRENT. NON_SSA_VARS is bitmap of all non ssa
456 variables used and RETURN_BB is return basic block.
457 See if we can split function here. */
458
459static void
460consider_split (struct split_point *current, bitmap non_ssa_vars,
461 basic_block return_bb)
462{
463 tree parm;
464 unsigned int num_args = 0;
465 unsigned int call_overhead;
466 edge e;
467 edge_iterator ei;
468 gphi_iterator bsi;
469 unsigned int i;
470 int incoming_freq = 0;
471 tree retval;
472 tree retbnd;
473 bool back_edge = false;
474
475 if (dump_file && (dump_flags & TDF_DETAILS))
476 dump_split_point (dump_file, current);
477
478 FOR_EACH_EDGE (e, ei, current->entry_bb->preds)
479 {
480 if (e->flags & EDGE_DFS_BACK)
481 back_edge = true;
482 if (!bitmap_bit_p (current->split_bbs, e->src->index))
483 incoming_freq += EDGE_FREQUENCY (e);
484 }
485
486 /* Do not split when we would end up calling function anyway. */
487 if (incoming_freq
488 >= (ENTRY_BLOCK_PTR_FOR_FN (cfun)->frequency
489 * PARAM_VALUE (PARAM_PARTIAL_INLINING_ENTRY_PROBABILITY) / 100))
490 {
491 /* When profile is guessed, we can not expect it to give us
492 realistic estimate on likelyness of function taking the
493 complex path. As a special case, when tail of the function is
494 a loop, enable splitting since inlining code skipping the loop
495 is likely noticeable win. */
496 if (back_edge
497 && profile_status_for_fn (cfun) != PROFILE_READ
498 && incoming_freq < ENTRY_BLOCK_PTR_FOR_FN (cfun)->frequency)
499 {
500 if (dump_file && (dump_flags & TDF_DETAILS))
501 fprintf (dump_file,
502 " Split before loop, accepting despite low frequencies %i %i.\n",
503 incoming_freq,
504 ENTRY_BLOCK_PTR_FOR_FN (cfun)->frequency);
505 }
506 else
507 {
508 if (dump_file && (dump_flags & TDF_DETAILS))
509 fprintf (dump_file,
510 " Refused: incoming frequency is too large.\n");
511 return;
512 }
513 }
514
515 if (!current->header_size)
516 {
517 if (dump_file && (dump_flags & TDF_DETAILS))
518 fprintf (dump_file, " Refused: header empty\n");
519 return;
520 }
521
522 /* Verify that PHI args on entry are either virtual or all their operands
523 incoming from header are the same. */
524 for (bsi = gsi_start_phis (current->entry_bb); !gsi_end_p (bsi); gsi_next (&bsi))
525 {
526 gphi *stmt = bsi.phi ();
527 tree val = NULL;
528
529 if (virtual_operand_p (gimple_phi_result (stmt)))
530 continue;
531 for (i = 0; i < gimple_phi_num_args (stmt); i++)
532 {
533 edge e = gimple_phi_arg_edge (stmt, i);
534 if (!bitmap_bit_p (current->split_bbs, e->src->index))
535 {
536 tree edge_val = gimple_phi_arg_def (stmt, i);
537 if (val && edge_val != val)
538 {
539 if (dump_file && (dump_flags & TDF_DETAILS))
540 fprintf (dump_file,
541 " Refused: entry BB has PHI with multiple variants\n");
542 return;
543 }
544 val = edge_val;
545 }
546 }
547 }
548
549
550 /* See what argument we will pass to the split function and compute
551 call overhead. */
552 call_overhead = eni_size_weights.call_cost;
553 for (parm = DECL_ARGUMENTS (current_function_decl); parm;
554 parm = DECL_CHAIN (parm))
555 {
556 if (!is_gimple_reg (parm))
557 {
558 if (bitmap_bit_p (non_ssa_vars, DECL_UID (parm)))
559 {
560 if (dump_file && (dump_flags & TDF_DETAILS))
561 fprintf (dump_file,
562 " Refused: need to pass non-ssa param values\n");
563 return;
564 }
565 }
566 else
567 {
568 tree ddef = ssa_default_def (cfun, parm);
569 if (ddef
570 && bitmap_bit_p (current->ssa_names_to_pass,
571 SSA_NAME_VERSION (ddef)))
572 {
573 if (!VOID_TYPE_P (TREE_TYPE (parm)))
574 call_overhead += estimate_move_cost (TREE_TYPE (parm), false);
575 num_args++;
576 }
577 }
578 }
579 if (!VOID_TYPE_P (TREE_TYPE (current_function_decl)))
580 call_overhead += estimate_move_cost (TREE_TYPE (current_function_decl),
581 false);
582
583 if (current->split_size <= call_overhead)
584 {
585 if (dump_file && (dump_flags & TDF_DETAILS))
586 fprintf (dump_file,
587 " Refused: split size is smaller than call overhead\n");
588 return;
589 }
590 if (current->header_size + call_overhead
591 >= (unsigned int)(DECL_DECLARED_INLINE_P (current_function_decl)
592 ? MAX_INLINE_INSNS_SINGLE
593 : MAX_INLINE_INSNS_AUTO))
594 {
595 if (dump_file && (dump_flags & TDF_DETAILS))
596 fprintf (dump_file,
597 " Refused: header size is too large for inline candidate\n");
598 return;
599 }
600
38c0c85b
JM
601 /* Splitting functions brings the target out of comdat group; this will
602 lead to code duplication if the function is reused by other unit.
603 Limit this duplication. This is consistent with limit in tree-sra.c
604 FIXME: with LTO we ought to be able to do better! */
605 if (DECL_ONE_ONLY (current_function_decl)
606 && current->split_size >= (unsigned int) MAX_INLINE_INSNS_AUTO)
607 {
608 if (dump_file && (dump_flags & TDF_DETAILS))
609 fprintf (dump_file,
610 " Refused: function is COMDAT and tail is too large\n");
611 return;
612 }
613 /* For comdat functions also reject very small tails; those will likely get
614 inlined back and we do not want to risk the duplication overhead.
615 FIXME: with LTO we ought to be able to do better! */
616 if (DECL_ONE_ONLY (current_function_decl)
617 && current->split_size
618 <= (unsigned int) PARAM_VALUE (PARAM_EARLY_INLINING_INSNS) / 2)
619 {
620 if (dump_file && (dump_flags & TDF_DETAILS))
621 fprintf (dump_file,
622 " Refused: function is COMDAT and tail is too small\n");
623 return;
624 }
625
dda118e3
JM
626 /* FIXME: we currently can pass only SSA function parameters to the split
627 arguments. Once parm_adjustment infrastructure is supported by cloning,
628 we can pass more than that. */
629 if (num_args != bitmap_count_bits (current->ssa_names_to_pass))
630 {
631
632 if (dump_file && (dump_flags & TDF_DETAILS))
633 fprintf (dump_file,
634 " Refused: need to pass non-param values\n");
635 return;
636 }
637
638 /* When there are non-ssa vars used in the split region, see if they
639 are used in the header region. If so, reject the split.
640 FIXME: we can use nested function support to access both. */
641 if (!bitmap_empty_p (non_ssa_vars)
642 && !verify_non_ssa_vars (current, non_ssa_vars, return_bb))
643 {
644 if (dump_file && (dump_flags & TDF_DETAILS))
645 fprintf (dump_file,
646 " Refused: split part has non-ssa uses\n");
647 return;
648 }
649
650 /* If the split point is dominated by a forbidden block, reject
651 the split. */
652 if (!bitmap_empty_p (forbidden_dominators)
653 && dominated_by_forbidden (current->entry_bb))
654 {
655 if (dump_file && (dump_flags & TDF_DETAILS))
656 fprintf (dump_file,
657 " Refused: split point dominated by forbidden block\n");
658 return;
659 }
660
661 /* See if retval used by return bb is computed by header or split part.
662 When it is computed by split part, we need to produce return statement
663 in the split part and add code to header to pass it around.
664
665 This is bit tricky to test:
666 1) When there is no return_bb or no return value, we always pass
667 value around.
668 2) Invariants are always computed by caller.
669 3) For SSA we need to look if defining statement is in header or split part
670 4) For non-SSA we need to look where the var is computed. */
671 retval = find_retval (return_bb);
672 if (!retval)
673 current->split_part_set_retval = true;
674 else if (is_gimple_min_invariant (retval))
675 current->split_part_set_retval = false;
676 /* Special case is value returned by reference we record as if it was non-ssa
677 set to result_decl. */
678 else if (TREE_CODE (retval) == SSA_NAME
679 && SSA_NAME_VAR (retval)
680 && TREE_CODE (SSA_NAME_VAR (retval)) == RESULT_DECL
681 && DECL_BY_REFERENCE (DECL_RESULT (current_function_decl)))
682 current->split_part_set_retval
683 = bitmap_bit_p (non_ssa_vars, DECL_UID (SSA_NAME_VAR (retval)));
684 else if (TREE_CODE (retval) == SSA_NAME)
685 current->split_part_set_retval
686 = split_part_set_ssa_name_p (retval, current, return_bb);
687 else if (TREE_CODE (retval) == PARM_DECL)
688 current->split_part_set_retval = false;
689 else if (TREE_CODE (retval) == VAR_DECL
690 || TREE_CODE (retval) == RESULT_DECL)
691 current->split_part_set_retval
692 = bitmap_bit_p (non_ssa_vars, DECL_UID (retval));
693 else
694 current->split_part_set_retval = true;
695
696 /* See if retbnd used by return bb is computed by header or split part. */
697 retbnd = find_retbnd (return_bb);
698 if (retbnd)
699 {
700 bool split_part_set_retbnd
701 = split_part_set_ssa_name_p (retbnd, current, return_bb);
702
703 /* If we have both return value and bounds then keep their definitions
704 in a single function. We use SSA names to link returned bounds and
705 value and therefore do not handle cases when result is passed by
706 reference (which should not be our case anyway since bounds are
707 returned for pointers only). */
708 if ((DECL_BY_REFERENCE (DECL_RESULT (current_function_decl))
709 && current->split_part_set_retval)
710 || split_part_set_retbnd != current->split_part_set_retval)
711 {
712 if (dump_file && (dump_flags & TDF_DETAILS))
713 fprintf (dump_file,
714 " Refused: split point splits return value and bounds\n");
715 return;
716 }
717 }
718
719 /* split_function fixes up at most one PHI non-virtual PHI node in return_bb,
720 for the return value. If there are other PHIs, give up. */
721 if (return_bb != EXIT_BLOCK_PTR_FOR_FN (cfun))
722 {
723 gphi_iterator psi;
724
725 for (psi = gsi_start_phis (return_bb); !gsi_end_p (psi); gsi_next (&psi))
726 if (!virtual_operand_p (gimple_phi_result (psi.phi ()))
727 && !(retval
728 && current->split_part_set_retval
729 && TREE_CODE (retval) == SSA_NAME
730 && !DECL_BY_REFERENCE (DECL_RESULT (current_function_decl))
731 && SSA_NAME_DEF_STMT (retval) == psi.phi ()))
732 {
733 if (dump_file && (dump_flags & TDF_DETAILS))
734 fprintf (dump_file,
735 " Refused: return bb has extra PHIs\n");
736 return;
737 }
738 }
739
740 if (dump_file && (dump_flags & TDF_DETAILS))
741 fprintf (dump_file, " Accepted!\n");
742
743 /* At the moment chose split point with lowest frequency and that leaves
744 out smallest size of header.
745 In future we might re-consider this heuristics. */
746 if (!best_split_point.split_bbs
747 || best_split_point.entry_bb->frequency > current->entry_bb->frequency
748 || (best_split_point.entry_bb->frequency == current->entry_bb->frequency
749 && best_split_point.split_size < current->split_size))
750
751 {
752 if (dump_file && (dump_flags & TDF_DETAILS))
753 fprintf (dump_file, " New best split point!\n");
754 if (best_split_point.ssa_names_to_pass)
755 {
756 BITMAP_FREE (best_split_point.ssa_names_to_pass);
757 BITMAP_FREE (best_split_point.split_bbs);
758 }
759 best_split_point = *current;
760 best_split_point.ssa_names_to_pass = BITMAP_ALLOC (NULL);
761 bitmap_copy (best_split_point.ssa_names_to_pass,
762 current->ssa_names_to_pass);
763 best_split_point.split_bbs = BITMAP_ALLOC (NULL);
764 bitmap_copy (best_split_point.split_bbs, current->split_bbs);
765 }
766}
767
768/* Return basic block containing RETURN statement. We allow basic blocks
769 of the form:
770 <retval> = tmp_var;
771 return <retval>
38c0c85b
JM
772 but return_bb can not be more complex than this (except for
773 -fsanitize=thread we allow TSAN_FUNC_EXIT () internal call in there).
dda118e3
JM
774 If nothing is found, return the exit block.
775
776 When there are multiple RETURN statement, chose one with return value,
777 since that one is more likely shared by multiple code paths.
778
779 Return BB is special, because for function splitting it is the only
780 basic block that is duplicated in between header and split part of the
781 function.
782
783 TODO: We might support multiple return blocks. */
784
785static basic_block
786find_return_bb (void)
787{
788 edge e;
789 basic_block return_bb = EXIT_BLOCK_PTR_FOR_FN (cfun);
790 gimple_stmt_iterator bsi;
791 bool found_return = false;
792 tree retval = NULL_TREE;
793
794 if (!single_pred_p (EXIT_BLOCK_PTR_FOR_FN (cfun)))
795 return return_bb;
796
797 e = single_pred_edge (EXIT_BLOCK_PTR_FOR_FN (cfun));
798 for (bsi = gsi_last_bb (e->src); !gsi_end_p (bsi); gsi_prev (&bsi))
799 {
800 gimple stmt = gsi_stmt (bsi);
801 if (gimple_code (stmt) == GIMPLE_LABEL
802 || is_gimple_debug (stmt)
803 || gimple_clobber_p (stmt))
804 ;
805 else if (gimple_code (stmt) == GIMPLE_ASSIGN
806 && found_return
807 && gimple_assign_single_p (stmt)
808 && (auto_var_in_fn_p (gimple_assign_rhs1 (stmt),
809 current_function_decl)
810 || is_gimple_min_invariant (gimple_assign_rhs1 (stmt)))
811 && retval == gimple_assign_lhs (stmt))
812 ;
813 else if (greturn *return_stmt = dyn_cast <greturn *> (stmt))
814 {
815 found_return = true;
816 retval = gimple_return_retval (return_stmt);
817 }
38c0c85b
JM
818 /* For -fsanitize=thread, allow also TSAN_FUNC_EXIT () in the return
819 bb. */
820 else if ((flag_sanitize & SANITIZE_THREAD)
821 && is_gimple_call (stmt)
822 && gimple_call_internal_p (stmt)
823 && gimple_call_internal_fn (stmt) == IFN_TSAN_FUNC_EXIT)
824 ;
dda118e3
JM
825 else
826 break;
827 }
828 if (gsi_end_p (bsi) && found_return)
829 return_bb = e->src;
830
831 return return_bb;
832}
833
834/* Given return basic block RETURN_BB, see where return value is really
835 stored. */
836static tree
837find_retval (basic_block return_bb)
838{
839 gimple_stmt_iterator bsi;
840 for (bsi = gsi_start_bb (return_bb); !gsi_end_p (bsi); gsi_next (&bsi))
841 if (greturn *return_stmt = dyn_cast <greturn *> (gsi_stmt (bsi)))
842 return gimple_return_retval (return_stmt);
843 else if (gimple_code (gsi_stmt (bsi)) == GIMPLE_ASSIGN
844 && !gimple_clobber_p (gsi_stmt (bsi)))
845 return gimple_assign_rhs1 (gsi_stmt (bsi));
846 return NULL;
847}
848
849/* Given return basic block RETURN_BB, see where return bounds are really
850 stored. */
851static tree
852find_retbnd (basic_block return_bb)
853{
854 gimple_stmt_iterator bsi;
855 for (bsi = gsi_last_bb (return_bb); !gsi_end_p (bsi); gsi_prev (&bsi))
856 if (gimple_code (gsi_stmt (bsi)) == GIMPLE_RETURN)
857 return gimple_return_retbnd (gsi_stmt (bsi));
858 return NULL;
859}
860
861/* Callback for walk_stmt_load_store_addr_ops. If T is non-SSA automatic
862 variable, mark it as used in bitmap passed via DATA.
863 Return true when access to T prevents splitting the function. */
864
865static bool
866mark_nonssa_use (gimple, tree t, tree, void *data)
867{
868 t = get_base_address (t);
869
870 if (!t || is_gimple_reg (t))
871 return false;
872
873 /* At present we can't pass non-SSA arguments to split function.
874 FIXME: this can be relaxed by passing references to arguments. */
875 if (TREE_CODE (t) == PARM_DECL)
876 {
877 if (dump_file && (dump_flags & TDF_DETAILS))
878 fprintf (dump_file,
879 "Cannot split: use of non-ssa function parameter.\n");
880 return true;
881 }
882
883 if ((TREE_CODE (t) == VAR_DECL
884 && auto_var_in_fn_p (t, current_function_decl))
885 || TREE_CODE (t) == RESULT_DECL
886 || (TREE_CODE (t) == LABEL_DECL
887 && FORCED_LABEL (t)))
888 bitmap_set_bit ((bitmap)data, DECL_UID (t));
889
890 /* For DECL_BY_REFERENCE, the return value is actually a pointer. We want
891 to pretend that the value pointed to is actual result decl. */
892 if ((TREE_CODE (t) == MEM_REF || INDIRECT_REF_P (t))
893 && TREE_CODE (TREE_OPERAND (t, 0)) == SSA_NAME
894 && SSA_NAME_VAR (TREE_OPERAND (t, 0))
895 && TREE_CODE (SSA_NAME_VAR (TREE_OPERAND (t, 0))) == RESULT_DECL
896 && DECL_BY_REFERENCE (DECL_RESULT (current_function_decl)))
897 return
898 bitmap_bit_p ((bitmap)data,
899 DECL_UID (DECL_RESULT (current_function_decl)));
900
901 return false;
902}
903
904/* Compute local properties of basic block BB we collect when looking for
905 split points. We look for ssa defs and store them in SET_SSA_NAMES,
906 for ssa uses and store them in USED_SSA_NAMES and for any non-SSA automatic
907 vars stored in NON_SSA_VARS.
908
909 When BB has edge to RETURN_BB, collect uses in RETURN_BB too.
910
911 Return false when BB contains something that prevents it from being put into
912 split function. */
913
914static bool
915visit_bb (basic_block bb, basic_block return_bb,
916 bitmap set_ssa_names, bitmap used_ssa_names,
917 bitmap non_ssa_vars)
918{
919 edge e;
920 edge_iterator ei;
921 bool can_split = true;
922
923 for (gimple_stmt_iterator bsi = gsi_start_bb (bb); !gsi_end_p (bsi);
924 gsi_next (&bsi))
925 {
926 gimple stmt = gsi_stmt (bsi);
927 tree op;
928 ssa_op_iter iter;
929 tree decl;
930
931 if (is_gimple_debug (stmt))
932 continue;
933
934 if (gimple_clobber_p (stmt))
935 continue;
936
937 /* FIXME: We can split regions containing EH. We can not however
938 split RESX, EH_DISPATCH and EH_POINTER referring to same region
939 into different partitions. This would require tracking of
940 EH regions and checking in consider_split_point if they
941 are not used elsewhere. */
942 if (gimple_code (stmt) == GIMPLE_RESX)
943 {
944 if (dump_file && (dump_flags & TDF_DETAILS))
945 fprintf (dump_file, "Cannot split: resx.\n");
946 can_split = false;
947 }
948 if (gimple_code (stmt) == GIMPLE_EH_DISPATCH)
949 {
950 if (dump_file && (dump_flags & TDF_DETAILS))
951 fprintf (dump_file, "Cannot split: eh dispatch.\n");
952 can_split = false;
953 }
954
955 /* Check builtins that prevent splitting. */
956 if (gimple_code (stmt) == GIMPLE_CALL
957 && (decl = gimple_call_fndecl (stmt)) != NULL_TREE
958 && DECL_BUILT_IN (decl)
959 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
960 switch (DECL_FUNCTION_CODE (decl))
961 {
962 /* FIXME: once we will allow passing non-parm values to split part,
963 we need to be sure to handle correct builtin_stack_save and
964 builtin_stack_restore. At the moment we are safe; there is no
965 way to store builtin_stack_save result in non-SSA variable
966 since all calls to those are compiler generated. */
967 case BUILT_IN_APPLY:
968 case BUILT_IN_APPLY_ARGS:
969 case BUILT_IN_VA_START:
970 if (dump_file && (dump_flags & TDF_DETAILS))
971 fprintf (dump_file,
972 "Cannot split: builtin_apply and va_start.\n");
973 can_split = false;
974 break;
975 case BUILT_IN_EH_POINTER:
976 if (dump_file && (dump_flags & TDF_DETAILS))
977 fprintf (dump_file, "Cannot split: builtin_eh_pointer.\n");
978 can_split = false;
979 break;
980 default:
981 break;
982 }
983
984 FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_DEF)
985 bitmap_set_bit (set_ssa_names, SSA_NAME_VERSION (op));
986 FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
987 bitmap_set_bit (used_ssa_names, SSA_NAME_VERSION (op));
988 can_split &= !walk_stmt_load_store_addr_ops (stmt, non_ssa_vars,
989 mark_nonssa_use,
990 mark_nonssa_use,
991 mark_nonssa_use);
992 }
993 for (gphi_iterator bsi = gsi_start_phis (bb); !gsi_end_p (bsi);
994 gsi_next (&bsi))
995 {
996 gphi *stmt = bsi.phi ();
997 unsigned int i;
998
999 if (virtual_operand_p (gimple_phi_result (stmt)))
1000 continue;
1001 bitmap_set_bit (set_ssa_names,
1002 SSA_NAME_VERSION (gimple_phi_result (stmt)));
1003 for (i = 0; i < gimple_phi_num_args (stmt); i++)
1004 {
1005 tree op = gimple_phi_arg_def (stmt, i);
1006 if (TREE_CODE (op) == SSA_NAME)
1007 bitmap_set_bit (used_ssa_names, SSA_NAME_VERSION (op));
1008 }
1009 can_split &= !walk_stmt_load_store_addr_ops (stmt, non_ssa_vars,
1010 mark_nonssa_use,
1011 mark_nonssa_use,
1012 mark_nonssa_use);
1013 }
1014 /* Record also uses coming from PHI operand in return BB. */
1015 FOR_EACH_EDGE (e, ei, bb->succs)
1016 if (e->dest == return_bb)
1017 {
1018 for (gphi_iterator bsi = gsi_start_phis (return_bb);
1019 !gsi_end_p (bsi);
1020 gsi_next (&bsi))
1021 {
1022 gphi *stmt = bsi.phi ();
1023 tree op = gimple_phi_arg_def (stmt, e->dest_idx);
1024
1025 if (virtual_operand_p (gimple_phi_result (stmt)))
1026 continue;
1027 if (TREE_CODE (op) == SSA_NAME)
1028 bitmap_set_bit (used_ssa_names, SSA_NAME_VERSION (op));
1029 else
1030 can_split &= !mark_nonssa_use (stmt, op, op, non_ssa_vars);
1031 }
1032 }
1033 return can_split;
1034}
1035
1036/* Stack entry for recursive DFS walk in find_split_point. */
1037
1038typedef struct
1039{
1040 /* Basic block we are examining. */
1041 basic_block bb;
1042
1043 /* SSA names set and used by the BB and all BBs reachable
1044 from it via DFS walk. */
1045 bitmap set_ssa_names, used_ssa_names;
1046 bitmap non_ssa_vars;
1047
1048 /* All BBS visited from this BB via DFS walk. */
1049 bitmap bbs_visited;
1050
1051 /* Last examined edge in DFS walk. Since we walk unoriented graph,
1052 the value is up to sum of incoming and outgoing edges of BB. */
1053 unsigned int edge_num;
1054
1055 /* Stack entry index of earliest BB reachable from current BB
1056 or any BB visited later in DFS walk. */
1057 int earliest;
1058
1059 /* Overall time and size of all BBs reached from this BB in DFS walk. */
1060 int overall_time, overall_size;
1061
1062 /* When false we can not split on this BB. */
1063 bool can_split;
1064} stack_entry;
1065
1066
1067/* Find all articulations and call consider_split on them.
1068 OVERALL_TIME and OVERALL_SIZE is time and size of the function.
1069
1070 We perform basic algorithm for finding an articulation in a graph
1071 created from CFG by considering it to be an unoriented graph.
1072
1073 The articulation is discovered via DFS walk. We collect earliest
1074 basic block on stack that is reachable via backward edge. Articulation
1075 is any basic block such that there is no backward edge bypassing it.
1076 To reduce stack usage we maintain heap allocated stack in STACK vector.
1077 AUX pointer of BB is set to index it appears in the stack or -1 once
1078 it is visited and popped off the stack.
1079
1080 The algorithm finds articulation after visiting the whole component
1081 reachable by it. This makes it convenient to collect information about
1082 the component used by consider_split. */
1083
1084static void
38c0c85b 1085find_split_points (basic_block return_bb, int overall_time, int overall_size)
dda118e3
JM
1086{
1087 stack_entry first;
1088 vec<stack_entry> stack = vNULL;
1089 basic_block bb;
dda118e3
JM
1090 struct split_point current;
1091
1092 current.header_time = overall_time;
1093 current.header_size = overall_size;
1094 current.split_time = 0;
1095 current.split_size = 0;
1096 current.ssa_names_to_pass = BITMAP_ALLOC (NULL);
1097
1098 first.bb = ENTRY_BLOCK_PTR_FOR_FN (cfun);
1099 first.edge_num = 0;
1100 first.overall_time = 0;
1101 first.overall_size = 0;
1102 first.earliest = INT_MAX;
1103 first.set_ssa_names = 0;
1104 first.used_ssa_names = 0;
1105 first.non_ssa_vars = 0;
1106 first.bbs_visited = 0;
1107 first.can_split = false;
1108 stack.safe_push (first);
1109 ENTRY_BLOCK_PTR_FOR_FN (cfun)->aux = (void *)(intptr_t)-1;
1110
1111 while (!stack.is_empty ())
1112 {
1113 stack_entry *entry = &stack.last ();
1114
1115 /* We are walking an acyclic graph, so edge_num counts
1116 succ and pred edges together. However when considering
1117 articulation, we want to have processed everything reachable
1118 from articulation but nothing that reaches into it. */
1119 if (entry->edge_num == EDGE_COUNT (entry->bb->succs)
1120 && entry->bb != ENTRY_BLOCK_PTR_FOR_FN (cfun))
1121 {
1122 int pos = stack.length ();
1123 entry->can_split &= visit_bb (entry->bb, return_bb,
1124 entry->set_ssa_names,
1125 entry->used_ssa_names,
1126 entry->non_ssa_vars);
1127 if (pos <= entry->earliest && !entry->can_split
1128 && dump_file && (dump_flags & TDF_DETAILS))
1129 fprintf (dump_file,
1130 "found articulation at bb %i but can not split\n",
1131 entry->bb->index);
1132 if (pos <= entry->earliest && entry->can_split)
1133 {
1134 if (dump_file && (dump_flags & TDF_DETAILS))
1135 fprintf (dump_file, "found articulation at bb %i\n",
1136 entry->bb->index);
1137 current.entry_bb = entry->bb;
1138 current.ssa_names_to_pass = BITMAP_ALLOC (NULL);
1139 bitmap_and_compl (current.ssa_names_to_pass,
1140 entry->used_ssa_names, entry->set_ssa_names);
1141 current.header_time = overall_time - entry->overall_time;
1142 current.header_size = overall_size - entry->overall_size;
1143 current.split_time = entry->overall_time;
1144 current.split_size = entry->overall_size;
1145 current.split_bbs = entry->bbs_visited;
1146 consider_split (&current, entry->non_ssa_vars, return_bb);
1147 BITMAP_FREE (current.ssa_names_to_pass);
1148 }
1149 }
1150 /* Do actual DFS walk. */
1151 if (entry->edge_num
1152 < (EDGE_COUNT (entry->bb->succs)
1153 + EDGE_COUNT (entry->bb->preds)))
1154 {
1155 edge e;
1156 basic_block dest;
1157 if (entry->edge_num < EDGE_COUNT (entry->bb->succs))
1158 {
1159 e = EDGE_SUCC (entry->bb, entry->edge_num);
1160 dest = e->dest;
1161 }
1162 else
1163 {
1164 e = EDGE_PRED (entry->bb, entry->edge_num
1165 - EDGE_COUNT (entry->bb->succs));
1166 dest = e->src;
1167 }
1168
1169 entry->edge_num++;
1170
1171 /* New BB to visit, push it to the stack. */
1172 if (dest != return_bb && dest != EXIT_BLOCK_PTR_FOR_FN (cfun)
1173 && !dest->aux)
1174 {
1175 stack_entry new_entry;
1176
1177 new_entry.bb = dest;
1178 new_entry.edge_num = 0;
1179 new_entry.overall_time
1180 = bb_info_vec[dest->index].time;
1181 new_entry.overall_size
1182 = bb_info_vec[dest->index].size;
1183 new_entry.earliest = INT_MAX;
1184 new_entry.set_ssa_names = BITMAP_ALLOC (NULL);
1185 new_entry.used_ssa_names = BITMAP_ALLOC (NULL);
1186 new_entry.bbs_visited = BITMAP_ALLOC (NULL);
1187 new_entry.non_ssa_vars = BITMAP_ALLOC (NULL);
1188 new_entry.can_split = true;
1189 bitmap_set_bit (new_entry.bbs_visited, dest->index);
1190 stack.safe_push (new_entry);
1191 dest->aux = (void *)(intptr_t)stack.length ();
1192 }
1193 /* Back edge found, record the earliest point. */
1194 else if ((intptr_t)dest->aux > 0
1195 && (intptr_t)dest->aux < entry->earliest)
1196 entry->earliest = (intptr_t)dest->aux;
1197 }
1198 /* We are done with examining the edges. Pop off the value from stack
1199 and merge stuff we accumulate during the walk. */
1200 else if (entry->bb != ENTRY_BLOCK_PTR_FOR_FN (cfun))
1201 {
1202 stack_entry *prev = &stack[stack.length () - 2];
1203
1204 entry->bb->aux = (void *)(intptr_t)-1;
1205 prev->can_split &= entry->can_split;
1206 if (prev->set_ssa_names)
1207 {
1208 bitmap_ior_into (prev->set_ssa_names, entry->set_ssa_names);
1209 bitmap_ior_into (prev->used_ssa_names, entry->used_ssa_names);
1210 bitmap_ior_into (prev->bbs_visited, entry->bbs_visited);
1211 bitmap_ior_into (prev->non_ssa_vars, entry->non_ssa_vars);
1212 }
1213 if (prev->earliest > entry->earliest)
1214 prev->earliest = entry->earliest;
1215 prev->overall_time += entry->overall_time;
1216 prev->overall_size += entry->overall_size;
1217 BITMAP_FREE (entry->set_ssa_names);
1218 BITMAP_FREE (entry->used_ssa_names);
1219 BITMAP_FREE (entry->bbs_visited);
1220 BITMAP_FREE (entry->non_ssa_vars);
1221 stack.pop ();
1222 }
1223 else
1224 stack.pop ();
1225 }
1226 ENTRY_BLOCK_PTR_FOR_FN (cfun)->aux = NULL;
1227 FOR_EACH_BB_FN (bb, cfun)
1228 bb->aux = NULL;
1229 stack.release ();
1230 BITMAP_FREE (current.ssa_names_to_pass);
1231}
1232
1233/* Build and insert initialization of returned bounds RETBND
1234 for returned value RETVAL. Statements are inserted after
1235 a statement pointed by GSI and GSI is modified to point to
1236 the last inserted statement. */
1237
1238static void
1239insert_bndret_call_after (tree retbnd, tree retval, gimple_stmt_iterator *gsi)
1240{
1241 tree fndecl = targetm.builtin_chkp_function (BUILT_IN_CHKP_BNDRET);
1242 gimple bndret = gimple_build_call (fndecl, 1, retval);
1243 gimple_call_set_lhs (bndret, retbnd);
1244 gsi_insert_after (gsi, bndret, GSI_CONTINUE_LINKING);
1245}
38c0c85b 1246
dda118e3
JM
1247/* Split function at SPLIT_POINT. */
1248
1249static void
38c0c85b
JM
1250split_function (basic_block return_bb, struct split_point *split_point,
1251 bool add_tsan_func_exit)
dda118e3
JM
1252{
1253 vec<tree> args_to_pass = vNULL;
1254 bitmap args_to_skip;
1255 tree parm;
1256 int num = 0;
1257 cgraph_node *node, *cur_node = cgraph_node::get (current_function_decl);
dda118e3 1258 basic_block call_bb;
38c0c85b 1259 gcall *call, *tsan_func_exit_call = NULL;
dda118e3
JM
1260 edge e;
1261 edge_iterator ei;
1262 tree retval = NULL, real_retval = NULL, retbnd = NULL;
1263 bool split_part_return_p = false;
1264 bool with_bounds = chkp_function_instrumented_p (current_function_decl);
1265 gimple last_stmt = NULL;
1266 unsigned int i;
1267 tree arg, ddef;
1268 vec<tree, va_gc> **debug_args = NULL;
1269
1270 if (dump_file)
1271 {
1272 fprintf (dump_file, "\n\nSplitting function at:\n");
1273 dump_split_point (dump_file, split_point);
1274 }
1275
1276 if (cur_node->local.can_change_signature)
1277 args_to_skip = BITMAP_ALLOC (NULL);
1278 else
1279 args_to_skip = NULL;
1280
1281 /* Collect the parameters of new function and args_to_skip bitmap. */
1282 for (parm = DECL_ARGUMENTS (current_function_decl);
1283 parm; parm = DECL_CHAIN (parm), num++)
1284 if (args_to_skip
1285 && (!is_gimple_reg (parm)
1286 || (ddef = ssa_default_def (cfun, parm)) == NULL_TREE
1287 || !bitmap_bit_p (split_point->ssa_names_to_pass,
1288 SSA_NAME_VERSION (ddef))))
1289 bitmap_set_bit (args_to_skip, num);
1290 else
1291 {
1292 /* This parm might not have been used up to now, but is going to be
1293 used, hence register it. */
1294 if (is_gimple_reg (parm))
1295 arg = get_or_create_ssa_default_def (cfun, parm);
1296 else
1297 arg = parm;
1298
1299 if (!useless_type_conversion_p (DECL_ARG_TYPE (parm), TREE_TYPE (arg)))
1300 arg = fold_convert (DECL_ARG_TYPE (parm), arg);
1301 args_to_pass.safe_push (arg);
1302 }
1303
1304 /* See if the split function will return. */
1305 FOR_EACH_EDGE (e, ei, return_bb->preds)
1306 if (bitmap_bit_p (split_point->split_bbs, e->src->index))
1307 break;
1308 if (e)
1309 split_part_return_p = true;
1310
1311 /* Add return block to what will become the split function.
1312 We do not return; no return block is needed. */
1313 if (!split_part_return_p)
1314 ;
1315 /* We have no return block, so nothing is needed. */
1316 else if (return_bb == EXIT_BLOCK_PTR_FOR_FN (cfun))
1317 ;
1318 /* When we do not want to return value, we need to construct
1319 new return block with empty return statement.
1320 FIXME: Once we are able to change return type, we should change function
1321 to return void instead of just outputting function with undefined return
1322 value. For structures this affects quality of codegen. */
1323 else if (!split_point->split_part_set_retval
1324 && find_retval (return_bb))
1325 {
1326 bool redirected = true;
1327 basic_block new_return_bb = create_basic_block (NULL, 0, return_bb);
1328 gimple_stmt_iterator gsi = gsi_start_bb (new_return_bb);
1329 gsi_insert_after (&gsi, gimple_build_return (NULL), GSI_NEW_STMT);
1330 while (redirected)
1331 {
1332 redirected = false;
1333 FOR_EACH_EDGE (e, ei, return_bb->preds)
1334 if (bitmap_bit_p (split_point->split_bbs, e->src->index))
1335 {
1336 new_return_bb->count += e->count;
1337 new_return_bb->frequency += EDGE_FREQUENCY (e);
1338 redirect_edge_and_branch (e, new_return_bb);
1339 redirected = true;
1340 break;
1341 }
1342 }
1343 e = make_edge (new_return_bb, EXIT_BLOCK_PTR_FOR_FN (cfun), 0);
1344 e->probability = REG_BR_PROB_BASE;
1345 e->count = new_return_bb->count;
1346 add_bb_to_loop (new_return_bb, current_loops->tree_root);
1347 bitmap_set_bit (split_point->split_bbs, new_return_bb->index);
1348 }
1349 /* When we pass around the value, use existing return block. */
1350 else
1351 bitmap_set_bit (split_point->split_bbs, return_bb->index);
1352
1353 /* If RETURN_BB has virtual operand PHIs, they must be removed and the
1354 virtual operand marked for renaming as we change the CFG in a way that
1355 tree-inline is not able to compensate for.
1356
1357 Note this can happen whether or not we have a return value. If we have
1358 a return value, then RETURN_BB may have PHIs for real operands too. */
1359 if (return_bb != EXIT_BLOCK_PTR_FOR_FN (cfun))
1360 {
1361 bool phi_p = false;
1362 for (gphi_iterator gsi = gsi_start_phis (return_bb);
1363 !gsi_end_p (gsi);)
1364 {
1365 gphi *stmt = gsi.phi ();
1366 if (!virtual_operand_p (gimple_phi_result (stmt)))
1367 {
1368 gsi_next (&gsi);
1369 continue;
1370 }
1371 mark_virtual_phi_result_for_renaming (stmt);
1372 remove_phi_node (&gsi, true);
1373 phi_p = true;
1374 }
1375 /* In reality we have to rename the reaching definition of the
1376 virtual operand at return_bb as we will eventually release it
1377 when we remove the code region we outlined.
1378 So we have to rename all immediate virtual uses of that region
1379 if we didn't see a PHI definition yet. */
1380 /* ??? In real reality we want to set the reaching vdef of the
1381 entry of the SESE region as the vuse of the call and the reaching
1382 vdef of the exit of the SESE region as the vdef of the call. */
1383 if (!phi_p)
1384 for (gimple_stmt_iterator gsi = gsi_start_bb (return_bb);
1385 !gsi_end_p (gsi);
1386 gsi_next (&gsi))
1387 {
1388 gimple stmt = gsi_stmt (gsi);
1389 if (gimple_vuse (stmt))
1390 {
1391 gimple_set_vuse (stmt, NULL_TREE);
1392 update_stmt (stmt);
1393 }
1394 if (gimple_vdef (stmt))
1395 break;
1396 }
1397 }
1398
1399 /* Now create the actual clone. */
1400 cgraph_edge::rebuild_edges ();
1401 node = cur_node->create_version_clone_with_body
1402 (vNULL, NULL, args_to_skip, !split_part_return_p, split_point->split_bbs,
1403 split_point->entry_bb, "part");
1404
1405 /* Let's take a time profile for splitted function. */
1406 node->tp_first_run = cur_node->tp_first_run + 1;
1407
1408 /* For usual cloning it is enough to clear builtin only when signature
1409 changes. For partial inlining we however can not expect the part
1410 of builtin implementation to have same semantic as the whole. */
1411 if (DECL_BUILT_IN (node->decl))
1412 {
1413 DECL_BUILT_IN_CLASS (node->decl) = NOT_BUILT_IN;
1414 DECL_FUNCTION_CODE (node->decl) = (enum built_in_function) 0;
1415 }
1416
1417 /* If the original function is instrumented then it's
1418 part is also instrumented. */
1419 if (with_bounds)
1420 chkp_function_mark_instrumented (node->decl);
1421
1422 /* If the original function is declared inline, there is no point in issuing
1423 a warning for the non-inlinable part. */
1424 DECL_NO_INLINE_WARNING_P (node->decl) = 1;
1425 cur_node->remove_callees ();
1426 cur_node->remove_all_references ();
1427 if (!split_part_return_p)
1428 TREE_THIS_VOLATILE (node->decl) = 1;
1429 if (dump_file)
1430 dump_function_to_file (node->decl, dump_file, dump_flags);
1431
1432 /* Create the basic block we place call into. It is the entry basic block
1433 split after last label. */
1434 call_bb = split_point->entry_bb;
1435 for (gimple_stmt_iterator gsi = gsi_start_bb (call_bb); !gsi_end_p (gsi);)
1436 if (gimple_code (gsi_stmt (gsi)) == GIMPLE_LABEL)
1437 {
1438 last_stmt = gsi_stmt (gsi);
1439 gsi_next (&gsi);
1440 }
1441 else
1442 break;
1443 e = split_block (split_point->entry_bb, last_stmt);
1444 remove_edge (e);
1445
1446 /* Produce the call statement. */
1447 gimple_stmt_iterator gsi = gsi_last_bb (call_bb);
1448 FOR_EACH_VEC_ELT (args_to_pass, i, arg)
1449 if (!is_gimple_val (arg))
1450 {
1451 arg = force_gimple_operand_gsi (&gsi, arg, true, NULL_TREE,
1452 false, GSI_CONTINUE_LINKING);
1453 args_to_pass[i] = arg;
1454 }
1455 call = gimple_build_call_vec (node->decl, args_to_pass);
1456 gimple_call_set_with_bounds (call, with_bounds);
1457 gimple_set_block (call, DECL_INITIAL (current_function_decl));
1458 args_to_pass.release ();
1459
1460 /* For optimized away parameters, add on the caller side
1461 before the call
1462 DEBUG D#X => parm_Y(D)
1463 stmts and associate D#X with parm in decl_debug_args_lookup
1464 vector to say for debug info that if parameter parm had been passed,
1465 it would have value parm_Y(D). */
1466 if (args_to_skip)
1467 for (parm = DECL_ARGUMENTS (current_function_decl), num = 0;
1468 parm; parm = DECL_CHAIN (parm), num++)
1469 if (bitmap_bit_p (args_to_skip, num)
1470 && is_gimple_reg (parm))
1471 {
1472 tree ddecl;
1473 gimple def_temp;
1474
1475 /* This needs to be done even without MAY_HAVE_DEBUG_STMTS,
1476 otherwise if it didn't exist before, we'd end up with
1477 different SSA_NAME_VERSIONs between -g and -g0. */
1478 arg = get_or_create_ssa_default_def (cfun, parm);
1479 if (!MAY_HAVE_DEBUG_STMTS)
1480 continue;
1481
1482 if (debug_args == NULL)
1483 debug_args = decl_debug_args_insert (node->decl);
1484 ddecl = make_node (DEBUG_EXPR_DECL);
1485 DECL_ARTIFICIAL (ddecl) = 1;
1486 TREE_TYPE (ddecl) = TREE_TYPE (parm);
1487 DECL_MODE (ddecl) = DECL_MODE (parm);
1488 vec_safe_push (*debug_args, DECL_ORIGIN (parm));
1489 vec_safe_push (*debug_args, ddecl);
1490 def_temp = gimple_build_debug_bind (ddecl, unshare_expr (arg),
1491 call);
1492 gsi_insert_after (&gsi, def_temp, GSI_NEW_STMT);
1493 }
1494 /* And on the callee side, add
1495 DEBUG D#Y s=> parm
1496 DEBUG var => D#Y
1497 stmts to the first bb where var is a VAR_DECL created for the
1498 optimized away parameter in DECL_INITIAL block. This hints
1499 in the debug info that var (whole DECL_ORIGIN is the parm PARM_DECL)
1500 is optimized away, but could be looked up at the call site
1501 as value of D#X there. */
1502 if (debug_args != NULL)
1503 {
1504 unsigned int i;
1505 tree var, vexpr;
1506 gimple_stmt_iterator cgsi;
1507 gimple def_temp;
1508
1509 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
1510 var = BLOCK_VARS (DECL_INITIAL (node->decl));
1511 i = vec_safe_length (*debug_args);
1512 cgsi = gsi_after_labels (single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun)));
1513 do
1514 {
1515 i -= 2;
1516 while (var != NULL_TREE
1517 && DECL_ABSTRACT_ORIGIN (var) != (**debug_args)[i])
1518 var = TREE_CHAIN (var);
1519 if (var == NULL_TREE)
1520 break;
1521 vexpr = make_node (DEBUG_EXPR_DECL);
1522 parm = (**debug_args)[i];
1523 DECL_ARTIFICIAL (vexpr) = 1;
1524 TREE_TYPE (vexpr) = TREE_TYPE (parm);
1525 DECL_MODE (vexpr) = DECL_MODE (parm);
1526 def_temp = gimple_build_debug_source_bind (vexpr, parm,
1527 NULL);
1528 gsi_insert_before (&cgsi, def_temp, GSI_SAME_STMT);
1529 def_temp = gimple_build_debug_bind (var, vexpr, NULL);
1530 gsi_insert_before (&cgsi, def_temp, GSI_SAME_STMT);
1531 }
1532 while (i);
1533 pop_cfun ();
1534 }
1535
1536 /* We avoid address being taken on any variable used by split part,
1537 so return slot optimization is always possible. Moreover this is
1538 required to make DECL_BY_REFERENCE work. */
1539 if (aggregate_value_p (DECL_RESULT (current_function_decl),
1540 TREE_TYPE (current_function_decl))
1541 && (!is_gimple_reg_type (TREE_TYPE (DECL_RESULT (current_function_decl)))
1542 || DECL_BY_REFERENCE (DECL_RESULT (current_function_decl))))
1543 gimple_call_set_return_slot_opt (call, true);
1544
38c0c85b
JM
1545 if (add_tsan_func_exit)
1546 tsan_func_exit_call = gimple_build_call_internal (IFN_TSAN_FUNC_EXIT, 0);
1547
dda118e3
JM
1548 /* Update return value. This is bit tricky. When we do not return,
1549 do nothing. When we return we might need to update return_bb
1550 or produce a new return statement. */
1551 if (!split_part_return_p)
38c0c85b
JM
1552 {
1553 gsi_insert_after (&gsi, call, GSI_NEW_STMT);
1554 if (tsan_func_exit_call)
1555 gsi_insert_after (&gsi, tsan_func_exit_call, GSI_NEW_STMT);
1556 }
dda118e3
JM
1557 else
1558 {
1559 e = make_edge (call_bb, return_bb,
1560 return_bb == EXIT_BLOCK_PTR_FOR_FN (cfun)
1561 ? 0 : EDGE_FALLTHRU);
1562 e->count = call_bb->count;
1563 e->probability = REG_BR_PROB_BASE;
1564
1565 /* If there is return basic block, see what value we need to store
1566 return value into and put call just before it. */
1567 if (return_bb != EXIT_BLOCK_PTR_FOR_FN (cfun))
1568 {
1569 real_retval = retval = find_retval (return_bb);
1570 retbnd = find_retbnd (return_bb);
1571
1572 if (real_retval && split_point->split_part_set_retval)
1573 {
1574 gphi_iterator psi;
1575
1576 /* See if we need new SSA_NAME for the result.
1577 When DECL_BY_REFERENCE is true, retval is actually pointer to
1578 return value and it is constant in whole function. */
1579 if (TREE_CODE (retval) == SSA_NAME
1580 && !DECL_BY_REFERENCE (DECL_RESULT (current_function_decl)))
1581 {
1582 retval = copy_ssa_name (retval, call);
1583
1584 /* See if there is PHI defining return value. */
1585 for (psi = gsi_start_phis (return_bb);
1586 !gsi_end_p (psi); gsi_next (&psi))
1587 if (!virtual_operand_p (gimple_phi_result (psi.phi ())))
1588 break;
1589
1590 /* When there is PHI, just update its value. */
1591 if (TREE_CODE (retval) == SSA_NAME
1592 && !gsi_end_p (psi))
1593 add_phi_arg (psi.phi (), retval, e, UNKNOWN_LOCATION);
1594 /* Otherwise update the return BB itself.
1595 find_return_bb allows at most one assignment to return value,
1596 so update first statement. */
1597 else
1598 {
1599 gimple_stmt_iterator bsi;
1600 for (bsi = gsi_start_bb (return_bb); !gsi_end_p (bsi);
1601 gsi_next (&bsi))
1602 if (greturn *return_stmt
1603 = dyn_cast <greturn *> (gsi_stmt (bsi)))
1604 {
1605 gimple_return_set_retval (return_stmt, retval);
1606 break;
1607 }
1608 else if (gimple_code (gsi_stmt (bsi)) == GIMPLE_ASSIGN
1609 && !gimple_clobber_p (gsi_stmt (bsi)))
1610 {
1611 gimple_assign_set_rhs1 (gsi_stmt (bsi), retval);
1612 break;
1613 }
1614 update_stmt (gsi_stmt (bsi));
1615 }
1616
1617 /* Replace retbnd with new one. */
1618 if (retbnd)
1619 {
1620 gimple_stmt_iterator bsi;
1621 for (bsi = gsi_last_bb (return_bb); !gsi_end_p (bsi);
1622 gsi_prev (&bsi))
1623 if (gimple_code (gsi_stmt (bsi)) == GIMPLE_RETURN)
1624 {
1625 retbnd = copy_ssa_name (retbnd, call);
1626 gimple_return_set_retbnd (gsi_stmt (bsi), retbnd);
1627 update_stmt (gsi_stmt (bsi));
1628 break;
1629 }
1630 }
1631 }
1632 if (DECL_BY_REFERENCE (DECL_RESULT (current_function_decl)))
1633 {
1634 gimple_call_set_lhs (call, build_simple_mem_ref (retval));
1635 gsi_insert_after (&gsi, call, GSI_NEW_STMT);
1636 }
1637 else
1638 {
1639 tree restype;
1640 restype = TREE_TYPE (DECL_RESULT (current_function_decl));
1641 gsi_insert_after (&gsi, call, GSI_NEW_STMT);
1642 if (!useless_type_conversion_p (TREE_TYPE (retval), restype))
1643 {
1644 gimple cpy;
1645 tree tem = create_tmp_reg (restype);
1646 tem = make_ssa_name (tem, call);
1647 cpy = gimple_build_assign (retval, NOP_EXPR, tem);
1648 gsi_insert_after (&gsi, cpy, GSI_NEW_STMT);
1649 retval = tem;
1650 }
1651 /* Build bndret call to obtain returned bounds. */
1652 if (retbnd)
1653 insert_bndret_call_after (retbnd, retval, &gsi);
1654 gimple_call_set_lhs (call, retval);
1655 update_stmt (call);
1656 }
1657 }
1658 else
1659 gsi_insert_after (&gsi, call, GSI_NEW_STMT);
38c0c85b
JM
1660 if (tsan_func_exit_call)
1661 gsi_insert_after (&gsi, tsan_func_exit_call, GSI_NEW_STMT);
dda118e3
JM
1662 }
1663 /* We don't use return block (there is either no return in function or
1664 multiple of them). So create new basic block with return statement.
1665 */
1666 else
1667 {
1668 greturn *ret;
1669 if (split_point->split_part_set_retval
1670 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
1671 {
1672 retval = DECL_RESULT (current_function_decl);
1673
1674 if (chkp_function_instrumented_p (current_function_decl)
1675 && BOUNDED_P (retval))
1676 retbnd = create_tmp_reg (pointer_bounds_type_node);
1677
1678 /* We use temporary register to hold value when aggregate_value_p
1679 is false. Similarly for DECL_BY_REFERENCE we must avoid extra
1680 copy. */
1681 if (!aggregate_value_p (retval, TREE_TYPE (current_function_decl))
1682 && !DECL_BY_REFERENCE (retval))
1683 retval = create_tmp_reg (TREE_TYPE (retval));
1684 if (is_gimple_reg (retval))
1685 {
1686 /* When returning by reference, there is only one SSA name
1687 assigned to RESULT_DECL (that is pointer to return value).
1688 Look it up or create new one if it is missing. */
1689 if (DECL_BY_REFERENCE (retval))
1690 retval = get_or_create_ssa_default_def (cfun, retval);
1691 /* Otherwise produce new SSA name for return value. */
1692 else
1693 retval = make_ssa_name (retval, call);
1694 }
1695 if (DECL_BY_REFERENCE (DECL_RESULT (current_function_decl)))
1696 gimple_call_set_lhs (call, build_simple_mem_ref (retval));
1697 else
1698 gimple_call_set_lhs (call, retval);
1699 }
1700 gsi_insert_after (&gsi, call, GSI_NEW_STMT);
1701 /* Build bndret call to obtain returned bounds. */
1702 if (retbnd)
1703 insert_bndret_call_after (retbnd, retval, &gsi);
38c0c85b
JM
1704 if (tsan_func_exit_call)
1705 gsi_insert_after (&gsi, tsan_func_exit_call, GSI_NEW_STMT);
dda118e3
JM
1706 ret = gimple_build_return (retval);
1707 gsi_insert_after (&gsi, ret, GSI_NEW_STMT);
1708 }
1709 }
1710 free_dominance_info (CDI_DOMINATORS);
1711 free_dominance_info (CDI_POST_DOMINATORS);
1712 compute_inline_parameters (node, true);
1713}
1714
1715/* Execute function splitting pass. */
1716
1717static unsigned int
1718execute_split_functions (void)
1719{
1720 gimple_stmt_iterator bsi;
1721 basic_block bb;
1722 int overall_time = 0, overall_size = 0;
1723 int todo = 0;
1724 struct cgraph_node *node = cgraph_node::get (current_function_decl);
1725
1726 if (flags_from_decl_or_type (current_function_decl)
1727 & (ECF_NORETURN|ECF_MALLOC))
1728 {
1729 if (dump_file)
1730 fprintf (dump_file, "Not splitting: noreturn/malloc function.\n");
1731 return 0;
1732 }
1733 if (MAIN_NAME_P (DECL_NAME (current_function_decl)))
1734 {
1735 if (dump_file)
1736 fprintf (dump_file, "Not splitting: main function.\n");
1737 return 0;
1738 }
1739 /* This can be relaxed; function might become inlinable after splitting
1740 away the uninlinable part. */
1741 if (inline_edge_summary_vec.exists ()
1742 && !inline_summaries->get (node)->inlinable)
1743 {
1744 if (dump_file)
1745 fprintf (dump_file, "Not splitting: not inlinable.\n");
1746 return 0;
1747 }
1748 if (DECL_DISREGARD_INLINE_LIMITS (node->decl))
1749 {
1750 if (dump_file)
1751 fprintf (dump_file, "Not splitting: disregarding inline limits.\n");
1752 return 0;
1753 }
1754 /* This can be relaxed; most of versioning tests actually prevents
1755 a duplication. */
1756 if (!tree_versionable_function_p (current_function_decl))
1757 {
1758 if (dump_file)
1759 fprintf (dump_file, "Not splitting: not versionable.\n");
1760 return 0;
1761 }
1762 /* FIXME: we could support this. */
1763 if (DECL_STRUCT_FUNCTION (current_function_decl)->static_chain_decl)
1764 {
1765 if (dump_file)
1766 fprintf (dump_file, "Not splitting: nested function.\n");
1767 return 0;
1768 }
1769
1770 /* See if it makes sense to try to split.
1771 It makes sense to split if we inline, that is if we have direct calls to
1772 handle or direct calls are possibly going to appear as result of indirect
1773 inlining or LTO. Also handle -fprofile-generate as LTO to allow non-LTO
1774 training for LTO -fprofile-use build.
1775
1776 Note that we are not completely conservative about disqualifying functions
1777 called once. It is possible that the caller is called more then once and
1778 then inlining would still benefit. */
1779 if ((!node->callers
1780 /* Local functions called once will be completely inlined most of time. */
1781 || (!node->callers->next_caller && node->local.local))
1782 && !node->address_taken
9f50539d 1783 && !node->has_aliases_p ()
dda118e3
JM
1784 && (!flag_lto || !node->externally_visible))
1785 {
1786 if (dump_file)
1787 fprintf (dump_file, "Not splitting: not called directly "
1788 "or called once.\n");
1789 return 0;
1790 }
1791
1792 /* FIXME: We can actually split if splitting reduces call overhead. */
1793 if (!flag_inline_small_functions
1794 && !DECL_DECLARED_INLINE_P (current_function_decl))
1795 {
1796 if (dump_file)
1797 fprintf (dump_file, "Not splitting: not autoinlining and function"
1798 " is not inline.\n");
1799 return 0;
1800 }
1801
1802 /* We enforce splitting after loop headers when profile info is not
1803 available. */
1804 if (profile_status_for_fn (cfun) != PROFILE_READ)
1805 mark_dfs_back_edges ();
1806
1807 /* Initialize bitmap to track forbidden calls. */
1808 forbidden_dominators = BITMAP_ALLOC (NULL);
1809 calculate_dominance_info (CDI_DOMINATORS);
1810
1811 /* Compute local info about basic blocks and determine function size/time. */
1812 bb_info_vec.safe_grow_cleared (last_basic_block_for_fn (cfun) + 1);
1813 memset (&best_split_point, 0, sizeof (best_split_point));
38c0c85b
JM
1814 basic_block return_bb = find_return_bb ();
1815 int tsan_exit_found = -1;
dda118e3
JM
1816 FOR_EACH_BB_FN (bb, cfun)
1817 {
1818 int time = 0;
1819 int size = 0;
1820 int freq = compute_call_stmt_bb_frequency (current_function_decl, bb);
1821
1822 if (dump_file && (dump_flags & TDF_DETAILS))
1823 fprintf (dump_file, "Basic block %i\n", bb->index);
1824
1825 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
1826 {
1827 int this_time, this_size;
1828 gimple stmt = gsi_stmt (bsi);
1829
1830 this_size = estimate_num_insns (stmt, &eni_size_weights);
1831 this_time = estimate_num_insns (stmt, &eni_time_weights) * freq;
1832 size += this_size;
1833 time += this_time;
1834 check_forbidden_calls (stmt);
1835
1836 if (dump_file && (dump_flags & TDF_DETAILS))
1837 {
1838 fprintf (dump_file, " freq:%6i size:%3i time:%3i ",
1839 freq, this_size, this_time);
1840 print_gimple_stmt (dump_file, stmt, 0, 0);
1841 }
38c0c85b
JM
1842
1843 if ((flag_sanitize & SANITIZE_THREAD)
1844 && is_gimple_call (stmt)
1845 && gimple_call_internal_p (stmt)
1846 && gimple_call_internal_fn (stmt) == IFN_TSAN_FUNC_EXIT)
1847 {
1848 /* We handle TSAN_FUNC_EXIT for splitting either in the
1849 return_bb, or in its immediate predecessors. */
1850 if ((bb != return_bb && !find_edge (bb, return_bb))
1851 || (tsan_exit_found != -1
1852 && tsan_exit_found != (bb != return_bb)))
1853 {
1854 if (dump_file)
1855 fprintf (dump_file, "Not splitting: TSAN_FUNC_EXIT"
1856 " in unexpected basic block.\n");
1857 BITMAP_FREE (forbidden_dominators);
1858 bb_info_vec.release ();
1859 return 0;
1860 }
1861 tsan_exit_found = bb != return_bb;
1862 }
dda118e3
JM
1863 }
1864 overall_time += time;
1865 overall_size += size;
1866 bb_info_vec[bb->index].time = time;
1867 bb_info_vec[bb->index].size = size;
1868 }
38c0c85b 1869 find_split_points (return_bb, overall_time, overall_size);
dda118e3
JM
1870 if (best_split_point.split_bbs)
1871 {
38c0c85b 1872 split_function (return_bb, &best_split_point, tsan_exit_found == 1);
dda118e3
JM
1873 BITMAP_FREE (best_split_point.ssa_names_to_pass);
1874 BITMAP_FREE (best_split_point.split_bbs);
1875 todo = TODO_update_ssa | TODO_cleanup_cfg;
1876 }
1877 BITMAP_FREE (forbidden_dominators);
1878 bb_info_vec.release ();
1879 return todo;
1880}
1881
1882namespace {
1883
1884const pass_data pass_data_split_functions =
1885{
1886 GIMPLE_PASS, /* type */
1887 "fnsplit", /* name */
1888 OPTGROUP_NONE, /* optinfo_flags */
1889 TV_IPA_FNSPLIT, /* tv_id */
1890 PROP_cfg, /* properties_required */
1891 0, /* properties_provided */
1892 0, /* properties_destroyed */
1893 0, /* todo_flags_start */
1894 0, /* todo_flags_finish */
1895};
1896
1897class pass_split_functions : public gimple_opt_pass
1898{
1899public:
1900 pass_split_functions (gcc::context *ctxt)
1901 : gimple_opt_pass (pass_data_split_functions, ctxt)
1902 {}
1903
1904 /* opt_pass methods: */
1905 virtual bool gate (function *);
1906 virtual unsigned int execute (function *)
1907 {
1908 return execute_split_functions ();
1909 }
1910
1911}; // class pass_split_functions
1912
1913bool
1914pass_split_functions::gate (function *)
1915{
1916 /* When doing profile feedback, we want to execute the pass after profiling
1917 is read. So disable one in early optimization. */
1918 return (flag_partial_inlining
1919 && !profile_arc_flag && !flag_branch_probabilities);
1920}
1921
1922} // anon namespace
1923
1924gimple_opt_pass *
1925make_pass_split_functions (gcc::context *ctxt)
1926{
1927 return new pass_split_functions (ctxt);
1928}
1929
1930/* Execute function splitting pass. */
1931
1932static unsigned int
1933execute_feedback_split_functions (void)
1934{
1935 unsigned int retval = execute_split_functions ();
1936 if (retval)
1937 retval |= TODO_rebuild_cgraph_edges;
1938 return retval;
1939}
1940
1941namespace {
1942
1943const pass_data pass_data_feedback_split_functions =
1944{
1945 GIMPLE_PASS, /* type */
1946 "feedback_fnsplit", /* name */
1947 OPTGROUP_NONE, /* optinfo_flags */
1948 TV_IPA_FNSPLIT, /* tv_id */
1949 PROP_cfg, /* properties_required */
1950 0, /* properties_provided */
1951 0, /* properties_destroyed */
1952 0, /* todo_flags_start */
1953 0, /* todo_flags_finish */
1954};
1955
1956class pass_feedback_split_functions : public gimple_opt_pass
1957{
1958public:
1959 pass_feedback_split_functions (gcc::context *ctxt)
1960 : gimple_opt_pass (pass_data_feedback_split_functions, ctxt)
1961 {}
1962
1963 /* opt_pass methods: */
1964 virtual bool gate (function *);
1965 virtual unsigned int execute (function *)
1966 {
1967 return execute_feedback_split_functions ();
1968 }
1969
1970}; // class pass_feedback_split_functions
1971
1972bool
1973pass_feedback_split_functions::gate (function *)
1974{
1975 /* We don't need to split when profiling at all, we are producing
1976 lousy code anyway. */
1977 return (flag_partial_inlining
1978 && flag_branch_probabilities);
1979}
1980
1981} // anon namespace
1982
1983gimple_opt_pass *
1984make_pass_feedback_split_functions (gcc::context *ctxt)
1985{
1986 return new pass_feedback_split_functions (ctxt);
1987}