fold-const+optabs: Change return type of predicate functions from int to bool
Also change some internal variables and function argument from int to bool. gcc/ChangeLog: * fold-const.h (multiple_of_p): Change return type from int to bool. * fold-const.cc (split_tree): Change negl_p, neg_litp_p, neg_conp_p and neg_var_p variables to bool. (const_binop): Change sat_p variable to bool. (merge_ranges): Change no_overlap variable to bool. (extract_muldiv_1): Change same_p variable to bool. (tree_swap_operands_p): Update function body for bool return type. (fold_truth_andor): Change commutative variable to bool. (multiple_of_p): Change return type from int to void and adjust function body accordingly. * optabs.h (expand_twoval_unop): Change return type from int to bool. (expand_twoval_binop): Ditto. (can_compare_p): Ditto. (have_add2_insn): Ditto. (have_addptr3_insn): Ditto. (have_sub2_insn): Ditto. (have_insn_for): Ditto. * optabs.cc (add_equal_note): Ditto. (widen_operand): Change no_extend argument from int to bool. (expand_binop): Ditto. (expand_twoval_unop): Change return type from int to void and adjust function body accordingly. (expand_twoval_binop): Ditto. (can_compare_p): Ditto. (have_add2_insn): Ditto. (have_addptr3_insn): Ditto. (have_sub2_insn): Ditto. (have_insn_for): Ditto.
This commit is contained in:
Uros Bizjak
parent
900945f663
commit
ca15abc0ff
4 changed files with 88 additions and 88 deletions
|
|
@ -922,8 +922,8 @@ split_tree (tree in, tree type, enum tree_code code,
|
|||
{
|
||||
tree op0 = TREE_OPERAND (in, 0);
|
||||
tree op1 = TREE_OPERAND (in, 1);
|
||||
int neg1_p = TREE_CODE (in) == MINUS_EXPR;
|
||||
int neg_litp_p = 0, neg_conp_p = 0, neg_var_p = 0;
|
||||
bool neg1_p = TREE_CODE (in) == MINUS_EXPR;
|
||||
bool neg_litp_p = false, neg_conp_p = false, neg_var_p = false;
|
||||
|
||||
/* First see if either of the operands is a literal, then a constant. */
|
||||
if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST
|
||||
|
|
@ -1450,7 +1450,7 @@ const_binop (enum tree_code code, tree arg1, tree arg2)
|
|||
FIXED_VALUE_TYPE f2;
|
||||
FIXED_VALUE_TYPE result;
|
||||
tree t, type;
|
||||
int sat_p;
|
||||
bool sat_p;
|
||||
bool overflow_p;
|
||||
|
||||
/* The following codes are handled by fixed_arithmetic. */
|
||||
|
|
@ -5680,7 +5680,7 @@ bool
|
|||
merge_ranges (int *pin_p, tree *plow, tree *phigh, int in0_p, tree low0,
|
||||
tree high0, int in1_p, tree low1, tree high1)
|
||||
{
|
||||
int no_overlap;
|
||||
bool no_overlap;
|
||||
int subset;
|
||||
int temp;
|
||||
tree tem;
|
||||
|
|
@ -6855,7 +6855,7 @@ extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type,
|
|||
> GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (type)))
|
||||
? wide_type : type);
|
||||
tree t1, t2;
|
||||
int same_p = tcode == code;
|
||||
bool same_p = tcode == code;
|
||||
tree op0 = NULL_TREE, op1 = NULL_TREE;
|
||||
bool sub_strict_overflow_p;
|
||||
|
||||
|
|
@ -7467,17 +7467,17 @@ bool
|
|||
tree_swap_operands_p (const_tree arg0, const_tree arg1)
|
||||
{
|
||||
if (CONSTANT_CLASS_P (arg1))
|
||||
return 0;
|
||||
return false;
|
||||
if (CONSTANT_CLASS_P (arg0))
|
||||
return 1;
|
||||
return true;
|
||||
|
||||
STRIP_NOPS (arg0);
|
||||
STRIP_NOPS (arg1);
|
||||
|
||||
if (TREE_CONSTANT (arg1))
|
||||
return 0;
|
||||
return false;
|
||||
if (TREE_CONSTANT (arg0))
|
||||
return 1;
|
||||
return true;
|
||||
|
||||
/* It is preferable to swap two SSA_NAME to ensure a canonical form
|
||||
for commutative and comparison operators. Ensuring a canonical
|
||||
|
|
@ -7486,21 +7486,21 @@ tree_swap_operands_p (const_tree arg0, const_tree arg1)
|
|||
if (TREE_CODE (arg0) == SSA_NAME
|
||||
&& TREE_CODE (arg1) == SSA_NAME
|
||||
&& SSA_NAME_VERSION (arg0) > SSA_NAME_VERSION (arg1))
|
||||
return 1;
|
||||
return true;
|
||||
|
||||
/* Put SSA_NAMEs last. */
|
||||
if (TREE_CODE (arg1) == SSA_NAME)
|
||||
return 0;
|
||||
return false;
|
||||
if (TREE_CODE (arg0) == SSA_NAME)
|
||||
return 1;
|
||||
return true;
|
||||
|
||||
/* Put variables last. */
|
||||
if (DECL_P (arg1))
|
||||
return 0;
|
||||
return false;
|
||||
if (DECL_P (arg0))
|
||||
return 1;
|
||||
return true;
|
||||
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -9693,10 +9693,10 @@ fold_truth_andor (location_t loc, enum tree_code code, tree type,
|
|||
tree a01 = TREE_OPERAND (arg0, 1);
|
||||
tree a10 = TREE_OPERAND (arg1, 0);
|
||||
tree a11 = TREE_OPERAND (arg1, 1);
|
||||
int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
|
||||
|| TREE_CODE (arg0) == TRUTH_AND_EXPR)
|
||||
&& (code == TRUTH_AND_EXPR
|
||||
|| code == TRUTH_OR_EXPR));
|
||||
bool commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
|
||||
|| TREE_CODE (arg0) == TRUTH_AND_EXPR)
|
||||
&& (code == TRUTH_AND_EXPR
|
||||
|| code == TRUTH_OR_EXPR));
|
||||
|
||||
if (operand_equal_p (a00, a10, 0))
|
||||
return fold_build2_loc (loc, TREE_CODE (arg0), type, a00,
|
||||
|
|
@ -14012,8 +14012,8 @@ fold_binary_initializer_loc (location_t loc, tree_code code, tree type,
|
|||
#undef START_FOLD_INIT
|
||||
#undef END_FOLD_INIT
|
||||
|
||||
/* Determine if first argument is a multiple of second argument. Return 0 if
|
||||
it is not, or we cannot easily determined it to be.
|
||||
/* Determine if first argument is a multiple of second argument. Return
|
||||
false if it is not, or we cannot easily determined it to be.
|
||||
|
||||
An example of the sort of thing we care about (at this point; this routine
|
||||
could surely be made more general, and expanded to do what the *_DIV_EXPR's
|
||||
|
|
@ -14058,17 +14058,17 @@ fold_binary_initializer_loc (location_t loc, tree_code code, tree type,
|
|||
NOWRAP is mostly used to treat expressions in TYPE_SIZE and friends
|
||||
as not wrapping even though they are generally using unsigned arithmetic. */
|
||||
|
||||
int
|
||||
bool
|
||||
multiple_of_p (tree type, const_tree top, const_tree bottom, bool nowrap)
|
||||
{
|
||||
gimple *stmt;
|
||||
tree op1, op2;
|
||||
|
||||
if (operand_equal_p (top, bottom, 0))
|
||||
return 1;
|
||||
return true;
|
||||
|
||||
if (TREE_CODE (type) != INTEGER_TYPE)
|
||||
return 0;
|
||||
return false;
|
||||
|
||||
switch (TREE_CODE (top))
|
||||
{
|
||||
|
|
@ -14076,7 +14076,7 @@ multiple_of_p (tree type, const_tree top, const_tree bottom, bool nowrap)
|
|||
/* Bitwise and provides a power of two multiple. If the mask is
|
||||
a multiple of BOTTOM then TOP is a multiple of BOTTOM. */
|
||||
if (!integer_pow2p (bottom))
|
||||
return 0;
|
||||
return false;
|
||||
return (multiple_of_p (type, TREE_OPERAND (top, 1), bottom, nowrap)
|
||||
|| multiple_of_p (type, TREE_OPERAND (top, 0), bottom, nowrap));
|
||||
|
||||
|
|
@ -14087,7 +14087,7 @@ multiple_of_p (tree type, const_tree top, const_tree bottom, bool nowrap)
|
|||
if (!nowrap
|
||||
&& !TYPE_OVERFLOW_UNDEFINED (type)
|
||||
&& !integer_pow2p (bottom))
|
||||
return 0;
|
||||
return false;
|
||||
if (TREE_CODE (bottom) == INTEGER_CST)
|
||||
{
|
||||
op1 = TREE_OPERAND (top, 0);
|
||||
|
|
@ -14097,7 +14097,7 @@ multiple_of_p (tree type, const_tree top, const_tree bottom, bool nowrap)
|
|||
if (TREE_CODE (op2) == INTEGER_CST)
|
||||
{
|
||||
if (multiple_of_p (type, op2, bottom, nowrap))
|
||||
return 1;
|
||||
return true;
|
||||
/* Handle multiple_of_p ((x * 2 + 2) * 4, 8). */
|
||||
if (multiple_of_p (type, bottom, op2, nowrap))
|
||||
{
|
||||
|
|
@ -14129,7 +14129,7 @@ multiple_of_p (tree type, const_tree top, const_tree bottom, bool nowrap)
|
|||
nowrap);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
return false;
|
||||
|
||||
case MINUS_EXPR:
|
||||
case PLUS_EXPR:
|
||||
|
|
@ -14139,7 +14139,7 @@ multiple_of_p (tree type, const_tree top, const_tree bottom, bool nowrap)
|
|||
if (!nowrap
|
||||
&& !TYPE_OVERFLOW_UNDEFINED (type)
|
||||
&& !integer_pow2p (bottom))
|
||||
return 0;
|
||||
return false;
|
||||
|
||||
/* Handle cases like op0 + 0xfffffffd as op0 - 3 if the expression has
|
||||
unsigned type. For example, (X / 3) + 0xfffffffd is multiple of 3,
|
||||
|
|
@ -14163,7 +14163,7 @@ multiple_of_p (tree type, const_tree top, const_tree bottom, bool nowrap)
|
|||
if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
|
||||
|| (TYPE_PRECISION (type)
|
||||
< TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
|
||||
return 0;
|
||||
return false;
|
||||
/* NOWRAP only extends to operations in the outermost type so
|
||||
make sure to strip it off here. */
|
||||
return multiple_of_p (TREE_TYPE (TREE_OPERAND (top, 0)),
|
||||
|
|
@ -14178,7 +14178,7 @@ multiple_of_p (tree type, const_tree top, const_tree bottom, bool nowrap)
|
|||
|
||||
case INTEGER_CST:
|
||||
if (TREE_CODE (bottom) != INTEGER_CST || integer_zerop (bottom))
|
||||
return 0;
|
||||
return false;
|
||||
return wi::multiple_of_p (wi::to_widest (top), wi::to_widest (bottom),
|
||||
SIGNED);
|
||||
|
||||
|
|
@ -14204,7 +14204,7 @@ multiple_of_p (tree type, const_tree top, const_tree bottom, bool nowrap)
|
|||
&& integer_pow2p (bottom)
|
||||
&& wi::multiple_of_p (wi::to_widest (op2),
|
||||
wi::to_widest (bottom), UNSIGNED))
|
||||
return 1;
|
||||
return true;
|
||||
|
||||
op1 = gimple_assign_rhs1 (stmt);
|
||||
if (code == MINUS_EXPR
|
||||
|
|
@ -14215,7 +14215,7 @@ multiple_of_p (tree type, const_tree top, const_tree bottom, bool nowrap)
|
|||
&& (code = gimple_assign_rhs_code (stmt)) == TRUNC_MOD_EXPR
|
||||
&& operand_equal_p (op1, gimple_assign_rhs1 (stmt), 0)
|
||||
&& operand_equal_p (bottom, gimple_assign_rhs2 (stmt), 0))
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
/* fall through */
|
||||
|
|
@ -14225,7 +14225,7 @@ multiple_of_p (tree type, const_tree top, const_tree bottom, bool nowrap)
|
|||
return multiple_p (wi::to_poly_widest (top),
|
||||
wi::to_poly_widest (bottom));
|
||||
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -103,7 +103,7 @@ extern void fold_overflow_warning (const char*, enum warn_strict_overflow_code);
|
|||
extern enum tree_code fold_div_compare (enum tree_code, tree, tree,
|
||||
tree *, tree *, bool *);
|
||||
extern bool operand_equal_p (const_tree, const_tree, unsigned int flags = 0);
|
||||
extern int multiple_of_p (tree, const_tree, const_tree, bool = true);
|
||||
extern bool multiple_of_p (tree, const_tree, const_tree, bool = true);
|
||||
#define omit_one_operand(T1,T2,T3)\
|
||||
omit_one_operand_loc (UNKNOWN_LOCATION, T1, T2, T3)
|
||||
extern tree omit_one_operand_loc (location_t, tree, tree, tree);
|
||||
|
|
|
|||
|
|
@ -63,13 +63,13 @@ void debug_optab_libfuncs (void);
|
|||
the result of operation CODE applied to OP0 (and OP1 if it is a binary
|
||||
operation). OP0_MODE is OP0's mode.
|
||||
|
||||
If the last insn does not set TARGET, don't do anything, but return 1.
|
||||
If the last insn does not set TARGET, don't do anything, but return true.
|
||||
|
||||
If the last insn or a previous insn sets TARGET and TARGET is one of OP0
|
||||
or OP1, don't add the REG_EQUAL note but return 0. Our caller can then
|
||||
or OP1, don't add the REG_EQUAL note but return false. Our caller can then
|
||||
try again, ensuring that TARGET is not one of the operands. */
|
||||
|
||||
static int
|
||||
static bool
|
||||
add_equal_note (rtx_insn *insns, rtx target, enum rtx_code code, rtx op0,
|
||||
rtx op1, machine_mode op0_mode)
|
||||
{
|
||||
|
|
@ -84,10 +84,10 @@ add_equal_note (rtx_insn *insns, rtx target, enum rtx_code code, rtx op0,
|
|||
&& GET_RTX_CLASS (code) != RTX_COMM_COMPARE
|
||||
&& GET_RTX_CLASS (code) != RTX_COMPARE
|
||||
&& GET_RTX_CLASS (code) != RTX_UNARY)
|
||||
return 1;
|
||||
return true;
|
||||
|
||||
if (GET_CODE (target) == ZERO_EXTRACT)
|
||||
return 1;
|
||||
return true;
|
||||
|
||||
for (last_insn = insns;
|
||||
NEXT_INSN (last_insn) != NULL_RTX;
|
||||
|
|
@ -118,20 +118,20 @@ add_equal_note (rtx_insn *insns, rtx target, enum rtx_code code, rtx op0,
|
|||
&& (rtx_equal_p (SET_DEST (set), XEXP (SET_SRC (set), 0))
|
||||
|| (op1 && rtx_equal_p (SET_DEST (set),
|
||||
XEXP (SET_SRC (set), 1)))))
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
set = set_for_reg_notes (last_insn);
|
||||
if (set == NULL_RTX)
|
||||
return 1;
|
||||
return true;
|
||||
|
||||
if (! rtx_equal_p (SET_DEST (set), target)
|
||||
/* For a STRICT_LOW_PART, the REG_NOTE applies to what is inside it. */
|
||||
&& (GET_CODE (SET_DEST (set)) != STRICT_LOW_PART
|
||||
|| ! rtx_equal_p (XEXP (SET_DEST (set), 0), target)))
|
||||
return 1;
|
||||
return true;
|
||||
|
||||
if (GET_RTX_CLASS (code) == RTX_UNARY)
|
||||
switch (code)
|
||||
|
|
@ -165,7 +165,7 @@ add_equal_note (rtx_insn *insns, rtx target, enum rtx_code code, rtx op0,
|
|||
|
||||
set_unique_reg_note (last_insn, REG_EQUAL, note);
|
||||
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Given two input operands, OP0 and OP1, determine what the correct from_mode
|
||||
|
|
@ -193,14 +193,14 @@ widened_mode (machine_mode to_mode, rtx op0, rtx op1)
|
|||
}
|
||||
|
||||
/* Widen OP to MODE and return the rtx for the widened operand. UNSIGNEDP
|
||||
says whether OP is signed or unsigned. NO_EXTEND is nonzero if we need
|
||||
says whether OP is signed or unsigned. NO_EXTEND is true if we need
|
||||
not actually do a sign-extend or zero-extend, but can leave the
|
||||
higher-order bits of the result rtx undefined, for example, in the case
|
||||
of logical operations, but not right shifts. */
|
||||
|
||||
static rtx
|
||||
widen_operand (rtx op, machine_mode mode, machine_mode oldmode,
|
||||
int unsignedp, int no_extend)
|
||||
int unsignedp, bool no_extend)
|
||||
{
|
||||
rtx result;
|
||||
scalar_int_mode int_mode;
|
||||
|
|
@ -1657,7 +1657,7 @@ expand_binop (machine_mode mode, optab binoptab, rtx op0, rtx op1,
|
|||
!= CODE_FOR_nothing)))
|
||||
{
|
||||
rtx xop0 = op0, xop1 = op1;
|
||||
int no_extend = 0;
|
||||
bool no_extend = false;
|
||||
|
||||
/* For certain integer operations, we need not actually extend
|
||||
the narrow operands, as long as we will truncate
|
||||
|
|
@ -1669,7 +1669,7 @@ expand_binop (machine_mode mode, optab binoptab, rtx op0, rtx op1,
|
|||
|| binoptab == smul_optab || binoptab == ashl_optab)
|
||||
&& mclass == MODE_INT)
|
||||
{
|
||||
no_extend = 1;
|
||||
no_extend = true;
|
||||
xop0 = avoid_expensive_constant (mode, binoptab, 0,
|
||||
xop0, unsignedp);
|
||||
if (binoptab != ashl_optab)
|
||||
|
|
@ -2262,7 +2262,7 @@ expand_binop (machine_mode mode, optab binoptab, rtx op0, rtx op1,
|
|||
&& optab_libfunc (binoptab, wider_mode)))
|
||||
{
|
||||
rtx xop0 = op0, xop1 = op1;
|
||||
int no_extend = 0;
|
||||
bool no_extend = false;
|
||||
|
||||
/* For certain integer operations, we need not actually extend
|
||||
the narrow operands, as long as we will truncate
|
||||
|
|
@ -2273,7 +2273,7 @@ expand_binop (machine_mode mode, optab binoptab, rtx op0, rtx op1,
|
|||
|| binoptab == add_optab || binoptab == sub_optab
|
||||
|| binoptab == smul_optab || binoptab == ashl_optab)
|
||||
&& mclass == MODE_INT)
|
||||
no_extend = 1;
|
||||
no_extend = true;
|
||||
|
||||
xop0 = widen_operand (xop0, wider_mode, mode,
|
||||
unsignedp, no_extend);
|
||||
|
|
@ -2372,9 +2372,9 @@ sign_expand_binop (machine_mode mode, optab uoptab, optab soptab,
|
|||
the result is not actually wanted. We will generate it into
|
||||
a dummy pseudo-reg and discard it. They may not both be zero.
|
||||
|
||||
Returns 1 if this operation can be performed; 0 if not. */
|
||||
Returns true if this operation can be performed; false if not. */
|
||||
|
||||
int
|
||||
bool
|
||||
expand_twoval_unop (optab unoptab, rtx op0, rtx targ0, rtx targ1,
|
||||
int unsignedp)
|
||||
{
|
||||
|
|
@ -2403,7 +2403,7 @@ expand_twoval_unop (optab unoptab, rtx op0, rtx targ0, rtx targ1,
|
|||
create_fixed_operand (&ops[1], targ1);
|
||||
create_convert_operand_from (&ops[2], op0, mode, unsignedp);
|
||||
if (maybe_expand_insn (icode, 3, ops))
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
/* It can't be done in this mode. Can we do it in a wider mode? */
|
||||
|
|
@ -2422,7 +2422,7 @@ expand_twoval_unop (optab unoptab, rtx op0, rtx targ0, rtx targ1,
|
|||
{
|
||||
convert_move (targ0, t0, unsignedp);
|
||||
convert_move (targ1, t1, unsignedp);
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
delete_insns_since (last);
|
||||
|
|
@ -2431,7 +2431,7 @@ expand_twoval_unop (optab unoptab, rtx op0, rtx targ0, rtx targ1,
|
|||
}
|
||||
|
||||
delete_insns_since (entry_last);
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Generate code to perform an operation specified by BINOPTAB
|
||||
|
|
@ -2444,9 +2444,9 @@ expand_twoval_unop (optab unoptab, rtx op0, rtx targ0, rtx targ1,
|
|||
the result is not actually wanted. We will generate it into
|
||||
a dummy pseudo-reg and discard it. They may not both be zero.
|
||||
|
||||
Returns 1 if this operation can be performed; 0 if not. */
|
||||
Returns true if this operation can be performed; false if not. */
|
||||
|
||||
int
|
||||
bool
|
||||
expand_twoval_binop (optab binoptab, rtx op0, rtx op1, rtx targ0, rtx targ1,
|
||||
int unsignedp)
|
||||
{
|
||||
|
|
@ -2483,7 +2483,7 @@ expand_twoval_binop (optab binoptab, rtx op0, rtx op1, rtx targ0, rtx targ1,
|
|||
create_convert_operand_from (&ops[2], xop1, mode, unsignedp);
|
||||
create_fixed_operand (&ops[3], targ1);
|
||||
if (maybe_expand_insn (icode, 4, ops))
|
||||
return 1;
|
||||
return true;
|
||||
delete_insns_since (last);
|
||||
}
|
||||
|
||||
|
|
@ -2505,7 +2505,7 @@ expand_twoval_binop (optab binoptab, rtx op0, rtx op1, rtx targ0, rtx targ1,
|
|||
{
|
||||
convert_move (targ0, t0, unsignedp);
|
||||
convert_move (targ1, t1, unsignedp);
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
delete_insns_since (last);
|
||||
|
|
@ -2514,7 +2514,7 @@ expand_twoval_binop (optab binoptab, rtx op0, rtx op1, rtx targ0, rtx targ1,
|
|||
}
|
||||
|
||||
delete_insns_since (entry_last);
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Expand the two-valued library call indicated by BINOPTAB, but
|
||||
|
|
@ -4298,7 +4298,7 @@ emit_libcall_block (rtx_insn *insns, rtx target, rtx result, rtx equiv)
|
|||
emit_libcall_block_1 (insns, target, result, equiv, false);
|
||||
}
|
||||
|
||||
/* Nonzero if we can perform a comparison of mode MODE straightforwardly.
|
||||
/* True if we can perform a comparison of mode MODE straightforwardly.
|
||||
PURPOSE describes how this comparison will be used. CODE is the rtx
|
||||
comparison code we will be using.
|
||||
|
||||
|
|
@ -4306,7 +4306,7 @@ emit_libcall_block (rtx_insn *insns, rtx target, rtx result, rtx equiv)
|
|||
required to implement all of the normal bcc operations, but not
|
||||
required to implement all (or any) of the unordered bcc operations. */
|
||||
|
||||
int
|
||||
bool
|
||||
can_compare_p (enum rtx_code code, machine_mode mode,
|
||||
enum can_compare_purpose purpose)
|
||||
{
|
||||
|
|
@ -4319,21 +4319,21 @@ can_compare_p (enum rtx_code code, machine_mode mode,
|
|||
if (purpose == ccp_jump
|
||||
&& (icode = optab_handler (cbranch_optab, mode)) != CODE_FOR_nothing
|
||||
&& insn_operand_matches (icode, 0, test))
|
||||
return 1;
|
||||
return true;
|
||||
if (purpose == ccp_store_flag
|
||||
&& (icode = optab_handler (cstore_optab, mode)) != CODE_FOR_nothing
|
||||
&& insn_operand_matches (icode, 1, test))
|
||||
return 1;
|
||||
return true;
|
||||
if (purpose == ccp_cmov
|
||||
&& optab_handler (cmov_optab, mode) != CODE_FOR_nothing)
|
||||
return 1;
|
||||
return true;
|
||||
|
||||
mode = GET_MODE_WIDER_MODE (mode).else_void ();
|
||||
PUT_MODE (test, mode);
|
||||
}
|
||||
while (mode != VOIDmode);
|
||||
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Return whether RTL code CODE corresponds to an unsigned optab. */
|
||||
|
|
@ -5369,7 +5369,7 @@ gen_add3_insn (rtx r0, rtx r1, rtx c)
|
|||
return GEN_FCN (icode) (r0, r1, c);
|
||||
}
|
||||
|
||||
int
|
||||
bool
|
||||
have_add2_insn (rtx x, rtx y)
|
||||
{
|
||||
enum insn_code icode;
|
||||
|
|
@ -5379,14 +5379,14 @@ have_add2_insn (rtx x, rtx y)
|
|||
icode = optab_handler (add_optab, GET_MODE (x));
|
||||
|
||||
if (icode == CODE_FOR_nothing)
|
||||
return 0;
|
||||
return false;
|
||||
|
||||
if (!insn_operand_matches (icode, 0, x)
|
||||
|| !insn_operand_matches (icode, 1, x)
|
||||
|| !insn_operand_matches (icode, 2, y))
|
||||
return 0;
|
||||
return false;
|
||||
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Generate and return an insn body to add Y to X. */
|
||||
|
|
@ -5406,7 +5406,7 @@ gen_addptr3_insn (rtx x, rtx y, rtx z)
|
|||
/* Return true if the target implements an addptr pattern and X, Y,
|
||||
and Z are valid for the pattern predicates. */
|
||||
|
||||
int
|
||||
bool
|
||||
have_addptr3_insn (rtx x, rtx y, rtx z)
|
||||
{
|
||||
enum insn_code icode;
|
||||
|
|
@ -5416,14 +5416,14 @@ have_addptr3_insn (rtx x, rtx y, rtx z)
|
|||
icode = optab_handler (addptr3_optab, GET_MODE (x));
|
||||
|
||||
if (icode == CODE_FOR_nothing)
|
||||
return 0;
|
||||
return false;
|
||||
|
||||
if (!insn_operand_matches (icode, 0, x)
|
||||
|| !insn_operand_matches (icode, 1, y)
|
||||
|| !insn_operand_matches (icode, 2, z))
|
||||
return 0;
|
||||
return false;
|
||||
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Generate and return an insn body to subtract Y from X. */
|
||||
|
|
@ -5457,7 +5457,7 @@ gen_sub3_insn (rtx r0, rtx r1, rtx c)
|
|||
return GEN_FCN (icode) (r0, r1, c);
|
||||
}
|
||||
|
||||
int
|
||||
bool
|
||||
have_sub2_insn (rtx x, rtx y)
|
||||
{
|
||||
enum insn_code icode;
|
||||
|
|
@ -5467,14 +5467,14 @@ have_sub2_insn (rtx x, rtx y)
|
|||
icode = optab_handler (sub_optab, GET_MODE (x));
|
||||
|
||||
if (icode == CODE_FOR_nothing)
|
||||
return 0;
|
||||
return false;
|
||||
|
||||
if (!insn_operand_matches (icode, 0, x)
|
||||
|| !insn_operand_matches (icode, 1, x)
|
||||
|| !insn_operand_matches (icode, 2, y))
|
||||
return 0;
|
||||
return false;
|
||||
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Generate the body of an insn to extend Y (with mode MFROM)
|
||||
|
|
@ -6057,7 +6057,7 @@ expand_sfix_optab (rtx to, rtx from, convert_optab tab)
|
|||
|
||||
/* Report whether we have an instruction to perform the operation
|
||||
specified by CODE on operands of mode MODE. */
|
||||
int
|
||||
bool
|
||||
have_insn_for (enum rtx_code code, machine_mode mode)
|
||||
{
|
||||
return (code_to_optab (code)
|
||||
|
|
|
|||
16
gcc/optabs.h
16
gcc/optabs.h
|
|
@ -200,10 +200,10 @@ extern rtx sign_expand_binop (machine_mode, optab, optab, rtx, rtx,
|
|||
rtx, int, enum optab_methods);
|
||||
|
||||
/* Generate code to perform an operation on one operand with two results. */
|
||||
extern int expand_twoval_unop (optab, rtx, rtx, rtx, int);
|
||||
extern bool expand_twoval_unop (optab, rtx, rtx, rtx, int);
|
||||
|
||||
/* Generate code to perform an operation on two operands with two results. */
|
||||
extern int expand_twoval_binop (optab, rtx, rtx, rtx, rtx, int);
|
||||
extern bool expand_twoval_binop (optab, rtx, rtx, rtx, rtx, int);
|
||||
|
||||
/* Generate code to perform an operation on two operands with two
|
||||
results, using a library function. */
|
||||
|
|
@ -243,8 +243,8 @@ enum can_compare_purpose
|
|||
|
||||
/* Nonzero if a compare of mode MODE can be done straightforwardly
|
||||
(without splitting it into pieces). */
|
||||
extern int can_compare_p (enum rtx_code, machine_mode,
|
||||
enum can_compare_purpose);
|
||||
extern bool can_compare_p (enum rtx_code, machine_mode,
|
||||
enum can_compare_purpose);
|
||||
|
||||
/* Return whether the backend can emit a vector comparison (vec_cmp/vec_cmpu)
|
||||
for code CODE, comparing operands of mode VALUE_MODE and producing a result
|
||||
|
|
@ -298,12 +298,12 @@ rtx emit_conditional_add (rtx, enum rtx_code, rtx, rtx, machine_mode,
|
|||
Likewise for subtraction and for just copying. */
|
||||
extern rtx_insn *gen_add2_insn (rtx, rtx);
|
||||
extern rtx_insn *gen_add3_insn (rtx, rtx, rtx);
|
||||
extern int have_add2_insn (rtx, rtx);
|
||||
extern bool have_add2_insn (rtx, rtx);
|
||||
extern rtx_insn *gen_addptr3_insn (rtx, rtx, rtx);
|
||||
extern int have_addptr3_insn (rtx, rtx, rtx);
|
||||
extern bool have_addptr3_insn (rtx, rtx, rtx);
|
||||
extern rtx_insn *gen_sub2_insn (rtx, rtx);
|
||||
extern rtx_insn *gen_sub3_insn (rtx, rtx, rtx);
|
||||
extern int have_sub2_insn (rtx, rtx);
|
||||
extern bool have_sub2_insn (rtx, rtx);
|
||||
|
||||
/* Generate the body of an insn to extend Y (with mode MFROM)
|
||||
into X (with mode MTO). Do zero-extension if UNSIGNEDP is nonzero. */
|
||||
|
|
@ -323,7 +323,7 @@ extern bool expand_sfix_optab (rtx, rtx, convert_optab);
|
|||
|
||||
/* Report whether the machine description contains an insn which can
|
||||
perform the operation described by CODE and MODE. */
|
||||
extern int have_insn_for (enum rtx_code, machine_mode);
|
||||
extern bool have_insn_for (enum rtx_code, machine_mode);
|
||||
|
||||
/* Generate a conditional trap instruction. */
|
||||
extern rtx_insn *gen_cond_trap (enum rtx_code, rtx, rtx, rtx);
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue