[PATCH 0/8] Arithmetic for 128-bit types

[PATCH 0/8] Arithmetic for 128-bit types

[Tom Tromey]

This series adss basic arithmetic for 128-bit integer types to gdb.

This is done using GMP, which gdb already requires.  While this
involves extra allocation, my view is that this hardly matters in most
expression contexts.  However, if it does turn out to matter, we can
try to switch to GCC's wide-integer code.

While this series, or something like it, is necessary for supporting
128-bit types, it is not sufficient.  In particular, none of the
lexers or parsers are touched, and integers that are part of types
(e.g., range bounds) are not handled.

This series is based on my earlier series to clean up the GMP classes.

Regression tested on x86-64 Fedora 36.

Tom

[PATCH 1/8] Add many operators to gdb_mpz

[Tom Tromey]

This adds many operator overloads and other useful methods to gdb_mpz.
This is preparation for using this class for scalar arithmetic in gdb
expression evaluation.
---
 gdb/gmp-utils.h | 138 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 138 insertions(+)

diff --git a/gdb/gmp-utils.h b/gdb/gmp-utils.h
index 274c28c0ce8..d4e5015e345 100644
--- a/gdb/gmp-utils.h
+++ b/gdb/gmp-utils.h
@@ -90,6 +90,12 @@ struct gdb_mpz
     return *this;
   }
 
+  gdb_mpz &operator= (bool src)
+  {
+    mpz_set_ui (m_val, (unsigned long) src);
+    return *this;
+  }
+
   /* Initialize this value from a string and a base.  Returns true if
      the string was parsed successfully, false otherwise.  */
   bool set (const char *str, int base)
@@ -105,6 +111,14 @@ struct gdb_mpz
     return result;
   }
 
+  /* Return a new value that is this value raised to EXP.  */
+  gdb_mpz pow (unsigned long exp) const
+  {
+    gdb_mpz result;
+    mpz_pow_ui (result.m_val, m_val, exp);
+    return result;
+  }
+
   /* Convert VAL to an integer of the given type.
 
      The return type can signed or unsigned, with no size restriction.  */
@@ -137,35 +151,154 @@ struct gdb_mpz
     mpz_neg (m_val, m_val);
   }
 
+  /* Take the one's complement in place.  */
+  void complement ()
+  { mpz_com (m_val, m_val); }
+
+  /* Mask this value to N bits, in place.  */
+  void mask (unsigned n)
+  { mpz_tdiv_r_2exp (m_val, m_val, n); }
+
+  /* Return the sign of this value.  This returns -1 for a negative
+     value, 0 if the value is 0, and 1 for a positive value.  */
+  int sgn () const
+  { return mpz_sgn (m_val); }
+
+  explicit operator bool () const
+  { return sgn () != 0; }
+
   gdb_mpz &operator*= (long other)
   {
     mpz_mul_si (m_val, m_val, other);
     return *this;
   }
 
+  gdb_mpz operator* (const gdb_mpz &other) const
+  {
+    gdb_mpz result;
+    mpz_mul (result.m_val, m_val, other.m_val);
+    return result;
+  }
+
+  gdb_mpz operator/ (const gdb_mpz &other) const
+  {
+    gdb_mpz result;
+    mpz_tdiv_q (result.m_val, m_val, other.m_val);
+    return result;
+  }
+
+  gdb_mpz operator% (const gdb_mpz &other) const
+  {
+    gdb_mpz result;
+    mpz_tdiv_r (result.m_val, m_val, other.m_val);
+    return result;
+  }
+
   gdb_mpz &operator+= (unsigned long other)
   {
     mpz_add_ui (m_val, m_val, other);
     return *this;
   }
 
+  gdb_mpz &operator+= (const gdb_mpz &other)
+  {
+    mpz_add (m_val, m_val, other.m_val);
+    return *this;
+  }
+
+  gdb_mpz operator+ (const gdb_mpz &other) const
+  {
+    gdb_mpz result;
+    mpz_add (result.m_val, m_val, other.m_val);
+    return result;
+  }
+
   gdb_mpz &operator-= (unsigned long other)
   {
     mpz_sub_ui (m_val, m_val, other);
     return *this;
   }
 
+  gdb_mpz &operator-= (const gdb_mpz &other)
+  {
+    mpz_sub (m_val, m_val, other.m_val);
+    return *this;
+  }
+
+  gdb_mpz operator- (const gdb_mpz &other) const
+  {
+    gdb_mpz result;
+    mpz_sub (result.m_val, m_val, other.m_val);
+    return result;
+  }
+
   gdb_mpz &operator<<= (unsigned long nbits)
   {
     mpz_mul_2exp (m_val, m_val, nbits);
     return *this;
   }
 
+  gdb_mpz operator<< (unsigned long nbits) const
+  {
+    gdb_mpz result;
+    mpz_mul_2exp (result.m_val, m_val, nbits);
+    return result;
+  }
+
+  gdb_mpz operator>> (unsigned long nbits) const
+  {
+    gdb_mpz result;
+    mpz_tdiv_q_2exp (result.m_val, m_val, nbits);
+    return result;
+  }
+
+  gdb_mpz &operator>>= (unsigned long nbits)
+  {
+    mpz_tdiv_q_2exp (m_val, m_val, nbits);
+    return *this;
+  }
+
+  gdb_mpz operator& (const gdb_mpz &other) const
+  {
+    gdb_mpz result;
+    mpz_and (result.m_val, m_val, other.m_val);
+    return result;
+  }
+
+  gdb_mpz operator| (const gdb_mpz &other) const
+  {
+    gdb_mpz result;
+    mpz_ior (result.m_val, m_val, other.m_val);
+    return result;
+  }
+
+  gdb_mpz operator^ (const gdb_mpz &other) const
+  {
+    gdb_mpz result;
+    mpz_xor (result.m_val, m_val, other.m_val);
+    return result;
+  }
+
   bool operator> (const gdb_mpz &other) const
   {
     return mpz_cmp (m_val, other.m_val) > 0;
   }
 
+  bool operator>= (const gdb_mpz &other) const
+  {
+    return mpz_cmp (m_val, other.m_val) >= 0;
+  }
+
+  bool operator< (const gdb_mpz &other) const
+  {
+    return mpz_cmp (m_val, other.m_val) < 0;
+  }
+
+  bool operator<= (const gdb_mpz &other) const
+  {
+    return mpz_cmp (m_val, other.m_val) <= 0;
+  }
+
   bool operator< (int other) const
   {
     return mpz_cmp_si (m_val, other) < 0;
@@ -181,6 +314,11 @@ struct gdb_mpz
     return mpz_cmp (m_val, other.m_val) == 0;
   }
 
+  bool operator!= (const gdb_mpz &other) const
+  {
+    return mpz_cmp (m_val, other.m_val) != 0;
+  }
+
 private:
 
   /* Helper template for constructor and operator=.  */
-- 
2.39.1

[PATCH 2/8] Avoid a copy in gdb_mpz::safe_export

[Tom Tromey]

Currently, gdb_mpz::safe_export will always make a copy of *this.
However, this copy isn't always needed.  This patch makes this code
slightly more efficient, by avoiding the copy when possible.
---
 gdb/gmp-utils.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/gdb/gmp-utils.c b/gdb/gmp-utils.c
