support: Fix TEST_COMPARE for uintptr_t.

TEST_COMPARE should allow comparison between two capability values.

diff --git a/support/check.h b/support/check.h
index fa080cf4805319b2583050937bc8d908f0a1ec1e..202d5a8047c51fd3047fce787b159901929c110f 100644 (file)
--- a/support/check.h
+++ b/support/check.h
@@ -98,7 +98,8 @@ void support_record_failure (void);
 
 /* Compare the two integers LEFT and RIGHT and report failure if they
    are different.  */
-#define TEST_COMPARE(left, right)                                       \
+#ifndef __CHERI_PURE_CAPABILITY__
+# define TEST_COMPARE(left, right)                                      \
   ({                                                                    \
     /* + applies the integer promotions, for bitfield support.   */     \
     typedef __typeof__ (+ (left)) __left_type;                          \
@@ -126,6 +127,32 @@ void support_record_failure (void);
          #left, __left_value, __left_is_positive, sizeof (__left_type), \
          #right, __right_value, __right_is_positive, sizeof (__right_type)); \
   })
+#else
+# define TEST_COMPARE(left, right)                                      \
+  ({                                                                    \
+    /* + applies the integer promotions, for bitfield support.   */     \
+    typedef __typeof__ (+ (left)) __left_type;                          \
+    typedef __typeof__ (+ (right)) __right_type;                        \
+    __left_type __left_value = (left);                                  \
+    __right_type __right_value = (right);                               \
+    int __left_is_positive = __left_value > 0;                          \
+    int __right_is_positive = __right_value > 0;                        \
+    /* Prevent use with floating-point types.  */                       \
+    support_static_assert ((__left_type) 1.0 == (__left_type) 1.5,      \
+                           "left value has floating-point type");       \
+    support_static_assert ((__right_type) 1.0 == (__right_type) 1.5,    \
+                           "right value has floating-point type");      \
+    /* Compare the value.  */                                           \
+    if (__left_value != __right_value                                   \
+        || __left_is_positive != __right_is_positive)                   \
+      /* Pass the sign for printing the correct value.  */              \
+      support_test_compare_failure                                      \
+        (__FILE__, __LINE__,                                            \
+         #left, __left_value, __left_is_positive, sizeof (__left_type), \
+         #right, __right_value, __right_is_positive, sizeof (__right_type)); \
+  })
+#endif
+
 
 /* Internal implementation of TEST_COMPARE.  LEFT_POSITIVE and
    RIGHT_POSITIVE are used to store the sign separately, so that both
@@ -133,6 +160,7 @@ void support_record_failure (void);
    RIGHT_VALUE, and the function can still print the original value.
    LEFT_SIZE and RIGHT_SIZE specify the size of the argument in bytes,
    for hexadecimal formatting.  */
+#ifndef __CHERI_PURE_CAPABILITY__
 void support_test_compare_failure (const char *file, int line,
                                    const char *left_expr,
                                    long long left_value,
@@ -142,7 +170,17 @@ void support_test_compare_failure (const char *file, int line,
                                    long long right_value,
                                    int right_positive,
                                    int right_size);
-
+#else
+void support_test_compare_failure (const char *file, int line,
+                                   const char *left_expr,
+                                   __uintcap_t left_value,
+                                   int left_positive,
+                                   int left_size,
+                                   const char *right_expr,
+                                   __uintcap_t right_value,
+                                   int right_positive,
+                                   int right_size);
+#endif
 
 /* Compare [LEFT, LEFT + LEFT_LENGTH) with [RIGHT, RIGHT +
    RIGHT_LENGTH) and report a test failure if the arrays are

diff --git a/support/support_test_compare_failure.c b/support/support_test_compare_failure.c
index 792cc2074efacbfdf0f0b08164cf458240b669ba..75f000a182a5b9d50ce9b76e378f0ecaffd86660 100644 (file)
--- a/support/support_test_compare_failure.c
+++ b/support/support_test_compare_failure.c
@@ -34,6 +34,7 @@ report (const char *which, const char *expr, long long value, int positive,
   printf (" (0x%llx); from: %s\n", (unsigned long long) value & mask, expr);
 }
 
+#ifndef __CHERI_PURE_CAPABILITY__
 void
 support_test_compare_failure (const char *file, int line,
                               const char *left_expr,
@@ -56,3 +57,27 @@ support_test_compare_failure (const char *file, int line,
   report ("right", right_expr, right_value, right_positive, right_size);
   errno = saved_errno;
 }
+#else
+void
+support_test_compare_failure (const char *file, int line,
+                              const char *left_expr,
+                              __uintcap_t left_value,
+                              int left_positive,
+                              int left_size,
+                              const char *right_expr,
+                              __uintcap_t right_value,
+                              int right_positive,
+                              int right_size)
+{
+  int saved_errno = errno;
+  support_record_failure ();
+  if (left_size != right_size)
+    printf ("%s:%d: numeric comparison failure (widths %d and %d)\n",
+            file, line, left_size * 8, right_size * 8);
+  else
+    printf ("%s:%d: numeric comparison failure\n", file, line);
+  report (" left", left_expr, left_value, left_positive, left_size);
+  report ("right", right_expr, right_value, right_positive, right_size);
+  errno = saved_errno;
+}
+#endif