diff mbox series

[FYI,debug] Avoid dropping bits from num/den in fixed-point types

Message ID orv81mpx79.fsf@lxoliva.fsfla.org
State New
Headers show
Series [FYI,debug] Avoid dropping bits from num/den in fixed-point types | expand

Commit Message

Alexandre Oliva July 3, 2024, 10:49 a.m. UTC 
We used to use an unsigned 128-bit type to hold the numerator and
denominator used to represent the delta of a fixed-point type in debug
information, but there are cases in which that was not enough, and
more significant bits silently overflowed and got omitted from debug
information.

Introduce a mode in which UI_to_gnu selects a wide-enough unsigned
type, and use that to convert numerator and denominator.  While at
that, avoid exceeding the maximum precision for wide ints, and for
available int modes, when selecting a type to represent very wide
constants, falling back to 0/0 for unrepresentable fractions.

Regstrapped on x86_64-linux-gnu.  Pre-approved by Eric.  I'm checking it in.


for  gcc/ada/ChangeLog

	* gcc-interface/cuintp.cc (UI_To_gnu): Add mode that selects a
	wide enough unsigned type.  Fail if the constant exceeds the
	representable numbers.
	* gcc-interface/decl.cc (gnat_to_gnu_entity): Use it for
	numerator and denominator of fixed-point types.  In case of
	failure, fall back to an indeterminate fraction.
---
 gcc/ada/gcc-interface/cuintp.cc |   66 +++++++++++++++++++++++++++++----------
 gcc/ada/gcc-interface/decl.cc   |   19 +++++++++--
 2 files changed, 64 insertions(+), 21 deletions(-)
diff mbox series

Patch

diff --git a/gcc/ada/gcc-interface/cuintp.cc b/gcc/ada/gcc-interface/cuintp.cc
index cdf6c0197500d..1903c5af0f19a 100644
--- a/gcc/ada/gcc-interface/cuintp.cc
+++ b/gcc/ada/gcc-interface/cuintp.cc
@@ -35,6 +35,7 @@ 
 #include "tree.h"
 #include "inchash.h"
 #include "fold-const.h"
+#include "stor-layout.h"
 
 #include "ada.h"
 #include "types.h"
@@ -67,7 +68,9 @@  build_cst_from_int (tree type, HOST_WIDE_INT low)
 /* Similar to UI_To_Int, but return a GCC INTEGER_CST or REAL_CST node,
    depending on whether TYPE is an integral or real type.  Overflow is tested
    by the constant-folding used to build the node.  TYPE is the GCC type of
-   the resulting node.  */
+   the resulting node.  If TYPE is NULL, an unsigned integer type wide enough
+   to hold the entire constant is selected, and if no such type exists,
+   return NULL_TREE.  */
 
 tree
 UI_To_gnu (Uint Input, tree type)
@@ -77,8 +80,10 @@  UI_To_gnu (Uint Input, tree type)
      any such possible value for intermediate computations and then rely on a
      conversion back to TYPE to perform the bias adjustment when need be.  */
   tree comp_type
-    = TREE_CODE (type) == INTEGER_TYPE && TYPE_BIASED_REPRESENTATION_P (type)
-      ? get_base_type (type) : type;
+    = (!type ? gnat_type_for_size (32, 1)
+       : (TREE_CODE (type) == INTEGER_TYPE
+	  && TYPE_BIASED_REPRESENTATION_P (type))
+       ? get_base_type (type) : type);
   tree gnu_ret;
 
   if (Input <= Uint_Direct_Last)
@@ -88,9 +93,14 @@  UI_To_gnu (Uint Input, tree type)
       Int Idx = (*Uints_Ptr)[Input - Uint_Table_Start].Loc;
       Pos Length = (*Uints_Ptr)[Input - Uint_Table_Start].Length;
       Int First = (*Udigits_Ptr)[Idx];
+      tree_code code = First < 0 ? MINUS_EXPR : PLUS_EXPR;
       tree gnu_base;
 
       gcc_assert (Length > 0);