index d134bc32a1d..57f5f9766b9 100644
--- a/gdb/gmp-utils.c
+++ b/gdb/gmp-utils.c
@@ -81,7 +81,8 @@ gdb_mpz::safe_export (gdb::array_view<gdb_byte> buf,
 {
   gdb_assert (buf.size () > 0);
 
-  if (mpz_sgn (m_val) == 0)
+  int sign = mpz_sgn (m_val);
+  if (sign == 0)
     {
       /* Our value is zero, so no need to call mpz_export to do the work,
 	 especially since mpz_export's documentation explicitly says
@@ -121,17 +122,16 @@ gdb_mpz::safe_export (gdb::array_view<gdb_byte> buf,
 	   lo.str ().c_str (),
 	   hi.str ().c_str ());
 
-  gdb_mpz exported_val (m_val);
-
-  if (mpz_cmp_ui (exported_val.m_val, 0) < 0)
+  const gdb_mpz *exported_val = this;
+  gdb_mpz un_signed;
+  if (sign < 0)
     {
       /* mpz_export does not handle signed values, so create a positive
 	 value whose bit representation as an unsigned of the same length
 	 would be the same as our negative value.  */
-      gdb_mpz neg_offset;
-
-      mpz_ui_pow_ui (neg_offset.m_val, 2, buf.size () * HOST_CHAR_BIT);
-      mpz_add (exported_val.m_val, exported_val.m_val, neg_offset.m_val);
+      gdb_mpz neg_offset = gdb_mpz::pow (2, buf.size () * HOST_CHAR_BIT);
+      un_signed = *exported_val + neg_offset;
+      exported_val = &un_signed;
     }
 
   /* Do the export into a buffer allocated by GMP itself; that way,
@@ -147,7 +147,7 @@ gdb_mpz::safe_export (gdb::array_view<gdb_byte> buf,
   size_t word_countp;
   gdb::unique_xmalloc_ptr<void> exported
     (mpz_export (NULL, &word_countp, -1 /* order */, buf.size () /* size */,
-		 endian, 0 /* nails */, exported_val.m_val));
+		 endian, 0 /* nails */, exported_val->m_val));
 
   gdb_assert (word_countp == 1);
 
-- 
2.39.1

[PATCH 3/8] Add truncation mode to gdb_mpz

[Tom Tromey]

This renames gdb_mpz::safe_export to export_bits, and adds a new flag
to export a truncated value.  This is needed by value arithmetic.
---
 gdb/gmp-utils.c | 93 ++++++++++++++++++++++++++++---------------------
 gdb/gmp-utils.h | 29 +++++++++++----
 2 files changed, 76 insertions(+), 46 deletions(-)

diff --git a/gdb/gmp-utils.c b/gdb/gmp-utils.c
index 57f5f9766b9..0afa344781b 100644
--- a/gdb/gmp-utils.c
+++ b/gdb/gmp-utils.c
@@ -66,18 +66,8 @@ gdb_mpz::read (gdb::array_view<const gdb_byte> buf, enum bfd_endian byte_order,
 /* See gmp-utils.h.  */
 
 void
-gdb_mpz::write (gdb::array_view<gdb_byte> buf, enum bfd_endian byte_order,
-		bool unsigned_p) const
-{
-  this->safe_export
-    (buf, byte_order == BFD_ENDIAN_BIG ? 1 : -1 /* endian */, unsigned_p);
-}
-
-/* See gmp-utils.h.  */
-
-void
-gdb_mpz::safe_export (gdb::array_view<gdb_byte> buf,
-		      int endian, bool unsigned_p) const
+gdb_mpz::export_bits (gdb::array_view<gdb_byte> buf, int endian, bool unsigned_p,
+		      bool safe) const
 {
   gdb_assert (buf.size () > 0);
 
@@ -92,36 +82,39 @@ gdb_mpz::safe_export (gdb::array_view<gdb_byte> buf,
       return;
     }
 
-  /* Determine the maximum range of values that our buffer can hold,
-     and verify that VAL is within that range.  */
-
-  gdb_mpz lo, hi;
-  const size_t max_usable_bits = buf.size () * HOST_CHAR_BIT;
-  if (unsigned_p)
-    {
-      lo = 0;
-
-      mpz_ui_pow_ui (hi.m_val, 2, max_usable_bits);
-      mpz_sub_ui (hi.m_val, hi.m_val, 1);
-    }
-  else
+  if (safe)
     {
-      mpz_ui_pow_ui (lo.m_val, 2, max_usable_bits - 1);
-      mpz_neg (lo.m_val, lo.m_val);
-
-      mpz_ui_pow_ui (hi.m_val, 2, max_usable_bits - 1);
-      mpz_sub_ui (hi.m_val, hi.m_val, 1);
+      /* Determine the maximum range of values that our buffer can
+	 hold, and verify that VAL is within that range.  */
+
+      gdb_mpz lo, hi;
+      const size_t max_usable_bits = buf.size () * HOST_CHAR_BIT;
+      if (unsigned_p)
+	{
+	  lo = 0;
+
+	  mpz_ui_pow_ui (hi.m_val, 2, max_usable_bits);
+	  mpz_sub_ui (hi.m_val, hi.m_val, 1);
+	}
+      else
+	{
+	  mpz_ui_pow_ui (lo.m_val, 2, max_usable_bits - 1);
+	  mpz_neg (lo.m_val, lo.m_val);
+
+	  mpz_ui_pow_ui (hi.m_val, 2, max_usable_bits - 1);
+	  mpz_sub_ui (hi.m_val, hi.m_val, 1);
+	}
+
+      if (mpz_cmp (m_val, lo.m_val) < 0 || mpz_cmp (m_val, hi.m_val) > 0)
+	error (_("Cannot export value %s as %zu-bits %s integer"
+		 " (must be between %s and %s)"),
+	       this->str ().c_str (),
+	       max_usable_bits,
+	       unsigned_p ? _("unsigned") : _("signed"),
+	       lo.str ().c_str (),
+	       hi.str ().c_str ());
     }
 
-  if (mpz_cmp (m_val, lo.m_val) < 0 || mpz_cmp (m_val, hi.m_val) > 0)
-    error (_("Cannot export value %s as %zu-bits %s integer"
-	     " (must be between %s and %s)"),
-	   this->str ().c_str (),
-	   max_usable_bits,
-	   unsigned_p ? _("unsigned") : _("signed"),
-	   lo.str ().c_str (),
-	   hi.str ().c_str ());
-
   const gdb_mpz *exported_val = this;
   gdb_mpz un_signed;
   if (sign < 0)
@@ -134,6 +127,28 @@ gdb_mpz::safe_export (gdb::array_view<gdb_byte> buf,
       exported_val = &un_signed;
     }
 
+  /* If the value is too large, truncate it.  */
+  if (!safe
+      && mpz_sizeinbase (exported_val->m_val, 2) > buf.size () * HOST_CHAR_BIT)
+    {
+      /* If we don't already have a copy, make it now.  */
+      if (exported_val != &un_signed)
+	{
+	  un_signed = *exported_val;
+	  exported_val = &un_signed;
+	}
+
+      un_signed.mask (buf.size () * HOST_CHAR_BIT);
+    }
+
+  /* It's possible that one of the above results in zero, which has to
+     be handled specially.  */
+  if (exported_val->sgn () == 0)
+    {
+      memset (buf.data (), 0, buf.size ());
+      return;
+    }
+
   /* Do the export into a buffer allocated by GMP itself; that way,
      we can detect cases where BUF is not large enough to export
      our value, and thus avoid a buffer overlow.  Normally, this should
diff --git a/gdb/gmp-utils.h b/gdb/gmp-utils.h
index d4e5015e345..d378499d287 100644
--- a/gdb/gmp-utils.h
+++ b/gdb/gmp-utils.h
@@ -137,7 +137,20 @@ struct gdb_mpz
 
      UNSIGNED_P indicates whether the number has an unsigned type.  */
   void write (gdb::array_view<gdb_byte> buf, enum bfd_endian byte_order,
-	      bool unsigned_p) const;
+	      bool unsigned_p) const
+  {
+    export_bits (buf, byte_order == BFD_ENDIAN_BIG ? 1 : -1 /* endian */,
+		 unsigned_p, true /* safe */);
+  }
+
+  /* Like write, but truncates the value to the desired number of
+     bytes.  */
+  void truncate (gdb::array_view<gdb_byte> buf, enum bfd_endian byte_order,
+		 bool unsigned_p) const
+  {
+    export_bits (buf, byte_order == BFD_ENDIAN_BIG ? 1 : -1 /* endian */,
+		 unsigned_p, false /* safe */);
+  }
 
   /* Return a string containing VAL.  */
   std::string str () const { return gmp_string_printf ("%Zd", m_val); }
@@ -337,10 +350,11 @@ struct gdb_mpz
 	   . -1 for least significant byte first; or
 	   . 0 for native endianness.
 
-    An error is raised if BUF is not large enough to contain the value
-    being exported.  */
-  void safe_export (gdb::array_view<gdb_byte> buf,
-		    int endian, bool unsigned_p) const;
+    If SAFE is true, an error is raised if BUF is not large enough to
+    contain the value being exported.  If SAFE is false, the value is
+    truncated to fit in BUF.  */
+  void export_bits (gdb::array_view<gdb_byte> buf, int endian, bool unsigned_p,
+		    bool safe) const;
 
   friend struct gdb_mpq;
   friend struct gdb_mpf;
@@ -590,9 +604,10 @@ gdb_mpz::as_integer () const
 {
   T result;
 
-  this->safe_export ({(gdb_byte *) &result, sizeof (result)},
+  this->export_bits ({(gdb_byte *) &result, sizeof (result)},
 		     0 /* endian (0 = native) */,
-		     !std::is_signed<T>::value /* unsigned_p */);
+		     !std::is_signed<T>::value /* unsigned_p */,
+		     true /* safe */);
 
   return result;
 }
-- 
2.39.1

[PATCH 4/8] Add value_as_mpz and value_from_mpz

[Tom Tromey]

This adds the two new functions, value_as_mpz and value_from_mpz,
useful for manipulation values via gdb_mpz.
---
 gdb/value.c | 106 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 gdb/value.h |   7 ++++
 2 files changed, 113 insertions(+)

diff --git a/gdb/value.c b/gdb/value.c
index e9afa89c243..19da9e1a00b 100644
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -2551,6 +2551,76 @@ value_as_long (struct value *val)
   return unpack_long (val->type (), val->contents ().data ());
 }
 
