start supporting 32bit arches

1 files changed, 169 insertions, 63 deletions

diff --git a/include/ejit/ejit.h b/include/ejit/ejit.h
index b0d8651..0c7f4c5 100644
--- a/include/ejit/ejit.h
+++ b/include/ejit/ejit.h
@@ -25,17 +25,47 @@ enum ejit_type
 	EJIT_DOUBLE,
 };
 
+static inline enum ejit_type ejit_unsigned_type(size_t w)
+{
+	switch (w) {
+	case 1: return EJIT_UINT8;
+	case 2: return EJIT_UINT16;
+	case 4: return EJIT_UINT32;
+	case 8: return EJIT_UINT64;
+	default: assert(0 && "unknown width of unsigned type");
+	}
+
+	/* shut up some warnings */
+	return EJIT_UINT32;
+}
+
+static inline enum ejit_type ejit_signed_type(size_t w)
+{
+	switch (w) {
+	case 1: return EJIT_INT8;
+	case 2: return EJIT_INT16;
+	case 4: return EJIT_INT32;
+	case 8: return EJIT_INT64;
+	default: assert(0 && "unknown width of signed type");
+	}
+
+	/* shut up some warnings */
+	return EJIT_INT32;
+}
+
 /* can be kind of dangerous since we default to a pointer, hmm */
 #define EJIT_TYPE(x)                    \
 	_Generic((typeof(x))(0),        \
-		 int8_t: EJIT_INT8,     \
-		 int16_t: EJIT_INT16,   \
-		 int32_t: EJIT_INT32,   \
-		 int64_t: EJIT_INT64,   \
-		 uint8_t: EJIT_UINT8,   \
-		 uint16_t: EJIT_UINT16, \
-		 uint32_t: EJIT_UINT32, \
-		 uint64_t: EJIT_UINT64, \
+		 unsigned char     : ejit_unsigned_type(sizeof(x)),     \
+		 unsigned short    : ejit_unsigned_type(sizeof(x)), \
+		 unsigned int      : ejit_unsigned_type(sizeof(x)), \
+		 unsigned long     : ejit_unsigned_type(sizeof(x)), \
+		 unsigned long long: ejit_unsigned_type(sizeof(x)), \
+		 signed char       : ejit_signed_type(sizeof(x)),   \
+		 signed short      : ejit_signed_type(sizeof(x)),   \
+		 signed int        : ejit_signed_type(sizeof(x)),   \
+		 signed long       : ejit_signed_type(sizeof(x)),   \
+		 signed long long  : ejit_signed_type(sizeof(x)),   \
 		 float: EJIT_FLOAT,     \
 		 double: EJIT_DOUBLE,   \
 		 default: EJIT_POINTER)
