[PATCHv3 0/3] Add Type.is_scalar and Type.is_signed properties

[PATCHv3 0/3] Add Type.is_scalar and Type.is_signed properties

[Andrew Burgess]

Thanks for all the feedback on V1, and V2.  Additionally, Simon gave
some awesome suggestions on IRC

The new V3 series is a complete rewrite, main points are:

  - New Type.is_scalar property in patch #1,

  - Now have a Type.is_signed property (patch #2), which is either
    True or False.  Attempting to read this property on a non-scalar
    type will raise a ValueError.

  - Finally, patch #3 adds a test for to cover the 'char' is different
    to 'signed char' and 'unsigned char' issue.  This characteristic
    should be detected by simply comparing types.

Thoughts?

Thanks,
Andrew

---

Andrew Burgess (3):
  gdb/python: add Type.is_scalar property
  gdb/python: add Type.is_signed property
  gdb/testsuite: add new test for comparing char types in Python

 gdb/NEWS                             |  8 +++
 gdb/doc/python.texi                  | 16 +++++
 gdb/python/py-type.c                 | 38 ++++++++++++
 gdb/testsuite/gdb.python/py-arch.exp | 15 ++++-
 gdb/testsuite/gdb.python/py-type.c   | 16 +++++
 gdb/testsuite/gdb.python/py-type.exp | 88 +++++++++++++++++++++++++++-
 6 files changed, 179 insertions(+), 2 deletions(-)

-- 
2.25.4

[PATCHv3 1/3] gdb/python: add Type.is_scalar property

[Andrew Burgess]

Add a new read-only property which is True for scalar types,
otherwise, it's False.
---
 gdb/NEWS                             |  3 +++
 gdb/doc/python.texi                  |  6 ++++++
 gdb/python/py-type.c                 | 15 +++++++++++++++
 gdb/testsuite/gdb.python/py-type.c   | 16 ++++++++++++++++
 gdb/testsuite/gdb.python/py-type.exp | 26 +++++++++++++++++++++++++-
 5 files changed, 65 insertions(+), 1 deletion(-)

diff --git a/gdb/NEWS b/gdb/NEWS
index fdd42049994..874ec94b8a2 100644
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -187,6 +187,9 @@ GNU/Linux/LoongArch    loongarch*-*-linux*
      set styling').  When false, which is the default if the argument
      is not given, then no styling is applied to the returned string.
 
+  ** New read-only attribute gdb.Type.is_scalar, which is True for
+     scalar types, and False for all other types.
+
 * New features in the GDB remote stub, GDBserver
 
   ** GDBserver is now supported on OpenRISC GNU/Linux.
diff --git a/gdb/doc/python.texi b/gdb/doc/python.texi
index c1a3f5f2a7e..fa14dacf3ad 100644
--- a/gdb/doc/python.texi
+++ b/gdb/doc/python.texi
@@ -1263,6 +1263,12 @@
 there is no associated objfile.
 @end defvar
 
+@defvar Type.is_scalar
+This property is @code{True} if the type is a scalar type, otherwise,
+this property is @code{False}.  Examples of non-scalar types include
+structures, unions, and classes.
+@end defvar
+
 The following methods are provided:
 
 @defun Type.fields ()
diff --git a/gdb/python/py-type.c b/gdb/python/py-type.c
index 13dae1e2559..54761236d52 100644
--- a/gdb/python/py-type.c
+++ b/gdb/python/py-type.c
@@ -433,6 +433,19 @@ typy_get_objfile (PyObject *self, void *closure)
   return objfile_to_objfile_object (objfile).release ();
 }
 
+/* Return true if this is a scalar type, otherwise, returns false.  */
+
+static PyObject *
+typy_is_scalar (PyObject *self, void *closure)
+{
+  struct type *type = ((type_object *) self)->type;
+
+  if (is_scalar_type (type))
+    Py_RETURN_TRUE;
+  else
+    Py_RETURN_FALSE;
+}
+
 /* Return the type, stripped of typedefs. */
 static PyObject *
 typy_strip_typedefs (PyObject *self, PyObject *args)
@@ -1487,6 +1500,8 @@ static gdb_PyGetSetDef type_object_getset[] =
     "The tag name for this type, or None.", NULL },
   { "objfile", typy_get_objfile, NULL,
     "The objfile this type was defined in, or None.", NULL },