+/* See value.h.  */
+
+gdb_mpz
+value_as_mpz (struct value *val)
+{
+  val = coerce_array (val);
+  struct type *type = check_typedef (val->type ());
+
+  switch (type->code ())
+    {
+    case TYPE_CODE_ENUM:
+    case TYPE_CODE_BOOL:
+    case TYPE_CODE_INT:
+    case TYPE_CODE_CHAR:
+    case TYPE_CODE_RANGE:
+      break;
+
+    default:
+      return gdb_mpz (value_as_long (val));
+    }
+
+  gdb_mpz result;
+
+  gdb::array_view<const gdb_byte> valbytes = val->contents ();
+  enum bfd_endian byte_order = type_byte_order (type);
+
+  /* Handle integers that are either not a multiple of the word size,
+     or that are stored at some bit offset.  */
+  unsigned bit_off = 0, bit_size = 0;
+  if (type->bit_size_differs_p ())
+    {
+      bit_size = type->bit_size ();
+      if (bit_size == 0)
+	{
+	  /* We can just handle this immediately.  */
+	  return result;
+	}
+
+      bit_off = type->bit_offset ();
+
+      unsigned n_bytes = ((bit_off % 8) + bit_size + 7) / 8;
+      valbytes = valbytes.slice (bit_off / 8, n_bytes);
+
+      if (byte_order == BFD_ENDIAN_BIG)
+	bit_off = (n_bytes * 8 - bit_off % 8 - bit_size);
+      else
+	bit_off %= 8;
+    }
+
+  result.read (val->contents (), byte_order, type->is_unsigned ());
+
+  /* Shift off any low bits, if needed.  */
+  if (bit_off != 0)
+    result >>= bit_off;
+
+  /* Mask off any high bits, if needed.  */
+  if (bit_size)
+    result.mask (bit_size);
+
+  /* Now handle any range bias.  */
+  if (type->code () == TYPE_CODE_RANGE && type->bounds ()->bias != 0)
+    {
+      /* Unfortunately we have to box here, because LONGEST is
+	 probably wider than long.  */
+      result += gdb_mpz (type->bounds ()->bias);
+    }
+
+  return result;
+}
+
 /* Extract a value as a C pointer.  Does not deallocate the value.
    Note that val's type may not actually be a pointer; value_as_long
    handles all the cases.  */
@@ -3378,6 +3448,42 @@ value_from_ulongest (struct type *type, ULONGEST num)
   return val;
 }
 
+/* See value.h.  */
+
+struct value *
+value_from_mpz (struct type *type, const gdb_mpz &v)
+{
+  struct type *real_type = check_typedef (type);
+
+  const gdb_mpz *val = &v;
+  gdb_mpz storage;
+  if (real_type->code () == TYPE_CODE_RANGE && type->bounds ()->bias != 0)
+    {
+      storage = *val;
+      val = &storage;
+      storage -= type->bounds ()->bias;
+    }
+
+  if (type->bit_size_differs_p ())
+    {
+      unsigned bit_off = type->bit_offset ();
+      unsigned bit_size = type->bit_size ();
+
+      if (val != &storage)
+	{
+	  storage = *val;
+	  val = &storage;
+	}
+
+      storage.mask ((ULONGEST) 1 << bit_size);
+      storage <<= bit_off;
+    }
+
+  struct value *result = value::allocate (type);
+  val->truncate (result->contents_raw (), type_byte_order (type),
+		 type->is_unsigned ());
+  return result;
+}
 
 /* Create a value representing a pointer of type TYPE to the address
    ADDR.  */
diff --git a/gdb/value.h b/gdb/value.h
index d83c4ab3674..1b4eff22f37 100644
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -1029,6 +1029,11 @@ extern bool is_floating_value (struct value *val);
 extern LONGEST value_as_long (struct value *val);
 extern CORE_ADDR value_as_address (struct value *val);
 
+/* Extract the value from VAL as a MPZ.  This coerces arrays and
+   handles various integer-like types as well.  */
+
+extern gdb_mpz value_as_mpz (struct value *val);
+
 extern LONGEST unpack_long (struct type *type, const gdb_byte *valaddr);
 extern CORE_ADDR unpack_pointer (struct type *type, const gdb_byte *valaddr);
 
@@ -1075,6 +1080,8 @@ extern struct value *value_from_history_ref (const char *, const char **);
 extern struct value *value_from_component (struct value *, struct type *,
 					   LONGEST);
 
+/* Convert the value V into a newly allocated value.  */
+extern struct value *value_from_mpz (struct type *type, const gdb_mpz &v);
 
 extern struct value *value_at (struct type *type, CORE_ADDR addr);
 extern struct value *value_at_lazy (struct type *type, CORE_ADDR addr);
-- 
2.39.1

[PATCH 5/8] Simplify binop_promote

[Tom Tromey]

binop_promote currently only handles integer sizes up to
builtin_long_long.  However, this may not handle 128-bit types.
Simplify this code, unify the C and non-C (but not OpenCL, as I don't
know how to test this) cases, and handle 128-bit integers as well.

This still doesn't exactly follow C or C++ rules.  This could be
implemented, but if so, I think it makes more sense as a C-specific
expression node.
---
 gdb/eval.c | 55 +++++++++++++++++++-----------------------------------
 1 file changed, 19 insertions(+), 36 deletions(-)

diff --git a/gdb/eval.c b/gdb/eval.c
index f8bbb9ef766..6b362f46424 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -371,29 +371,6 @@ binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
 
       switch (language->la_language)
 	{
-	case language_c:
-	case language_cplus:
-	case language_asm:
-	case language_objc:
-	  if (result_len <= builtin->builtin_int->length ())
-	    {
-	      promoted_type = (unsigned_operation
-			       ? builtin->builtin_unsigned_int
-			       : builtin->builtin_int);
-	    }
-	  else if (result_len <= builtin->builtin_long->length ())
-	    {
-	      promoted_type = (unsigned_operation
-			       ? builtin->builtin_unsigned_long
-			       : builtin->builtin_long);
-	    }
-	  else
-	    {
-	      promoted_type = (unsigned_operation
-			       ? builtin->builtin_unsigned_long_long
-			       : builtin->builtin_long_long);
-	    }
-	  break;
 	case language_opencl:
 	  if (result_len
 	      <= lookup_signed_typename (language, "int")->length())
@@ -413,23 +390,29 @@ binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
 	    }
 	  break;
 	default:
