From 02fff24e2c6d4affc47dac1433b2fb182dadd4db Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Tue, 19 Nov 2024 20:34:36 +0100 Subject: c: Fix up __builtin_stdc_rotate_{left,right} lowering [PR117456] Apparently the middle-end/expansion can only handle {L,R}ROTATE_EXPR on types with mode precision, or large/huge BITINT_TYPE. So, the following patch uses the rotate exprs only in those cases where it can be handled, and emits code with shifts/ior otherwise. As types without mode precision including small/medium BITINT_TYPE have unlikely power of two precision and TRUNC_MOD_EXPR is on many targets quite expensive, I chose to expand e.g. __builtin_stdc_rotate_left (arg1, arg2) as ((tem = arg1, count = arg2 % prec) ? ((tem << count) | (tem >> (prec - count))) : tem) rather than (((tem = arg1) << (count = arg2 % prec)) | (tem >> (-count % prec)) (where the assignments are really save_exprs, so no UB), because I think another TRUNC_MOD_EXPR would be more costly in most cases when the shift count is non-constant (and when it is constant, it folds to 2 shifts by constant and ior in either case). 2024-11-19 Jakub Jelinek PR c/117456 gcc/c/ * c-parser.cc (c_parser_postfix_expression): Use LROTATE_EXPR or RROTATE_EXPR only if type_has_mode_precision_p or if arg1 has BITINT_TYPE with precision larger than MAX_FIXED_MODE_SIZE. Otherwise build BIT_IOR_EXPR of LSHIFT_EXPR and RSHIFT_EXPR and wrap it into a COND_EXPR depending on if arg2 is 0 or not. * c-fold.cc (c_fully_fold_internal): Check for suppression of -Wshift-count-overflow warning. gcc/testsuite/ * gcc.dg/builtin-stdc-rotate-4.c: New test. --- gcc/c/c-fold.cc | 3 ++- gcc/c/c-parser.cc | 34 ++++++++++++++++++++++++++++++++-- 2 files changed, 34 insertions(+), 3 deletions(-) (limited to 'gcc/c') diff --git a/gcc/c/c-fold.cc b/gcc/c/c-fold.cc index deb6896..0c4c590 100644 --- a/gcc/c/c-fold.cc +++ b/gcc/c/c-fold.cc @@ -410,7 +410,8 @@ c_fully_fold_internal (tree expr, bool in_init, bool *maybe_const_operands, || TREE_CODE (TREE_TYPE (orig_op0)) == FIXED_POINT_TYPE) && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (orig_op0))) - >= 0) + >= 0 + && !warning_suppressed_p (expr, OPT_Wshift_count_overflow)) warning_at (loc, OPT_Wshift_count_overflow, (code == LSHIFT_EXPR ? G_("left shift count >= width of type") diff --git a/gcc/c/c-parser.cc b/gcc/c/c-parser.cc index 70fbf94..def6b30 100644 --- a/gcc/c/c-parser.cc +++ b/gcc/c/c-parser.cc @@ -12638,8 +12638,38 @@ c_parser_postfix_expression (c_parser *parser) build_int_cst (utype, prec)); } - expr.value = build2_loc (loc, code, TREE_TYPE (arg1), arg1, - arg2); + /* The middle-end isn't prepared to handle {L,R}ROTATE_EXPR + on types without mode precision, except for large/huge + _BitInt types. */ + if (type_has_mode_precision_p (TREE_TYPE (arg1)) + || (TREE_CODE (TREE_TYPE (arg1)) == BITINT_TYPE + && prec > MAX_FIXED_MODE_SIZE)) + expr.value = build2_loc (loc, code, TREE_TYPE (arg1), arg1, + arg2); + else + { + arg2 = save_expr (arg2); + tree t1 = build2_loc (loc, (code == LROTATE_EXPR + ? LSHIFT_EXPR : RSHIFT_EXPR), + TREE_TYPE (arg1), arg1, arg2); + tree t2 = build2_loc (loc, MINUS_EXPR, + TREE_TYPE (arg2), + build_int_cst (TREE_TYPE (arg2), + prec), arg2); + t2 = build2_loc (loc, (code == LROTATE_EXPR + ? RSHIFT_EXPR : LSHIFT_EXPR), + TREE_TYPE (arg1), arg1, t2); + suppress_warning (t2, OPT_Wshift_count_overflow); + tree t3 = build2_loc (loc, BIT_IOR_EXPR, + TREE_TYPE (arg1), t1, t2); + tree t4 = build2_loc (loc, NE_EXPR, boolean_type_node, + arg2, + build_zero_cst (TREE_TYPE (arg2))); + t4 = build2_loc (loc, COMPOUND_EXPR, boolean_type_node, + arg1, t4); + expr.value = build3_loc (loc, COND_EXPR, + TREE_TYPE (arg1), t4, t3, arg1); + } if (instrument_expr) expr.value = build2_loc (loc, COMPOUND_EXPR, TREE_TYPE (expr.value), -- cgit v1.1