diff options
Diffstat (limited to 'include')
| -rw-r--r-- | include/ejit/ejit.h | 232 |
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); |