-	  /* For other languages the result type is unchanged from gdb
-	     version 6.7 for backward compatibility.
-	     If either arg was long long, make sure that value is also long
-	     long.  Otherwise use long.  */
-	  if (unsigned_operation)
+	  if (result_len <= builtin->builtin_int->length ())
 	    {
-	      if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
-		promoted_type = builtin->builtin_unsigned_long_long;
-	      else
-		promoted_type = builtin->builtin_unsigned_long;
+	      promoted_type = (unsigned_operation
+			       ? builtin->builtin_unsigned_int
+			       : builtin->builtin_int);
+	    }
+	  else if (result_len <= builtin->builtin_long->length ())
+	    {
+	      promoted_type = (unsigned_operation
+			       ? builtin->builtin_unsigned_long
+			       : builtin->builtin_long);
+	    }
+	  else if (result_len <= builtin->builtin_long_long->length ())
+	    {
+	      promoted_type = (unsigned_operation
+			       ? builtin->builtin_unsigned_long_long
+			       : builtin->builtin_long_long);
 	    }
 	  else
 	    {
-	      if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
-		promoted_type = builtin->builtin_long_long;
-	      else
-		promoted_type = builtin->builtin_long;
+	      promoted_type = (unsigned_operation
+			       ? builtin->builtin_uint128
+			       : builtin->builtin_int128);
 	    }
 	  break;
 	}
-- 
2.39.1

[PATCH 6/8] Use value_true in value_equal and value_less

[Tom Tromey]

Both value_equal and value_less use value_as_long to check a
presumably boolean result of calling value_binop.  However,
value_binop in this case actually returns an int as wide as its
arguments, and this approach can then fail for integers wider than
LONGEST.  Instead, rewrite this in a form that works for any size
integer.
---
 gdb/valarith.c | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/gdb/valarith.c b/gdb/valarith.c
index 9d681dc9d97..99597bef695 100644
--- a/gdb/valarith.c
+++ b/gdb/valarith.c
@@ -1761,8 +1761,7 @@ value_equal (struct value *arg1, struct value *arg2)
   is_int2 = is_integral_type (type2);
 
   if (is_int1 && is_int2)
-    return longest_to_int (value_as_long (value_binop (arg1, arg2,
-						       BINOP_EQUAL)));
+    return value_true (value_binop (arg1, arg2, BINOP_EQUAL));
   else if ((is_floating_value (arg1) || is_int1)
 	   && (is_floating_value (arg2) || is_int2))
     {
@@ -1849,8 +1848,7 @@ value_less (struct value *arg1, struct value *arg2)
 
   if ((is_int1 && is_int2)
       || (is_fixed_point_type (type1) && is_fixed_point_type (type2)))
-    return longest_to_int (value_as_long (value_binop (arg1, arg2,
-						       BINOP_LESS)));
+    return value_true (value_binop (arg1, arg2, BINOP_LESS));
   else if ((is_floating_value (arg1) || is_int1)
 	   && (is_floating_value (arg2) || is_int2))
     {
-- 
2.39.1

[PATCH 7/8] Use gdb_gmp for scalar arithmetic

[Tom Tromey]

This changes gdb to use scalar arithmetic for expression evaluation.

I suspect this patch is not truly complete, as there may be code paths
that still don't correctly handle 128-bit integers.  However, many
things do work now.

Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=30190
---
 gdb/testsuite/gdb.rust/onetwoeight.exp |  65 ++++
 gdb/testsuite/gdb.rust/onetwoeight.rs  |  31 ++
 gdb/utils.c                            |  30 --
 gdb/utils.h                            |   7 -
 gdb/valarith.c                         | 489 ++++++++-----------------
 gdb/valops.c                           |  14 +-
 6 files changed, 253 insertions(+), 383 deletions(-)
 create mode 100644 gdb/testsuite/gdb.rust/onetwoeight.exp
 create mode 100644 gdb/testsuite/gdb.rust/onetwoeight.rs

diff --git a/gdb/testsuite/gdb.rust/onetwoeight.exp b/gdb/testsuite/gdb.rust/onetwoeight.exp
new file mode 100644
index 00000000000..317c848a899
--- /dev/null
+++ b/gdb/testsuite/gdb.rust/onetwoeight.exp
@@ -0,0 +1,65 @@
+# Copyright (C) 2023 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# Test expression parsing and evaluation that requires Rust compiler.
+
+load_lib rust-support.exp
+require allow_rust_tests
+
+set v [split [rust_compiler_version] .]
+if {[lindex $v 0] == 1 && [lindex $v 1] < 43} {
+    untested "128-bit ints require rust 1.43 or greater"
+    return -1
+}
+
+standard_testfile .rs
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug rust}]} {
+    return -1
+}
+
+set line [gdb_get_line_number "BREAK"]
+if {![runto ${srcfile}:$line]} {
+    untested "could not run to breakpoint"
+    return -1
+}
+
+gdb_test "print x" " = 340282366920938463463374607431768211455"
+gdb_test "print y" " = 170141183460469231731687303715884105727"
+
+gdb_test "print x / 2" " = 170141183460469231731687303715884105727"
+gdb_test "print sm * 2" " = 170141183460469231731687303715884105726"
+gdb_test "print sm + sm" " = 170141183460469231731687303715884105726"
+gdb_test "print x - y" " = 170141183460469231731687303715884105728"
+gdb_test "print -y" " = -170141183460469231731687303715884105727"
+gdb_test "print +y" " = 170141183460469231731687303715884105727"
+
+gdb_test "print/x x" " = 0xffffffffffffffffffffffffffffffff"
+gdb_test "print x % 4" " = 3"
+gdb_test "print !x" " = 0"
+
+gdb_test "print x < 0" " = false"
+gdb_test "print -y < 0" " = true"
+gdb_test "print x > y" " = true"
+gdb_test "print y >= y" " = true"
+gdb_test "print y <= y" " = true"
+gdb_test "print y == y" " = true"
+gdb_test "print x != y" " = true"
+
+gdb_test "print sm << 2" "= 340282366920938463463374607431768211452"
+gdb_test "print x >> 2" "= 85070591730234615865843651857942052863"
+
+gdb_test "print/x x & mask" " = 0xf0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0"
+gdb_test "print/x x ^ mask" " = 0xf0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f"
+gdb_test "print/x mask | (mask >> 4)" " = 0xffffffffffffffffffffffffffffffff"
diff --git a/gdb/testsuite/gdb.rust/onetwoeight.rs b/gdb/testsuite/gdb.rust/onetwoeight.rs
new file mode 100644
index 00000000000..aa8cb1cf7b1
--- /dev/null
+++ b/gdb/testsuite/gdb.rust/onetwoeight.rs
@@ -0,0 +1,31 @@
+// Copyright (C) 2023 Free Software Foundation, Inc.
+
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#![allow(dead_code)]
+#![allow(unused_variables)]
+#![allow(unused_assignments)]
+
+
+fn empty() {
+}
+
+fn main () {
+    let x : u128 = 340_282_366_920_938_463_463_374_607_431_768_211_455;
+    let sm : u128 = x /4;
+    let y : i128 = 170_141_183_460_469_231_731_687_303_715_884_105_727;
+    let mask : u128 = 0xf0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0;
+
+    empty();			// BREAK
+}
diff --git a/gdb/utils.c b/gdb/utils.c
index 0138c8e9fb6..9ca83246b24 100644
--- a/gdb/utils.c
+++ b/gdb/utils.c
@@ -723,36 +723,6 @@ myread (int desc, char *addr, int len)
   return orglen;
 }
 
