1 /* Conditional Dead Call Elimination pass for the GNU compiler.
2 Copyright (C) 2008-2014 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"
30 #include "hard-reg-set.h"
33 #include "dominance.h"
35 #include "basic-block.h"
37 #include "stor-layout.h"
38 #include "gimple-pretty-print.h"
39 #include "tree-ssa-alias.h"
40 #include "internal-fn.h"
41 #include "gimple-expr.h"
44 #include "gimple-iterator.h"
45 #include "gimple-ssa.h"
47 #include "stringpool.h"
48 #include "tree-ssanames.h"
49 #include "tree-into-ssa.h"
50 #include "tree-pass.h"
54 /* Conditional dead call elimination
56 Some builtin functions can set errno on error conditions, but they
57 are otherwise pure. If the result of a call to such a function is
58 not used, the compiler can still not eliminate the call without
59 powerful interprocedural analysis to prove that the errno is not
60 checked. However, if the conditions under which the error occurs
61 are known, the compiler can conditionally dead code eliminate the
62 calls by shrink-wrapping the semi-dead calls into the error condition:
66 if (error_cond (args))
69 An actual simple example is :
70 log (x); // Mostly dead call
74 With this change, call to log (x) is effectively eliminated, as
75 in majority of the cases, log won't be called with x out of
76 range. The branch is totally predictable, so the branch cost
79 Note that library functions are not supposed to clear errno to zero without
80 error. See IEEE Std 1003.1, section 2.3 Error Numbers, and section 7.5:3 of
83 The condition wrapping the builtin call is conservatively set to avoid too
84 aggressive (wrong) shrink wrapping. The optimization is called conditional
85 dead call elimination because the call is eliminated under the condition
86 that the input arguments would not lead to domain or range error (for
87 instance when x <= 0 for a log (x) call), however the chances that the error
88 condition is hit is very low (those builtin calls which are conditionally
89 dead are usually part of the C++ abstraction penalty exposed after
93 /* A structure for representing input domain of
94 a function argument in integer. If the lower
95 bound is -inf, has_lb is set to false. If the
96 upper bound is +inf, has_ub is false.
97 is_lb_inclusive and is_ub_inclusive are flags
98 to indicate if lb and ub value are inclusive
101 typedef struct input_domain
107 bool is_lb_inclusive
;
108 bool is_ub_inclusive
;
111 /* A helper function to construct and return an input
112 domain object. LB is the lower bound, HAS_LB is
113 a boolean flag indicating if the lower bound exists,
114 and LB_INCLUSIVE is a boolean flag indicating if the
115 lower bound is inclusive or not. UB, HAS_UB, and
116 UB_INCLUSIVE have the same meaning, but for upper
117 bound of the domain. */
120 get_domain (int lb
, bool has_lb
, bool lb_inclusive
,
121 int ub
, bool has_ub
, bool ub_inclusive
)
125 domain
.has_lb
= has_lb
;
126 domain
.is_lb_inclusive
= lb_inclusive
;
128 domain
.has_ub
= has_ub
;
129 domain
.is_ub_inclusive
= ub_inclusive
;
133 /* A helper function to check the target format for the
134 argument type. In this implementation, only IEEE formats
135 are supported. ARG is the call argument to be checked.
136 Returns true if the format is supported. To support other
137 target formats, function get_no_error_domain needs to be
138 enhanced to have range bounds properly computed. Since
139 the check is cheap (very small number of candidates
140 to be checked), the result is not cached for each float type. */
143 check_target_format (tree arg
)
146 enum machine_mode mode
;
147 const struct real_format
*rfmt
;
149 type
= TREE_TYPE (arg
);
150 mode
= TYPE_MODE (type
);
151 rfmt
= REAL_MODE_FORMAT (mode
);
153 && (rfmt
== &ieee_single_format
|| rfmt
== &mips_single_format
154 || rfmt
== &motorola_single_format
))
156 && (rfmt
== &ieee_double_format
|| rfmt
== &mips_double_format
157 || rfmt
== &motorola_double_format
))
158 /* For long double, we can not really check XFmode
159 which is only defined on intel platforms.
160 Candidate pre-selection using builtin function
161 code guarantees that we are checking formats
162 for long double modes: double, quad, and extended. */
163 || (mode
!= SFmode
&& mode
!= DFmode
164 && (rfmt
== &ieee_quad_format
165 || rfmt
== &mips_quad_format
166 || rfmt
== &ieee_extended_motorola_format
167 || rfmt
== &ieee_extended_intel_96_format
168 || rfmt
== &ieee_extended_intel_128_format
169 || rfmt
== &ieee_extended_intel_96_round_53_format
)))
176 /* A helper function to help select calls to pow that are suitable for
177 conditional DCE transformation. It looks for pow calls that can be
178 guided with simple conditions. Such calls either have constant base
179 values or base values converted from integers. Returns true if
180 the pow call POW_CALL is a candidate. */
182 /* The maximum integer bit size for base argument of a pow call
183 that is suitable for shrink-wrapping transformation. */
184 #define MAX_BASE_INT_BIT_SIZE 32
187 check_pow (gimple pow_call
)
190 enum tree_code bc
, ec
;
192 if (gimple_call_num_args (pow_call
) != 2)
195 base
= gimple_call_arg (pow_call
, 0);
196 expn
= gimple_call_arg (pow_call
, 1);
198 if (!check_target_format (expn
))
201 bc
= TREE_CODE (base
);
202 ec
= TREE_CODE (expn
);
204 /* Folding candidates are not interesting.
205 Can actually assert that it is already folded. */
206 if (ec
== REAL_CST
&& bc
== REAL_CST
)
211 /* Only handle a fixed range of constant. */
213 REAL_VALUE_TYPE bcv
= TREE_REAL_CST (base
);
214 if (REAL_VALUES_EQUAL (bcv
, dconst1
))
216 if (REAL_VALUES_LESS (bcv
, dconst1
))
218 real_from_integer (&mv
, TYPE_MODE (TREE_TYPE (base
)), 256, UNSIGNED
);
219 if (REAL_VALUES_LESS (mv
, bcv
))
223 else if (bc
== SSA_NAME
)
225 tree base_val0
, type
;
229 /* Only handles cases where base value is converted
230 from integer values. */
231 base_def
= SSA_NAME_DEF_STMT (base
);
232 if (gimple_code (base_def
) != GIMPLE_ASSIGN
)
235 if (gimple_assign_rhs_code (base_def
) != FLOAT_EXPR
)
237 base_val0
= gimple_assign_rhs1 (base_def
);
239 type
= TREE_TYPE (base_val0
);
240 if (TREE_CODE (type
) != INTEGER_TYPE
)
242 bit_sz
= TYPE_PRECISION (type
);
243 /* If the type of the base is too wide,
244 the resulting shrink wrapping condition
245 will be too conservative. */
246 if (bit_sz
> MAX_BASE_INT_BIT_SIZE
)
255 /* A helper function to help select candidate function calls that are
256 suitable for conditional DCE. Candidate functions must have single
257 valid input domain in this implementation except for pow (see check_pow).
258 Returns true if the function call is a candidate. */
261 check_builtin_call (gimple bcall
)
265 arg
= gimple_call_arg (bcall
, 0);
266 return check_target_format (arg
);
269 /* A helper function to determine if a builtin function call is a
270 candidate for conditional DCE. Returns true if the builtin call
274 is_call_dce_candidate (gimple call
)
277 enum built_in_function fnc
;
279 /* Only potentially dead calls are considered. */
280 if (gimple_call_lhs (call
))
283 fn
= gimple_call_fndecl (call
);
285 || !DECL_BUILT_IN (fn
)
286 || (DECL_BUILT_IN_CLASS (fn
) != BUILT_IN_NORMAL
))
289 fnc
= DECL_FUNCTION_CODE (fn
);
292 /* Trig functions. */
293 CASE_FLT_FN (BUILT_IN_ACOS
):
294 CASE_FLT_FN (BUILT_IN_ASIN
):
295 /* Hyperbolic functions. */
296 CASE_FLT_FN (BUILT_IN_ACOSH
):
297 CASE_FLT_FN (BUILT_IN_ATANH
):
298 CASE_FLT_FN (BUILT_IN_COSH
):
299 CASE_FLT_FN (BUILT_IN_SINH
):
301 CASE_FLT_FN (BUILT_IN_LOG
):
302 CASE_FLT_FN (BUILT_IN_LOG2
):
303 CASE_FLT_FN (BUILT_IN_LOG10
):
304 CASE_FLT_FN (BUILT_IN_LOG1P
):
306 CASE_FLT_FN (BUILT_IN_EXP
):
307 CASE_FLT_FN (BUILT_IN_EXP2
):
308 CASE_FLT_FN (BUILT_IN_EXP10
):
309 CASE_FLT_FN (BUILT_IN_EXPM1
):
310 CASE_FLT_FN (BUILT_IN_POW10
):
312 CASE_FLT_FN (BUILT_IN_SQRT
):
313 return check_builtin_call (call
);
314 /* Special one: two argument pow. */
316 return check_pow (call
);
325 /* A helper function to generate gimple statements for
326 one bound comparison. ARG is the call argument to
327 be compared with the bound, LBUB is the bound value
328 in integer, TCODE is the tree_code of the comparison,
329 TEMP_NAME1/TEMP_NAME2 are names of the temporaries,
330 CONDS is a vector holding the produced GIMPLE statements,
331 and NCONDS points to the variable holding the number
332 of logical comparisons. CONDS is either empty or
333 a list ended with a null tree. */
336 gen_one_condition (tree arg
, int lbub
,
337 enum tree_code tcode
,
338 const char *temp_name1
,
339 const char *temp_name2
,
343 tree lbub_real_cst
, lbub_cst
, float_type
;
344 tree temp
, tempn
, tempc
, tempcn
;
345 gimple stmt1
, stmt2
, stmt3
;
347 float_type
= TREE_TYPE (arg
);
348 lbub_cst
= build_int_cst (integer_type_node
, lbub
);
349 lbub_real_cst
= build_real_from_int_cst (float_type
, lbub_cst
);
351 temp
= create_tmp_var (float_type
, temp_name1
);
352 stmt1
= gimple_build_assign (temp
, arg
);
353 tempn
= make_ssa_name (temp
, stmt1
);
354 gimple_assign_set_lhs (stmt1
, tempn
);
356 tempc
= create_tmp_var (boolean_type_node
, temp_name2
);
357 stmt2
= gimple_build_assign (tempc
,
360 tempn
, lbub_real_cst
));
361 tempcn
= make_ssa_name (tempc
, stmt2
);
362 gimple_assign_set_lhs (stmt2
, tempcn
);
364 stmt3
= gimple_build_cond_from_tree (tempcn
, NULL_TREE
, NULL_TREE
);
365 conds
.quick_push (stmt1
);
366 conds
.quick_push (stmt2
);
367 conds
.quick_push (stmt3
);
371 /* A helper function to generate GIMPLE statements for
372 out of input domain check. ARG is the call argument
373 to be runtime checked, DOMAIN holds the valid domain
374 for the given function, CONDS points to the vector
375 holding the result GIMPLE statements. *NCONDS is
376 the number of logical comparisons. This function
377 produces no more than two logical comparisons, one
378 for lower bound check, one for upper bound check. */
381 gen_conditions_for_domain (tree arg
, inp_domain domain
,
386 gen_one_condition (arg
, domain
.lb
,
387 (domain
.is_lb_inclusive
388 ? LT_EXPR
: LE_EXPR
),
389 "DCE_COND_LB", "DCE_COND_LB_TEST",
394 /* Now push a separator. */
396 conds
.quick_push (NULL
);
398 gen_one_condition (arg
, domain
.ub
,
399 (domain
.is_ub_inclusive
400 ? GT_EXPR
: GE_EXPR
),
401 "DCE_COND_UB", "DCE_COND_UB_TEST",
407 /* A helper function to generate condition
408 code for the y argument in call pow (some_const, y).
409 See candidate selection in check_pow. Since the
410 candidates' base values have a limited range,
411 the guarded code generated for y are simple:
414 Note max_y can be computed separately for each
415 const base, but in this implementation, we
416 choose to compute it using the max base
417 in the allowed range for the purpose of
418 simplicity. BASE is the constant base value,
419 EXPN is the expression for the exponent argument,
420 *CONDS is the vector to hold resulting statements,
421 and *NCONDS is the number of logical conditions. */
424 gen_conditions_for_pow_cst_base (tree base
, tree expn
,
428 inp_domain exp_domain
;
429 /* Validate the range of the base constant to make
430 sure it is consistent with check_pow. */
432 REAL_VALUE_TYPE bcv
= TREE_REAL_CST (base
);
433 gcc_assert (!REAL_VALUES_EQUAL (bcv
, dconst1
)
434 && !REAL_VALUES_LESS (bcv
, dconst1
));
435 real_from_integer (&mv
, TYPE_MODE (TREE_TYPE (base
)), 256, UNSIGNED
);
436 gcc_assert (!REAL_VALUES_LESS (mv
, bcv
));
438 exp_domain
= get_domain (0, false, false,
441 gen_conditions_for_domain (expn
, exp_domain
,
445 /* Generate error condition code for pow calls with
446 non constant base values. The candidates selected
447 have their base argument value converted from
448 integer (see check_pow) value (1, 2, 4 bytes), and
449 the max exp value is computed based on the size
450 of the integer type (i.e. max possible base value).
451 The resulting input domain for exp argument is thus
452 conservative (smaller than the max value allowed by
453 the runtime value of the base). BASE is the integer
454 base value, EXPN is the expression for the exponent
455 argument, *CONDS is the vector to hold resulting
456 statements, and *NCONDS is the number of logical
460 gen_conditions_for_pow_int_base (tree base
, tree expn
,
471 inp_domain exp_domain
;
473 base_def
= SSA_NAME_DEF_STMT (base
);
474 base_val0
= gimple_assign_rhs1 (base_def
);
475 int_type
= TREE_TYPE (base_val0
);
476 bit_sz
= TYPE_PRECISION (int_type
);
477 gcc_assert (bit_sz
> 0
478 && bit_sz
<= MAX_BASE_INT_BIT_SIZE
);
480 /* Determine the max exp argument value according to
481 the size of the base integer. The max exp value
482 is conservatively estimated assuming IEEE754 double
486 else if (bit_sz
== 16)
490 gcc_assert (bit_sz
== MAX_BASE_INT_BIT_SIZE
);
494 /* For pow ((double)x, y), generate the following conditions:
501 if (temp2 > max_exp_real_cst) */
503 /* Generate condition in reverse order -- first
504 the condition for the exp argument. */
506 exp_domain
= get_domain (0, false, false,
507 max_exp
, true, true);
509 gen_conditions_for_domain (expn
, exp_domain
,
512 /* Now generate condition for the base argument.
513 Note it does not use the helper function
514 gen_conditions_for_domain because the base
517 /* Push a separator. */
518 conds
.quick_push (NULL
);
520 temp
= create_tmp_var (int_type
, "DCE_COND1");
521 cst0
= build_int_cst (int_type
, 0);
522 stmt1
= gimple_build_assign (temp
, base_val0
);
523 tempn
= make_ssa_name (temp
, stmt1
);
524 gimple_assign_set_lhs (stmt1
, tempn
);
525 stmt2
= gimple_build_cond (LE_EXPR
, tempn
, cst0
, NULL_TREE
, NULL_TREE
);
527 conds
.quick_push (stmt1
);
528 conds
.quick_push (stmt2
);
532 /* Method to generate conditional statements for guarding conditionally
533 dead calls to pow. One or more statements can be generated for
534 each logical condition. Statement groups of different conditions
535 are separated by a NULL tree and they are stored in the vec
536 conds. The number of logical conditions are stored in *nconds.
538 See C99 standard, 7.12.7.4:2, for description of pow (x, y).
539 The precise condition for domain errors are complex. In this
540 implementation, a simplified (but conservative) valid domain
541 for x and y are used: x is positive to avoid dom errors, while
542 y is smaller than a upper bound (depending on x) to avoid range
543 errors. Runtime code is generated to check x (if not constant)
544 and y against the valid domain. If it is out, jump to the call,
545 otherwise the call is bypassed. POW_CALL is the call statement,
546 *CONDS is a vector holding the resulting condition statements,
547 and *NCONDS is the number of logical conditions. */
550 gen_conditions_for_pow (gimple pow_call
, vec
<gimple
> conds
,
556 gcc_checking_assert (check_pow (pow_call
));
560 base
= gimple_call_arg (pow_call
, 0);
561 expn
= gimple_call_arg (pow_call
, 1);
563 bc
= TREE_CODE (base
);
566 gen_conditions_for_pow_cst_base (base
, expn
, conds
, nconds
);
567 else if (bc
== SSA_NAME
)
568 gen_conditions_for_pow_int_base (base
, expn
, conds
, nconds
);
573 /* A helper routine to help computing the valid input domain
574 for a builtin function. See C99 7.12.7 for details. In this
575 implementation, we only handle single region domain. The
576 resulting region can be conservative (smaller) than the actual
577 one and rounded to integers. Some of the bounds are documented
578 in the standard, while other limit constants are computed
579 assuming IEEE floating point format (for SF and DF modes).
580 Since IEEE only sets minimum requirements for long double format,
581 different long double formats exist under different implementations
582 (e.g, 64 bit double precision (DF), 80 bit double-extended
583 precision (XF), and 128 bit quad precision (QF) ). For simplicity,
584 in this implementation, the computed bounds for long double assume
585 64 bit format (DF), and are therefore conservative. Another
586 assumption is that single precision float type is always SF mode,
587 and double type is DF mode. This function is quite
588 implementation specific, so it may not be suitable to be part of
589 builtins.c. This needs to be revisited later to see if it can
590 be leveraged in x87 assembly expansion. */
593 get_no_error_domain (enum built_in_function fnc
)
597 /* Trig functions: return [-1, +1] */
598 CASE_FLT_FN (BUILT_IN_ACOS
):
599 CASE_FLT_FN (BUILT_IN_ASIN
):
600 return get_domain (-1, true, true,
602 /* Hyperbolic functions. */
603 CASE_FLT_FN (BUILT_IN_ACOSH
):
604 /* acosh: [1, +inf) */
605 return get_domain (1, true, true,
607 CASE_FLT_FN (BUILT_IN_ATANH
):
608 /* atanh: (-1, +1) */
609 return get_domain (-1, true, false,
613 /* coshf: (-89, +89) */
614 return get_domain (-89, true, false,
620 /* cosh: (-710, +710) */
621 return get_domain (-710, true, false,
623 /* Log functions: (0, +inf) */
624 CASE_FLT_FN (BUILT_IN_LOG
):
625 CASE_FLT_FN (BUILT_IN_LOG2
):
626 CASE_FLT_FN (BUILT_IN_LOG10
):
627 return get_domain (0, true, false,
629 CASE_FLT_FN (BUILT_IN_LOG1P
):
630 return get_domain (-1, true, false,
634 case BUILT_IN_EXPM1F
:
635 /* expf: (-inf, 88) */
636 return get_domain (-1, false, false,
641 case BUILT_IN_EXPM1L
:
642 /* exp: (-inf, 709) */
643 return get_domain (-1, false, false,
646 /* exp2f: (-inf, 128) */
647 return get_domain (-1, false, false,
651 /* exp2: (-inf, 1024) */
652 return get_domain (-1, false, false,
654 case BUILT_IN_EXP10F
:
655 case BUILT_IN_POW10F
:
656 /* exp10f: (-inf, 38) */
657 return get_domain (-1, false, false,
661 case BUILT_IN_EXP10L
:
662 case BUILT_IN_POW10L
:
663 /* exp10: (-inf, 308) */
664 return get_domain (-1, false, false,
666 /* sqrt: [0, +inf) */
667 CASE_FLT_FN (BUILT_IN_SQRT
):
668 return get_domain (0, true, true,
677 /* The function to generate shrink wrap conditions for a partially
678 dead builtin call whose return value is not used anywhere,
679 but has to be kept live due to potential error condition.
680 BI_CALL is the builtin call, CONDS is the vector of statements
681 for condition code, NCODES is the pointer to the number of
682 logical conditions. Statements belonging to different logical
683 condition are separated by NULL tree in the vector. */
686 gen_shrink_wrap_conditions (gimple bi_call
, vec
<gimple
> conds
,
687 unsigned int *nconds
)
691 enum built_in_function fnc
;
693 gcc_assert (nconds
&& conds
.exists ());
694 gcc_assert (conds
.length () == 0);
695 gcc_assert (is_gimple_call (bi_call
));
698 fn
= gimple_call_fndecl (call
);
699 gcc_assert (fn
&& DECL_BUILT_IN (fn
));
700 fnc
= DECL_FUNCTION_CODE (fn
);
703 if (fnc
== BUILT_IN_POW
)
704 gen_conditions_for_pow (call
, conds
, nconds
);
708 inp_domain domain
= get_no_error_domain (fnc
);
710 arg
= gimple_call_arg (bi_call
, 0);
711 gen_conditions_for_domain (arg
, domain
, conds
, nconds
);
718 /* Probability of the branch (to the call) is taken. */
719 #define ERR_PROB 0.01
721 /* The function to shrink wrap a partially dead builtin call
722 whose return value is not used anywhere, but has to be kept
723 live due to potential error condition. Returns true if the
724 transformation actually happens. */
727 shrink_wrap_one_built_in_call (gimple bi_call
)
729 gimple_stmt_iterator bi_call_bsi
;
730 basic_block bi_call_bb
, join_tgt_bb
, guard_bb
, guard_bb0
;
731 edge join_tgt_in_edge_from_call
, join_tgt_in_edge_fall_thru
;
732 edge bi_call_in_edge0
, guard_bb_in_edge
;
733 unsigned tn_cond_stmts
, nconds
;
735 gimple cond_expr
= NULL
;
736 gimple cond_expr_start
;
737 tree bi_call_label_decl
;
738 gimple bi_call_label
;
740 auto_vec
<gimple
, 12> conds
;
741 gen_shrink_wrap_conditions (bi_call
, conds
, &nconds
);
743 /* This can happen if the condition generator decides
744 it is not beneficial to do the transformation. Just
745 return false and do not do any transformation for
750 bi_call_bb
= gimple_bb (bi_call
);
752 /* Now find the join target bb -- split bi_call_bb if needed. */
753 if (stmt_ends_bb_p (bi_call
))
755 /* If the call must be the last in the bb, don't split the block,
756 it could e.g. have EH edges. */
757 join_tgt_in_edge_from_call
= find_fallthru_edge (bi_call_bb
->succs
);
758 if (join_tgt_in_edge_from_call
== NULL
)
762 join_tgt_in_edge_from_call
= split_block (bi_call_bb
, bi_call
);
764 bi_call_bsi
= gsi_for_stmt (bi_call
);
766 join_tgt_bb
= join_tgt_in_edge_from_call
->dest
;
768 /* Now it is time to insert the first conditional expression
769 into bi_call_bb and split this bb so that bi_call is
771 tn_cond_stmts
= conds
.length ();
773 cond_expr_start
= conds
[0];
774 for (ci
= 0; ci
< tn_cond_stmts
; ci
++)
776 gimple c
= conds
[ci
];
777 gcc_assert (c
|| ci
!= 0);
780 gsi_insert_before (&bi_call_bsi
, c
, GSI_SAME_STMT
);
785 gcc_assert (cond_expr
&& gimple_code (cond_expr
) == GIMPLE_COND
);
788 bi_call_label_decl
= create_artificial_label (gimple_location (bi_call
));
789 bi_call_label
= gimple_build_label (bi_call_label_decl
);
790 gsi_insert_before (&bi_call_bsi
, bi_call_label
, GSI_SAME_STMT
);
792 bi_call_in_edge0
= split_block (bi_call_bb
, cond_expr
);
793 bi_call_in_edge0
->flags
&= ~EDGE_FALLTHRU
;
794 bi_call_in_edge0
->flags
|= EDGE_TRUE_VALUE
;
795 guard_bb0
= bi_call_bb
;
796 bi_call_bb
= bi_call_in_edge0
->dest
;
797 join_tgt_in_edge_fall_thru
= make_edge (guard_bb0
, join_tgt_bb
,
800 bi_call_in_edge0
->probability
= REG_BR_PROB_BASE
* ERR_PROB
;
801 bi_call_in_edge0
->count
=
802 apply_probability (guard_bb0
->count
,
803 bi_call_in_edge0
->probability
);
804 join_tgt_in_edge_fall_thru
->probability
=
805 inverse_probability (bi_call_in_edge0
->probability
);
806 join_tgt_in_edge_fall_thru
->count
=
807 guard_bb0
->count
- bi_call_in_edge0
->count
;
809 /* Code generation for the rest of the conditions */
810 guard_bb
= guard_bb0
;
814 edge bi_call_in_edge
;
815 gimple_stmt_iterator guard_bsi
= gsi_for_stmt (cond_expr_start
);
817 cond_expr_start
= conds
[ci0
];
818 for (; ci
< tn_cond_stmts
; ci
++)
820 gimple c
= conds
[ci
];
821 gcc_assert (c
|| ci
!= ci0
);
824 gsi_insert_before (&guard_bsi
, c
, GSI_SAME_STMT
);
829 gcc_assert (cond_expr
&& gimple_code (cond_expr
) == GIMPLE_COND
);
830 guard_bb_in_edge
= split_block (guard_bb
, cond_expr
);
831 guard_bb_in_edge
->flags
&= ~EDGE_FALLTHRU
;
832 guard_bb_in_edge
->flags
|= EDGE_FALSE_VALUE
;
834 bi_call_in_edge
= make_edge (guard_bb
, bi_call_bb
, EDGE_TRUE_VALUE
);
836 bi_call_in_edge
->probability
= REG_BR_PROB_BASE
* ERR_PROB
;
837 bi_call_in_edge
->count
=
838 apply_probability (guard_bb
->count
,
839 bi_call_in_edge
->probability
);
840 guard_bb_in_edge
->probability
=
841 inverse_probability (bi_call_in_edge
->probability
);
842 guard_bb_in_edge
->count
= guard_bb
->count
- bi_call_in_edge
->count
;
845 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
848 loc
= gimple_location (bi_call
);
850 "%s:%d: note: function call is shrink-wrapped"
851 " into error conditions.\n",
852 LOCATION_FILE (loc
), LOCATION_LINE (loc
));
858 /* The top level function for conditional dead code shrink
859 wrapping transformation. */
862 shrink_wrap_conditional_dead_built_in_calls (vec
<gimple
> calls
)
864 bool changed
= false;
867 unsigned n
= calls
.length ();
873 gimple bi_call
= calls
[i
];
874 changed
|= shrink_wrap_one_built_in_call (bi_call
);
882 const pass_data pass_data_call_cdce
=
884 GIMPLE_PASS
, /* type */
886 OPTGROUP_NONE
, /* optinfo_flags */
887 TV_TREE_CALL_CDCE
, /* tv_id */
888 ( PROP_cfg
| PROP_ssa
), /* properties_required */
889 0, /* properties_provided */
890 0, /* properties_destroyed */
891 0, /* todo_flags_start */
892 0, /* todo_flags_finish */
895 class pass_call_cdce
: public gimple_opt_pass
898 pass_call_cdce (gcc::context
*ctxt
)
899 : gimple_opt_pass (pass_data_call_cdce
, ctxt
)
902 /* opt_pass methods: */
903 virtual bool gate (function
*fun
)
905 /* The limit constants used in the implementation
906 assume IEEE floating point format. Other formats
907 can be supported in the future if needed. */
908 return flag_tree_builtin_call_dce
!= 0
909 && optimize_function_for_speed_p (fun
);
912 virtual unsigned int execute (function
*);
914 }; // class pass_call_cdce
917 pass_call_cdce::execute (function
*fun
)
920 gimple_stmt_iterator i
;
921 bool something_changed
= false;
922 auto_vec
<gimple
> cond_dead_built_in_calls
;
923 FOR_EACH_BB_FN (bb
, fun
)
925 /* Collect dead call candidates. */
926 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
928 gimple stmt
= gsi_stmt (i
);
929 if (is_gimple_call (stmt
)
930 && 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
);