@@ -102,21 +132,19 @@ static inline bool ejit_float_type(enum ejit_type t)
 
 static inline struct ejit_arg ejit_build_arg(enum ejit_type type, uint64_t x)
 {
-	assert(ejit_int_type(type));
-
 	struct ejit_arg a;
 	a.type = type;
 
 	switch (type) {
-	case EJIT_INT8: a.i8 = x; break;
-	case EJIT_INT16: a.i16 = x; break;
-	case EJIT_INT32: a.i32 = x; break;
-	case EJIT_INT64: a.i64 = x; break;
-	case EJIT_UINT8: a.u8 = x; break;
-	case EJIT_UINT16: a.u16 = x; break;
-	case EJIT_UINT32: a.u32 = x; break;
-	case EJIT_UINT64: a.u64 = x; break;
-	case EJIT_POINTER: a.p = (void *)x; break;
+	case EJIT_INT8: a.u64 = (int8_t)x; break;
+	case EJIT_INT16: a.u64 = (int16_t)x; break;
+	case EJIT_INT32: a.u64 = (int32_t)x; break;
+	case EJIT_INT64: a.u64 = (int64_t)x; break;
+	case EJIT_UINT8: a.u64 = (uint8_t)x; break;
+	case EJIT_UINT16: a.u64 = (uint16_t)x; break;
+	case EJIT_UINT32: a.u64 = (uint32_t)x; break;
+	case EJIT_UINT64: a.u64 = (uint64_t)x; break;
+	case EJIT_POINTER: a.p = (void *)(uintptr_t)x; break;
 	default: abort();
 	}
 
@@ -125,8 +153,6 @@ static inline struct ejit_arg ejit_build_arg(enum ejit_type type, uint64_t x)
 
 static inline struct ejit_arg ejit_build_arg_f(enum ejit_type type, double x)
 {
-	assert(ejit_float_type(type));
-
 	struct ejit_arg a;
 	a.type = type;
 
@@ -139,8 +165,6 @@ static inline struct ejit_arg ejit_build_arg_f(enum ejit_type type, double x)
 	return a;
 }
 
-/* register allocator could be just pushing everything above V0 or whatever onto
- * the stack, heh */
 struct ejit_gpr {
 	size_t r;
 };
@@ -182,35 +206,34 @@ void ejit_compile_func(struct ejit_func *f);
 void ejit_select_compile_func(struct ejit_func *f, size_t gpr, size_t fpr,
                               bool use_64, bool try_jit);
 
-int64_t ejit_run_func(struct ejit_func *f, size_t argc,
+long ejit_run_func_i(struct ejit_func *f, size_t argc,
                       struct ejit_arg args[argc]);
 
-static inline int64_t ejit_run_func_1(struct ejit_func *f, struct ejit_arg a0)
-{
-	return ejit_run_func(f, 1, &a0);
-}
+int64_t ejit_run_func_l(struct ejit_func *f, size_t argc,
+                      struct ejit_arg args[argc]);
 
-static inline int64_t ejit_run_func_2(struct ejit_func *f, struct ejit_arg a0,
-                                      struct ejit_arg a1)
-{
-	struct ejit_arg args[2] = {a0, a1};
-	return ejit_run_func(f, 2, args);
-}
+float ejit_run_func_f(struct ejit_func *f, size_t argc,
+                       struct ejit_arg args[argc]);
 
-double ejit_run_func_f(struct ejit_func *f, size_t argc,
+double ejit_run_func_d(struct ejit_func *f, size_t argc,
                        struct ejit_arg args[argc]);
 
-static inline double ejit_run_func_f_1(struct ejit_func *f, struct ejit_arg a0)
-{
-	return ejit_run_func_f(f, 1, &a0);
-}
+struct ejit_arg ejit_run_func(struct ejit_func *f, size_t argc, struct ejit_arg args[argc]);
+
+
+/* currently unused, the idea is that an escape could get the interpreter state
+ * and pass it on to speed up entering/exiting the VM, could be useful for more
+ * dynamic languages */
+struct interp_state;
+
+long ejit_run_func_ctx_i(struct ejit_func *f, size_t argc, struct ejit_arg args[argc], struct interp_state *ctx);
+
+int64_t ejit_run_func_ctx_l(struct ejit_func *f, size_t argc, struct ejit_arg args[argc], struct interp_state *ctx);
+
+float ejit_run_func_ctx_f(struct ejit_func *f, size_t argc, struct ejit_arg args[argc], struct interp_state *ctx);
+
+double ejit_run_func_ctx_d(struct ejit_func *f, size_t argc, struct ejit_arg args[argc], struct interp_state *ctx);
 
-static inline double ejit_run_func_f_2(struct ejit_func *f, struct ejit_arg a0,
-                                       struct ejit_arg a1)
-{
-	struct ejit_arg args[2] = {a0, a1};
-	return ejit_run_func_f(f, 2, args);
-}
 
 void ejit_destroy_func(struct ejit_func *s);
 
@@ -258,6 +281,26 @@ static inline struct ejit_arg ejit_i64(int64_t a)
 	return (struct ejit_arg){.i64 = a, .type = EJIT_INT64};
 }
 
+static inline struct ejit_arg ejit_u8(uint8_t a)
+{
+	return (struct ejit_arg){.i64 = a, .type = EJIT_UINT8};
+}
+
+static inline struct ejit_arg ejit_u16(uint16_t a)
+{
+	return (struct ejit_arg){.i64 = a, .type = EJIT_UINT16};
+}
+
+static inline struct ejit_arg ejit_u32(uint32_t a)
+{
+	return (struct ejit_arg){.i64 = a, .type = EJIT_UINT32};
+}
+
+static inline struct ejit_arg ejit_u64(uint64_t a)
+{
+	return (struct ejit_arg){.i64 = a, .type = EJIT_UINT64};
+}
+
 static inline struct ejit_arg ejit_pointer(void *p)
 {
 	return (struct ejit_arg){.p = p, .type = EJIT_POINTER};
@@ -273,20 +316,70 @@ static inline struct ejit_arg ejit_double(double a)
 	return (struct ejit_arg){.d = a, .type = EJIT_DOUBLE};
 }
 
+static inline struct ejit_arg ejit_unsigned_arg(uint64_t a, size_t w)
+{
+	switch (w) {
+	case 1: return ejit_u8(a);
+	case 2: return ejit_u16(a);
+	case 4: return ejit_u32(a);
+	case 8: return ejit_u64(a);
+	default: assert(0 && "unknown width for unsigned arg");
+	}
+
+	/* shut up some warnings */
+	return ejit_u32(a);
+}
+
+static inline struct ejit_arg ejit_signed_arg(int64_t a, size_t w)
+{
+	switch (w) {
+	case 1: return ejit_i8(a);
+	case 2: return ejit_i16(a);
+	case 4: return ejit_i32(a);
+	case 8: return ejit_i64(a);
+	default: assert(0 && "unknown width for signed arg");
+	}
+
+	/* shut up some warnings */
+	return ejit_i32(a);
+}
+
+static inline struct ejit_arg ejit_float_arg(float f, size_t w)
+{
+	(void)w;
+	assert(w == 4);
+	return ejit_float(f);
+}
+
+static inline struct ejit_arg ejit_double_arg(double d, size_t w)
+{
+	(void)w;
+	assert(w == 8);
+	return ejit_double(d);
+}
+
+static inline struct ejit_arg ejit_pointer_arg(void *p, size_t w)
+{
+	(void)w;
+	return ejit_pointer(p);
+}
+
 #define EJIT_ARG(x, t)                 \
 	_Generic((t)(0),               \
-		 int8_t: ejit_i8,      \
-		 int16_t: ejit_i16,    \
-		 int32_t: ejit_i32,    \
-		 int64_t: ejit_i64,    \
-		 uint8_t: ejit_i8,     \
-		 uint16_t: ejit_i16,   \
-		 uint32_t: ejit_i32,   \
-		 uint64_t: ejit_i64,   \
-		 float: ejit_float,    \
-		 double: ejit_double,  \
-		 default: ejit_pointer \
-		 )(x)
+		 signed char       : ejit_signed_arg,      \
+		 signed short      : ejit_signed_arg,    \
+		 signed int        : ejit_signed_arg,    \
+		 signed long       : ejit_signed_arg,    \
+		 signed long long  : ejit_signed_arg, \
+		 unsigned char     : ejit_unsigned_arg,      \
+		 unsigned short    : ejit_unsigned_arg,    \
+		 unsigned int      : ejit_unsigned_arg,    \
+		 unsigned long     : ejit_unsigned_arg,    \
+		 unsigned long long: ejit_unsigned_arg, \
+		 float             : ejit_float_arg,    \
+		 double            : ejit_double_arg,  \
+		 default           : ejit_pointer_arg \
+		 )((t)(x), sizeof(t))
 
 #define EJIT_AUTO(x) \
 	EJIT_ARG(x, typeof(x))
@@ -302,30 +395,43 @@ static inline bool ejit_use64(struct ejit_arg a)
 #define EJIT_USE64(t) \
 	ejit_use64(EJIT_ARG(0, t))
 
-typedef long (*ejit_escape_t)(size_t argc, const struct ejit_arg args[argc]);
-typedef double (*ejit_escape_f_t)(size_t argc,
-                                  const struct ejit_arg args[argc]);
+typedef long (*ejit_escape_i_t)(size_t argc, const struct ejit_arg args[argc]);
+typedef int64_t (*ejit_escape_l_t)(size_t argc, const struct ejit_arg args[argc]);
+typedef float (*ejit_escape_f_t)(size_t argc, const struct ejit_arg args[argc]);
+typedef double (*ejit_escape_d_t)(size_t argc, const struct ejit_arg args[argc]);
 
 struct ejit_label ejit_label(struct ejit_func *s);
 
-void ejit_calli(struct ejit_func *s, struct ejit_func *f, size_t argc,
+void ejit_calli_i(struct ejit_func *s, struct ejit_func *f, size_t argc,
+                const struct ejit_operand args[argc]);
+
+void ejit_calli_l(struct ejit_func *s, struct ejit_func *f, size_t argc,
                 const struct ejit_operand args[argc]);
 
 void ejit_calli_f(struct ejit_func *s, struct ejit_func *f, size_t argc,
                   const struct ejit_operand args[argc]);
 
-void ejit_escapei(struct ejit_func *s, ejit_escape_t f, size_t argc,
+void ejit_calli_d(struct ejit_func *s, struct ejit_func *f, size_t argc,
+                  const struct ejit_operand args[argc]);
+
+void ejit_escapei_i(struct ejit_func *s, ejit_escape_i_t f, size_t argc,
+                  const struct ejit_operand args[argc]);
+
+void ejit_escapei_l(struct ejit_func *s, ejit_escape_l_t f, size_t argc,
                   const struct ejit_operand args[argc]);
 
 void ejit_escapei_f(struct ejit_func *s, ejit_escape_f_t f, size_t argc,
                     const struct ejit_operand args[argc]);
 
+void ejit_escapei_d(struct ejit_func *s, ejit_escape_d_t f, size_t argc,
+                    const struct ejit_operand args[argc]);
+
 void ejit_ret(struct ejit_func *s);
 void ejit_retr(struct ejit_func *s, struct ejit_gpr r0);
 void ejit_retr_f(struct ejit_func *s, struct ejit_fpr r0);
 void ejit_retr_d(struct ejit_func *s, struct ejit_fpr r0);
 
-void ejit_reti(struct ejit_func *s, long i);
+void ejit_reti(struct ejit_func *s, int64_t i);
 void ejit_reti_f(struct ejit_func *s, float f);
 void ejit_reti_d(struct ejit_func *s, double f);