+      /* The extension of unsigned types we use to try to fit the
+	 constant only works if we're dealing with nonnegative
+	 constants, but that's what we expect when !TYPE.  */
+      gcc_assert (type || First >= 0);
 
       /* The computations we perform below always require a type at least as
 	 large as an integer not to overflow.  FP types are always fine, but
@@ -103,22 +113,44 @@  UI_To_gnu (Uint Input, tree type)
       gnu_base = build_cst_from_int (comp_type, Base);
 
       gnu_ret = build_cst_from_int (comp_type, First);
-      if (First < 0)
-	for (Idx++, Length--; Length; Idx++, Length--)
-	  gnu_ret = fold_build2 (MINUS_EXPR, comp_type,
-				 fold_build2 (MULT_EXPR, comp_type,
-					      gnu_ret, gnu_base),
-				 build_cst_from_int (comp_type,
-						     (*Udigits_Ptr)[Idx]));
-      else
-	for (Idx++, Length--; Length; Idx++, Length--)
-	  gnu_ret = fold_build2 (PLUS_EXPR, comp_type,
-				 fold_build2 (MULT_EXPR, comp_type,
-					      gnu_ret, gnu_base),
-				 build_cst_from_int (comp_type,
-						     (*Udigits_Ptr)[Idx]));
+      for (Idx++, Length--; Length; Idx++, Length--)
+	for (;;)
+	  {
+	    tree elt, scaled, next_ret;
+	    elt = build_cst_from_int (comp_type, (*Udigits_Ptr)[Idx]);
+	    /* We want to detect overflows with an unsigned type when
+	       TYPE is not given, but int_const_binop doesn't work for
+	       e.g. floating-point TYPEs.  */
+	    if (!type)
+	      {
+		scaled = int_const_binop (MULT_EXPR, gnu_ret, gnu_base, -1);
+		next_ret = int_const_binop (code, scaled, elt, -1);
+	      }
+	    else
+	      {
+		scaled = fold_build2 (MULT_EXPR, comp_type, gnu_ret, gnu_base);
+		next_ret = fold_build2 (code, comp_type, scaled, elt);
+	      }
+	    if (!TREE_OVERFLOW (next_ret) || type)
+	      {
+		gnu_ret = next_ret;
+		break;
+	      }
+	    opt_scalar_int_mode wider_mode
+	      = GET_MODE_WIDER_MODE (SCALAR_INT_TYPE_MODE
+				     (comp_type)).require ();
+	    if (!wider_mode.exists ())
+	      /* Signal that we couldn't represent the value.  */
+	      return NULL_TREE;
+	    comp_type = make_unsigned_type (GET_MODE_BITSIZE
+					    (wider_mode.require ()));
+	    gnu_base = convert (comp_type, gnu_base);
+	    gnu_ret = convert (comp_type, gnu_ret);
+	  }
     }
 
+  if (!type)
+    type = comp_type;
   gnu_ret = convert (type, gnu_ret);
 
   /* We don't need any NOP_EXPR or NON_LVALUE_EXPR on GNU_RET.  */
diff --git a/gcc/ada/gcc-interface/decl.cc b/gcc/ada/gcc-interface/decl.cc
index 5b3a3b4961b42..d7c17238bbc05 100644
--- a/gcc/ada/gcc-interface/decl.cc
+++ b/gcc/ada/gcc-interface/decl.cc
@@ -1767,14 +1767,25 @@  gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, bool definition)
 
 	/* Use the arbitrary scale factor description.  Note that we support
 	   a Small_Value whose magnitude is larger than 64-bit even on 32-bit
-	   platforms, so we unconditionally use a (dummy) 128-bit type.  */
+	   platforms.  UI_To_gnu chooses a wide-enough integral type.  */
 	else
 	  {
 	    const Uint gnat_num = Norm_Num (gnat_small_value);
 	    const Uint gnat_den = Norm_Den (gnat_small_value);
-	    tree gnu_small_type = make_unsigned_type (128);
-	    tree gnu_num = UI_To_gnu (gnat_num, gnu_small_type);
-	    tree gnu_den = UI_To_gnu (gnat_den, gnu_small_type);
+	    tree gnu_num = UI_To_gnu (gnat_num, NULL_TREE);
+	    tree gnu_den = UI_To_gnu (gnat_den, NULL_TREE);
+
+	    if (!gnu_num || !gnu_den)
+	      gnu_num = gnu_den = integer_zero_node;
+
+	    tree gnu_num_type = TREE_TYPE (gnu_num);
+	    tree gnu_den_type = TREE_TYPE (gnu_den);
+	    tree gnu_small_type = (TYPE_PRECISION (gnu_num_type)
+				   >= TYPE_PRECISION (gnu_den_type)
+				   ? gnu_num_type : gnu_den_type);
+
+	    gnu_num = convert (gnu_small_type, gnu_num);
+	    gnu_den = convert (gnu_small_type, gnu_den);
 
 	    scale_factor
 	      = build2 (RDIV_EXPR, gnu_small_type, gnu_num, gnu_den);