diff --git a/gcc/doc/md.texi b/gcc/doc/md.texi index c08691ab4c9a4bfe55ae81e5e228a414d6242d78..f8b32ec12f46d3fb3815f121a16b5a8a1819b66a 100644 --- a/gcc/doc/md.texi +++ b/gcc/doc/md.texi @@ -6972,6 +6972,13 @@ case, you can and should make operand 1's predicate reject some operators in the @samp{cstore@var{mode}4} pattern, or remove the pattern altogether from the machine description. +@cindex @code{tbranch@var{mode}4} instruction pattern +@item @samp{tbranch@var{mode}4} +Conditional branch instruction combined with a bit test-and-compare +instruction. Operand 0 is a comparison operator. Operand 1 is the +operand of the comparison. Operand 2 is the bit position of Operand 1 to test. +Operand 3 is the @code{code_label} to jump to. + @cindex @code{cbranch@var{mode}4} instruction pattern @item @samp{cbranch@var{mode}4} Conditional branch instruction combined with a compare instruction. diff --git a/gcc/dojump.h b/gcc/dojump.h index e379cceb34bb1765cb575636e4c05b61501fc2cf..d1d79c490c420a805fe48d58740a79c1f25fb839 100644 --- a/gcc/dojump.h +++ b/gcc/dojump.h @@ -71,6 +71,10 @@ extern void jumpifnot (tree exp, rtx_code_label *label, extern void jumpifnot_1 (enum tree_code, tree, tree, rtx_code_label *, profile_probability); +extern void do_compare_rtx_and_jump (rtx, rtx, enum rtx_code, int, tree, + machine_mode, rtx, rtx_code_label *, + rtx_code_label *, profile_probability); + extern void do_compare_rtx_and_jump (rtx, rtx, enum rtx_code, int, machine_mode, rtx, rtx_code_label *, rtx_code_label *, profile_probability); diff --git a/gcc/dojump.cc b/gcc/dojump.cc index 2af0cd1aca3b6af13d5d8799094ee93f18022296..190324f36f1a31990f8c49bc8c0f45c23da5c31e 100644 --- a/gcc/dojump.cc +++ b/gcc/dojump.cc @@ -619,7 +619,7 @@ do_jump (tree exp, rtx_code_label *if_false_label, } do_compare_rtx_and_jump (temp, CONST0_RTX (GET_MODE (temp)), NE, TYPE_UNSIGNED (TREE_TYPE (exp)), - GET_MODE (temp), NULL_RTX, + exp, GET_MODE (temp), NULL_RTX, if_false_label, if_true_label, prob); } @@ -687,7 +687,7 @@ do_jump_by_parts_greater_rtx (scalar_int_mode mode, int unsignedp, rtx op0, /* All but high-order word must be compared as unsigned. */ do_compare_rtx_and_jump (op0_word, op1_word, code, (unsignedp || i > 0), - word_mode, NULL_RTX, NULL, if_true_label, + NULL, word_mode, NULL_RTX, NULL, if_true_label, prob); /* Emit only one comparison for 0. Do not emit the last cond jump. */ @@ -695,8 +695,8 @@ do_jump_by_parts_greater_rtx (scalar_int_mode mode, int unsignedp, rtx op0, break; /* Consider lower words only if these are equal. */ - do_compare_rtx_and_jump (op0_word, op1_word, NE, unsignedp, word_mode, - NULL_RTX, NULL, if_false_label, + do_compare_rtx_and_jump (op0_word, op1_word, NE, unsignedp, NULL, + word_mode, NULL_RTX, NULL, if_false_label, prob.invert ()); } @@ -755,7 +755,7 @@ do_jump_by_parts_zero_rtx (scalar_int_mode mode, rtx op0, if (part != 0) { - do_compare_rtx_and_jump (part, const0_rtx, EQ, 1, word_mode, + do_compare_rtx_and_jump (part, const0_rtx, EQ, 1, NULL, word_mode, NULL_RTX, if_false_label, if_true_label, prob); return; } @@ -766,7 +766,7 @@ do_jump_by_parts_zero_rtx (scalar_int_mode mode, rtx op0, for (i = 0; i < nwords; i++) do_compare_rtx_and_jump (operand_subword_force (op0, i, mode), - const0_rtx, EQ, 1, word_mode, NULL_RTX, + const0_rtx, EQ, 1, NULL, word_mode, NULL_RTX, if_false_label, NULL, prob); if (if_true_label) @@ -809,8 +809,8 @@ do_jump_by_parts_equality_rtx (scalar_int_mode mode, rtx op0, rtx op1, for (i = 0; i < nwords; i++) do_compare_rtx_and_jump (operand_subword_force (op0, i, mode), - operand_subword_force (op1, i, mode), - EQ, 0, word_mode, NULL_RTX, + operand_subword_force (op1, i, mode), + EQ, 0, NULL, word_mode, NULL_RTX, if_false_label, NULL, prob); if (if_true_label) @@ -962,6 +962,23 @@ do_compare_rtx_and_jump (rtx op0, rtx op1, enum rtx_code code, int unsignedp, rtx_code_label *if_false_label, rtx_code_label *if_true_label, profile_probability prob) +{ + do_compare_rtx_and_jump (op0, op1, code, unsignedp, NULL, mode, size, + if_false_label, if_true_label, prob); +} + +/* Like do_compare_and_jump but expects the values to compare as two rtx's. + The decision as to signed or unsigned comparison must be made by the caller. + + If MODE is BLKmode, SIZE is an RTX giving the size of the objects being + compared. */ + +void +do_compare_rtx_and_jump (rtx op0, rtx op1, enum rtx_code code, int unsignedp, + tree val, machine_mode mode, rtx size, + rtx_code_label *if_false_label, + rtx_code_label *if_true_label, + profile_probability prob) { rtx tem; rtx_code_label *dummy_label = NULL; @@ -1177,8 +1194,10 @@ do_compare_rtx_and_jump (rtx op0, rtx op1, enum rtx_code code, int unsignedp, } else dest_label = if_false_label; - do_compare_rtx_and_jump (op0, op1, first_code, unsignedp, mode, - size, dest_label, NULL, first_prob); + + do_compare_rtx_and_jump (op0, op1, first_code, unsignedp, + val, mode, size, dest_label, NULL, + first_prob); } /* For !and_them we want to split: if (x) goto t; // prob; @@ -1192,8 +1211,9 @@ do_compare_rtx_and_jump (rtx op0, rtx op1, enum rtx_code code, int unsignedp, else { profile_probability first_prob = prob.split (cprob); - do_compare_rtx_and_jump (op0, op1, first_code, unsignedp, mode, - size, NULL, if_true_label, first_prob); + do_compare_rtx_and_jump (op0, op1, first_code, unsignedp, + val, mode, size, NULL, + if_true_label, first_prob); if (orig_code == NE && can_compare_p (UNEQ, mode, ccp_jump)) { /* x != y can be split into x unord y || x ltgt y @@ -1215,7 +1235,7 @@ do_compare_rtx_and_jump (rtx op0, rtx op1, enum rtx_code code, int unsignedp, } } - emit_cmp_and_jump_insns (op0, op1, code, size, mode, unsignedp, + emit_cmp_and_jump_insns (op0, op1, code, size, mode, unsignedp, val, if_true_label, prob); } @@ -1289,9 +1309,9 @@ do_compare_and_jump (tree treeop0, tree treeop1, enum rtx_code signed_code, op1 = new_op1; } - do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode, - ((mode == BLKmode) - ? expr_size (treeop0) : NULL_RTX), + do_compare_rtx_and_jump (op0, op1, code, unsignedp, treeop0, mode, + ((mode == BLKmode) + ? expr_size (treeop0) : NULL_RTX), if_false_label, if_true_label, prob); } diff --git a/gcc/optabs.cc b/gcc/optabs.cc index cff37ccb0dfc3dd79b97d0abfd872f340855dc96..5b368f77e91d3fce29870f1a5b54a0301e6b7794 100644 --- a/gcc/optabs.cc +++ b/gcc/optabs.cc @@ -46,6 +46,7 @@ along with GCC; see the file COPYING3. If not see #include "libfuncs.h" #include "internal-fn.h" #include "langhooks.h" +#include "gimple.h" static void prepare_float_lib_cmp (rtx, rtx, enum rtx_code, rtx *, machine_mode *); @@ -4620,7 +4621,7 @@ prepare_operand (enum insn_code icode, rtx x, int opnum, machine_mode mode, static void emit_cmp_and_jump_insn_1 (rtx test, machine_mode mode, rtx label, - profile_probability prob) + direct_optab cmp_optab, profile_probability prob) { machine_mode optab_mode; enum mode_class mclass; @@ -4629,7 +4630,7 @@ emit_cmp_and_jump_insn_1 (rtx test, machine_mode mode, rtx label, mclass = GET_MODE_CLASS (mode); optab_mode = (mclass == MODE_CC) ? CCmode : mode; - icode = optab_handler (cbranch_optab, optab_mode); + icode = optab_handler (cmp_optab, optab_mode); gcc_assert (icode != CODE_FOR_nothing); gcc_assert (insn_operand_matches (icode, 0, test)); @@ -4644,6 +4645,71 @@ emit_cmp_and_jump_insn_1 (rtx test, machine_mode mode, rtx label, add_reg_br_prob_note (insn, prob); } +/* Check to see if the supplied comparison in PTEST can be performed as a + bit-test-and-branch instead. VAL must contain the original tree + expression of the non-zero operand which will be used to rewrite the + comparison in PTEST. + + Returns TRUE if operation succeeds and returns updated PMODE and PTEST, + else FALSE. */ + +bool +static validate_test_and_branch (tree val, rtx *ptest, machine_mode *pmode) +{ + if (!val) + return false; + + machine_mode mode = TYPE_MODE (TREE_TYPE (val)); + rtx test = *ptest; + + if (GET_CODE (test) != EQ && GET_CODE (test) != NE) + return false; + + if (tree_zero_one_valued_p (val)) + { + auto pos = BYTES_BIG_ENDIAN ? GET_MODE_BITSIZE (mode) - 1 : 0; + XEXP (test, 1) = gen_int_mode (pos, mode); + *ptest = test; + *pmode = mode; + return true; + } + + if (TREE_CODE (val) != SSA_NAME) + return false; + + gimple *def = SSA_NAME_DEF_STMT (val); + if (!is_gimple_assign (def) + || gimple_assign_rhs_code (def) != BIT_AND_EXPR) + return false; + + tree cst = gimple_assign_rhs2 (def); + + if (!tree_fits_uhwi_p (cst)) + return false; + + tree op0 = gimple_assign_rhs1 (def); + if (TREE_CODE (op0) == SSA_NAME) + { + def = SSA_NAME_DEF_STMT (op0); + if (gimple_assign_cast_p (def)) + op0 = gimple_assign_rhs1 (def); + } + + wide_int wcst = wi::uhwi (tree_to_uhwi (cst), + TYPE_PRECISION (TREE_TYPE (op0))); + int bitpos; + + if ((bitpos = wi::exact_log2 (wcst)) == -1) + return false; + + mode = TYPE_MODE (TREE_TYPE (op0)); + auto pos = BYTES_BIG_ENDIAN ? GET_MODE_BITSIZE (mode) - 1 - bitpos : bitpos; + XEXP (test, 1) = gen_int_mode (pos, mode); + *ptest = test; + *pmode = mode; + return true; +} + /* Generate code to compare X with Y so that the condition codes are set and to jump to LABEL if the condition is true. If X is a constant and Y is not a constant, then the comparison is swapped to @@ -4661,15 +4727,18 @@ emit_cmp_and_jump_insn_1 (rtx test, machine_mode mode, rtx label, It will be potentially converted into an unsigned variant based on UNSIGNEDP to select a proper jump instruction. - PROB is the probability of jumping to LABEL. */ + PROB is the probability of jumping to LABEL. If the comparison is against + zero then VAL contains the expression from which the non-zero RTL is + derived. */ void emit_cmp_and_jump_insns (rtx x, rtx y, enum rtx_code comparison, rtx size, - machine_mode mode, int unsignedp, rtx label, + machine_mode mode, int unsignedp, tree val, rtx label, profile_probability prob) { rtx op0 = x, op1 = y; rtx test; + enum insn_code icode; /* Swap operands and condition to ensure canonical RTL. */ if (swap_commutative_operands_p (x, y) @@ -4690,10 +4759,37 @@ emit_cmp_and_jump_insns (rtx x, rtx y, enum rtx_code comparison, rtx size, prepare_cmp_insn (op0, op1, comparison, size, unsignedp, OPTAB_LIB_WIDEN, &test, &mode); - emit_cmp_and_jump_insn_1 (test, mode, label, prob); + + /* Check if we're comparing a truth type with 0, and if so check if + the target supports tbranch. */ + machine_mode tmode = mode; + if (op1 == CONST0_RTX (GET_MODE (op1)) + && validate_test_and_branch (val, &test, &tmode)) + { + /* If the target supports the testbit comparison directly, great. */ + icode = direct_optab_handler (tbranch_optab, tmode); + if (icode != CODE_FOR_nothing) + { + emit_cmp_and_jump_insn_1 (test, tmode, label, tbranch_optab, prob); + return; + } + } + + emit_cmp_and_jump_insn_1 (test, mode, label, cbranch_optab, prob); } - +/* Overloaded version of emit_cmp_and_jump_insns in which VAL is unknown. */ + +void +emit_cmp_and_jump_insns (rtx x, rtx y, enum rtx_code comparison, rtx size, + machine_mode mode, int unsignedp, rtx label, + profile_probability prob) +{ + emit_cmp_and_jump_insns (x, y, comparison, size, mode, unsignedp, NULL, + label, prob); +} + + /* Emit a library call comparison between floating point X and Y. COMPARISON is the rtl operator to compare with (EQ, NE, GT, etc.). */ diff --git a/gcc/optabs.def b/gcc/optabs.def index 9947aed67fb8a3b675cb0aab9aeb059f89644106..623a596aca2f538a03602e02e6ac12f43f3303c4 100644 --- a/gcc/optabs.def +++ b/gcc/optabs.def @@ -220,6 +220,7 @@ OPTAB_D (reload_in_optab, "reload_in$a") OPTAB_D (reload_out_optab, "reload_out$a") OPTAB_DC(cbranch_optab, "cbranch$a4", COMPARE) +OPTAB_D (tbranch_optab, "tbranch$a4") OPTAB_D (addcc_optab, "add$acc") OPTAB_D (negcc_optab, "neg$acc") OPTAB_D (notcc_optab, "not$acc") diff --git a/gcc/optabs.h b/gcc/optabs.h index cfd7c742d2d21b0539f5227c22a94f32c793d6f7..cd55604bc3d452d7e28c5530bb4793d481766f4f 100644 --- a/gcc/optabs.h +++ b/gcc/optabs.h @@ -268,6 +268,10 @@ extern void emit_cmp_and_jump_insns (rtx, rtx, enum rtx_code, rtx, machine_mode, int, rtx, profile_probability prob = profile_probability::uninitialized ()); +extern void emit_cmp_and_jump_insns (rtx, rtx, enum rtx_code, rtx, + machine_mode, int, tree, rtx, + profile_probability prob + = profile_probability::uninitialized ()); /* Generate code to indirectly jump to a location given in the rtx LOC. */ extern void emit_indirect_jump (rtx); diff --git a/gcc/tree.h b/gcc/tree.h index 8f8a9660c9e0605eb516de194640b8c1b531b798..be3d2dee82f692e81082cf21c878c10f9fe9e1f1 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -4690,6 +4690,7 @@ extern tree signed_or_unsigned_type_for (int, tree); extern tree signed_type_for (tree); extern tree unsigned_type_for (tree); extern bool is_truth_type_for (tree, tree); +extern bool tree_zero_one_valued_p (tree); extern tree truth_type_for (tree); extern tree build_pointer_type_for_mode (tree, machine_mode, bool); extern tree build_pointer_type (tree);