fix big endian compilation

+ Code used some assumptions about type aliasing that might not hold for
  all systems

1 files changed, 93 insertions, 31 deletions

diff --git a/include/ejit/ejit.h b/include/ejit/ejit.h
index 920fdc5..2afdc61 100644
--- a/include/ejit/ejit.h
+++ b/include/ejit/ejit.h
@@ -72,29 +72,20 @@ static inline enum ejit_type ejit_signed_type(size_t w)
 
 struct ejit_arg {
 	union {
-		int8_t i8;
-		uint8_t u8;
+		int8_t  i8;
 		int16_t i16;
-		uint16_t u16;
 		int32_t i32;
-		uint32_t u32;
 		int64_t i64;
-		uint64_t u64;
 
-		signed char c;
-		unsigned char uc;
-		signed short s;
-		unsigned short us;
-		signed int i;
-		unsigned int ui;
-		signed long l;
-		unsigned long ul;
-		signed long long ll;
-		unsigned long long ull;
+		uint8_t  u8;
+		uint16_t u16;
+		uint32_t u32;
+		uint64_t u64;
 
 		float f;
 		double d;
 		void *p;
+		long l;
 	};
 	enum ejit_type type;
 };
@@ -136,15 +127,15 @@ static inline struct ejit_arg ejit_build_arg(enum ejit_type type, uint64_t x)
 	a.type = type;
 
 	switch (type) {
-	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;
+	case EJIT_INT8:    a.i8  = (int8_t)x; break;
+	case EJIT_INT16:   a.i16 = (int16_t)x; break;
+	case EJIT_INT32:   a.i32 = (int32_t)x; break;
+	case EJIT_INT64:   a.i64 = (int64_t)x; break;
+	case EJIT_UINT8:   a.u8  = (uint8_t)x; break;
+	case EJIT_UINT16:  a.u16 = (uint16_t)x; break;
+	case EJIT_UINT32:  a.u32 = (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();
 	}
 
@@ -251,17 +242,17 @@ void ejit_destroy_func(struct ejit_func *s);
 /* maybe slight hack, but increase width to interpeter register width */
 static inline struct ejit_arg ejit_i8(int8_t a)
 {
-	return (struct ejit_arg){.i64 = a, .type = EJIT_INT8};
+	return (struct ejit_arg){.i8 = a, .type = EJIT_INT8};
 }
 
 static inline struct ejit_arg ejit_i16(int16_t a)
 {
-	return (struct ejit_arg){.i64 = a, .type = EJIT_INT16};
+	return (struct ejit_arg){.i16 = a, .type = EJIT_INT16};
 }
 
 static inline struct ejit_arg ejit_i32(int32_t a)
 {
-	return (struct ejit_arg){.i64 = a, .type = EJIT_INT32};
+	return (struct ejit_arg){.i32 = a, .type = EJIT_INT32};
 }
 
 static inline struct ejit_arg ejit_i64(int64_t a)
@@ -271,22 +262,22 @@ static inline struct ejit_arg ejit_i64(int64_t a)
 
 static inline struct ejit_arg ejit_u8(uint8_t a)
 {
-	return (struct ejit_arg){.i64 = a, .type = EJIT_UINT8};
+	return (struct ejit_arg){.u8 = a, .type = EJIT_UINT8};
 }
 
 static inline struct ejit_arg ejit_u16(uint16_t a)
 {
-	return (struct ejit_arg){.i64 = a, .type = EJIT_UINT16};
+	return (struct ejit_arg){.u16 = a, .type = EJIT_UINT16};
 }
 
 static inline struct ejit_arg ejit_u32(uint32_t a)
 {
-	return (struct ejit_arg){.i64 = a, .type = EJIT_UINT32};
+	return (struct ejit_arg){.u32 = a, .type = EJIT_UINT32};
 }
 
 static inline struct ejit_arg ejit_u64(uint64_t a)
 {
-	return (struct ejit_arg){.i64 = a, .type = EJIT_UINT64};
+	return (struct ejit_arg){.u64 = a, .type = EJIT_UINT64};
 }
 
 static inline struct ejit_arg ejit_pointer(void *p)
@@ -372,6 +363,77 @@ static inline struct ejit_arg ejit_pointer_arg(void *p, size_t w)
 #define EJIT_AUTO(x) \
 	EJIT_ARG(x, typeof(x))
 
+static inline int64_t ejit_signed_param(size_t argc, const struct ejit_arg args[argc],
+		size_t idx, enum ejit_type type)
+{
+	assert(idx < argc);
+	assert(args[idx].type == type);
+	switch (type) {
+	case EJIT_INT64: return args[idx].i64;
+	case EJIT_INT32: return args[idx].i32;
+	case EJIT_INT16: return args[idx].i16;
+	case EJIT_INT8:  return args[idx].i8;
+	default: abort();
+	}
+
+	return 0;
+}
+
+static inline uint64_t ejit_unsigned_param(size_t argc, const struct ejit_arg args[argc],
+		size_t idx, enum ejit_type type)
+{
+	assert(idx < argc);
+	assert(args[idx].type == type);
+	switch (type) {
+	case EJIT_UINT64: return args[idx].u64;
+	case EJIT_UINT32: return args[idx].u32;
+	case EJIT_UINT16: return args[idx].u16;
+	case EJIT_UINT8:  return args[idx].u8;
+	default: abort();
+	}
+}
+
+static inline float ejit_float_param(size_t argc, const struct ejit_arg args[argc],
+		size_t idx, enum ejit_type type)
+{
+	assert(idx < argc);
+	assert(args[idx].type == type && type == EJIT_FLOAT);
+	return args[idx].f;
+}
+
+static inline double ejit_double_param(size_t argc, const struct ejit_arg args[argc],
+		size_t idx, enum ejit_type type)
+{
+	assert(idx < argc);
+	assert(args[idx].type == type && type == EJIT_DOUBLE);
+	return args[idx].d;
+}
+
+static inline void *ejit_pointer_param(size_t argc, const struct ejit_arg args[argc],
+		size_t idx, enum ejit_type type)
+{
+	assert(idx < argc);
+	assert(args[idx].type == type && type == EJIT_POINTER);
+	return args[idx].p;
+}
+
+#define EJIT_PARAM(argc, args, idx, t)                 \
+	_Generic((t)(0),               \
+		 signed char       : ejit_signed_param,      \
+		 signed short      : ejit_signed_param,    \
+		 signed int        : ejit_signed_param,    \
+		 signed long       : ejit_signed_param,    \
+		 signed long long  : ejit_signed_param, \
+		 unsigned char     : ejit_unsigned_param,      \
+		 unsigned short    : ejit_unsigned_param,    \
+		 unsigned int      : ejit_unsigned_param,    \
+		 unsigned long     : ejit_unsigned_param,    \
+		 unsigned long long: ejit_unsigned_param, \
+		 float             : ejit_float_param,    \
+		 double            : ejit_double_param,  \
+		 default           : ejit_pointer_param \
+		 )(argc, args, idx, EJIT_TYPE(t))
+
 static inline bool ejit_use64(struct ejit_arg a)
 {
 	if (a.type == EJIT_INT64 || a.type == EJIT_UINT64)