1 /* Conditional Dead Call Elimination pass for the GNU compiler.
3 Free Software Foundation, Inc.
4 Contributed by Xinliang David Li <davidxl@google.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 3, or (at your option) any
13 GCC is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
28 /* These RTL headers are needed for basic-block.h. */
31 #include "hard-reg-set.h"
33 #include "basic-block.h"
36 #include "diagnostic.h"
37 #include "tree-flow.h"
38 #include "tree-gimple.h"
39 #include "tree-dump.h"
40 #include "tree-pass.h"
45 /* Conditional dead call elimination
47 Some builtin functions can set errno on error conditions, but they
48 are otherwise pure. If the result of a call to such a function is
49 not used, the compiler can still not eliminate the call without
50 powerful interprocedural analysis to prove that the errno is not
51 checked. However, if the conditions under which the error occurs
52 are known, the compiler can conditionally dead code eliminate the
53 calls by shrink-wrapping the semi-dead calls into the error condition:
57 if (error_cond (args))
60 An actual simple example is :
61 log (x); // Mostly dead call
65 With this change, call to log (x) is effectively eliminated, as
66 in majority of the cases, log won't be called with x out of
67 range. The branch is totally predictable, so the branch cost
70 Note that library functions are not supposed to clear errno to zero without
71 error. See IEEE Std 1003.1, section 2.3 Error Numbers, and section 7.5:3 of
74 The condition wrapping the builtin call is conservatively set to avoid too
75 aggressive (wrong) shrink wrapping. The optimization is called conditional
76 dead call elimination because the call is eliminated under the condition
77 that the input arguments would not lead to domain or range error (for
78 instance when x <= 0 for a log (x) call), however the chances that the error
79 condition is hit is very low (those builtin calls which are conditionally
80 dead are usually part of the C++ abstraction penalty exposed after
84 /* A structure for representing input domain of
85 a function argument in integer. If the lower
86 bound is -inf, has_lb is set to false. If the
87 upper bound is +inf, has_ub is false.
88 is_lb_inclusive and is_ub_inclusive are flags
89 to indicate if lb and ub value are inclusive
92 typedef struct input_domain
102 static VEC (tree
, heap
) *cond_dead_built_in_calls
;
104 /* A helper function to construct and return an input
105 domain object. LB is the lower bound, HAS_LB is
106 a boolean flag indicating if the lower bound exists,
107 and LB_INCLUSIVE is a boolean flag indicating if the
108 lower bound is inclusive or not. UB, HAS_UB, and
109 UB_INCLUSIVE have the same meaning, but for upper
110 bound of the domain. */
113 get_domain (int lb
, bool has_lb
, bool lb_inclusive
,
114 int ub
, bool has_ub
, bool ub_inclusive
)
118 domain
.has_lb
= has_lb
;
119 domain
.is_lb_inclusive
= lb_inclusive
;
121 domain
.has_ub
= has_ub
;
122 domain
.is_ub_inclusive
= ub_inclusive
;
126 /* A helper function to check the target format for the
127 argument type. In this implementation, only IEEE formats
128 are supported. ARG is the call argument to be checked.
129 Returns true if the format is supported. To support other
130 target formats, function get_no_error_domain needs to be
131 enhanced to have range bounds properly computed. Since
132 the check is cheap (very small number of candidates
133 to be checked), the result is not cached for each float type. */
136 check_target_format (tree arg
)
139 enum machine_mode mode
;
140 const struct real_format
*rfmt
;
142 type
= TREE_TYPE (arg
);
143 mode
= TYPE_MODE (type
);
144 rfmt
= REAL_MODE_FORMAT (mode
);
145 if ((mode
== SFmode
&& rfmt
== &ieee_single_format
)
146 || (mode
== DFmode
&& rfmt
== &ieee_double_format
)
147 /* For long double, we can not really check XFmode
148 which is only defined on intel platforms.
149 Candidate pre-selection using builtin function
150 code guarantees that we are checking formats
151 for long double modes: double, quad, and extended. */
152 || (mode
!= SFmode
&& mode
!= DFmode
153 && (rfmt
== &ieee_quad_format
154 || rfmt
== &ieee_extended_intel_96_format
155 || rfmt
== &ieee_extended_intel_128_format
156 || rfmt
== &ieee_extended_intel_96_round_53_format
)))
163 /* A helper function to help select calls to pow that are suitable for
164 conditional DCE transformation. It looks for pow calls that can be
165 guided with simple conditions. Such calls either have constant base
166 values or base values converted from integers. Returns true if
167 the pow call POW_CALL is a candidate. */
169 /* The maximum integer bit size for base argument of a pow call
170 that is suitable for shrink-wrapping transformation. */
171 #define MAX_BASE_INT_BIT_SIZE 32
174 check_pow (tree pow_call
)
177 enum tree_code bc
, ec
;
179 if (call_expr_nargs (pow_call
) != 2)
182 base
= CALL_EXPR_ARG (pow_call
, 0);
183 expn
= CALL_EXPR_ARG (pow_call
, 1);
185 if (!check_target_format (expn
))
188 bc
= TREE_CODE (base
);
189 ec
= TREE_CODE (expn
);
191 /* Folding candidates are not interesting.
192 Can actually assert that it is already folded. */
193 if (ec
== REAL_CST
&& bc
== REAL_CST
)
198 /* Only handle a fixed range of constant. */
200 REAL_VALUE_TYPE bcv
= TREE_REAL_CST (base
);
201 if (REAL_VALUES_EQUAL (bcv
, dconst1
))
203 if (REAL_VALUES_LESS (bcv
, dconst1
))
205 real_from_integer (&mv
, TYPE_MODE (TREE_TYPE (base
)), 256, 0, 1);
206 if (REAL_VALUES_LESS (mv
, bcv
))
210 else if (bc
== SSA_NAME
)
212 tree base_def
, base_val
, base_val0
, base_var
, type
;
215 /* Only handles cases where base value is converted
216 from integer values. */
217 base_def
= SSA_NAME_DEF_STMT (base
);
218 if (TREE_CODE (base_def
) != GIMPLE_MODIFY_STMT
)
221 base_val
= GIMPLE_STMT_OPERAND (base_def
, 1);
223 if (TREE_CODE (base_val
) != FLOAT_EXPR
)
225 base_val0
= TREE_OPERAND (base_val
, 0);
227 base_var
= SSA_NAME_VAR (base_val0
);
228 if (!DECL_P (base_var
))
231 type
= TREE_TYPE (base_var
);
232 if (TREE_CODE (type
) != INTEGER_TYPE
)
234 bit_sz
= TYPE_PRECISION (type
);
235 /* If the type of the base is too wide,
236 the resulting shrink wrapping condition
237 will be too conservative. */
238 if (bit_sz
> MAX_BASE_INT_BIT_SIZE
)
247 /* A helper function to help select candidate function calls that are
248 suitable for conditional DCE. Candidate functions must have single
249 valid input domain in this implementation except for pow (see check_pow).
250 Returns true if the function call is a candidate. */
253 check_builtin_call (tree bcall
)
257 arg
= CALL_EXPR_ARG (bcall
, 0);
258 return check_target_format (arg
);
261 /* A helper function to determine if a builtin function call is a
262 candidate for conditional DCE. Returns true if the builtin call
266 is_call_dce_candidate (tree call
)
269 enum built_in_function fnc
;
271 if (!flag_tree_builtin_call_dce
)
274 gcc_assert (call
&& TREE_CODE (call
) == CALL_EXPR
);
276 fn
= get_callee_fndecl (call
);
277 if (!fn
|| !DECL_BUILT_IN (fn
)
278 || (DECL_BUILT_IN_CLASS (fn
) != BUILT_IN_NORMAL
))
281 fnc
= DECL_FUNCTION_CODE (fn
);
284 /* Trig functions. */
285 CASE_FLT_FN (BUILT_IN_ACOS
):
286 CASE_FLT_FN (BUILT_IN_ASIN
):
287 /* Hyperbolic functions. */
288 CASE_FLT_FN (BUILT_IN_ACOSH
):
289 CASE_FLT_FN (BUILT_IN_ATANH
):
290 CASE_FLT_FN (BUILT_IN_COSH
):
291 CASE_FLT_FN (BUILT_IN_SINH
):
293 CASE_FLT_FN (BUILT_IN_LOG
):
294 CASE_FLT_FN (BUILT_IN_LOG2
):
295 CASE_FLT_FN (BUILT_IN_LOG10
):
296 CASE_FLT_FN (BUILT_IN_LOG1P
):
298 CASE_FLT_FN (BUILT_IN_EXP
):
299 CASE_FLT_FN (BUILT_IN_EXP2
):
300 CASE_FLT_FN (BUILT_IN_EXP10
):
301 CASE_FLT_FN (BUILT_IN_EXPM1
):
302 CASE_FLT_FN (BUILT_IN_POW10
):
304 CASE_FLT_FN (BUILT_IN_SQRT
):
305 return check_builtin_call (call
);
306 /* Special one: two argument pow. */
308 return check_pow (call
);
317 /* A helper function to generate gimple statements for
318 one bound comparison. ARG is the call argument to
319 be compared with the bound, LBUB is the bound value
320 in integer, TCODE is the tree_code of the comparison,
321 TEMP_NAME1/TEMP_NAME2 are names of the temporaries,
322 CONDS is a vector holding the produced GIMPLE statements,
323 and NCONDS points to the variable holding the number
324 of logical comparisons. CONDS is either empty or
325 a list ended with a null tree. */
328 gen_one_condition (tree arg
, int lbub
,
329 enum tree_code tcode
,
330 const char *temp_name1
,
331 const char *temp_name2
,
332 VEC (tree
, heap
) *conds
,
335 tree lbub_real_cst
, lbub_cst
, float_type
;
336 tree temp
, tempn
, tempc
, tempcn
;
337 tree stmt1
, stmt2
, stmt3
;
339 float_type
= TREE_TYPE (arg
);
340 lbub_cst
= build_int_cst (integer_type_node
, lbub
);
341 lbub_real_cst
= build_real_from_int_cst (float_type
, lbub_cst
);
343 temp
= create_tmp_var (float_type
, temp_name1
);
344 stmt1
= build_gimple_modify_stmt (temp
, arg
);
345 tempn
= make_ssa_name (temp
, stmt1
);
346 GIMPLE_STMT_OPERAND (stmt1
, 0) = tempn
;
348 tempc
= create_tmp_var (boolean_type_node
, temp_name2
);
349 stmt2
= build_gimple_modify_stmt (tempc
,
352 tempn
, lbub_real_cst
));
353 tempcn
= make_ssa_name (tempc
, stmt2
);
354 GIMPLE_STMT_OPERAND (stmt2
, 0) = tempcn
;
356 /* fold_built3 not used for gimple statement here,
357 as it will hit assertion. */
358 stmt3
= build3 (COND_EXPR
, void_type_node
,
359 tempcn
, NULL_TREE
, NULL_TREE
);
360 VEC_quick_push (tree
, conds
, stmt1
);
361 VEC_quick_push (tree
, conds
, stmt2
);
362 VEC_quick_push (tree
, conds
, stmt3
);
366 /* A helper function to generate GIMPLE statements for
367 out of input domain check. ARG is the call argument
368 to be runtime checked, DOMAIN holds the valid domain
369 for the given function, CONDS points to the vector
370 holding the result GIMPLE statements. *NCONDS is
371 the number of logical comparisons. This function
372 produces no more than two logical comparisons, one
373 for lower bound check, one for upper bound check. */
376 gen_conditions_for_domain (tree arg
, inp_domain domain
,
377 VEC (tree
, heap
) *conds
,
381 gen_one_condition (arg
, domain
.lb
,
382 (domain
.is_lb_inclusive
383 ? LT_EXPR
: LE_EXPR
),
384 "DCE_COND_LB", "DCE_COND_LB_TEST",
389 /* Now push a separator. */
391 VEC_quick_push (tree
, conds
, NULL
);
393 gen_one_condition (arg
, domain
.ub
,
394 (domain
.is_ub_inclusive
395 ? GT_EXPR
: GE_EXPR
),
396 "DCE_COND_UB", "DCE_COND_UB_TEST",
402 /* A helper function to generate condition
403 code for the y argument in call pow (some_const, y).
404 See candidate selection in check_pow. Since the
405 candidates' base values have a limited range,
406 the guarded code generated for y are simple:
409 Note max_y can be computed separately for each
410 const base, but in this implementation, we
411 choose to compute it using the max base
412 in the allowed range for the purpose of
413 simplicity. BASE is the constant base value,
414 EXPN is the expression for the exponent argument,
415 *CONDS is the vector to hold resulting statements,
416 and *NCONDS is the number of logical conditions. */
419 gen_conditions_for_pow_cst_base (tree base
, tree expn
,
420 VEC (tree
, heap
) *conds
,
423 inp_domain exp_domain
;
424 /* Validate the range of the base constant to make
425 sure it is consistent with check_pow. */
427 REAL_VALUE_TYPE bcv
= TREE_REAL_CST (base
);
428 gcc_assert (!REAL_VALUES_EQUAL (bcv
, dconst1
)
429 && !REAL_VALUES_LESS (bcv
, dconst1
));
430 real_from_integer (&mv
, TYPE_MODE (TREE_TYPE (base
)), 256, 0, 1);
431 gcc_assert (!REAL_VALUES_LESS (mv
, bcv
));
433 exp_domain
= get_domain (0, false, false,
436 gen_conditions_for_domain (expn
, exp_domain
,
440 /* Generate error condition code for pow calls with
441 non constant base values. The candidates selected
442 have their base argument value converted from
443 integer (see check_pow) value (1, 2, 4 bytes), and
444 the max exp value is computed based on the size
445 of the integer type (i.e. max possible base value).
446 The resulting input domain for exp argument is thus
447 conservative (smaller than the max value allowed by
448 the runtime value of the base). BASE is the integer
449 base value, EXPN is the expression for the exponent
450 argument, *CONDS is the vector to hold resulting
451 statements, and *NCONDS is the number of logical
455 gen_conditions_for_pow_int_base (tree base
, tree expn
,
456 VEC (tree
, heap
) *conds
,
459 tree base_def
, base_nm
, base_val
, base_val0
;
460 tree base_var
, int_type
;
462 tree cst0
, stmt1
, stmt2
;
464 inp_domain exp_domain
;
466 base_def
= SSA_NAME_DEF_STMT (base
);
467 base_nm
= GIMPLE_STMT_OPERAND (base_def
, 0);
468 base_val
= GIMPLE_STMT_OPERAND (base_def
, 1);
469 base_val0
= TREE_OPERAND (base_val
, 0);
470 base_var
= SSA_NAME_VAR (base_val0
);
471 int_type
= TREE_TYPE (base_var
);
472 bit_sz
= TYPE_PRECISION (int_type
);
473 gcc_assert (bit_sz
> 0
474 && bit_sz
<= MAX_BASE_INT_BIT_SIZE
);
476 /* Determine the max exp argument value according to
477 the size of the base integer. The max exp value
478 is conservatively estimated assuming IEEE754 double
482 else if (bit_sz
== 16)
486 gcc_assert (bit_sz
== MAX_BASE_INT_BIT_SIZE
);
490 /* For pow ((double)x, y), generate the following conditions:
497 if (temp2 > max_exp_real_cst) */
499 /* Generate condition in reverse order -- first
500 the condition for the exp argument. */
502 exp_domain
= get_domain (0, false, false,
503 max_exp
, true, true);
505 gen_conditions_for_domain (expn
, exp_domain
,
508 /* Now generate condition for the base argument.
509 Note it does not use the helper function
510 gen_conditions_for_domain because the base
513 /* Push a separator. */
514 VEC_quick_push (tree
, conds
, NULL
);
516 temp
= create_tmp_var (int_type
, "DCE_COND1");
517 cst0
= build_int_cst (int_type
, 0);
518 stmt1
= build_gimple_modify_stmt (temp
, base_val0
);
519 tempn
= make_ssa_name (temp
, stmt1
);
520 GIMPLE_STMT_OPERAND (stmt1
, 0) = tempn
;
521 stmt2
= build3 (COND_EXPR
, void_type_node
,
522 fold_build2 (LE_EXPR
, boolean_type_node
, tempn
, cst0
),
523 NULL_TREE
, NULL_TREE
);
525 VEC_quick_push (tree
, conds
, stmt1
);
526 VEC_quick_push (tree
, conds
, stmt2
);
530 /* Method to generate conditional statements for guarding conditionally
531 dead calls to pow. One or more statements can be generated for
532 each logical condition. Statement groups of different conditions
533 are separated by a NULL tree and they are stored in the VEC
534 conds. The number of logical conditions are stored in *nconds.
536 See C99 standard, 7.12.7.4:2, for description of pow (x, y).
537 The precise condition for domain errors are complex. In this
538 implementation, a simplified (but conservative) valid domain
539 for x and y are used: x is positive to avoid dom errors, while
540 y is smaller than a upper bound (depending on x) to avoid range
541 errors. Runtime code is generated to check x (if not constant)
542 and y against the valid domain. If it is out, jump to the call,
543 otherwise the call is bypassed. POW_CALL is the call statement,
544 *CONDS is a vector holding the resulting condition statements,
545 and *NCONDS is the number of logical conditions. */
548 gen_conditions_for_pow (tree pow_call
, VEC (tree
, heap
) *conds
,
552 enum tree_code bc
, ec
;
554 #ifdef ENABLE_CHECKING
555 gcc_assert (check_pow (pow_call
));
560 base
= CALL_EXPR_ARG (pow_call
, 0);
561 expn
= CALL_EXPR_ARG (pow_call
, 1);
563 bc
= TREE_CODE (base
);
564 ec
= TREE_CODE (expn
);
567 gen_conditions_for_pow_cst_base (base
, expn
,
569 else if (bc
== SSA_NAME
)
570 gen_conditions_for_pow_int_base (base
, expn
,
576 /* A helper routine to help computing the valid input domain
577 for a builtin function. See C99 7.12.7 for details. In this
578 implementation, we only handle single region domain. The
579 resulting region can be conservative (smaller) than the actual
580 one and rounded to integers. Some of the bounds are documented
581 in the standard, while other limit constants are computed
582 assuming IEEE floating point format (for SF and DF modes).
583 Since IEEE only sets minimum requirements for long double format,
584 different long double formats exist under different implementations
585 (e.g, 64 bit double precision (DF), 80 bit double-extended
586 precision (XF), and 128 bit quad precision (QF) ). For simplicity,
587 in this implementation, the computed bounds for long double assume
588 64 bit format (DF), and are therefore conservative. Another
589 assumption is that single precision float type is always SF mode,
590 and double type is DF mode. This function is quite
591 implementation specific, so it may not be suitable to be part of
592 builtins.c. This needs to be revisited later to see if it can
593 be leveraged in x87 assembly expansion. */
596 get_no_error_domain (enum built_in_function fnc
)
600 /* Trig functions: return [-1, +1] */
601 CASE_FLT_FN (BUILT_IN_ACOS
):
602 CASE_FLT_FN (BUILT_IN_ASIN
):
603 return get_domain (-1, true, true,
605 /* Hyperbolic functions. */
606 CASE_FLT_FN (BUILT_IN_ACOSH
):
607 /* acosh: [1, +inf) */
608 return get_domain (1, true, true,
610 CASE_FLT_FN (BUILT_IN_ATANH
):
611 /* atanh: (-1, +1) */
612 return get_domain (-1, true, false,
616 /* coshf: (-89, +89) */
617 return get_domain (-89, true, false,
623 /* cosh: (-710, +710) */
624 return get_domain (-710, true, false,
626 /* Log functions: (0, +inf) */
627 CASE_FLT_FN (BUILT_IN_LOG
):
628 CASE_FLT_FN (BUILT_IN_LOG2
):
629 CASE_FLT_FN (BUILT_IN_LOG10
):
630 return get_domain (0, true, false,
632 CASE_FLT_FN (BUILT_IN_LOG1P
):
633 return get_domain (-1, true, false,
637 case BUILT_IN_EXPM1F
:
638 /* expf: (-inf, 88) */
639 return get_domain (-1, false, false,
644 case BUILT_IN_EXPM1L
:
645 /* exp: (-inf, 709) */
646 return get_domain (-1, false, false,
649 /* exp2f: (-inf, 128) */
650 return get_domain (-1, false, false,
654 /* exp2: (-inf, 1024) */
655 return get_domain (-1, false, false,
657 case BUILT_IN_EXP10F
:
658 case BUILT_IN_POW10F
:
659 /* exp10f: (-inf, 38) */
660 return get_domain (-1, false, false,
664 case BUILT_IN_EXP10L
:
665 case BUILT_IN_POW10L
:
666 /* exp10: (-inf, 308) */
667 return get_domain (-1, false, false,
669 /* sqrt: [0, +inf) */
670 CASE_FLT_FN (BUILT_IN_SQRT
):
671 return get_domain (0, true, true,
680 /* The function to generate shrink wrap conditions for a partially
681 dead builtin call whose return value is not used anywhere,
682 but has to be kept live due to potential error condition.
683 BI_CALL is the builtin call, CONDS is the vector of statements
684 for condition code, NCODES is the pointer to the number of
685 logical conditions. Statements belonging to different logical
686 condition are separated by NULL tree in the vector. */
689 gen_shrink_wrap_conditions (tree bi_call
, VEC (tree
, heap
) *conds
,
690 unsigned int *nconds
)
693 enum built_in_function fnc
;
695 gcc_assert (nconds
&& conds
);
696 gcc_assert (VEC_length (tree
, conds
) == 0);
697 gcc_assert (TREE_CODE (bi_call
) == GIMPLE_MODIFY_STMT
698 || TREE_CODE (bi_call
) == CALL_EXPR
);
701 if (TREE_CODE (call
) == GIMPLE_MODIFY_STMT
)
702 call
= get_call_expr_in (bi_call
);
704 fn
= get_callee_fndecl (call
);
705 gcc_assert (fn
&& DECL_BUILT_IN (fn
));
706 fnc
= DECL_FUNCTION_CODE (fn
);
709 if (fnc
== BUILT_IN_POW
)
710 gen_conditions_for_pow (call
, conds
, nconds
);
714 inp_domain domain
= get_no_error_domain (fnc
);
716 arg
= CALL_EXPR_ARG (bi_call
, 0);
717 gen_conditions_for_domain (arg
, domain
, conds
, nconds
);
724 /* Probability of the branch (to the call) is taken. */
725 #define ERR_PROB 0.01
727 /* The function to shrink wrap a partially dead builtin call
728 whose return value is not used anywhere, but has to be kept
729 live due to potential error condition. Returns true if the
730 transformation actually happens. */
733 shrink_wrap_one_built_in_call (tree bi_call
)
735 block_stmt_iterator bi_call_bsi
;
736 basic_block bi_call_bb
, join_tgt_bb
, guard_bb
, guard_bb0
;
737 edge join_tgt_in_edge_from_call
, join_tgt_in_edge_fall_thru
;
738 edge bi_call_in_edge0
, guard_bb_in_edge
;
739 VEC (tree
, heap
) *conds
;
740 unsigned tn_cond_stmts
, nconds
;
742 tree cond_expr
= NULL
;
743 tree cond_expr_start
;
744 tree bi_call_label_decl
;
747 conds
= VEC_alloc (tree
, heap
, 12);
748 gen_shrink_wrap_conditions (bi_call
, conds
, &nconds
);
750 /* This can happen if the condition generator decides
751 it is not beneficial to do the transformation. Just
752 return false and do not do any transformation for
757 bi_call_bb
= bb_for_stmt (bi_call
);
759 /* Now find the join target bb -- split
760 bi_call_bb if needed. */
761 bi_call_bsi
= bsi_for_stmt (bi_call
);
763 join_tgt_in_edge_from_call
= split_block (bi_call_bb
, bi_call
);
764 bi_call_bsi
= bsi_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
= VEC_length (tree
, conds
);
773 cond_expr_start
= VEC_index (tree
, conds
, 0);
774 for (ci
= 0; ci
< tn_cond_stmts
; ci
++)
776 tree c
= VEC_index (tree
, conds
, ci
);
777 gcc_assert (c
|| ci
!= 0);
780 bsi_insert_before (&bi_call_bsi
, c
, BSI_SAME_STMT
);
785 gcc_assert (cond_expr
&& TREE_CODE (cond_expr
) == COND_EXPR
);
788 bi_call_label_decl
= create_artificial_label ();
789 bi_call_label
= build1 (LABEL_EXPR
, void_type_node
, bi_call_label_decl
);
790 bsi_insert_before (&bi_call_bsi
, bi_call_label
, BSI_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 join_tgt_in_edge_fall_thru
->probability
=
802 REG_BR_PROB_BASE
- bi_call_in_edge0
->probability
;
804 /* Code generation for the rest of the conditions */
805 guard_bb
= guard_bb0
;
809 edge bi_call_in_edge
;
810 block_stmt_iterator guard_bsi
= bsi_for_stmt (cond_expr_start
);
812 cond_expr_start
= VEC_index (tree
, conds
, ci0
);
813 for (; ci
< tn_cond_stmts
; ci
++)
815 tree c
= VEC_index (tree
, conds
, ci
);
816 gcc_assert (c
|| ci
!= ci0
);
819 bsi_insert_before (&guard_bsi
, c
, BSI_SAME_STMT
);
824 gcc_assert (cond_expr
&& TREE_CODE (cond_expr
) == COND_EXPR
);
825 guard_bb_in_edge
= split_block (guard_bb
, cond_expr
);
826 guard_bb_in_edge
->flags
&= ~EDGE_FALLTHRU
;
827 guard_bb_in_edge
->flags
|= EDGE_FALSE_VALUE
;
829 bi_call_in_edge
= make_edge (guard_bb
, bi_call_bb
, EDGE_TRUE_VALUE
);
831 bi_call_in_edge
->probability
= REG_BR_PROB_BASE
* ERR_PROB
;
832 guard_bb_in_edge
->probability
=
833 REG_BR_PROB_BASE
- bi_call_in_edge
->probability
;
836 VEC_free (tree
, heap
, conds
);
837 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
840 loc
= EXPR_LOCATION (bi_call
);
842 "%s:%d: note: function call is shrink-wrapped"
843 " into error conditions.\n",
844 LOCATION_FILE (loc
), LOCATION_LINE (loc
));
850 /* The top level function for conditional dead code shrink
851 wrapping transformation. */
854 shrink_wrap_conditional_dead_built_in_calls (void)
856 bool changed
= false;
859 unsigned n
= VEC_length (tree
, cond_dead_built_in_calls
);
865 tree bi_call
= VEC_index (tree
, cond_dead_built_in_calls
, i
);
866 changed
|= shrink_wrap_one_built_in_call (bi_call
);
872 /* Pass entry points. */
875 tree_call_cdce (void)
878 block_stmt_iterator i
;
879 bool something_changed
= false;
880 cond_dead_built_in_calls
= VEC_alloc (tree
, heap
, 64);
884 /* Collect dead call candidates. */
885 for (i
= bsi_start (bb
); ! bsi_end_p (i
); bsi_next (&i
))
887 tree stmt
= bsi_stmt (i
);
888 if (TREE_CODE (stmt
) == CALL_EXPR
889 && is_call_dce_candidate (stmt
))
891 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
893 fprintf (dump_file
, "Found conditional dead call: ");
894 print_generic_stmt (dump_file
, stmt
, TDF_SLIM
);
895 fprintf (dump_file
, "\n");
897 VEC_quick_push (tree
, cond_dead_built_in_calls
, stmt
);
903 shrink_wrap_conditional_dead_built_in_calls ();
905 VEC_free (tree
, heap
, cond_dead_built_in_calls
);
907 if (something_changed
)
909 free_dominance_info (CDI_DOMINATORS
);
910 free_dominance_info (CDI_POST_DOMINATORS
);
911 return (TODO_update_ssa
| TODO_cleanup_cfg
| TODO_ggc_collect
912 | TODO_remove_unused_locals
);
919 gate_call_cdce (void)
921 /* The limit constants used in the implementation
922 assume IEEE floating point format. Other formats
923 can be supported in the future if needed. */
924 return flag_tree_builtin_call_dce
!= 0;
927 struct gimple_opt_pass pass_call_cdce
=
932 gate_call_cdce
, /* gate */
933 tree_call_cdce
, /* execute */
936 0, /* static_pass_number */
937 TV_TREE_CALL_CDCE
, /* tv_id */
938 PROP_cfg
| PROP_ssa
, /* properties_required */
939 0, /* properties_provided */
940 0, /* properties_destroyed */
941 0, /* todo_flags_start */
942 TODO_dump_func
| TODO_verify_ssa
/* todo_flags_finish */