-/* See utils.h.  */
-
-ULONGEST
-uinteger_pow (ULONGEST v1, LONGEST v2)
-{
-  if (v2 < 0)
-    {
-      if (v1 == 0)
-	error (_("Attempt to raise 0 to negative power."));
-      else
-	return 0;
-    }
-  else
-    {
-      /* The Russian Peasant's Algorithm.  */
-      ULONGEST v;
-
-      v = 1;
-      for (;;)
-	{
-	  if (v2 & 1L)
-	    v *= v1;
-	  v2 >>= 1;
-	  if (v2 == 0)
-	    return v;
-	  v1 *= v1;
-	}
-    }
-}
-
 \f
 
 /* An RAII class that sets up to handle input and then tears down
diff --git a/gdb/utils.h b/gdb/utils.h
index 6e240deccbf..a383036bcfe 100644
--- a/gdb/utils.h
+++ b/gdb/utils.h
@@ -303,13 +303,6 @@ extern pid_t wait_to_die_with_timeout (pid_t pid, int *status, int timeout);
 
 extern int myread (int, char *, int);
 
-/* Integer exponentiation: Return V1**V2, where both arguments
-   are integers.
-
-   Requires V1 != 0 if V2 < 0.
-   Returns 1 for 0 ** 0.  */
-extern ULONGEST uinteger_pow (ULONGEST v1, LONGEST v2);
-
 /* Resource limits used by getrlimit and setrlimit.  */
 
 enum resource_limit_kind
diff --git a/gdb/valarith.c b/gdb/valarith.c
index 99597bef695..a8ae17e1730 100644
--- a/gdb/valarith.c
+++ b/gdb/valarith.c
@@ -34,13 +34,6 @@ static struct value *value_subscripted_rvalue (struct value *array,
 					       LONGEST index,
 					       LONGEST lowerbound);
 
-/* Define whether or not the C operator '/' truncates towards zero for
-   differently signed operands (truncation direction is undefined in C).  */
-
-#ifndef TRUNCATION_TOWARDS_ZERO
-#define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
-#endif
-
 /* Given a pointer, return the size of its target.
    If the pointer type is void *, then return 1.
    If the target type is incomplete, then error out.
@@ -726,36 +719,6 @@ value_concat (struct value *arg1, struct value *arg2)
   return result;
 }
 \f
-/* Integer exponentiation: V1**V2, where both arguments are
-   integers.  Requires V1 != 0 if V2 < 0.  Returns 1 for 0 ** 0.  */
-
-static LONGEST
-integer_pow (LONGEST v1, LONGEST v2)
-{
-  if (v2 < 0)
-    {
-      if (v1 == 0)
-	error (_("Attempt to raise 0 to negative power."));
-      else
-	return 0;
-    }
-  else 
-    {
-      /* The Russian Peasant's Algorithm.  */
-      LONGEST v;
-      
-      v = 1;
-      for (;;)
-	{
-	  if (v2 & 1L) 
-	    v *= v1;
-	  v2 >>= 1;
-	  if (v2 == 0)
-	    return v;
-	  v1 *= v1;
-	}
-    }
-}
 
 /* Obtain argument values for binary operation, converting from
    other types if one of them is not floating point.  */
@@ -1099,33 +1062,39 @@ type_length_bits (type *type)
    both negative and too-large shift amounts, which are undefined, and
    would crash a GDB built with UBSan.  Depending on the current
    language, if the shift is not valid, this either warns and returns