+  { "is_scalar", typy_is_scalar, nullptr,
+    "Is this a scalar type?", nullptr },
   { NULL }
 };
 
diff --git a/gdb/testsuite/gdb.python/py-type.c b/gdb/testsuite/gdb.python/py-type.c
index 10cbd3b0875..92297d5ad4b 100644
--- a/gdb/testsuite/gdb.python/py-type.c
+++ b/gdb/testsuite/gdb.python/py-type.c
@@ -32,6 +32,13 @@ TS ts;
 
 int aligncheck;
 
+union UU
+{
+  int i;
+  float f;
+  int a[5];
+};
+
 #ifdef __cplusplus
 struct C
 {
@@ -72,6 +79,14 @@ Temargs<D, 23, &C::c> temvar;
 
 #endif
 
+unsigned char global_unsigned_char;
+char global_char;
+signed char global_signed_char;
+
+unsigned int global_unsigned_int;
+int global_int;
+signed int global_signed_int;
+
 enum E
 { v1, v2, v3
 };
@@ -91,6 +106,7 @@ main ()
   int ar[2] = {1,2};
   struct s st;
   struct SS ss;
+  union UU uu;
 #ifdef __cplusplus
   C c;
   c.c = 1;
diff --git a/gdb/testsuite/gdb.python/py-type.exp b/gdb/testsuite/gdb.python/py-type.exp
index 4990eeb7ddb..2bb2bf67218 100644
--- a/gdb/testsuite/gdb.python/py-type.exp
+++ b/gdb/testsuite/gdb.python/py-type.exp
@@ -270,6 +270,29 @@ proc test_template {} {
     gdb_test "python print (ttype.template_argument(2))" "&C::c"
 }
 
+# Test the gdb.Type.is_scalar property.
+proc test_is_scalar { lang } {
+    if {$lang == "c++"} {
+	gdb_test "python print(gdb.parse_and_eval ('c').type.is_scalar)" "False"
+	gdb_test "python print(gdb.parse_and_eval ('&c').type.is_scalar)" "True"
+    }
+
+    foreach type { char int } {
+	gdb_test "python print(gdb.parse_and_eval('global_unsigned_${type}').type.is_scalar)" "True"
+	gdb_test "python print(gdb.parse_and_eval('global_${type}').type.is_scalar)" "True"
+	gdb_test "python print(gdb.parse_and_eval('global_signed_${type}').type.is_scalar)" "True"
+    }
+
+    gdb_test "python print(gdb.parse_and_eval ('ss.x').type.is_scalar)" "True"
+    gdb_test "python print(gdb.parse_and_eval ('ss').type.is_scalar)" "False"
+    gdb_test "python print(gdb.parse_and_eval ('uu').type.is_scalar)" "False"
+
+    gdb_test "python print(gdb.parse_and_eval ('uu.i').type.is_scalar)" "True"
+    gdb_test "python print(gdb.parse_and_eval ('uu.f').type.is_scalar)" "True"
+    gdb_test "python print(gdb.parse_and_eval ('uu.a').type.is_scalar)"  "False"
+    gdb_test "python print(gdb.parse_and_eval ('&ss.x').type.is_scalar)" "True"
+}
+
 # Perform C Tests.
 if { [build_inferior "${binfile}" "c"] == 0 } {
   restart_gdb "${binfile}"
@@ -296,10 +319,10 @@ if { [build_inferior "${binfile}" "c"] == 0 } {
       runto_bp "break to inspect struct and array."
       test_fields "c"
       test_enums
+      test_is_scalar "c"
   }
 }
 
-
 # Perform C++ Tests.
 if { [build_inferior "${binfile}-cxx" "c++"] == 0 } {
   restart_gdb "${binfile}-cxx"
@@ -310,5 +333,6 @@ if { [build_inferior "${binfile}-cxx" "c++"] == 0 } {
       test_range
       test_template
       test_enums
+      test_is_scalar "c++"
   }
 }
-- 
2.25.4

[PATCHv3 2/3] gdb/python: add Type.is_signed property

[Andrew Burgess]

Add a new read-only property, Type.is_signed, which is True for signed
types, and False otherwise.

This property should only be read on types for which Type.is_scalar is
true, attempting to read this property for non-scalar types will raise
a ValueError.

I chose 'is_signed' rather than 'is_unsigned' in order to match the
existing Architecture.integer_type method, which takes a 'signed'
parameter.  As far as I could find, that was the only existing
signed/unsigned selector in the Python API, so it seemed reasonable to
stay consistent.
---
 gdb/NEWS                             |  5 +++++
 gdb/doc/python.texi                  | 10 ++++++++++
 gdb/python/py-type.c                 | 23 +++++++++++++++++++++++
 gdb/testsuite/gdb.python/py-arch.exp | 15 ++++++++++++++-
 gdb/testsuite/gdb.python/py-type.exp | 28 ++++++++++++++++++++++++++++
 5 files changed, 80 insertions(+), 1 deletion(-)

diff --git a/gdb/NEWS b/gdb/NEWS
index 874ec94b8a2..7c3cc2c8ef7 100644
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -190,6 +190,11 @@ GNU/Linux/LoongArch    loongarch*-*-linux*
   ** New read-only attribute gdb.Type.is_scalar, which is True for
      scalar types, and False for all other types.
 
+  ** New read-only attribute gdb.Type.is_signed.  This attribute
+     should only be read when Type.is_scalar is True, and will be True
+     for signed types, and False for all other types.  Attempting to
+     read this attribute for non-scalar types will raise a ValueError.
+
 * New features in the GDB remote stub, GDBserver
 
   ** GDBserver is now supported on OpenRISC GNU/Linux.
diff --git a/gdb/doc/python.texi b/gdb/doc/python.texi
index fa14dacf3ad..bcd7213c707 100644
--- a/gdb/doc/python.texi
+++ b/gdb/doc/python.texi
@@ -1269,6 +1269,16 @@
 structures, unions, and classes.
 @end defvar
 
+@defvar Type.is_signed
+For scalar types (those for which @code{Type.is_scalar} is
+@code{True}), this property is @code{True} if the type is signed,
+otherwise this property is @code{False}.
+
+Attempting to read this property for a non-scalar type (a type for
+which @code{Type.is_scalar} is @code{False}), will raise a
+@code{ValueError}.
+@end defvar
+
 The following methods are provided:
 
 @defun Type.fields ()
diff --git a/gdb/python/py-type.c b/gdb/python/py-type.c
index 54761236d52..7be3f3276c2 100644
--- a/gdb/python/py-type.c
+++ b/gdb/python/py-type.c
@@ -446,6 +446,27 @@ typy_is_scalar (PyObject *self, void *closure)
     Py_RETURN_FALSE;
 }
 
