1 /* Conditional Dead Call Elimination pass for the GNU compiler.
2 Copyright (C) 2008-2015 Free Software Foundation, Inc.
3 Contributed by Xinliang David Li <davidxl@google.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 3, or (at your option) any
12 GCC is distributed in the hope that it will be useful, but WITHOUT
13 ANY 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/>. */
23 #include "coretypes.h"
26 #include "hard-reg-set.h"
29 #include "dominance.h"
31 #include "basic-block.h"
35 #include "fold-const.h"
36 #include "stor-layout.h"
37 #include "gimple-pretty-print.h"
38 #include "tree-ssa-alias.h"
39 #include "internal-fn.h"
40 #include "gimple-expr.h"
43 #include "gimple-iterator.h"
44 #include "gimple-ssa.h"
46 #include "stringpool.h"
47 #include "tree-ssanames.h"
48 #include "tree-into-ssa.h"
49 #include "tree-pass.h"
53 /* Conditional dead call elimination
55 Some builtin functions can set errno on error conditions, but they
56 are otherwise pure. If the result of a call to such a function is
57 not used, the compiler can still not eliminate the call without
58 powerful interprocedural analysis to prove that the errno is not
59 checked. However, if the conditions under which the error occurs
60 are known, the compiler can conditionally dead code eliminate the
61 calls by shrink-wrapping the semi-dead calls into the error condition:
65 if (error_cond (args))
68 An actual simple example is :
69 log (x); // Mostly dead call
73 With this change, call to log (x) is effectively eliminated, as
74 in majority of the cases, log won't be called with x out of
75 range. The branch is totally predictable, so the branch cost
78 Note that library functions are not supposed to clear errno to zero without
79 error. See IEEE Std 1003.1, section 2.3 Error Numbers, and section 7.5:3 of
82 The condition wrapping the builtin call is conservatively set to avoid too
83 aggressive (wrong) shrink wrapping. The optimization is called conditional
84 dead call elimination because the call is eliminated under the condition
85 that the input arguments would not lead to domain or range error (for
86 instance when x <= 0 for a log (x) call), however the chances that the error
87 condition is hit is very low (those builtin calls which are conditionally
88 dead are usually part of the C++ abstraction penalty exposed after
92 /* A structure for representing input domain of
93 a function argument in integer. If the lower
94 bound is -inf, has_lb is set to false. If the
95 upper bound is +inf, has_ub is false.
96 is_lb_inclusive and is_ub_inclusive are flags
97 to indicate if lb and ub value are inclusive
100 typedef struct input_domain
106 bool is_lb_inclusive
;
107 bool is_ub_inclusive
;
110 /* A helper function to construct and return an input
111 domain object. LB is the lower bound, HAS_LB is
112 a boolean flag indicating if the lower bound exists,
113 and LB_INCLUSIVE is a boolean flag indicating if the
114 lower bound is inclusive or not. UB, HAS_UB, and
115 UB_INCLUSIVE have the same meaning, but for upper
116 bound of the domain. */
119 get_domain (int lb
, bool has_lb
, bool lb_inclusive
,
120 int ub
, bool has_ub
, bool ub_inclusive
)
124 domain
.has_lb
= has_lb
;
125 domain
.is_lb_inclusive
= lb_inclusive
;
127 domain
.has_ub
= has_ub
;
128 domain
.is_ub_inclusive
= ub_inclusive
;
132 /* A helper function to check the target format for the
133 argument type. In this implementation, only IEEE formats
134 are supported. ARG is the call argument to be checked.
135 Returns true if the format is supported. To support other
136 target formats, function get_no_error_domain needs to be
137 enhanced to have range bounds properly computed. Since
138 the check is cheap (very small number of candidates
139 to be checked), the result is not cached for each float type. */
142 check_target_format (tree arg
)
146 const struct real_format
*rfmt
;
148 type
= TREE_TYPE (arg
);
149 mode
= TYPE_MODE (type
);
150 rfmt
= REAL_MODE_FORMAT (mode
);
152 && (rfmt
== &ieee_single_format
|| rfmt
== &mips_single_format
153 || rfmt
== &motorola_single_format
))
155 && (rfmt
== &ieee_double_format
|| rfmt
== &mips_double_format
156 || rfmt
== &motorola_double_format
))
157 /* For long double, we can not really check XFmode
158 which is only defined on intel platforms.
159 Candidate pre-selection using builtin function
160 code guarantees that we are checking formats
161 for long double modes: double, quad, and extended. */
162 || (mode
!= SFmode
&& mode
!= DFmode
163 && (rfmt
== &ieee_quad_format
164 || rfmt
== &mips_quad_format
165 || rfmt
== &ieee_extended_motorola_format
166 || rfmt
== &ieee_extended_intel_96_format
167 || rfmt
== &ieee_extended_intel_128_format
168 || rfmt
== &ieee_extended_intel_96_round_53_format
)))
175 /* A helper function to help select calls to pow that are suitable for
176 conditional DCE transformation. It looks for pow calls that can be
177 guided with simple conditions. Such calls either have constant base
178 values or base values converted from integers. Returns true if
179 the pow call POW_CALL is a candidate. */
181 /* The maximum integer bit size for base argument of a pow call
182 that is suitable for shrink-wrapping transformation. */
183 #define MAX_BASE_INT_BIT_SIZE 32
186 check_pow (gcall
*pow_call
)
189 enum tree_code bc
, ec
;
191 if (gimple_call_num_args (pow_call
) != 2)
194 base
= gimple_call_arg (pow_call
, 0);
195 expn
= gimple_call_arg (pow_call
, 1);
197 if (!check_target_format (expn
))
200 bc
= TREE_CODE (base
);
201 ec
= TREE_CODE (expn
);
203 /* Folding candidates are not interesting.
204 Can actually assert that it is already folded. */
205 if (ec
== REAL_CST
&& bc
== REAL_CST
)
210 /* Only handle a fixed range of constant. */
212 REAL_VALUE_TYPE bcv
= TREE_REAL_CST (base
);
213 if (REAL_VALUES_EQUAL (bcv
, dconst1
))
215 if (REAL_VALUES_LESS (bcv
, dconst1
))
217 real_from_integer (&mv
, TYPE_MODE (TREE_TYPE (base
)), 256, UNSIGNED
);
218 if (REAL_VALUES_LESS (mv
, bcv
))
222 else if (bc
== SSA_NAME
)
224 tree base_val0
, type
;
228 /* Only handles cases where base value is converted
229 from integer values. */
230 base_def
= SSA_NAME_DEF_STMT (base
);
231 if (gimple_code (base_def
) != GIMPLE_ASSIGN
)
234 if (gimple_assign_rhs_code (base_def
) != FLOAT_EXPR
)
236 base_val0
= gimple_assign_rhs1 (base_def
);
238 type
= TREE_TYPE (base_val0
);
239 if (TREE_CODE (type
) != INTEGER_TYPE
)
241 bit_sz
= TYPE_PRECISION (type
);
242 /* If the type of the base is too wide,
243 the resulting shrink wrapping condition
244 will be too conservative. */
245 if (bit_sz
> MAX_BASE_INT_BIT_SIZE
)
254 /* A helper function to help select candidate function calls that are
255 suitable for conditional DCE. Candidate functions must have single
256 valid input domain in this implementation except for pow (see check_pow).
257 Returns true if the function call is a candidate. */
260 check_builtin_call (gcall
*bcall
)
264 arg
= gimple_call_arg (bcall
, 0);
265 return check_target_format (arg
);
268 /* A helper function to determine if a builtin function call is a
269 candidate for conditional DCE. Returns true if the builtin call
273 is_call_dce_candidate (gcall
*call
)
276 enum built_in_function fnc
;
278 /* Only potentially dead calls are considered. */
279 if (gimple_call_lhs (call
))
282 fn
= gimple_call_fndecl (call
);
284 || !DECL_BUILT_IN (fn
)
285 || (DECL_BUILT_IN_CLASS (fn
) != BUILT_IN_NORMAL
))
288 fnc
= DECL_FUNCTION_CODE (fn
);
291 /* Trig functions. */
292 CASE_FLT_FN (BUILT_IN_ACOS
):
293 CASE_FLT_FN (BUILT_IN_ASIN
):
294 /* Hyperbolic functions. */
295 CASE_FLT_FN (BUILT_IN_ACOSH
):
296 CASE_FLT_FN (BUILT_IN_ATANH
):
297 CASE_FLT_FN (BUILT_IN_COSH
):
298 CASE_FLT_FN (BUILT_IN_SINH
):
300 CASE_FLT_FN (BUILT_IN_LOG
):
301 CASE_FLT_FN (BUILT_IN_LOG2
):
302 CASE_FLT_FN (BUILT_IN_LOG10
):
303 CASE_FLT_FN (BUILT_IN_LOG1P
):
305 CASE_FLT_FN (BUILT_IN_EXP
):
306 CASE_FLT_FN (BUILT_IN_EXP2
):
307 CASE_FLT_FN (BUILT_IN_EXP10
):
308 CASE_FLT_FN (BUILT_IN_EXPM1
):
309 CASE_FLT_FN (BUILT_IN_POW10
):
311 CASE_FLT_FN (BUILT_IN_SQRT
):
312 return check_builtin_call (call
);
313 /* Special one: two argument pow. */
315 return check_pow (call
);
324 /* A helper function to generate gimple statements for
325 one bound comparison. ARG is the call argument to
326 be compared with the bound, LBUB is the bound value
327 in integer, TCODE is the tree_code of the comparison,
328 TEMP_NAME1/TEMP_NAME2 are names of the temporaries,
329 CONDS is a vector holding the produced GIMPLE statements,
330 and NCONDS points to the variable holding the number
331 of logical comparisons. CONDS is either empty or
332 a list ended with a null tree. */
335 gen_one_condition (tree arg
, int lbub
,
336 enum tree_code tcode
,
337 const char *temp_name1
,
338 const char *temp_name2
,
342 tree lbub_real_cst
, lbub_cst
, float_type
;
343 tree temp
, tempn
, tempc
, tempcn
;
348 float_type
= TREE_TYPE (arg
);
349 lbub_cst
= build_int_cst (integer_type_node
, lbub
);
350 lbub_real_cst
= build_real_from_int_cst (float_type
, lbub_cst
);
352 temp
= create_tmp_var (float_type
, temp_name1
);
353 stmt1
= gimple_build_assign (temp
, arg
);
354 tempn
= make_ssa_name (temp
, stmt1
);
355 gimple_assign_set_lhs (stmt1
, tempn
);
357 tempc
= create_tmp_var (boolean_type_node
, temp_name2
);
358 stmt2
= gimple_build_assign (tempc
,
361 tempn
, lbub_real_cst
));
362 tempcn
= make_ssa_name (tempc
, stmt2
);
363 gimple_assign_set_lhs (stmt2
, tempcn
);
365 stmt3
= gimple_build_cond_from_tree (tempcn
, NULL_TREE
, NULL_TREE
);
366 conds
.quick_push (stmt1
);
367 conds
.quick_push (stmt2
);
368 conds
.quick_push (stmt3
);
372 /* A helper function to generate GIMPLE statements for
373 out of input domain check. ARG is the call argument
374 to be runtime checked, DOMAIN holds the valid domain
375 for the given function, CONDS points to the vector
376 holding the result GIMPLE statements. *NCONDS is
377 the number of logical comparisons. This function
378 produces no more than two logical comparisons, one
379 for lower bound check, one for upper bound check. */
382 gen_conditions_for_domain (tree arg
, inp_domain domain
,
387 gen_one_condition (arg
, domain
.lb
,
388 (domain
.is_lb_inclusive
389 ? LT_EXPR
: LE_EXPR
),
390 "DCE_COND_LB", "DCE_COND_LB_TEST",
395 /* Now push a separator. */
397 conds
.quick_push (NULL
);
399 gen_one_condition (arg
, domain
.ub
,
400 (domain
.is_ub_inclusive
401 ? GT_EXPR
: GE_EXPR
),
402 "DCE_COND_UB", "DCE_COND_UB_TEST",
408 /* A helper function to generate condition
409 code for the y argument in call pow (some_const, y).
410 See candidate selection in check_pow. Since the
411 candidates' base values have a limited range,
412 the guarded code generated for y are simple:
415 Note max_y can be computed separately for each
416 const base, but in this implementation, we
417 choose to compute it using the max base
418 in the allowed range for the purpose of
419 simplicity. BASE is the constant base value,
420 EXPN is the expression for the exponent argument,
421 *CONDS is the vector to hold resulting statements,
422 and *NCONDS is the number of logical conditions. */
425 gen_conditions_for_pow_cst_base (tree base
, tree expn
,
429 inp_domain exp_domain
;
430 /* Validate the range of the base constant to make
431 sure it is consistent with check_pow. */
433 REAL_VALUE_TYPE bcv
= TREE_REAL_CST (base
);
434 gcc_assert (!REAL_VALUES_EQUAL (bcv
, dconst1
)
435 && !REAL_VALUES_LESS (bcv
, dconst1
));
436 real_from_integer (&mv
, TYPE_MODE (TREE_TYPE (base
)), 256, UNSIGNED
);
437 gcc_assert (!REAL_VALUES_LESS (mv
, bcv
));
439 exp_domain
= get_domain (0, false, false,
442 gen_conditions_for_domain (expn
, exp_domain
,
446 /* Generate error condition code for pow calls with
447 non constant base values. The candidates selected
448 have their base argument value converted from
449 integer (see check_pow) value (1, 2, 4 bytes), and
450 the max exp value is computed based on the size
451 of the integer type (i.e. max possible base value).
452 The resulting input domain for exp argument is thus
453 conservative (smaller than the max value allowed by
454 the runtime value of the base). BASE is the integer
455 base value, EXPN is the expression for the exponent
456 argument, *CONDS is the vector to hold resulting
457 statements, and *NCONDS is the number of logical
461 gen_conditions_for_pow_int_base (tree base
, tree expn
,
472 inp_domain exp_domain
;
474 base_def
= SSA_NAME_DEF_STMT (base
);
475 base_val0
= gimple_assign_rhs1 (base_def
);
476 int_type
= TREE_TYPE (base_val0
);
477 bit_sz
= TYPE_PRECISION (int_type
);
478 gcc_assert (bit_sz
> 0
479 && bit_sz
<= MAX_BASE_INT_BIT_SIZE
);
481 /* Determine the max exp argument value according to
482 the size of the base integer. The max exp value
483 is conservatively estimated assuming IEEE754 double
487 else if (bit_sz
== 16)
491 gcc_assert (bit_sz
== MAX_BASE_INT_BIT_SIZE
);
495 /* For pow ((double)x, y), generate the following conditions:
502 if (temp2 > max_exp_real_cst) */
504 /* Generate condition in reverse order -- first
505 the condition for the exp argument. */
507 exp_domain
= get_domain (0, false, false,
508 max_exp
, true, true);
510 gen_conditions_for_domain (expn
, exp_domain
,
513 /* Now generate condition for the base argument.
514 Note it does not use the helper function
515 gen_conditions_for_domain because the base
518 /* Push a separator. */
519 conds
.quick_push (NULL
);
521 temp
= create_tmp_var (int_type
, "DCE_COND1");
522 cst0
= build_int_cst (int_type
, 0);
523 stmt1
= gimple_build_assign (temp
, base_val0
);
524 tempn
= make_ssa_name (temp
, stmt1
);
525 gimple_assign_set_lhs (stmt1
, tempn
);
526 stmt2
= gimple_build_cond (LE_EXPR
, tempn
, cst0
, NULL_TREE
, NULL_TREE
);
528 conds
.quick_push (stmt1
);
529 conds
.quick_push (stmt2
);
533 /* Method to generate conditional statements for guarding conditionally
534 dead calls to pow. One or more statements can be generated for
535 each logical condition. Statement groups of different conditions
536 are separated by a NULL tree and they are stored in the vec
537 conds. The number of logical conditions are stored in *nconds.
539 See C99 standard, 7.12.7.4:2, for description of pow (x, y).
540 The precise condition for domain errors are complex. In this
541 implementation, a simplified (but conservative) valid domain
542 for x and y are used: x is positive to avoid dom errors, while
543 y is smaller than a upper bound (depending on x) to avoid range
544 errors. Runtime code is generated to check x (if not constant)
545 and y against the valid domain. If it is out, jump to the call,
546 otherwise the call is bypassed. POW_CALL is the call statement,
547 *CONDS is a vector holding the resulting condition statements,
548 and *NCONDS is the number of logical conditions. */
551 gen_conditions_for_pow (gcall
*pow_call
, vec
<gimple
> conds
,
557 gcc_checking_assert (check_pow (pow_call
));
561 base
= gimple_call_arg (pow_call
, 0);
562 expn
= gimple_call_arg (pow_call
, 1);
564 bc
= TREE_CODE (base
);
567 gen_conditions_for_pow_cst_base (base
, expn
, conds
, nconds
);
568 else if (bc
== SSA_NAME
)
569 gen_conditions_for_pow_int_base (base
, expn
, conds
, nconds
);
574 /* A helper routine to help computing the valid input domain
575 for a builtin function. See C99 7.12.7 for details. In this
576 implementation, we only handle single region domain. The
577 resulting region can be conservative (smaller) than the actual
578 one and rounded to integers. Some of the bounds are documented
579 in the standard, while other limit constants are computed
580 assuming IEEE floating point format (for SF and DF modes).
581 Since IEEE only sets minimum requirements for long double format,
582 different long double formats exist under different implementations
583 (e.g, 64 bit double precision (DF), 80 bit double-extended
584 precision (XF), and 128 bit quad precision (QF) ). For simplicity,
585 in this implementation, the computed bounds for long double assume
586 64 bit format (DF), and are therefore conservative. Another
587 assumption is that single precision float type is always SF mode,
588 and double type is DF mode. This function is quite
589 implementation specific, so it may not be suitable to be part of
590 builtins.c. This needs to be revisited later to see if it can
591 be leveraged in x87 assembly expansion. */
594 get_no_error_domain (enum built_in_function fnc
)
598 /* Trig functions: return [-1, +1] */
599 CASE_FLT_FN (BUILT_IN_ACOS
):
600 CASE_FLT_FN (BUILT_IN_ASIN
):
601 return get_domain (-1, true, true,
603 /* Hyperbolic functions. */
604 CASE_FLT_FN (BUILT_IN_ACOSH
):
605 /* acosh: [1, +inf) */
606 return get_domain (1, true, true,
608 CASE_FLT_FN (BUILT_IN_ATANH
):
609 /* atanh: (-1, +1) */
610 return get_domain (-1, true, false,
614 /* coshf: (-89, +89) */
615 return get_domain (-89, true, false,
621 /* cosh: (-710, +710) */
622 return get_domain (-710, true, false,
624 /* Log functions: (0, +inf) */
625 CASE_FLT_FN (BUILT_IN_LOG
):
626 CASE_FLT_FN (BUILT_IN_LOG2
):
627 CASE_FLT_FN (BUILT_IN_LOG10
):
628 return get_domain (0, true, false,
630 CASE_FLT_FN (BUILT_IN_LOG1P
):
631 return get_domain (-1, true, false,
635 case BUILT_IN_EXPM1F
:
636 /* expf: (-inf, 88) */
637 return get_domain (-1, false, false,
642 case BUILT_IN_EXPM1L
:
643 /* exp: (-inf, 709) */
644 return get_domain (-1, false, false,
647 /* exp2f: (-inf, 128) */
648 return get_domain (-1, false, false,
652 /* exp2: (-inf, 1024) */
653 return get_domain (-1, false, false,
655 case BUILT_IN_EXP10F
:
656 case BUILT_IN_POW10F
:
657 /* exp10f: (-inf, 38) */
658 return get_domain (-1, false, false,
662 case BUILT_IN_EXP10L
:
663 case BUILT_IN_POW10L
:
664 /* exp10: (-inf, 308) */
665 return get_domain (-1, false, false,
667 /* sqrt: [0, +inf) */
668 CASE_FLT_FN (BUILT_IN_SQRT
):
669 return get_domain (0, true, true,
678 /* The function to generate shrink wrap conditions for a partially
679 dead builtin call whose return value is not used anywhere,
680 but has to be kept live due to potential error condition.
681 BI_CALL is the builtin call, CONDS is the vector of statements
682 for condition code, NCODES is the pointer to the number of
683 logical conditions. Statements belonging to different logical
684 condition are separated by NULL tree in the vector. */
687 gen_shrink_wrap_conditions (gcall
*bi_call
, vec
<gimple
> conds
,
688 unsigned int *nconds
)
692 enum built_in_function fnc
;
694 gcc_assert (nconds
&& conds
.exists ());
695 gcc_assert (conds
.length () == 0);
696 gcc_assert (is_gimple_call (bi_call
));
699 fn
= gimple_call_fndecl (call
);
700 gcc_assert (fn
&& DECL_BUILT_IN (fn
));
701 fnc
= DECL_FUNCTION_CODE (fn
);
704 if (fnc
== BUILT_IN_POW
)
705 gen_conditions_for_pow (call
, conds
, nconds
);
709 inp_domain domain
= get_no_error_domain (fnc
);
711 arg
= gimple_call_arg (bi_call
, 0);
712 gen_conditions_for_domain (arg
, domain
, conds
, nconds
);
719 /* Probability of the branch (to the call) is taken. */
720 #define ERR_PROB 0.01
722 /* The function to shrink wrap a partially dead builtin call
723 whose return value is not used anywhere, but has to be kept
724 live due to potential error condition. Returns true if the
725 transformation actually happens. */
728 shrink_wrap_one_built_in_call (gcall
*bi_call
)
730 gimple_stmt_iterator bi_call_bsi
;
731 basic_block bi_call_bb
, join_tgt_bb
, guard_bb
, guard_bb0
;
732 edge join_tgt_in_edge_from_call
, join_tgt_in_edge_fall_thru
;
733 edge bi_call_in_edge0
, guard_bb_in_edge
;
734 unsigned tn_cond_stmts
, nconds
;
736 gimple cond_expr
= NULL
;
737 gimple cond_expr_start
;
738 tree bi_call_label_decl
;
739 gimple bi_call_label
;
741 auto_vec
<gimple
, 12> conds
;
742 gen_shrink_wrap_conditions (bi_call
, conds
, &nconds
);
744 /* This can happen if the condition generator decides
745 it is not beneficial to do the transformation. Just
746 return false and do not do any transformation for
751 bi_call_bb
= gimple_bb (bi_call
);
753 /* Now find the join target bb -- split bi_call_bb if needed. */
754 if (stmt_ends_bb_p (bi_call
))
756 /* If the call must be the last in the bb, don't split the block,
757 it could e.g. have EH edges. */
758 join_tgt_in_edge_from_call
= find_fallthru_edge (bi_call_bb
->succs
);
759 if (join_tgt_in_edge_from_call
== NULL
)
763 join_tgt_in_edge_from_call
= split_block (bi_call_bb
, bi_call
);
765 bi_call_bsi
= gsi_for_stmt (bi_call
);
767 join_tgt_bb
= join_tgt_in_edge_from_call
->dest
;
769 /* Now it is time to insert the first conditional expression
770 into bi_call_bb and split this bb so that bi_call is
772 tn_cond_stmts
= conds
.length ();
774 cond_expr_start
= conds
[0];
775 for (ci
= 0; ci
< tn_cond_stmts
; ci
++)
777 gimple c
= conds
[ci
];
778 gcc_assert (c
|| ci
!= 0);
781 gsi_insert_before (&bi_call_bsi
, c
, GSI_SAME_STMT
);
786 gcc_assert (cond_expr
&& gimple_code (cond_expr
) == GIMPLE_COND
);
789 bi_call_label_decl
= create_artificial_label (gimple_location (bi_call
));
790 bi_call_label
= gimple_build_label (bi_call_label_decl
);
791 gsi_insert_before (&bi_call_bsi
, bi_call_label
, GSI_SAME_STMT
);
793 bi_call_in_edge0
= split_block (bi_call_bb
, cond_expr
);
794 bi_call_in_edge0
->flags
&= ~EDGE_FALLTHRU
;
795 bi_call_in_edge0
->flags
|= EDGE_TRUE_VALUE
;
796 guard_bb0
= bi_call_bb
;
797 bi_call_bb
= bi_call_in_edge0
->dest
;
798 join_tgt_in_edge_fall_thru
= make_edge (guard_bb0
, join_tgt_bb
,
801 bi_call_in_edge0
->probability
= REG_BR_PROB_BASE
* ERR_PROB
;
802 bi_call_in_edge0
->count
=
803 apply_probability (guard_bb0
->count
,
804 bi_call_in_edge0
->probability
);
805 join_tgt_in_edge_fall_thru
->probability
=
806 inverse_probability (bi_call_in_edge0
->probability
);
807 join_tgt_in_edge_fall_thru
->count
=
808 guard_bb0
->count
- bi_call_in_edge0
->count
;
810 /* Code generation for the rest of the conditions */
811 guard_bb
= guard_bb0
;
815 edge bi_call_in_edge
;
816 gimple_stmt_iterator guard_bsi
= gsi_for_stmt (cond_expr_start
);
818 cond_expr_start
= conds
[ci0
];
819 for (; ci
< tn_cond_stmts
; ci
++)
821 gimple c
= conds
[ci
];
822 gcc_assert (c
|| ci
!= ci0
);
825 gsi_insert_before (&guard_bsi
, c
, GSI_SAME_STMT
);
830 gcc_assert (cond_expr
&& gimple_code (cond_expr
) == GIMPLE_COND
);
831 guard_bb_in_edge
= split_block (guard_bb
, cond_expr
);
832 guard_bb_in_edge
->flags
&= ~EDGE_FALLTHRU
;
833 guard_bb_in_edge
->flags
|= EDGE_FALSE_VALUE
;
835 bi_call_in_edge
= make_edge (guard_bb
, bi_call_bb
, EDGE_TRUE_VALUE
);
837 bi_call_in_edge
->probability
= REG_BR_PROB_BASE
* ERR_PROB
;
838 bi_call_in_edge
->count
=
839 apply_probability (guard_bb
->count
,
840 bi_call_in_edge
->probability
);
841 guard_bb_in_edge
->probability
=
842 inverse_probability (bi_call_in_edge
->probability
);
843 guard_bb_in_edge
->count
= guard_bb
->count
- bi_call_in_edge
->count
;
846 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
849 loc
= gimple_location (bi_call
);
851 "%s:%d: note: function call is shrink-wrapped"
852 " into error conditions.\n",
853 LOCATION_FILE (loc
), LOCATION_LINE (loc
));
859 /* The top level function for conditional dead code shrink
860 wrapping transformation. */
863 shrink_wrap_conditional_dead_built_in_calls (vec
<gcall
*> calls
)
865 bool changed
= false;
868 unsigned n
= calls
.length ();
874 gcall
*bi_call
= calls
[i
];
875 changed
|= shrink_wrap_one_built_in_call (bi_call
);
883 const pass_data pass_data_call_cdce
=
885 GIMPLE_PASS
, /* type */
887 OPTGROUP_NONE
, /* optinfo_flags */
888 TV_TREE_CALL_CDCE
, /* tv_id */
889 ( PROP_cfg
| PROP_ssa
), /* properties_required */
890 0, /* properties_provided */
891 0, /* properties_destroyed */
892 0, /* todo_flags_start */
893 0, /* todo_flags_finish */
896 class pass_call_cdce
: public gimple_opt_pass
899 pass_call_cdce (gcc::context
*ctxt
)
900 : gimple_opt_pass (pass_data_call_cdce
, ctxt
)
903 /* opt_pass methods: */
904 virtual bool gate (function
*fun
)
906 /* The limit constants used in the implementation
907 assume IEEE floating point format. Other formats
908 can be supported in the future if needed. */
909 return flag_tree_builtin_call_dce
!= 0
910 && optimize_function_for_speed_p (fun
);
913 virtual unsigned int execute (function
*);
915 }; // class pass_call_cdce
918 pass_call_cdce::execute (function
*fun
)
921 gimple_stmt_iterator i
;
922 bool something_changed
= false;
923 auto_vec
<gcall
*> cond_dead_built_in_calls
;
924 FOR_EACH_BB_FN (bb
, fun
)
926 /* Collect dead call candidates. */
927 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
929 gcall
*stmt
= dyn_cast
<gcall
*> (gsi_stmt (i
));
930 if (stmt
&& is_call_dce_candidate (stmt
))
932 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
934 fprintf (dump_file
, "Found conditional dead call: ");
935 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
936 fprintf (dump_file
, "\n");
938 if (!cond_dead_built_in_calls
.exists ())
939 cond_dead_built_in_calls
.create (64);
940 cond_dead_built_in_calls
.safe_push (stmt
);
945 if (!cond_dead_built_in_calls
.exists ())
949 = shrink_wrap_conditional_dead_built_in_calls (cond_dead_built_in_calls
);
951 if (something_changed
)
953 free_dominance_info (CDI_DOMINATORS
);
954 free_dominance_info (CDI_POST_DOMINATORS
);
955 /* As we introduced new control-flow we need to insert PHI-nodes
956 for the call-clobbers of the remaining call. */
957 mark_virtual_operands_for_renaming (fun
);
958 return TODO_update_ssa
;
967 make_pass_call_cdce (gcc::context
*ctxt
)
969 return new pass_call_cdce (ctxt
);