-   false, or errors out.  Returns true if valid.  */
+   false, or errors out.  Returns true and sets NBITS if valid.  */
 
 static bool
 check_valid_shift_count (enum exp_opcode op, type *result_type,
-			 type *shift_count_type, ULONGEST shift_count)
+			 type *shift_count_type, const gdb_mpz &shift_count,
+			 unsigned long &nbits)
 {
-  if (!shift_count_type->is_unsigned () && (LONGEST) shift_count < 0)
+  if (!shift_count_type->is_unsigned ())
     {
-      auto error_or_warning = [] (const char *msg)
-      {
-	/* Shifts by a negative amount are always an error in Go.  Other
-	   languages are more permissive and their compilers just warn or
-	   have modes to disable the errors.  */
-	if (current_language->la_language == language_go)
-	  error (("%s"), msg);
-	else
-	  warning (("%s"), msg);
-      };
+      LONGEST count = shift_count.as_integer<LONGEST> ();
+      if (count < 0)
+	{
+	  auto error_or_warning = [] (const char *msg)
+	  {
+	    /* Shifts by a negative amount are always an error in Go.  Other
+	       languages are more permissive and their compilers just warn or
+	       have modes to disable the errors.  */
+	    if (current_language->la_language == language_go)
+	      error (("%s"), msg);
+	    else
+	      warning (("%s"), msg);
+	  };
 
-      if (op == BINOP_RSH)
-	error_or_warning (_("right shift count is negative"));
-      else
-	error_or_warning (_("left shift count is negative"));
-      return false;
+	  if (op == BINOP_RSH)
+	    error_or_warning (_("right shift count is negative"));
+	  else
+	    error_or_warning (_("left shift count is negative"));
+	  return false;
+	}
     }
 
-  if (shift_count >= type_length_bits (result_type))
+  nbits = shift_count.as_integer<unsigned long> ();
+  if (nbits >= type_length_bits (result_type))
     {
       /* In Go, shifting by large amounts is defined.  Be silent and
 	 still return false, as the caller's error path does the right
@@ -1249,299 +1218,135 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
       else
 	result_type = promotion_type (type1, type2);
 
-      if (result_type->is_unsigned ())
+      gdb_mpz v1 = value_as_mpz (arg1);
+      gdb_mpz v2 = value_as_mpz (arg2);
+      gdb_mpz v;
+
+      switch (op)
 	{
-	  LONGEST v2_signed = value_as_long (arg2);
-	  ULONGEST v1, v2, v = 0;
+	case BINOP_ADD:
+	  v = v1 + v2;
+	  break;
 
-	  v1 = (ULONGEST) value_as_long (arg1);
-	  v2 = (ULONGEST) v2_signed;
+	case BINOP_SUB:
+	  v = v1 - v2;
+	  break;
 
-	  switch (op)
-	    {
-	    case BINOP_ADD:
-	      v = v1 + v2;
-	      break;
-
-	    case BINOP_SUB:
-	      v = v1 - v2;
-	      break;
-
-	    case BINOP_MUL:
-	      v = v1 * v2;
-	      break;
-
-	    case BINOP_DIV:
-	    case BINOP_INTDIV:
-	      if (v2 != 0)
-		v = v1 / v2;
-	      else
-		error (_("Division by zero"));
-	      break;
-
-	    case BINOP_EXP:
-	      v = uinteger_pow (v1, v2_signed);
-	      break;
-
-	    case BINOP_REM:
-	      if (v2 != 0)
-		v = v1 % v2;
-	      else
-		error (_("Division by zero"));
-	      break;
-
-	    case BINOP_MOD:
-	      /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
-		 v1 mod 0 has a defined value, v1.  */
-	      if (v2 == 0)
-		{
-		  v = v1;
-		}
-	      else
-		{
-		  v = v1 / v2;
-		  /* Note floor(v1/v2) == v1/v2 for unsigned.  */
-		  v = v1 - (v2 * v);
-		}
-	      break;
-
-	    case BINOP_LSH:
-	      if (!check_valid_shift_count (op, result_type, type2, v2))
-		v = 0;
-	      else
-		v = v1 << v2;
-	      break;
-
-	    case BINOP_RSH:
-	      if (!check_valid_shift_count (op, result_type, type2, v2))
-		v = 0;
-	      else
-		v = v1 >> v2;
-	      break;
-
-	    case BINOP_BITWISE_AND:
-	      v = v1 & v2;
-	      break;
-
-	    case BINOP_BITWISE_IOR:
-	      v = v1 | v2;
-	      break;
-
-	    case BINOP_BITWISE_XOR:
-	      v = v1 ^ v2;
-	      break;
-
-	    case BINOP_LOGICAL_AND:
-	      v = v1 && v2;
-	      break;
-
-	    case BINOP_LOGICAL_OR:
-	      v = v1 || v2;
-	      break;
-
-	    case BINOP_MIN:
-	      v = v1 < v2 ? v1 : v2;
-	      break;
-
-	    case BINOP_MAX:
-	      v = v1 > v2 ? v1 : v2;
-	      break;
-
-	    case BINOP_EQUAL:
-	      v = v1 == v2;
-	      break;
-
-	    case BINOP_NOTEQUAL:
-	      v = v1 != v2;
-	      break;
-
-	    case BINOP_LESS:
-	      v = v1 < v2;
-	      break;
-
-	    case BINOP_GTR:
-	      v = v1 > v2;
-	      break;
-
-	    case BINOP_LEQ:
-	      v = v1 <= v2;
-	      break;
-
-	    case BINOP_GEQ:
-	      v = v1 >= v2;
-	      break;
-
-	    default:
-	      error (_("Invalid binary operation on numbers."));
-	    }
+	case BINOP_MUL:
+	  v = v1 * v2;
+	  break;
 
-	  val = value::allocate (result_type);
-	  store_unsigned_integer (val->contents_raw ().data (),
-				  val->type ()->length (),
-				  type_byte_order (result_type),
-				  v);
-	}
-      else
-	{
-	  LONGEST v1, v2, v = 0;
+	case BINOP_DIV:
+	case BINOP_INTDIV:
+	  if (v2.sgn () != 0)
+	    v = v1 / v2;
+	  else
+	    error (_("Division by zero"));
+	  break;
 
-	  v1 = value_as_long (arg1);
-	  v2 = value_as_long (arg2);
+	case BINOP_EXP:
+	  v = v1.pow (v2.as_integer<unsigned long> ());
+	  break;
+
+	case BINOP_REM:
+	  if (v2.sgn () != 0)
+	    v = v1 % v2;
+	  else
+	    error (_("Division by zero"));
+	  break;
 
-	  switch (op)
+	case BINOP_MOD:
+	  /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
+	     v1 mod 0 has a defined value, v1.  */
+	  if (v2.sgn () == 0)
+	    {
+	      v = v1;
+	    }
+	  else
 	    {
-	    case BINOP_ADD:
-	      v = v1 + v2;
-	      break;
-
-	    case BINOP_SUB:
-	      /* Avoid runtime error: signed integer overflow: \
-		 0 - -9223372036854775808 cannot be represented in type
-		 'long int'.  */
-	      v = (ULONGEST)v1 - (ULONGEST)v2;
-	      break;
-
-	    case BINOP_MUL:
-	      v = v1 * v2;
-	      break;
-
-	    case BINOP_DIV:
-	    case BINOP_INTDIV:
-	      if (v2 != 0)
-		v = v1 / v2;
-	      else
-		error (_("Division by zero"));
-	      break;
-
-	    case BINOP_EXP:
-	      v = integer_pow (v1, v2);
-	      break;
-
-	    case BINOP_REM:
-	      if (v2 != 0)
-		v = v1 % v2;
-	      else
-		error (_("Division by zero"));
-	      break;
-
-	    case BINOP_MOD:
-	      /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
-		 X mod 0 has a defined value, X.  */
-	      if (v2 == 0)
-		{
-		  v = v1;
-		}
-	      else
-		{
-		  v = v1 / v2;
-		  /* Compute floor.  */
-		  if (TRUNCATION_TOWARDS_ZERO && (v < 0) && ((v1 % v2) != 0))
-		    {
-		      v--;
-		    }
-		  v = v1 - (v2 * v);
-		}
-	      break;
-
-	    case BINOP_LSH:
-	      if (!check_valid_shift_count (op, result_type, type2, v2))
-		v = 0;
-	      else
-		{
-		  /* Cast to unsigned to avoid undefined behavior on
-		     signed shift overflow (unless C++20 or later),
-		     which would crash GDB when built with UBSan.
-		     Note we don't warn on left signed shift overflow,
-		     because starting with C++20, that is actually
-		     defined behavior.  Also, note GDB assumes 2's
-		     complement throughout.  */
-		  v = (ULONGEST) v1 << v2;
-		}
-	      break;
-
-	    case BINOP_RSH:
-	      if (!check_valid_shift_count (op, result_type, type2, v2))
-		{
-		  /* Pretend the too-large shift was decomposed in a
-		     number of smaller shifts.  An arithmetic signed
-		     right shift of a negative number always yields -1
-		     with such semantics.  This is the right thing to
-		     do for Go, and we might as well do it for
-		     languages where it is undefined.  Also, pretend a
-		     shift by a negative number was a shift by the
-		     negative number cast to unsigned, which is the
-		     same as shifting by a too-large number.  */
-		  if (v1 < 0)
-		    v = -1;
-		  else
-		    v = 0;
-		}
-	      else
-		v = v1 >> v2;
-	      break;
-
-	    case BINOP_BITWISE_AND:
-	      v = v1 & v2;
-	      break;
-
-	    case BINOP_BITWISE_IOR:
-	      v = v1 | v2;
-	      break;
-
-	    case BINOP_BITWISE_XOR:
-	      v = v1 ^ v2;
-	      break;
-
-	    case BINOP_LOGICAL_AND:
-	      v = v1 && v2;
-	      break;
-
-	    case BINOP_LOGICAL_OR:
-	      v = v1 || v2;
-	      break;
-
-	    case BINOP_MIN:
-	      v = v1 < v2 ? v1 : v2;
-	      break;
-
-	    case BINOP_MAX:
-	      v = v1 > v2 ? v1 : v2;
-	      break;
-
-	    case BINOP_EQUAL:
-	      v = v1 == v2;
-	      break;
-
-	    case BINOP_NOTEQUAL:
-	      v = v1 != v2;
-	      break;
-
-	    case BINOP_LESS:
-	      v = v1 < v2;
-	      break;
-
-	    case BINOP_GTR:
-	      v = v1 > v2;
-	      break;
-
-	    case BINOP_LEQ:
-	      v = v1 <= v2;
-	      break;
-
-	    case BINOP_GEQ:
-	      v = v1 >= v2;
-	      break;
-
-	    default:
-	      error (_("Invalid binary operation on numbers."));
+	      v = v1 / v2;
+	      /* Note floor(v1/v2) == v1/v2 for unsigned.  */
+	      v = v1 - (v2 * v);
 	    }
+	  break;
 
-	  val = value::allocate (result_type);
-	  store_signed_integer (val->contents_raw ().data (),
-				val->type ()->length (),
-				type_byte_order (result_type),
-				v);
+	case BINOP_LSH:
+	  {
+	    unsigned long nbits;
+	    if (!check_valid_shift_count (op, result_type, type2, v2, nbits))
+	      v = 0;
+	    else
+	      v = v1 << nbits;
+	  }
+	  break;
+
+	case BINOP_RSH:
+	  {
+	    unsigned long nbits;
+	    if (!check_valid_shift_count (op, result_type, type2, v2, nbits))
+	      v = 0;
+	    else
+	      v = v1 >> nbits;
+	  }
+	  break;
+
+	case BINOP_BITWISE_AND:
+	  v = v1 & v2;
+	  break;
+
+	case BINOP_BITWISE_IOR:
+	  v = v1 | v2;
+	  break;
+
+	case BINOP_BITWISE_XOR:
+	  v = v1 ^ v2;
+	  break;
+
+	case BINOP_LOGICAL_AND:
+	  v = v1 && v2;
+	  break;
+
+	case BINOP_LOGICAL_OR:
+	  v = v1 || v2;
+	  break;
+
+	case BINOP_MIN:
+	  v = v1 < v2 ? v1 : v2;
+	  break;
+
+	case BINOP_MAX:
+	  v = v1 > v2 ? v1 : v2;
+	  break;
+
+	case BINOP_EQUAL:
+	  v = v1 == v2;
+	  break;
+
+	case BINOP_NOTEQUAL:
+	  v = v1 != v2;
+	  break;
+
+	case BINOP_LESS:
+	  v = v1 < v2;
+	  break;
+
+	case BINOP_GTR:
+	  v = v1 > v2;
+	  break;
+
+	case BINOP_LEQ:
+	  v = v1 <= v2;
+	  break;
+
+	case BINOP_GEQ:
+	  v = v1 >= v2;
+	  break;
+
+	default:
+	  error (_("Invalid binary operation on numbers."));
 	}
+
+      val = value_from_mpz (result_type, v);
     }
 
   return val;
@@ -1960,7 +1765,11 @@ value_complement (struct value *arg1)
   type = check_typedef (arg1->type ());
 
   if (is_integral_type (type))