+/* Return true if this type is signed.  Raises a ValueError if this type
+   is not a scalar type.  */
+
+static PyObject *
+typy_is_signed (PyObject *self, void *closure)
+{
+  struct type *type = ((type_object *) self)->type;
+
+  if (!is_scalar_type (type))
+    {
+      PyErr_SetString (PyExc_ValueError,
+		       _("Type must be a scalar type"));
+      return nullptr;
+    }
+
+  if (type->is_unsigned ())
+    Py_RETURN_FALSE;
+  else
+    Py_RETURN_TRUE;
+}
+
 /* Return the type, stripped of typedefs. */
 static PyObject *
 typy_strip_typedefs (PyObject *self, PyObject *args)
@@ -1502,6 +1523,8 @@ static gdb_PyGetSetDef type_object_getset[] =
     "The objfile this type was defined in, or None.", NULL },
   { "is_scalar", typy_is_scalar, nullptr,
     "Is this a scalar type?", nullptr },
+  { "is_signed", typy_is_signed, nullptr,
+    "Is this an signed type?", nullptr },
   { NULL }
 };
 
diff --git a/gdb/testsuite/gdb.python/py-arch.exp b/gdb/testsuite/gdb.python/py-arch.exp
index b55778b0b72..58f6cb06b3e 100644
--- a/gdb/testsuite/gdb.python/py-arch.exp
+++ b/gdb/testsuite/gdb.python/py-arch.exp
@@ -64,12 +64,25 @@ if { ![is_address_zero_readable] } {
 }
 
 foreach size {0 1 2 3 4 8 16} {
-    foreach sign {"" ", True" ", False" ", None" ", \"blah\""} {
+    foreach sign_data {{"" True} \
+			   {", True" True} \
+			   {", False" False} \
+			   {", None" False} \
+			   {", \"blah\"" True}} {
+	set sign [lindex $sign_data 0]
+	# GDB's 0 bit type is always signed.
+	if { $size == 0 } {
+	    set sign_result True
+	} else {
+	    set sign_result [lindex $sign_data 1]
+	}
 	set fullsize [expr 8 * $size]
 	gdb_test_no_output "python t = arch.integer_type($fullsize$sign)" \
 	    "get integer type for $size$sign"
 	gdb_test "python print(t.sizeof)" "$size" \
 	    "print size of integer type for $size$sign"
+	gdb_test "python print(t.is_signed == ${sign_result})" "True" \
+	    "check signedness of type for $size$sign"
     }
 }
 
diff --git a/gdb/testsuite/gdb.python/py-type.exp b/gdb/testsuite/gdb.python/py-type.exp
index 2bb2bf67218..86cf8f3ff69 100644
--- a/gdb/testsuite/gdb.python/py-type.exp
+++ b/gdb/testsuite/gdb.python/py-type.exp
@@ -270,6 +270,32 @@ proc test_template {} {
     gdb_test "python print (ttype.template_argument(2))" "&C::c"
 }
 
+# Check the is_signed property of some types.
+proc test_is_signed {lang} {
+    if {$lang == "c++"} {
+	gdb_test "python print(gdb.parse_and_eval ('c').type.is_signed)"  \
+	"ValueError: Type must be a scalar type.*"
+	gdb_test "python print(gdb.parse_and_eval ('&c').type.is_signed == False)" "True"
+    }
+
+    gdb_test "python print(gdb.parse_and_eval('global_unsigned_char').type.is_signed == False)" "True"
+    gdb_test "python print(gdb.parse_and_eval('global_char').type.is_signed)" "True|False"
+    gdb_test "python print(gdb.parse_and_eval('global_signed_char').type.is_signed == True)" "True"
+
+    gdb_test "python print(gdb.parse_and_eval ('ss.x').type.is_signed == True)" "True"
+    gdb_test "python print(gdb.parse_and_eval ('ss').type.is_signed)" \
+	"ValueError: Type must be a scalar type.*"
+    gdb_test "python print(gdb.parse_and_eval ('uu').type.is_signed)"  \
+	"ValueError: Type must be a scalar type.*"
+    gdb_test "python print(gdb.parse_and_eval ('uu.i').type.is_signed == True)" "True"
+    gdb_test "python print(gdb.parse_and_eval ('uu.f').type.is_signed == True)" "True"
+    gdb_test "python print(gdb.parse_and_eval ('uu.a').type.is_signed)"  \
+	"ValueError: Type must be a scalar type.*"
+
+    gdb_test "python print(gdb.parse_and_eval ('&ss.x').type.is_signed == False)" "True"
+    gdb_test "python print(gdb.parse_and_eval ('&uu').type.is_signed == False)" "True"
+}
+
 # Test the gdb.Type.is_scalar property.
 proc test_is_scalar { lang } {
     if {$lang == "c++"} {
@@ -320,6 +346,7 @@ if { [build_inferior "${binfile}" "c"] == 0 } {
       test_fields "c"
       test_enums
       test_is_scalar "c"
+      test_is_signed "c"
   }
 }
 
@@ -334,5 +361,6 @@ if { [build_inferior "${binfile}-cxx" "c++"] == 0 } {
       test_template
       test_enums
       test_is_scalar "c++"
+      test_is_signed "c++"
   }
 }
-- 
2.25.4

[PATCHv3 3/3] gdb/testsuite: add new test for comparing char types in Python

[Andrew Burgess]

There's an interesting property of the 'char' type in C and C++, the
three types 'char', 'unsigned char', and 'signed char', are all
considered distinct.

In contrast, and 'int' is signed by default, and so 'int' and 'signed
int' are considered the same type.

This commit adds a test to ensure that this edge case is visible to a
user from Python.

It is worth noting that for any particular compiler implementation (or
the flags a compiler was invoked with), a 'char' will be either signed
or unsigned; it has to be one or the other, and a user can access this
information by using the Type.is_signed property.  However, for
something like function overload resolution, the 'char' type is
considered distinct from the signed and unsigned variants.

There's no change to GDB with this commit, this is just adding a new
test to guard some existing functionality.
---
 gdb/testsuite/gdb.python/py-type.exp | 34 ++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/gdb/testsuite/gdb.python/py-type.exp b/gdb/testsuite/gdb.python/py-type.exp
index 86cf8f3ff69..5613bc024f6 100644
--- a/gdb/testsuite/gdb.python/py-type.exp
+++ b/gdb/testsuite/gdb.python/py-type.exp
@@ -296,6 +296,38 @@ proc test_is_signed {lang} {
     gdb_test "python print(gdb.parse_and_eval ('&uu').type.is_signed == False)" "True"
 }
 
+# Compare the types of different symbols from the inferior, we're
+# checking that the types of different sybols of the same declared
+# type, are equal (in Python).
+proc test_type_equality {} {
+
+    foreach_with_prefix type { char int } {
+	gdb_test_no_output "python v1 = gdb.parse_and_eval('global_unsigned_${type}')"
+	gdb_test_no_output "python v2 = gdb.parse_and_eval('global_${type}')"
+	gdb_test_no_output "python v3 = gdb.parse_and_eval('global_signed_${type}')"
+
+	gdb_test_no_output "python t1 = v1.type"
+	gdb_test_no_output "python t2 = v2.type"
+	gdb_test_no_output "python t3 = v3.type"
+
+	if { $type == "char" } {
+	    # In C/C++ there's an interesting property of 'char' based types;
+	    # 'signed char', 'unsigned char', and 'char' are all distinct
+	    # types.  Weird, right?  Here we check that this property is
+	    # visible to Python code.
+	    gdb_test "python print(t1 != t2)" "True"
+	    gdb_test "python print(t1 != t3)" "True"
+	    gdb_test "python print(t2 != t3)" "True"
+	} else {
+	    # For 'int' type, when neither signed or unsigned is given
+	    # we expect the type to be signed by default.
+	    gdb_test "python print(t1 != t2)" "True"
+	    gdb_test "python print(t1 != t3)" "True"
+	    gdb_test "python print(t2 == t3)" "True"
+	}
+    }
+}
+
 # Test the gdb.Type.is_scalar property.
 proc test_is_scalar { lang } {
     if {$lang == "c++"} {
@@ -347,6 +379,7 @@ if { [build_inferior "${binfile}" "c"] == 0 } {
       test_enums
       test_is_scalar "c"
       test_is_signed "c"
+      test_type_equality
   }
 }
 
@@ -362,5 +395,6 @@ if { [build_inferior "${binfile}-cxx" "c++"] == 0 } {
       test_enums
       test_is_scalar "c++"
       test_is_signed "c++"
+      test_type_equality
   }
 }
-- 
2.25.4

Re: [PATCHv3 0/3] Add Type.is_scalar and Type.is_signed properties

[Andrew Burgess]

Apologies, this was sent to the wrong list.

Sorry for the noise.

Andrew

* Andrew Burgess via Binutils <binutils@sourceware.org> [2022-02-25 11:31:09 +0000]:

> Thanks for all the feedback on V1, and V2.  Additionally, Simon gave
> some awesome suggestions on IRC
> 
> The new V3 series is a complete rewrite, main points are:
> 
>   - New Type.is_scalar property in patch #1,
> 
>   - Now have a Type.is_signed property (patch #2), which is either
>     True or False.  Attempting to read this property on a non-scalar
>     type will raise a ValueError.
> 
>   - Finally, patch #3 adds a test for to cover the 'char' is different
>     to 'signed char' and 'unsigned char' issue.  This characteristic
>     should be detected by simply comparing types.
> 
> Thoughts?
> 
> Thanks,
> Andrew
> 
> ---
> 
> Andrew Burgess (3):
>   gdb/python: add Type.is_scalar property
>   gdb/python: add Type.is_signed property
>   gdb/testsuite: add new test for comparing char types in Python
> 
>  gdb/NEWS                             |  8 +++
>  gdb/doc/python.texi                  | 16 +++++
>  gdb/python/py-type.c                 | 38 ++++++++++++
>  gdb/testsuite/gdb.python/py-arch.exp | 15 ++++-
>  gdb/testsuite/gdb.python/py-type.c   | 16 +++++
>  gdb/testsuite/gdb.python/py-type.exp | 88 +++++++++++++++++++++++++++-
>  6 files changed, 179 insertions(+), 2 deletions(-)
> 
> -- 
> 2.25.4
>