[Commit] cairo_u128 ChangeLog, 1.2, 1.3 Makefile, 1.4,
1.5 cairo_test.c, 1.4, 1.5 cairo_uint128.c, 1.4,
1.5 cairo_uint128.h, 1.4, 1.5 checkdata.5c, 1.4,
1.5 makedata.5c, 1.2, 1.3
Keith Packard
commit at keithp.com
Thu May 27 22:47:19 PDT 2004
- Previous message: [Commit] nickle ChangeLog, 1.58, 1.59 int.c, 1.22, 1.23 nickle.h,
1.116, 1.117 value.h, 1.103, 1.104
- Next message: [Commit] nickle ChangeLog,1.59,1.60
- Messages sorted by:
[ date ]
[ thread ]
[ subject ]
[ author ]
Committed by: keithp
Update of /local/src/CVS/cairo_u128
In directory home.keithp.com:/tmp/cvs-serv13286
Modified Files:
ChangeLog Makefile cairo_test.c cairo_uint128.c
cairo_uint128.h checkdata.5c makedata.5c
Log Message:
2004-05-27 Keith Packard <keithp at keithp.com>
* Makefile:
* cairo_test.c: (zero_dump_uint64), (dump_uint64), (dump_int64),
(dump_uint128), (dump_int128), (read_int128), (_nz_den128),
(_nz_den64), (main):
* cairo_uint128.c: (_cairo_uint64_divrem),
(_cairo_uint32_to_uint64), (_cairo_int32_to_int64),
(_cairo_uint32s_to_uint64), (_cairo_uint64_add),
(_cairo_uint64_sub), (_cairo_uint32x32_64_mul),
(_cairo_uint64_mul), (_cairo_uint64_lsl), (_cairo_uint64_rsl),
(_cairo_uint64_rsa), (_cairo_uint64_lt), (_cairo_uint64_eq),
(_cairo_int64_lt), (_cairo_uint64_not), (_cairo_uint64_negate),
(_cairo_uint64x32_normalized_divrem), (_cairo_int64_divrem),
(_cairo_uint128_divrem), (_cairo_uint32_to_uint128),
(_cairo_int32_to_int128), (_cairo_uint64_to_uint128),
(_cairo_int64_to_int128), (_cairo_uint128_add),
(_cairo_uint128_sub), (uint64_lo), (uint64_hi), (uint64_shift32),
(_cairo_uint64x64_128_mul), (_cairo_uint128_mul),
(_cairo_uint128_lsl), (_cairo_uint128_rsl), (_cairo_uint128_rsa),
(_cairo_uint128_lt), (_cairo_int128_lt), (_cairo_uint128_eq),
(_cairo_uint128x64_normalized_divrem), (_cairo_leading_zeros64),
(_cairo_int128_divrem), (_cairo_int128_negate),
(_cairo_int128_not):
* cairo_uint128.h:
* checkdata.5c:
* makedata.5c:
Add signed arithmetic. Test all operations.
Allow for 'native' int128_t.
Index: ChangeLog
===================================================================
RCS file: /local/src/CVS/cairo_u128/ChangeLog,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- a/ChangeLog 25 May 2004 21:21:52 -0000 1.2
+++ b/ChangeLog 28 May 2004 05:47:16 -0000 1.3
@@ -1,3 +1,33 @@
+2004-05-27 Keith Packard <keithp at keithp.com>
+
+ * Makefile:
+ * cairo_test.c: (zero_dump_uint64), (dump_uint64), (dump_int64),
+ (dump_uint128), (dump_int128), (read_int128), (_nz_den128),
+ (_nz_den64), (main):
+ * cairo_uint128.c: (_cairo_uint64_divrem),
+ (_cairo_uint32_to_uint64), (_cairo_int32_to_int64),
+ (_cairo_uint32s_to_uint64), (_cairo_uint64_add),
+ (_cairo_uint64_sub), (_cairo_uint32x32_64_mul),
+ (_cairo_uint64_mul), (_cairo_uint64_lsl), (_cairo_uint64_rsl),
+ (_cairo_uint64_rsa), (_cairo_uint64_lt), (_cairo_uint64_eq),
+ (_cairo_int64_lt), (_cairo_uint64_not), (_cairo_uint64_negate),
+ (_cairo_uint64x32_normalized_divrem), (_cairo_int64_divrem),
+ (_cairo_uint128_divrem), (_cairo_uint32_to_uint128),
+ (_cairo_int32_to_int128), (_cairo_uint64_to_uint128),
+ (_cairo_int64_to_int128), (_cairo_uint128_add),
+ (_cairo_uint128_sub), (uint64_lo), (uint64_hi), (uint64_shift32),
+ (_cairo_uint64x64_128_mul), (_cairo_uint128_mul),
+ (_cairo_uint128_lsl), (_cairo_uint128_rsl), (_cairo_uint128_rsa),
+ (_cairo_uint128_lt), (_cairo_int128_lt), (_cairo_uint128_eq),
+ (_cairo_uint128x64_normalized_divrem), (_cairo_leading_zeros64),
+ (_cairo_int128_divrem), (_cairo_int128_negate),
+ (_cairo_int128_not):
+ * cairo_uint128.h:
+ * checkdata.5c:
+ * makedata.5c:
+ Add signed arithmetic. Test all operations.
+ Allow for 'native' int128_t.
+
2004-05-25 Keith Packard <keithp at keithp.com>
* Makefile:
Index: Makefile
===================================================================
RCS file: /local/src/CVS/cairo_u128/Makefile,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- a/Makefile 25 May 2004 21:21:52 -0000 1.4
+++ b/Makefile 28 May 2004 05:47:16 -0000 1.5
@@ -1,26 +1,27 @@
-SETS=10000
-REPS=100
+include params
HAVE_UINT64_T=1
+HAVE_UINT128_T=0
+CDEBUGFLAGS=-O4
-CFLAGS=-O4 -DHAVE_UINT64_T=$(HAVE_UINT64_T)
+CFLAGS=$(CDEBUGFLAGS) -DHAVE_UINT64_T=$(HAVE_UINT64_T) -DHAVE_UINT128_T=$(HAVE_UINT128_T)
OBJS = cairo_uint128.o cairo_test.o
check: c nickle
cmp c nickle
-c: cairo_test data Makefile
+c: cairo_test data params
./cairo_test $(SETS) < data > $@
-nickle: checkdata.5c data Makefile
+nickle: checkdata.5c data
./checkdata.5c < data > $@
-data: makedata.5c Makefile
+data: makedata.5c params
./makedata.5c $(SETS) > data
cairo_test: $(OBJS)
$(CC) $(CFLAGS) -o $@ $(OBJS)
-bench: cairo_test data Makefile
+bench: cairo_test data params
time ./cairo_test $(SETS) $(REPS) < data
$(OBJS): cairo_uint128.h Makefile
Index: cairo_test.c
===================================================================
RCS file: /local/src/CVS/cairo_u128/cairo_test.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- a/cairo_test.c 25 May 2004 21:21:52 -0000 1.4
+++ b/cairo_test.c 28 May 2004 05:47:16 -0000 1.5
@@ -33,10 +33,10 @@
#if HAVE_UINT64_T
printf (zero ? "%016llx" : "%llx", q);
#else
- if (q.b[1] || zero)
- printf (zero ? "%08x%08x" : "%x%08x", q.b[1], q.b[0]);
+ if (q.hi || zero)
+ printf (zero ? "%08x%08x" : "%x%08x", q.hi, q.lo);
else
- printf ("%x", q.b[0]);
+ printf ("%x", q.lo);
#endif
}
@@ -44,7 +44,17 @@
dump_uint64 (cairo_uint64_t q)
{
zero_dump_uint64 (q, 0);
- printf ("\n");
+}
+
+void
+dump_int64 (cairo_int64_t d)
+{
+ if (_cairo_int64_negative (d))
+ {
+ printf ("-");
+ d = _cairo_int64_negate (d);
+ }
+ dump_uint64 (_cairo_int64_to_uint64 (d));
}
void
@@ -52,22 +62,33 @@
{
int zero = 0;
- if (_cairo_uint64_ne(q.b[1], _cairo_uint32_to_uint64(0)))
+ if (_cairo_uint64_ne(q.hi, _cairo_uint32_to_uint64(0)))
{
- zero_dump_uint64 (q.b[1], 0);
+ zero_dump_uint64 (q.hi, 0);
zero = 1;
}
- zero_dump_uint64 (q.b[0], zero);
- printf ("\n");
+ zero_dump_uint64 (q.lo, zero);
}
-cairo_uint128_t
-read_uint128 (FILE *f)
+void
+dump_int128 (cairo_int128_t d)
{
- cairo_uint128_t x;
+ if (_cairo_int128_negative (d))
+ {
+ printf ("-");
+ d = _cairo_int128_negate (d);
+ }
+ dump_uint128 (_cairo_int128_to_uint128 (d));
+}
+
+cairo_int128_t
+read_int128 (FILE *f)
+{
+ cairo_int128_t x;
int c;
+ int neg = 0;
- x = _cairo_uint32_to_uint128 (0);
+ x = _cairo_int32_to_int128 (0);
while ((c = getc (f)) != EOF)
if (isxdigit (c))
{
@@ -81,38 +102,197 @@
v = c - 'a' + 10;
else if ('A' <= c && c <= 'F')
v = c - 'A' + 10;
- x = _cairo_uint128_lsl (x, 4);
- x = _cairo_uint128_add (x, _cairo_uint32_to_uint128 (v));
+ x = _cairo_int128_lsl (x, 4);
+ x = _cairo_int128_add (x, _cairo_int32_to_int128 (v));
c = getc (f);
} while (isxdigit (c));
if (c != EOF)
ungetc (c, f);
+ if (neg)
+ x = _cairo_int128_negate (x);
return x;
- }
+ } else if (c == '-')
+ neg = 1;
exit (0);
}
+typedef struct _op {
+ char *name;
+ int (*valid128) (cairo_int128_t, cairo_int128_t);
+ cairo_int128_t (*s128) (cairo_int128_t, cairo_int128_t);
+ cairo_uint128_t (*u128) (cairo_uint128_t, cairo_uint128_t);
+ int (*valid64) (cairo_int64_t, cairo_int64_t);
+ cairo_int64_t (*s64) (cairo_int64_t, cairo_int64_t);
+ cairo_uint64_t (*u64) (cairo_uint64_t, cairo_uint64_t);
+} Op;
+
+#define declare(name) \
+cairo_int128_t \
+f_cairo_int128_##name (cairo_int128_t a, cairo_int128_t b) { \
+ return _cairo_int128_##name (a, b); \
+} \
+cairo_uint128_t \
+f_cairo_uint128_##name (cairo_uint128_t a, cairo_uint128_t b) { \
+ return _cairo_uint128_##name (a, b); \
+} \
+cairo_int64_t \
+f_cairo_int64_##name (cairo_int64_t a, cairo_int64_t b) { \
+ return _cairo_int64_##name (a, b); \
+} \
+cairo_uint64_t \
+f_cairo_uint64_##name (cairo_uint64_t a, cairo_uint64_t b) { \
+ return _cairo_uint64_##name (a, b); \
+} \
+
+#define declare_shift(name) \
+cairo_int128_t \
+f_cairo_int128_##name (cairo_int128_t a, cairo_int128_t b) { \
+ return _cairo_int128_##name (a, _cairo_uint128_to_uint32(b) & 127); \
+} \
+cairo_uint128_t \
+f_cairo_uint128_##name (cairo_uint128_t a, cairo_uint128_t b) { \
+ return _cairo_uint128_##name (a, _cairo_uint128_to_uint32(b) & 127); \
+} \
+cairo_int64_t \
+f_cairo_int64_##name (cairo_int64_t a, cairo_int64_t b) { \
+ return _cairo_int64_##name (a, _cairo_uint64_to_uint32(b) & 63); \
+} \
+cairo_uint64_t \
+f_cairo_uint64_##name (cairo_uint64_t a, cairo_uint64_t b) { \
+ return _cairo_uint64_##name (a, _cairo_uint64_to_uint32(b) & 63); \
+} \
+
+#define declare_divrem(elt) \
+cairo_int128_t \
+f_cairo_int128_##elt (cairo_int128_t a, cairo_int128_t b) { \
+ return _cairo_int128_divrem (a, b).elt; \
+} \
+cairo_uint128_t \
+f_cairo_uint128_##elt (cairo_uint128_t a, cairo_uint128_t b) { \
+ return _cairo_uint128_divrem (a, b).elt; \
+} \
+cairo_int64_t \
+f_cairo_int64_##elt (cairo_int64_t a, cairo_int64_t b) { \
+ return _cairo_int64_divrem (a, b).elt; \
+} \
+cairo_uint64_t \
+f_cairo_uint64_##elt (cairo_uint64_t a, cairo_uint64_t b) { \
+ return _cairo_uint64_divrem (a, b).elt; \
+} \
+
+#define declare_unary(name) \
+cairo_int128_t \
+f_cairo_int128_##name (cairo_int128_t a, cairo_int128_t b) { \
+ return _cairo_int128_##name (a); \
+} \
+cairo_uint128_t \
+f_cairo_uint128_##name (cairo_uint128_t a, cairo_uint128_t b) { \
+ return _cairo_uint128_##name (a); \
+} \
+cairo_int64_t \
+f_cairo_int64_##name (cairo_int64_t a, cairo_int64_t b) { \
+ return _cairo_int64_##name (a); \
+} \
+cairo_uint64_t \
+f_cairo_uint64_##name (cairo_uint64_t a, cairo_uint64_t b) { \
+ return _cairo_uint64_##name (a); \
+} \
+
+#define declare_bool(name) \
+cairo_int128_t \
+f_cairo_int128_##name (cairo_int128_t a, cairo_int128_t b) { \
+ return _cairo_int32_to_int128 (_cairo_int128_##name (a, b)); \
+} \
+cairo_uint128_t \
+f_cairo_uint128_##name (cairo_uint128_t a, cairo_uint128_t b) { \
+ return _cairo_int32_to_int128 (_cairo_uint128_##name (a, b)); \
+} \
+cairo_int64_t \
+f_cairo_int64_##name (cairo_int64_t a, cairo_int64_t b) { \
+ return _cairo_int32_to_int64 (_cairo_int64_##name (a, b)); \
+} \
+cairo_uint64_t \
+f_cairo_uint64_##name (cairo_uint64_t a, cairo_uint64_t b) { \
+ return _cairo_int32_to_int64 (_cairo_uint64_##name (a, b)); \
+} \
+
+declare (add)
+declare (sub)
+declare (mul)
+declare_shift (lsl)
+declare_shift (rsl)
+declare_shift (rsa)
+declare_divrem (quo)
+declare_divrem (rem)
+declare_unary (negate)
+declare_bool (lt)
+declare_bool (le)
+declare_bool (eq)
+declare_bool (ne)
+declare_bool (ge)
+declare_bool (gt)
+
+#define ops(name) \
+ 0, f_cairo_int128_##name, f_cairo_uint128_##name, \
+ 0, f_cairo_int64_##name, f_cairo_uint64_##name,
+
+int
+_nz_den128 (cairo_int128_t num, cairo_int128_t den)
+{
+ return _cairo_int128_ne (den, _cairo_int32_to_int128 (0));
+}
+
+int
+_nz_den64 (cairo_int64_t num, cairo_int64_t den)
+{
+ return _cairo_int64_ne (den, _cairo_int32_to_int64 (0));
+}
+
+#define div_ops(name) \
+ _nz_den128, f_cairo_int128_##name, f_cairo_uint128_##name, \
+ _nz_den64, f_cairo_int64_##name, f_cairo_uint64_##name,
+
+Op ops[] = {
+ { "+", ops (add) },
+ { "-", ops (sub) },
+ { "*", ops (mul) },
+ { ">>", ops (rsl) },
+ { ">>>", ops (rsa) },
+ { "<<", ops (lsl) },
+ { "/", div_ops(quo) },
+ { "%", div_ops(rem) },
+ { "<", ops (lt) },
+ { "<=", ops (le) },
+ { "==", ops (eq) },
+ { "!=", ops (ne) },
+ { ">=", ops (ge) },
+ { ">", ops (gt) },
+};
+
+#define N_OP (sizeof (ops) / sizeof (ops[0]))
+
int
main (int argc, char **argv)
{
unsigned int i;
- cairo_uint128_t *q, qv;
- cairo_uint64_t *d, dv;
+ cairo_int128_t *q, qv;
+ cairo_int64_t *d, dv;
int c;
int width = 2;
int sets = atoi (argv[1]);
int reps = argv[2] ? atoi(argv[2]) : 1;
int r;
int s;
+ int op;
- q = malloc (width * sets * sizeof (cairo_uint128_t));
- d = malloc (width * sets * sizeof (cairo_uint64_t));
+ q = malloc (width * sets * sizeof (cairo_int128_t));
+ d = malloc (width * sets * sizeof (cairo_int64_t));
for (s = 0; s < sets; s++)
{
for (c = 0; c < width; c++)
{
- q[c + s*width] = read_uint128 (stdin);
- d[c + s*width] = _cairo_uint128_to_uint64 (q[c+s*width]);
+ q[c + s*width] = read_int128 (stdin);
+ d[c + s*width] = _cairo_int128_to_int64 (q[c+s*width]);
}
}
for (r = 0; r < reps; r++)
@@ -121,111 +301,71 @@
{
if (reps == 1)
{
+ printf ("s 64 ");
+ dump_int64 (d[0+s*width]);
+ printf (" ");
+ dump_int64 (d[1+s*width]);
+ printf ("\n");
+ printf ("u 64 ");
+ dump_uint64 (d[0+s*width]);
+ printf (" ");
+ dump_uint64 (d[1+s*width]);
+ printf ("\n");
+ printf ("s 128 ");
+ dump_int128 (q[0+s*width]);
+ printf (" ");
+ dump_int128 (q[1+s*width]);
+ printf ("\n");
+ printf ("u 128 ");
dump_uint128 (q[0+s*width]);
+ printf (" ");
dump_uint128 (q[1+s*width]);
+ printf ("\n");
+ printf ("\n");
}
- qv = _cairo_uint128_add (q[0+s*width], q[1+s*width]);
- if (reps == 1)
- {
- printf ("+ ");
- dump_uint128 (qv);
- }
-
- dv = _cairo_uint64_add (d[0+s*width], d[1+s*width]);
- if (reps == 1)
- {
- printf ("+ ");
- dump_uint64 (dv);
- }
-
- qv = _cairo_uint128_sub (q[0+s*width], q[1+s*width]);
- if (reps == 1)
- {
- printf ("- ");
- dump_uint128 (qv);
- }
-
- dv = _cairo_uint64_sub (d[0+s*width], d[1+s*width]);
- if (reps == 1)
- {
- printf ("- ");
- dump_uint64 (dv);
- }
-
- qv = _cairo_uint128_mul (q[0+s*width], q[1+s*width]);
- if (reps == 1)
- {
- printf ("* ");
- dump_uint128 (qv);
- }
-
- dv = _cairo_uint64_mul (d[0+s*width], d[1+s*width]);
- if (reps == 1)
- {
- printf ("* ");
- dump_uint64 (dv);
- }
-
- qv = _cairo_uint128_rsl (q[0+s*width],
- _cairo_uint128_to_uint32(q[1+s*width]) % 128);
- if (reps == 1)
- {
- printf (">> ");
- dump_uint128 (qv);
- }
-
- dv = _cairo_uint64_rsl (d[0+s*width],
- _cairo_uint64_to_uint32(d[1+s*width]) % 64);
- if (reps == 1)
- {
- printf (">> ");
- dump_uint64 (dv);
- }
-
- qv = _cairo_uint128_lsl (q[0+s*width],
- _cairo_uint128_to_uint32(q[1+s*width]) % 128);
- if (reps == 1)
- {
- printf ("<< ");
- dump_uint128 (qv);
- }
-
- dv = _cairo_uint64_lsl (d[0+s*width],
- _cairo_uint64_to_uint32(d[1+s*width]) % 64);
- if (reps == 1)
- {
- printf ("<< ");
- dump_uint64 (dv);
- }
-
- qv = _cairo_uint128_divmod (q[0+s*width], q[1+s*width]).quo;
- if (reps == 1)
- {
- printf ("/ ");
- dump_uint128 (qv);
- }
-
- dv = _cairo_uint64_divmod (d[0+s*width], d[1+s*width]).quo;
- if (reps == 1)
- {
- printf ("/ ");
- dump_uint64 (dv);
- }
-
- qv = _cairo_uint128_divmod (q[0+s*width], q[1+s*width]).rem;
- if (reps == 1)
+ for (op = 0; op < N_OP; op++)
{
- printf ("%% ");
- dump_uint128 (qv);
+ if (!ops[op].valid64 ||
+ (*ops[op].valid64) (d[0+s*width], d[1+s*width]))
+ {
+ dv = (*ops[op].s64)(d[0+s*width], d[1+s*width]);
+ if (reps == 1)
+ {
+ printf ("s 64 %s ", ops[op].name);
+ dump_int64 (dv);
+ printf ("\n");
+ }
+ dv = (*ops[op].u64)(d[0+s*width], d[1+s*width]);
+ if (reps == 1)
+ {
+ printf ("u 64 %s ", ops[op].name);
+ dump_uint64 (dv);
+ printf ("\n");
+ }
+ }
+ if (!ops[op].valid128 ||
+ (*ops[op].valid128) (q[0+s*width], q[1+s*width]))
+ {
+ qv = (*ops[op].s128)(q[0+s*width], q[1+s*width]);
+ if (reps == 1)
+ {
+ printf ("s 128 %s ", ops[op].name);
+ dump_int128 (qv);
+ printf ("\n");
+ }
+
+ qv = (*ops[op].u128)(q[0+s*width], q[1+s*width]);
+ if (reps == 1)
+ {
+ printf ("u 128 %s ", ops[op].name);
+ dump_uint128 (qv);
+ printf ("\n");
+ }
+ }
}
-
- dv = _cairo_uint64_divmod (d[0+s*width], d[1+s*width]).rem;
if (reps == 1)
- {
- printf ("%% ");
- dump_uint64 (dv);
- }
+ printf ("\n");
}
}
return 0;
Index: cairo_uint128.c
===================================================================
RCS file: /local/src/CVS/cairo_u128/cairo_uint128.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- a/cairo_uint128.c 25 May 2004 21:21:52 -0000 1.4
+++ b/cairo_uint128.c 28 May 2004 05:47:16 -0000 1.5
@@ -24,6 +24,8 @@
#include "cairo_uint128.h"
+#if !HAVE_UINT64_T || !HAVE_UINT128_T
+
static const unsigned char top_bit[256] =
{
0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
@@ -36,44 +38,22 @@
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
};
[...1010 lines suppressed...]
return qr;
}
+
+const cairo_int128_t
+_cairo_int128_negate (cairo_int128_t a)
+{
+ a.lo = _cairo_uint64_not (a.lo);
+ a.hi = _cairo_uint64_not (a.hi);
+ return _cairo_uint128_add (a, _cairo_uint32_to_uint128 (1));
+}
+const cairo_int128_t
+_cairo_int128_not (cairo_int128_t a)
+{
+ a.lo = _cairo_uint64_not (a.lo);
+ a.hi = _cairo_uint64_not (a.hi);
+ return a;
+}
+
+#endif /* !HAVE_UINT128_T */
Index: cairo_uint128.h
===================================================================
RCS file: /local/src/CVS/cairo_u128/cairo_uint128.h,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- a/cairo_uint128.h 25 May 2004 21:21:52 -0000 1.4
+++ b/cairo_uint128.h 28 May 2004 05:47:16 -0000 1.5
@@ -27,122 +27,242 @@
#include <stdint.h>
-#if !HAVE_UINT64_T
+/*
+ * 64-bit datatypes. Two separate implementations, one using
+ * built-in 64-bit signed/unsigned types another implemented
+ * as a pair of 32-bit ints
+ */
-#define CAIRO_NUM_IN_UINT64 2
+#if !HAVE_UINT64_T
typedef struct _cairo_uint64 {
- uint32_t b[CAIRO_NUM_IN_UINT64];
-} cairo_uint64_t;
-
-extern const cairo_uint64_t
-_cairo_uint32_to_uint64 (uint32_t i);
-
-extern const uint32_t
-_cairo_uint64_to_uint32 (cairo_uint64_t i);
+ uint32_t lo, hi;
+} cairo_uint64_t, cairo_int64_t;
-extern const cairo_uint64_t
-_cairo_uint64_add (cairo_uint64_t a, cairo_uint64_t b);
+const cairo_uint64_t _cairo_uint32_to_uint64 (uint32_t i);
+#define _cairo_uint64_to_uint32(a) ((a).lo)
+const cairo_uint64_t _cairo_uint64_add (cairo_uint64_t a, cairo_uint64_t b);
+const cairo_uint64_t _cairo_uint64_sub (cairo_uint64_t a, cairo_uint64_t b);
+const cairo_uint64_t _cairo_uint64_mul (cairo_uint64_t a, cairo_uint64_t b);
+const cairo_uint64_t _cairo_uint32x32_64_mul (uint32_t a, uint32_t b);
+const cairo_uint64_t _cairo_uint64_lsl (cairo_uint64_t a, int shift);
+const cairo_uint64_t _cairo_uint64_rsl (cairo_uint64_t a, int shift);
+const cairo_uint64_t _cairo_uint64_rsa (cairo_uint64_t a, int shift);
+const int _cairo_uint64_lt (cairo_uint64_t a, cairo_uint64_t b);
+const int _cairo_uint64_eq (cairo_uint64_t a, cairo_uint64_t b);
+const cairo_uint64_t _cairo_uint64_negate (cairo_uint64_t a);
+#define _cairo_uint64_negative(a) (((int32_t) ((a).hi)) < 0)
+const cairo_uint64_t _cairo_uint64_not (cairo_uint64_t a);
-extern const cairo_uint64_t
-_cairo_uint64_sub (cairo_uint64_t a, cairo_uint64_t b);
+#define _cairo_uint64_to_int64(i) (i)
+#define _cairo_int64_to_uint64(i) (i)
-extern const cairo_uint64_t
-_cairo_uint64_mul (cairo_uint64_t a, cairo_uint64_t b);
+const cairo_int64_t _cairo_int32_to_int64(int32_t i);
+#define _cairo_int64_to_int32(a) ((int32_t) _cairo_uint64_to_uint32(a))
+#define _cairo_int64_add(a,b) _cairo_uint64_add (a,b)
+#define _cairo_int64_sub(a,b) _cairo_uint64_sub (a,b)
+#define _cairo_int64_mul(a,b) _cairo_uint64_mul (a,b)
+#define _cairo_int32x32_64_mul(a,b) _cairo_uint32x32_64_mul ((uint32_t) (a), (uint32_t) (b)))
+const int _cairo_int64_lt (cairo_uint64_t a, cairo_uint64_t b);
+#define _cairo_int64_eq(a,b) _cairo_uint64_eq (a,b)
+#define _cairo_int64_lsl(a,b) _cairo_uint64_lsl (a,b)
+#define _cairo_int64_rsl(a,b) _cairo_uint64_rsl (a,b)
+#define _cairo_int64_rsa(a,b) _cairo_uint64_rsa (a,b)
+#define _cairo_int64_negate(a) _cairo_uint64_negate(a)
+#define _cairo_int64_negative(a) (((int32_t) ((a).hi)) < 0)
+#define _cairo_int64_not(a) _cairo_uint64_not(a)
-extern const cairo_uint64_t
-_cairo_uint32x32_64_mul (uint32_t a, uint32_t b);
+#else
-extern const cairo_uint64_t
-_cairo_uint64_lsl (cairo_uint64_t a, int shift);
+typedef uint64_t cairo_uint64_t;
+typedef int64_t cairo_int64_t;
-extern const cairo_uint64_t
-_cairo_uint64_rsl (cairo_uint64_t a, int shift);
+#define _cairo_uint32_to_uint64(i) ((uint64_t) (i))
+#define _cairo_uint64_to_uint32(i) ((uint32_t) (i))
+#define _cairo_uint64_add(a,b) ((a) + (b))
+#define _cairo_uint64_sub(a,b) ((a) - (b))
+#define _cairo_uint64_mul(a,b) ((a) * (b))
+#define _cairo_uint32x32_64_mul(a,b) ((uint64_t) (a) * (b))
+#define _cairo_uint64_lsl(a,b) ((a) << (b))
+#define _cairo_uint64_rsl(a,b) ((uint64_t) (a) >> (b))
+#define _cairo_uint64_rsa(a,b) ((uint64_t) ((int64_t) (a) >> (b)))
+#define _cairo_uint64_lt(a,b) ((a) < (b))
+#define _cairo_uint64_eq(a,b) ((a) == (b))
+#define _cairo_uint64_negate(a) ((uint64_t) -((int64_t) (a)))
+#define _cairo_uint64_negative(a) ((int64_t) (a) < 0)
+#define _cairo_uint64_not(a) (~(a))
-extern const int
-_cairo_uint64_less (cairo_uint64_t a, cairo_uint64_t b);
+#define _cairo_uint64_to_int64(i) ((int64_t) (i))
+#define _cairo_int64_to_uint64(i) ((uint64_t) (i))
-extern const int
-_cairo_uint64_equal (cairo_uint64_t a, cairo_uint64_t b);
+#define _cairo_int32_to_int64(i) ((int64_t) (i))
+#define _cairo_int64_to_int32(i) ((int32_t) (i))
+#define _cairo_int64_add(a,b) ((a) + (b))
+#define _cairo_int64_sub(a,b) ((a) - (b))
+#define _cairo_int64_mul(a,b) ((a) * (b))
+#define _cairo_int32x32_64_mul(a,b) ((int64_t) (a) * (b))
+#define _cairo_int64_lt(a,b) ((a) < (b))
+#define _cairo_int64_eq(a,b) ((a) == (b))
+#define _cairo_int64_lsl(a,b) ((a) << (b))
+#define _cairo_int64_rsl(a,b) ((int64_t) ((uint64_t) (a) >> (b)))
+#define _cairo_int64_rsa(a,b) ((int64_t) (a) >> (b))
+#define _cairo_int64_negate(a) (-(a))
+#define _cairo_int64_negative(a) ((a) < 0)
+#define _cairo_int64_not(a) (~(a))
-#else
+#endif
-typedef uint64_t cairo_uint64_t;
+/*
+ * 64-bit comparisions derived from lt or eq
+ */
+#define _cairo_uint64_le(a,b) (!_cairo_uint64_gt(a,b))
+#define _cairo_uint64_ne(a,b) (!_cairo_uint64_eq(a,b))
+#define _cairo_uint64_ge(a,b) (!_cairo_uint64_lt(a,b))
+#define _cairo_uint64_gt(a,b) _cairo_uint64_lt(b,a)
-#define _cairo_uint32_to_uint64(i) ((uint64_t) (i))
-#define _cairo_uint64_to_uint32(i) ((uint32_t) (i))
-#define _cairo_uint64_add(a,b) ((a) + (b))
-#define _cairo_uint64_sub(a,b) ((a) - (b))
-#define _cairo_uint64_mul(a,b) ((a) * (b))
-#define _cairo_uint32x32_64_mul(a,b) ((uint64_t) (a) * (b))
-#define _cairo_uint64_lsl(a,b) ((a) << (b))
-#define _cairo_uint64_rsl(a,b) ((a) >> (b))
-#define _cairo_uint64_lt(a,b) ((a) < (b))
-#define _cairo_uint64_eq(a,b) ((a) == (b))
+#define _cairo_int64_le(a,b) (!_cairo_int64_gt(a,b))
+#define _cairo_int64_ne(a,b) (!_cairo_int64_eq(a,b))
+#define _cairo_int64_ge(a,b) (!_cairo_int64_lt(a,b))
+#define _cairo_int64_gt(a,b) _cairo_int64_lt(b,a)
-#endif
+/*
+ * As the C implementation always computes both, create
+ * a function which returns both for the 'native' type as well
+ */
-typedef struct _cairo_quorem64 {
+typedef struct _cairo_uquorem64 {
cairo_uint64_t quo;
cairo_uint64_t rem;
-} cairo_quorem64_t;
-
-extern const cairo_quorem64_t
-_cairo_uint64_divmod (cairo_uint64_t num, cairo_uint64_t den);
+} cairo_uquorem64_t;
-#define _cairo_uint64_gt(a,b) _cairo_uint64_lt(b,a)
-#define _cairo_uint64_le(a,b) (!_cairo_uint64_gt(a,b))
-#define _cairo_uint64_ge(a,b) (!_cairo_uint64_lt(a,b))
-#define _cairo_uint64_ne(a,b) (!_cairo_uint64_eq(a,b))
+typedef struct _cairo_quorem64 {
+ cairo_int64_t quo;
+ cairo_int64_t rem;
+} cairo_quorem64_t;
-typedef struct cairo_uint128 {
- cairo_uint64_t b[2];
-} cairo_uint128_t;
+const cairo_uquorem64_t
+_cairo_uint64_divrem (cairo_uint64_t num, cairo_uint64_t den);
-extern const cairo_uint128_t
-_cairo_uint32_to_uint128 (uint32_t i);
+const cairo_quorem64_t
+_cairo_int64_divrem (cairo_int64_t num, cairo_int64_t den);
-extern const cairo_uint128_t
-_cairo_uint64_to_uint128 (cairo_uint64_t i);
+/*
+ * 128-bit datatypes. Again, provide two implementations in
+ * case the machine has a native 128-bit datatype. GCC supports int128_t
+ * on ia64
+ */
+
+#if !HAVE_UINT128_T
-extern const cairo_uint64_t
-_cairo_uint128_to_uint64 (cairo_uint128_t i);
+typedef struct cairo_uint128 {
+ cairo_uint64_t lo, hi;
+} cairo_uint128_t, cairo_int128_t;
-extern const uint32_t
-_cairo_uint128_to_uint32 (cairo_uint128_t i);
+const cairo_uint128_t _cairo_uint32_to_uint128 (uint32_t i);
+const cairo_uint128_t _cairo_uint64_to_uint128 (cairo_uint64_t i);
+#define _cairo_uint128_to_uint64(a) ((a).lo)
+#define _cairo_uint128_to_uint32(a) _cairo_uint64_to_uint32(_cairo_uint128_to_uint64(a))
+const cairo_uint128_t _cairo_uint128_add (cairo_uint128_t a, cairo_uint128_t b);
+const cairo_uint128_t _cairo_uint128_sub (cairo_uint128_t a, cairo_uint128_t b);
+const cairo_uint128_t _cairo_uint128_mul (cairo_uint128_t a, cairo_uint128_t b);
+const cairo_uint128_t _cairo_uint64x64_128_mul (cairo_uint64_t a, cairo_uint64_t b);
+const cairo_uint128_t _cairo_uint128_lsl (cairo_uint128_t a, int shift);
+const cairo_uint128_t _cairo_uint128_rsl (cairo_uint128_t a, int shift);
+const cairo_uint128_t _cairo_uint128_rsa (cairo_uint128_t a, int shift);
+const int _cairo_uint128_lt (cairo_uint128_t a, cairo_uint128_t b);
+const int _cairo_uint128_eq (cairo_uint128_t a, cairo_uint128_t b);
+const cairo_uint128_t _cairo_uint128_negate (cairo_uint128_t a);
+#define _cairo_uint128_negative(a) (_cairo_uint64_negative(a.hi))
+const cairo_uint128_t _cairo_uint128_not (cairo_uint128_t a);
-extern const cairo_uint128_t
-_cairo_uint128_add (cairo_uint128_t a, cairo_uint128_t b);
+#define _cairo_uint128_to_int128_(i) (i)
+#define _cairo_int128_to_uint128(i) (i)
-extern const cairo_uint128_t
-_cairo_uint128_sub (cairo_uint128_t a, cairo_uint128_t b);
+const cairo_int128_t _cairo_int32_to_int128 (int32_t i);
+const cairo_int128_t _cairo_int64_to_int128 (cairo_int64_t i);
+#define _cairo_int128_to_int64(a) ((cairo_int64_t) (a).lo);
+#define _cairo_int128_to_int32(a) _cairo_int64_to_int32(_cairo_int128_to_int64(a))
+#define _cairo_int128_add(a,b) _cairo_uint128_add(a,b)
+#define _cairo_int128_sub(a,b) _cairo_uint128_sub(a,b)
+#define _cairo_int128_mul(a,b) _cairo_uint128_mul(a,b)
+#define _cairo_int64x64_128_mul(a,b)_cairo_uint64x64_128_mul ((cairo_uint64_t) (a), (cairo_uint64_t) (b)))
+#define _cairo_int128_lsl(a,b) _cairo_uint128_lsl(a,b)
+#define _cairo_int128_rsl(a,b) _cairo_uint128_rsl(a,b)
+#define _cairo_int128_rsa(a,b) _cairo_uint128_rsa(a,b)
+const int _cairo_int128_lt (cairo_int128_t a, cairo_int128_t b);
+#define _cairo_int128_eq(a,b) _cairo_uint128_eq (a,b)
+#define _cairo_int128_negate(a) _cairo_uint128_negate(a)
+#define _cairo_int128_negative(a) (_cairo_uint128_negative(a))
+#define _cairo_int128_not(a) _cairo_uint128_not(a)
-extern const cairo_uint128_t
-_cairo_uint128_mul (cairo_uint128_t a, cairo_uint128_t b);
+#else /* !HAVE_UINT128_T */
-extern const cairo_uint128_t
-_cairo_uint128_lsl (cairo_uint128_t a, int shift);
+typedef uint128_t cairo_uint128_t;
+typedef int128_t cairo_int128_t;
-extern const cairo_uint128_t
-_cairo_uint128_rsl (cairo_uint128_t a, int shift);
+#define _cairo_uint32_to_uint128(i) ((uint128_t) (i))
+#define _cairo_uint64_to_uint128(i) ((uint128_t) (i))
+#define _cairo_uint128_to_uint64(i) ((uint64_t) (i))
+#define _cairo_uint128_to_uint32(i) ((uint32_t) (i))
+#define _cairo_uint128_add(a,b) ((a) + (b))
+#define _cairo_uint128_sub(a,b) ((a) - (b))
+#define _cairo_uint128_mul(a,b) ((a) * (b))
+#define _cairo_uint64x64_128_mul(a,b) ((uint128_t) (a) * (b))
+#define _cairo_uint128_lsl(a,b) ((a) << (b))
+#define _cairo_uint128_rsl(a,b) ((uint128_t) (a) >> (b))
+#define _cairo_uint128_rsa(a,b) ((uint128_t) ((int128_t) (a) >> (b)))
+#define _cairo_uint128_lt(a,b) ((a) < (b))
+#define _cairo_uint128_eq(a,b) ((a) == (b))
+#define _cairo_uint128_negate(a) ((uint128_t) -((int128_t) (a)))
+#define _cairo_uint128_negative(a) ((int128_t) (a) < 0)
+#define _cairo_uint128_not(a) (~(a))
-extern const int
-_cairo_uint128_lt (cairo_uint128_t a, cairo_uint128_t b);
+#define _cairo_uint128_to_int128(i) ((int128_t) (i))
+#define _cairo_int128_to_uint128(i) ((uint128_t) (i))
-extern const int
-_cairo_uint128_eq (cairo_uint128_t a, cairo_uint128_t b);
+#define _cairo_int32_to_int128(i) ((int128_t) (i))
+#define _cairo_int64_to_int128(i) ((int128_t) (i))
+#define _cairo_int128_to_int64(i) ((int64_t) (i))
+#define _cairo_int128_to_int32(i) ((int32_t) (i))
+#define _cairo_int128_add(a,b) ((a) + (b))
+#define _cairo_int128_sub(a,b) ((a) - (b))
+#define _cairo_int128_mul(a,b) ((a) * (b))
+#define _cairo_int64x64_128_mul(a,b) ((int128_t) (a) * (b))
+#define _cairo_int128_lt(a,b) ((a) < (b))
+#define _cairo_int128_eq(a,b) ((a) == (b))
+#define _cairo_int128_lsl(a,b) ((a) << (b))
+#define _cairo_int128_rsl(a,b) ((int128_t) ((uint128_t) (a) >> (b)))
+#define _cairo_int128_rsa(a,b) ((int128_t) (a) >> (b))
+#define _cairo_int128_negate(a) (-(a))
+#define _cairo_int128_negative(a) ((a) < 0)
+#define _cairo_int128_not(a) (~(a))
-#define _cairo_uint128_gt(a,b) _cairo_uint128_lt(b,a)
-#define _cairo_uint128_le(a,b) (!_cairo_uint128_gt(a,b))
-#define _cairo_uint128_ge(a,b) (!_cairo_uint128_lt(a,b))
-#define _cairo_uint128_ne(a,b) (!_cairo_uint128_eq(a,b))
+#endif /* HAVE_UINT128_T */
-typedef struct _cairo_quorem128 {
+typedef struct _cairo_uquorem128 {
cairo_uint128_t quo;
cairo_uint128_t rem;
+} cairo_uquorem128_t;
+
+typedef struct _cairo_quorem128 {
+ cairo_int128_t quo;
+ cairo_int128_t rem;
} cairo_quorem128_t;
-extern const cairo_quorem128_t
-_cairo_uint128_divmod (cairo_uint128_t num, cairo_uint128_t den);
+const cairo_uquorem128_t
+_cairo_uint128_divrem (cairo_uint128_t num, cairo_uint128_t den);
+
+const cairo_quorem128_t
+_cairo_int128_divrem (cairo_int128_t num, cairo_int128_t den);
+
+#define _cairo_uint128_le(a,b) (!_cairo_uint128_gt(a,b))
+#define _cairo_uint128_ne(a,b) (!_cairo_uint128_eq(a,b))
+#define _cairo_uint128_ge(a,b) (!_cairo_uint128_lt(a,b))
+#define _cairo_uint128_gt(a,b) _cairo_uint128_lt(b,a)
+
+#define _cairo_int128_le(a,b) (!_cairo_int128_gt(a,b))
+#define _cairo_int128_ne(a,b) (!_cairo_int128_eq(a,b))
+#define _cairo_int128_ge(a,b) (!_cairo_int128_lt(a,b))
+#define _cairo_int128_gt(a,b) _cairo_int128_lt(b,a)
#endif /* CAIRO_UINT128_H */
Index: checkdata.5c
===================================================================
RCS file: /local/src/CVS/cairo_u128/checkdata.5c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- a/checkdata.5c 25 May 2004 21:21:52 -0000 1.4
+++ b/checkdata.5c 28 May 2004 05:47:16 -0000 1.5
@@ -11,46 +11,103 @@
return x;
}
-int prod(int[*] q)
+int mask(int bits) {
+ return (1 << bits) - 1;
+}
+
+int unsigned (int n, int bits)
{
- int p = 1;
- for (int i = 0; i < dim(q); i++)
- p *= q[i];
- return p;
+ return n & mask (bits);
}
-int sum(int[*] q)
+int signed(int n, int bits)
{
- int p = 0;
- for (int i = 0; i < dim(q); i++)
- p += q[i];
- return p;
+ n &= mask (bits);
+ if ((n & (1 << (bits - 1))) != 0)
+ n |= -1 << bits;
+ return n;
}
void op (string name, int (int, int, int) f, int[2] n)
{
- void dump (int bits)
+ void dump (int bits, bool s)
{
try {
- int mask = (1 << bits) - 1;
- printf ("%s %x\n", name, f (n[0] & mask, n[1] & mask, bits) & mask);
+ int a, b;
+ if (s)
+ {
+ a = signed (n[0], bits);
+ b = signed (n[1], bits);
+ }
+ else
+ {
+ a = unsigned (n[0], bits);
+ b = unsigned (n[1], bits);
+ }
+
+ int v = f (a, b, bits);
+
+ if (s)
+ v = signed (v, bits);
+ else
+ v = unsigned (v, bits);
+
+ printf ("%s %3d %s %x\n",
+ s ? "s" : "u",
+ bits,
+ name, v);
} catch divide_by_zero (string msg, real a, real b) {
return;
}
}
- dump (128);
- dump (64);
+ dump (64, true);
+ dump (64, false);
+ dump (128, true);
+ dump (128, false);
+}
+
+int div(int a, int b) {
+ int d = abs (a) // abs (b);
+ if ((a < 0) != (b < 0))
+ d = -d;
+ return d;
+}
+
+int rem(int a, int b) {
+ int r = abs (a) % abs (b);
+ if (a < 0)
+ r = -r;
+ return r;
}
for (;;)
{
int[*] n = readnums();
- printf ("%x\n%x\n", n[0], n[1]);
+ for (int bits = 64; bits <= 128; bits <<= 1)
+ for (int f = 0; f < 2; f++)
+ printf ("%s %3d %x %x\n",
+ f == 0 ? "s" : "u",
+ bits,
+ (f == 0 ? signed : unsigned) (n[0], bits),
+ (f == 0 ? signed : unsigned) (n[1], bits));
+ printf ("\n");
op ("+", int func (int a, int b, int bits) { return a + b; }, n);
op ("-", int func (int a, int b, int bits) { return a - b; }, n);
op ("*", int func (int a, int b, int bits) { return a * b; }, n);
- op (">>", int func (int a, int b, int bits) { return a >> (b % bits); }, n);
- op ("<<", int func (int a, int b, int bits) { return a << (b % bits); }, n);
- op ("/", int func (int a, int b, int bits) { return a // b; }, n);
- op ("%", int func (int a, int b, int bits) { return a % b; }, n);
+ op (">>", int func (int a, int b, int bits) {
+ return unsigned (a, bits) >> (b % bits);
+ }, n);
+ op (">>>", int func (int a, int b, int bits) {
+ return signed (a, bits) >> (b % bits);
+ }, n);
+ op ("<<", int func (int a, int b, int bits) { return a << (b & (bits-1)); }, n);
+ op ("/", int func (int a, int b, int bits) { return div(a, b); }, n);
+ op ("%", int func (int a, int b, int bits) { return rem(a, b); }, n);
+ op ("<", int func (int a, int b, int bits) { return a < b ? 1 : 0; }, n);
+ op ("<=", int func (int a, int b, int bits) { return a <= b ? 1 : 0; }, n);
+ op ("==", int func (int a, int b, int bits) { return a == b ? 1 : 0; }, n);
+ op ("!=", int func (int a, int b, int bits) { return a != b ? 1 : 0; }, n);
+ op (">=", int func (int a, int b, int bits) { return a >= b ? 1 : 0; }, n);
+ op (">", int func (int a, int b, int bits) { return a > b ? 1 : 0; }, n);
+ printf ("\n");
}
Index: makedata.5c
===================================================================
RCS file: /local/src/CVS/cairo_u128/makedata.5c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- a/makedata.5c 25 May 2004 21:21:52 -0000 1.2
+++ b/makedata.5c 28 May 2004 05:47:16 -0000 1.3
@@ -5,7 +5,9 @@
for (int n = 0; n < nsets; n++)
{
for (int i = 0; i < 2; i++)
- printf ("%x ", PRNG::randbits(128));
+ printf ("%x ",
+ PRNG::randbits(PRNG::randint(126) + 1) *
+ (PRNG::randint(2) * 2 - 1));
printf ("\n");
}
- Previous message: [Commit] nickle ChangeLog, 1.58, 1.59 int.c, 1.22, 1.23 nickle.h,
1.116, 1.117 value.h, 1.103, 1.104
- Next message: [Commit] nickle ChangeLog,1.59,1.60
- Messages sorted by:
[ date ]
[ thread ]
[ subject ]
[ author ]
More information about the Commit
mailing list