-    val = value_from_longest (type, ~value_as_long (arg1));
+    {
+      gdb_mpz num = value_as_mpz (arg1);
+      num.complement ();
+      val = value_from_mpz (type, num);
+    }
   else if (type->code () == TYPE_CODE_ARRAY && type->is_vector ())
     {
       struct type *eltype = check_typedef (type->target_type ());
diff --git a/gdb/valops.c b/gdb/valops.c
index 2cef24fc4c5..f06969e92e6 100644
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -569,7 +569,7 @@ value_cast (struct type *type, struct value *arg2)
 	   && (scalar || code2 == TYPE_CODE_PTR
 	       || code2 == TYPE_CODE_MEMBERPTR))
     {
-      LONGEST longest;
+      gdb_mpz longest;
 
       /* When we cast pointers to integers, we mustn't use
 	 gdbarch_pointer_to_address to find the address the pointer
@@ -578,12 +578,14 @@ value_cast (struct type *type, struct value *arg2)
 	 sees a cast as a simple reinterpretation of the pointer's
 	 bits.  */
       if (code2 == TYPE_CODE_PTR)
-	longest = extract_unsigned_integer
-	  (arg2->contents (), type_byte_order (type2));
+	longest = extract_unsigned_integer (arg2->contents (),
+					    type_byte_order (type2));
       else
-	longest = value_as_long (arg2);
-      return value_from_longest (to_type, convert_to_boolean ?
-				 (LONGEST) (longest ? 1 : 0) : longest);
+	longest = value_as_mpz (arg2);
+      if (convert_to_boolean)
+	longest = bool (longest);
+
+      return value_from_mpz (to_type, longest);
     }
   else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT  
 				      || code2 == TYPE_CODE_ENUM 
-- 
2.39.1

[PATCH 8/8] Fix 128-bit integer bug in Ada

[Tom Tromey]

While working on 128-bit integer support, I found one spot in Ada that
needed a fix as well.
---
 gdb/ada-lang.c                          | 27 ++++--------------
 gdb/testsuite/gdb.ada/verylong.exp      | 37 +++++++++++++++++++++++++
 gdb/testsuite/gdb.ada/verylong/prog.adb | 20 +++++++++++++
 3 files changed, 63 insertions(+), 21 deletions(-)
 create mode 100644 gdb/testsuite/gdb.ada/verylong.exp
 create mode 100644 gdb/testsuite/gdb.ada/verylong/prog.adb

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 7b07c4f9473..d1afb1a27b1 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -62,14 +62,6 @@
 #include "charset.h"
 #include "ax-gdb.h"
 
-/* Define whether or not the C operator '/' truncates towards zero for
-   differently signed operands (truncation direction is undefined in C).
-   Copied from valarith.c.  */
-
-#ifndef TRUNCATION_TOWARDS_ZERO
-#define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
-#endif
-
 static struct type *desc_base_type (struct type *);
 
 static struct type *desc_bounds_type (struct type *);
@@ -9351,9 +9343,7 @@ coerce_for_assign (struct type *type, struct value *val)
 static struct value *
 ada_value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
 {
-  struct value *val;
   struct type *type1, *type2;
-  LONGEST v, v1, v2;
 
   arg1 = coerce_ref (arg1);
   arg2 = coerce_ref (arg2);
@@ -9374,8 +9364,8 @@ ada_value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
       return value_binop (arg1, arg2, op);
     }
 
-  v2 = value_as_long (arg2);
-  if (v2 == 0)
+  gdb_mpz v2 = value_as_mpz (arg2);
+  if (v2.sgn () == 0)
     {
       const char *name;
       if (op == BINOP_MOD)
@@ -9394,13 +9384,12 @@ ada_value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
   if (type1->is_unsigned () || op == BINOP_MOD)
     return value_binop (arg1, arg2, op);
 
-  v1 = value_as_long (arg1);
+  gdb_mpz v1 = value_as_mpz (arg1);
+  gdb_mpz v;
   switch (op)
     {
     case BINOP_DIV:
       v = v1 / v2;
-      if (!TRUNCATION_TOWARDS_ZERO && v1 * (v1 % v2) < 0)
-	v += v > 0 ? -1 : 1;
       break;
     case BINOP_REM:
       v = v1 % v2;
@@ -9409,14 +9398,10 @@ ada_value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
       break;
     default:
       /* Should not reach this point.  */
-      v = 0;
+      gdb_assert_not_reached ("invalid operator");
     }
 
-  val = value::allocate (type1);
-  store_unsigned_integer (val->contents_raw ().data (),
-			  val->type ()->length (),
-			  type_byte_order (type1), v);
-  return val;
+  return value_from_mpz (type1, v);
 }
 
 static int
diff --git a/gdb/testsuite/gdb.ada/verylong.exp b/gdb/testsuite/gdb.ada/verylong.exp
new file mode 100644
index 00000000000..93df785862b
--- /dev/null
+++ b/gdb/testsuite/gdb.ada/verylong.exp
@@ -0,0 +1,37 @@
+# Copyright 2023 Free Software Foundation, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+load_lib "ada.exp"
+
+require allow_ada_tests
+
+standard_ada_testfile prog
+
+if {[gdb_compile_ada "${srcfile}" "${binfile}" executable {debug}] != ""} {
+    return -1
+}
+
+clean_restart ${testfile}
+
+set bp_location [gdb_get_line_number "START" ${testdir}/prog.adb]
+runto "prog.adb:$bp_location"
+
+gdb_test "print x" " = 170141183460469231731687303715884105727"
+gdb_test "print x / 2" " = 85070591730234615865843651857942052863"
+gdb_test "print (x / 4) * 2" " = 85070591730234615865843651857942052862"
+gdb_test "print x - x" " = 0"
+gdb_test "print x - 99 + 1" " = 170141183460469231731687303715884105629"
+gdb_test "print -x" " = -170141183460469231731687303715884105727"
+gdb_test "print +x" " = 170141183460469231731687303715884105727"
diff --git a/gdb/testsuite/gdb.ada/verylong/prog.adb b/gdb/testsuite/gdb.ada/verylong/prog.adb
new file mode 100644
index 00000000000..766419d0a4f
--- /dev/null
+++ b/gdb/testsuite/gdb.ada/verylong/prog.adb
@@ -0,0 +1,20 @@
+--  Copyright 2023 Free Software Foundation, Inc.
+--
+--  This program is free software; you can redistribute it and/or modify
+--  it under the terms of the GNU General Public License as published by
+--  the Free Software Foundation; either version 3 of the License, or
+--  (at your option) any later version.
+--
+--  This program is distributed in the hope that it will be useful,
+--  but WITHOUT ANY WARRANTY; without even the implied warranty of
+--  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+--  GNU General Public License for more details.
+--
+--  You should have received a copy of the GNU General Public License
+--  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+procedure Main is
+   X : Long_Long_Long_Integer := Long_Long_Long_Integer'Last;
+begin
+   null; -- START
+end Main;
-- 
2.39.1

Re: [PATCH 0/8] Arithmetic for 128-bit types

[Eli Zaretskii]

> Date: Fri,  3 Mar 2023 14:11:59 -0700
> X-Spam-Status: No, score=-5.6 required=5.0 tests=BAYES_00, DKIM_SIGNED,
>  DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE,
>  SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6
> From: Tom Tromey via Gdb-patches <gdb-patches@sourceware.org>
> 
> This series adss basic arithmetic for 128-bit integer types to gdb.

Can you tell where and in what situations will this be useful?

Also, don't we need to announce this, at least in NEWS?

Thanks.

Re: [PATCH 1/8] Add many operators to gdb_mpz

[Alexandra Petlanova Hajkova]

