From: "Marc Poulhiès" <poulhies@adacore.com>
To: gcc-patches@gcc.gnu.org
Cc: Eric Botcazou <ebotcazou@adacore.com>
Subject: [COMMITTED 31/31] ada: Streamline implementation of simple nonbinary modular operations
Date: Tue, 21 May 2024 09:30:34 +0200 [thread overview]
Message-ID: <20240521073035.314024-31-poulhies@adacore.com> (raw)
In-Reply-To: <20240521073035.314024-1-poulhies@adacore.com>
From: Eric Botcazou <ebotcazou@adacore.com>
They are implemented by the nonbinary_modular_operation routine, which is
complex and, in particular, creates signed types and types with a partial
precision each time a subtraction or a multiplication resp. is generated.
Both are unnecessary and a simple approach even generates better code for
the subtraction on architectures with conditional moves.
gcc/ada/
* gcc-interface/utils2.cc (nonbinary_modular_operation): Rewrite.
Do not create signed types for subtraction, do not create types with
partial precision, call fold_convert instead of convert throughout.
Tested on x86_64-pc-linux-gnu, committed on master.
---
gcc/ada/gcc-interface/utils2.cc | 91 ++++++++++-----------------------
1 file changed, 28 insertions(+), 63 deletions(-)
diff --git a/gcc/ada/gcc-interface/utils2.cc b/gcc/ada/gcc-interface/utils2.cc
index 8fb86ab29e3..4b7e2739f6a 100644
--- a/gcc/ada/gcc-interface/utils2.cc
+++ b/gcc/ada/gcc-interface/utils2.cc
@@ -535,85 +535,50 @@ compare_fat_pointers (location_t loc, tree result_type, tree p1, tree p2)
}
/* Compute the result of applying OP_CODE to LHS and RHS, where both are of
- type TYPE. We know that TYPE is a modular type with a nonbinary
- modulus. */
+ TYPE. We know that TYPE is a modular type with a nonbinary modulus. */
static tree
nonbinary_modular_operation (enum tree_code op_code, tree type, tree lhs,
tree rhs)
{
tree modulus = TYPE_MODULUS (type);
- unsigned int needed_precision = tree_floor_log2 (modulus) + 1;
- unsigned int precision;
- bool unsignedp = true;
- tree op_type = type;
- tree result;
+ unsigned precision = tree_floor_log2 (modulus) + 1;
+ tree op_type, result;
- /* If this is an addition of a constant, convert it to a subtraction
- of a constant since we can do that faster. */
- if (op_code == PLUS_EXPR && TREE_CODE (rhs) == INTEGER_CST)
- {
- rhs = fold_build2 (MINUS_EXPR, type, modulus, rhs);
- op_code = MINUS_EXPR;
- }
-
- /* For the logical operations, we only need PRECISION bits. For
- addition and subtraction, we need one more and for multiplication we
- need twice as many. But we never want to make a size smaller than
- our size. */
+ /* For the logical operations, we only need PRECISION bits. For addition and
+ subtraction, we need one more, and for multiplication twice as many. */
if (op_code == PLUS_EXPR || op_code == MINUS_EXPR)
- needed_precision += 1;
+ precision += 1;
else if (op_code == MULT_EXPR)
- needed_precision *= 2;
-
- precision = MAX (needed_precision, TYPE_PRECISION (op_type));
+ precision *= 2;
- /* Unsigned will do for everything but subtraction. */
- if (op_code == MINUS_EXPR)
- unsignedp = false;
-
- /* If our type is the wrong signedness or isn't wide enough, make a new
- type and convert both our operands to it. */
- if (TYPE_PRECISION (op_type) < precision
- || TYPE_UNSIGNED (op_type) != unsignedp)
+ /* If the type is not wide enough, make a new type of the needed precision
+ and convert modulus and operands to it. Use a type with full precision
+ for its mode since operations are ultimately performed in the mode. */
+ if (TYPE_PRECISION (type) < precision)
{
- /* Copy the type so we ensure it can be modified to make it modular. */
- op_type = copy_type (gnat_type_for_size (precision, unsignedp));
- modulus = convert (op_type, modulus);
- SET_TYPE_MODULUS (op_type, modulus);
- TYPE_MODULAR_P (op_type) = 1;
- lhs = convert (op_type, lhs);
- rhs = convert (op_type, rhs);
+ const scalar_int_mode m = smallest_int_mode_for_size (precision);
+ op_type = gnat_type_for_mode (m, 1);
+ modulus = fold_convert (op_type, modulus);
+ lhs = fold_convert (op_type, lhs);
+ rhs = fold_convert (op_type, rhs);
}
+ else
+ op_type = type;
/* Do the operation, then we'll fix it up. */
result = fold_build2 (op_code, op_type, lhs, rhs);
- /* For multiplication, we have no choice but to do a full modulus
- operation. However, we want to do this in the narrowest
- possible size. */
- if (op_code == MULT_EXPR)
- {
- /* Copy the type so we ensure it can be modified to make it modular. */
- tree div_type = copy_type (gnat_type_for_size (needed_precision, 1));
- modulus = convert (div_type, modulus);
- SET_TYPE_MODULUS (div_type, modulus);
- TYPE_MODULAR_P (div_type) = 1;
- result = convert (op_type,
- fold_build2 (TRUNC_MOD_EXPR, div_type,
- convert (div_type, result), modulus));
- }
+ /* Unconditionally add the modulus to the result for a subtraction, this gets
+ rid of all its peculiarities by cancelling out the addition of the binary
+ modulus in the case where the subtraction wraps around in OP_TYPE, and may
+ even generate better code on architectures with conditional moves. */
+ if (op_code == MINUS_EXPR)
+ result = fold_build2 (PLUS_EXPR, op_type, result, modulus);
- /* For subtraction, add the modulus back if we are negative. */
- else if (op_code == MINUS_EXPR)
- {
- result = gnat_protect_expr (result);
- result = fold_build3 (COND_EXPR, op_type,
- fold_build2 (LT_EXPR, boolean_type_node, result,
- build_int_cst (op_type, 0)),
- fold_build2 (PLUS_EXPR, op_type, result, modulus),
- result);
- }
+ /* For a multiplication, we have no choice but to use a modulo operation. */
+ if (op_code == MULT_EXPR)
+ result = fold_build2 (TRUNC_MOD_EXPR, op_type, result, modulus);
/* For the other operations, subtract the modulus if we are >= it. */
else
@@ -627,7 +592,7 @@ nonbinary_modular_operation (enum tree_code op_code, tree type, tree lhs,
result);
}
- return convert (type, result);
+ return fold_convert (type, result);
}
/* This page contains routines that implement the Ada semantics with regard
--
2.43.2
prev parent reply other threads:[~2024-05-21 7:31 UTC|newest]
Thread overview: 31+ messages / expand[flat|nested] mbox.gz Atom feed top
2024-05-21 7:30 [COMMITTED 01/31] ada: Add new Mingw task priority mapping Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 02/31] ada: Follow-up fix to previous change for Text_Ptr Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 03/31] ada: Remove trailing NUL in minimal expansion of Put_Image attribute Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 04/31] ada: Remove conversion from String_Id to String and back to String_Id Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 05/31] ada: Do not leak tagged type names when Discard_Names is enabled Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 06/31] ada: Update documentation of warning messages Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 07/31] ada: Fix index entry for an implemented AI feature Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 08/31] ada: Sort list of implemented Ada 2012 features Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 09/31] ada: Fix formatting in " Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 10/31] ada: Remove some explicit yields in tasking run-time Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 11/31] ada: Simplify management of scopes while inlining Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 12/31] ada: Add elaboration switch tags to info messages Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 13/31] ada: Remove useless trampolines caused by Unchecked_Conversion Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 14/31] ada: Remove duplicate statement Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 15/31] ada: Fix layout in a list of aspects Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 16/31] ada: Missing constraint check for initial value of object with address clause Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 17/31] ada: Fix oversight in previous change Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 18/31] ada: Fix small inaccuracy for Size attribute applied to objects Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 19/31] ada: Fix crash on aliased constant with packed array type and -g switch Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 20/31] ada: Fix assembler error for gigantic library-level object on 64-bit Windows Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 21/31] ada: Remove unused dependencies from gnatbind object list Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 22/31] ada: Avoid temporary for conditional expression of discriminated record type Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 23/31] ada: Follow-up adjustment to earlier fix in Build_Allocate_Deallocate_Proc Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 24/31] ada: Minor typo fix in comment Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 25/31] ada: Fix crash with aliased array and if expression Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 26/31] ada: Fix strict aliasing violation in parameter passing Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 27/31] ada: Make detection of useless copy for return more robust Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 28/31] ada: Fix strict aliasing violation in parameter passing (continued) Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 29/31] ada: Fix internal error on discriminated record with Atomic aspect in Ada 2022 Marc Poulhiès
2024-05-21 7:30 ` [COMMITTED 30/31] ada: Simplify test for propagation of attributes to subtypes Marc Poulhiès
2024-05-21 7:30 ` Marc Poulhiès [this message]
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20240521073035.314024-31-poulhies@adacore.com \
--to=poulhies@adacore.com \
--cc=ebotcazou@adacore.com \
--cc=gcc-patches@gcc.gnu.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).