[-- Attachment #1: Type: text/plain, Size: 318 bytes --]

On Fri, Mar 3, 2023 at 10:12 PM Tom Tromey via Gdb-patches <
gdb-patches@sourceware.org> wrote:

> This adds many operator overloads and other useful methods to gdb_mpz.
> This is preparation for using this class for scalar arithmetic in gdb
> expression evaluation.
> ---
>
> Looks great, applies cleanly.

Re: [PATCH 4/8] Add value_as_mpz and value_from_mpz

[Lancelot SIX]

Hi,

On Fri, Mar 03, 2023 at 02:12:03PM -0700, Tom Tromey via Gdb-patches wrote:
> This adds the two new functions, value_as_mpz and value_from_mpz,
> useful for manipulation values via gdb_mpz.
> ---
>  gdb/value.c | 106 ++++++++++++++++++++++++++++++++++++++++++++++++++++
>  gdb/value.h |   7 ++++
>  2 files changed, 113 insertions(+)
> 
> diff --git a/gdb/value.c b/gdb/value.c
> index e9afa89c243..19da9e1a00b 100644
> --- a/gdb/value.c
> +++ b/gdb/value.c
> @@ -2551,6 +2551,76 @@ value_as_long (struct value *val)
>    return unpack_long (val->type (), val->contents ().data ());
>  }
>  
> +/* See value.h.  */
> +
> +gdb_mpz
> +value_as_mpz (struct value *val)
> +{
> +  val = coerce_array (val);
> +  struct type *type = check_typedef (val->type ());
> +
> +  switch (type->code ())
> +    {
> +    case TYPE_CODE_ENUM:
> +    case TYPE_CODE_BOOL:
> +    case TYPE_CODE_INT:
> +    case TYPE_CODE_CHAR:
> +    case TYPE_CODE_RANGE:
> +      break;
> +
> +    default:
> +      return gdb_mpz (value_as_long (val));
> +    }
> +
> +  gdb_mpz result;
> +
> +  gdb::array_view<const gdb_byte> valbytes = val->contents ();
> +  enum bfd_endian byte_order = type_byte_order (type);
> +
> +  /* Handle integers that are either not a multiple of the word size,
> +     or that are stored at some bit offset.  */
> +  unsigned bit_off = 0, bit_size = 0;
> +  if (type->bit_size_differs_p ())
> +    {
> +      bit_size = type->bit_size ();
> +      if (bit_size == 0)
> +	{
> +	  /* We can just handle this immediately.  */
> +	  return result;
> +	}
> +
> +      bit_off = type->bit_offset ();
> +
> +      unsigned n_bytes = ((bit_off % 8) + bit_size + 7) / 8;

This is a bit out of the scope of this patch as gdbvalue.h says that
bit_off / bit_size are 8 based, but should they be HOST_CHAR_BIT based
instead?  The n_bytes is used to to access a
"gdb::array_view<const gdb_byte>".

> +      valbytes = valbytes.slice (bit_off / 8, n_bytes);
> +
> +      if (byte_order == BFD_ENDIAN_BIG)
> +	bit_off = (n_bytes * 8 - bit_off % 8 - bit_size);
> +      else
> +	bit_off %= 8;
> +    }
> +
> +  result.read (val->contents (), byte_order, type->is_unsigned ());
> +
> +  /* Shift off any low bits, if needed.  */
> +  if (bit_off != 0)
> +    result >>= bit_off;
> +
> +  /* Mask off any high bits, if needed.  */
> +  if (bit_size)
> +    result.mask (bit_size);
> +
> +  /* Now handle any range bias.  */
> +  if (type->code () == TYPE_CODE_RANGE && type->bounds ()->bias != 0)
> +    {
> +      /* Unfortunately we have to box here, because LONGEST is
> +	 probably wider than long.  */
> +      result += gdb_mpz (type->bounds ()->bias);
> +    }
> +
> +  return result;
> +}
> +
>  /* Extract a value as a C pointer.  Does not deallocate the value.
>     Note that val's type may not actually be a pointer; value_as_long
>     handles all the cases.  */
> @@ -3378,6 +3448,42 @@ value_from_ulongest (struct type *type, ULONGEST num)
>    return val;
>  }
>  
> +/* See value.h.  */
> +
> +struct value *
> +value_from_mpz (struct type *type, const gdb_mpz &v)
> +{
> +  struct type *real_type = check_typedef (type);
> +
> +  const gdb_mpz *val = &v;
> +  gdb_mpz storage;
> +  if (real_type->code () == TYPE_CODE_RANGE && type->bounds ()->bias != 0)
> +    {
> +      storage = *val;
> +      val = &storage;
> +      storage -= type->bounds ()->bias;
> +    }
> +
> +  if (type->bit_size_differs_p ())
> +    {
> +      unsigned bit_off = type->bit_offset ();
> +      unsigned bit_size = type->bit_size ();
> +
> +      if (val != &storage)
> +	{
> +	  storage = *val;
> +	  val = &storage;
> +	}
> +
> +      storage.mask ((ULONGEST) 1 << bit_size);

I do not think you should have the "(ULONGEST) 1 <<" part here.
gdb_mpz::mask does mask N bits (N being its arg).

> +      storage <<= bit_off;
> +    }

Best,
Lancelot.

Re: [PATCH 4/8] Add value_as_mpz and value_from_mpz

[Tom Tromey]

>> +      unsigned n_bytes = ((bit_off % 8) + bit_size + 7) / 8;

Lancelot> This is a bit out of the scope of this patch as gdbvalue.h says that
Lancelot> bit_off / bit_size are 8 based, but should they be HOST_CHAR_BIT based
Lancelot> instead?  The n_bytes is used to to access a
Lancelot> "gdb::array_view<const gdb_byte>".

Yeah, I do not know.  I am not sure I've ever understood how gdb intends
to handle these scenarios, if it even really does.  I do see uses of
HOST_CHAR_BIT, but also plain '8'.

Also there's this weirdness:

    #if defined (CHAR_BIT)
    #define HOST_CHAR_BIT CHAR_BIT
    #else
    #define HOST_CHAR_BIT TARGET_CHAR_BIT
    #endif

It's hard to understand how this can ever make sense, even despite the
comment (which may be obsolete).

TARGET_CHAR_BIT is even worse because surely it cannot be a constant.

Anyway, this code in question in this patch is just copied from
elsewhere.

>> +      storage.mask ((ULONGEST) 1 << bit_size);

Lancelot> I do not think you should have the "(ULONGEST) 1 <<" part here.
Lancelot> gdb_mpz::mask does mask N bits (N being its arg).

Thank you.

Tom

Re: [PATCH 0/8] Arithmetic for 128-bit types

[Tom Tromey]

>>>>> "Eli" == Eli Zaretskii <eliz@gnu.org> writes:

>> Date: Fri,  3 Mar 2023 14:11:59 -0700
>> X-Spam-Status: No, score=-5.6 required=5.0 tests=BAYES_00, DKIM_SIGNED,
>> DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE,
>> SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6
>> From: Tom Tromey via Gdb-patches <gdb-patches@sourceware.org>
>> 
>> This series adss basic arithmetic for 128-bit integer types to gdb.

Eli> Can you tell where and in what situations will this be useful?

Right now, if the inferior uses 128-bit integer types, then 'print'
works but no other operations work.  So for example, you cannot "print x + 1".

128-bit types are somewhat more common now.  Several of the languages
gdb supports have them (at least C, C++, Rust, and Ada).

Eli> Also, don't we need to announce this, at least in NEWS?

I added this:

    * GDB now has some support for integer types larger than 64 bits.

Tom

Re: [PATCH 0/8] Arithmetic for 128-bit types

[Tom Tromey]

>>>>> "Tom" == Tom Tromey via Gdb-patches <gdb-patches@sourceware.org> writes:

Tom> This series adss basic arithmetic for 128-bit integer types to gdb.
Tom> This is done using GMP, which gdb already requires.  While this
Tom> involves extra allocation, my view is that this hardly matters in most
Tom> expression contexts.  However, if it does turn out to matter, we can
Tom> try to switch to GCC's wide-integer code.

Tom> While this series, or something like it, is necessary for supporting
Tom> 128-bit types, it is not sufficient.  In particular, none of the
Tom> lexers or parsers are touched, and integers that are part of types
Tom> (e.g., range bounds) are not handled.

Tom> This series is based on my earlier series to clean up the GMP classes.

Tom> Regression tested on x86-64 Fedora 36.

I've rebased this and re-run the regression tests.
I'm going to check it in now.

Tom