From e618924df98d4ee5037db86c768a8c8014e49c4c Mon Sep 17 00:00:00 2001 From: Kimplul Date: Sun, 30 Jun 2024 16:39:24 +0300 Subject: work through loads and stores --- include/ejit/ejit.h | 130 ++++++++++++++++++++++++--- src/common.h | 24 +++++ src/ejit.c | 247 ++++++++++++++++++++++++++++++++++++++++++++++++++-- src/interp.c | 179 +++++++++++++++++++++++++++++++++++++ tests/extr_16.c | 24 +++++ tests/extr_32.c | 25 ++++++ tests/extr_8.c | 24 +++++ tests/extr_c.c | 27 ------ tests/extr_d_f.c | 26 ------ tests/extr_f.c | 25 ------ tests/extr_i.c | 30 ------- tests/extr_s.c | 28 ------ tests/extr_u16.c | 24 +++++ tests/extr_u32.c | 24 +++++ tests/extr_u8.c | 24 +++++ tests/extr_uc.c | 27 ------ tests/extr_ui.c | 29 ------ tests/extr_us.c | 27 ------ tests/ger.c | 10 +-- tests/ger_u.c | 33 +++++++ tests/gtr.c | 8 +- tests/gtr_f.c | 10 +-- tests/gtr_u.c | 32 +++++++ tests/jmp0.c | 35 ++++---- tests/jmp_table.c | 80 ++++++++--------- tests/jmpi_local.c | 36 ++++---- tests/ldi_c.c | 24 ----- tests/ldi_d.c | 26 +++--- tests/ldi_f.c | 28 +++--- tests/ldi_i.c | 24 ----- tests/ldi_i16.c | 20 +++++ tests/ldi_i32.c | 19 ++++ tests/ldi_i64.c | 20 +++++ tests/ldi_i8.c | 19 ++++ tests/ldi_l.c | 26 ------ tests/ldi_s.c | 24 ----- tests/ldi_u16.c | 20 +++++ tests/ldi_u64.c | 19 ++++ tests/ldi_u8.c | 19 ++++ tests/ldi_uc.c | 24 ----- tests/ldi_ui.c | 26 ------ tests/ldi_us.c | 24 ----- tests/ldr_atomic.c | 28 ------ tests/ldr_c.c | 27 ------ tests/ldr_d.c | 27 ------ tests/ldr_f.c | 27 ------ tests/ldr_i.c | 27 ------ tests/ldr_l.c | 29 ------ tests/ldr_s.c | 27 ------ tests/ldr_uc.c | 27 ------ tests/ldr_ui.c | 29 ------ tests/ldr_us.c | 27 ------ tests/ldxi_c.c | 27 ------ tests/ldxi_d.c | 34 ++++---- tests/ldxi_f.c | 34 ++++---- tests/ldxi_i.c | 27 ------ tests/ldxi_i16.c | 24 +++++ tests/ldxi_i32.c | 24 +++++ tests/ldxi_i64.c | 25 ++++++ tests/ldxi_i8.c | 24 +++++ tests/ldxi_l.c | 29 ------ tests/ldxi_s.c | 27 ------ tests/ldxi_u16.c | 24 +++++ tests/ldxi_u32.c | 24 +++++ tests/ldxi_u64.c | 26 ++++++ tests/ldxi_u8.c | 24 +++++ tests/ldxi_uc.c | 27 ------ tests/ldxi_ui.c | 29 ------ tests/ldxi_us.c | 27 ------ tests/ldxr_c.c | 28 ------ tests/ldxr_d.c | 41 +++++---- tests/ldxr_f.c | 43 +++++---- tests/ldxr_i.c | 28 ------ tests/ldxr_i32.c | 26 ++++++ tests/ldxr_i64.c | 26 ++++++ tests/ldxr_i8.c | 25 ++++++ tests/ldxr_l.c | 30 ------- tests/ldxr_s.c | 28 ------ tests/ldxr_u16.c | 27 ++++++ tests/ldxr_u32.c | 27 ++++++ tests/ldxr_u8.c | 25 ++++++ tests/ldxr_uc.c | 28 ------ tests/ldxr_ui.c | 30 ------- tests/ldxr_us.c | 28 ------ tests/ler.c | 2 +- tests/ler_f.c | 4 +- tests/lshi.c | 34 +++----- tests/lshr.c | 205 +++++++++++++++++++++++++++++-------------- tests/ltr.c | 2 +- tests/ltr_f.c | 2 +- tests/mov_addr.c | 25 ------ 91 files changed, 1606 insertions(+), 1389 deletions(-) create mode 100644 tests/extr_16.c create mode 100644 tests/extr_32.c create mode 100644 tests/extr_8.c delete mode 100644 tests/extr_c.c delete mode 100644 tests/extr_d_f.c delete mode 100644 tests/extr_f.c delete mode 100644 tests/extr_i.c delete mode 100644 tests/extr_s.c create mode 100644 tests/extr_u16.c create mode 100644 tests/extr_u32.c create mode 100644 tests/extr_u8.c delete mode 100644 tests/extr_uc.c delete mode 100644 tests/extr_ui.c delete mode 100644 tests/extr_us.c create mode 100644 tests/ger_u.c create mode 100644 tests/gtr_u.c delete mode 100644 tests/ldi_c.c delete mode 100644 tests/ldi_i.c create mode 100644 tests/ldi_i16.c create mode 100644 tests/ldi_i32.c create mode 100644 tests/ldi_i64.c create mode 100644 tests/ldi_i8.c delete mode 100644 tests/ldi_l.c delete mode 100644 tests/ldi_s.c create mode 100644 tests/ldi_u16.c create mode 100644 tests/ldi_u64.c create mode 100644 tests/ldi_u8.c delete mode 100644 tests/ldi_uc.c delete mode 100644 tests/ldi_ui.c delete mode 100644 tests/ldi_us.c delete mode 100644 tests/ldr_atomic.c delete mode 100644 tests/ldr_c.c delete mode 100644 tests/ldr_d.c delete mode 100644 tests/ldr_f.c delete mode 100644 tests/ldr_i.c delete mode 100644 tests/ldr_l.c delete mode 100644 tests/ldr_s.c delete mode 100644 tests/ldr_uc.c delete mode 100644 tests/ldr_ui.c delete mode 100644 tests/ldr_us.c delete mode 100644 tests/ldxi_c.c delete mode 100644 tests/ldxi_i.c create mode 100644 tests/ldxi_i16.c create mode 100644 tests/ldxi_i32.c create mode 100644 tests/ldxi_i64.c create mode 100644 tests/ldxi_i8.c delete mode 100644 tests/ldxi_l.c delete mode 100644 tests/ldxi_s.c create mode 100644 tests/ldxi_u16.c create mode 100644 tests/ldxi_u32.c create mode 100644 tests/ldxi_u64.c create mode 100644 tests/ldxi_u8.c delete mode 100644 tests/ldxi_uc.c delete mode 100644 tests/ldxi_ui.c delete mode 100644 tests/ldxi_us.c delete mode 100644 tests/ldxr_c.c delete mode 100644 tests/ldxr_i.c create mode 100644 tests/ldxr_i32.c create mode 100644 tests/ldxr_i64.c create mode 100644 tests/ldxr_i8.c delete mode 100644 tests/ldxr_l.c delete mode 100644 tests/ldxr_s.c create mode 100644 tests/ldxr_u16.c create mode 100644 tests/ldxr_u32.c create mode 100644 tests/ldxr_u8.c delete mode 100644 tests/ldxr_uc.c delete mode 100644 tests/ldxr_ui.c delete mode 100644 tests/ldxr_us.c delete mode 100644 tests/mov_addr.c diff --git a/include/ejit/ejit.h b/include/ejit/ejit.h index 03137ab..eeac089 100644 --- a/include/ejit/ejit.h +++ b/include/ejit/ejit.h @@ -322,10 +322,10 @@ void ejit_movi(struct ejit_func *s, struct ejit_gpr r0, int64_t i); void ejit_movr(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1); void ejit_movr_f(struct ejit_func *s, struct ejit_fpr r0, struct ejit_fpr r1); -void ejit_ldi_8(struct ejit_func *s, struct ejit_gpr r0, void *p); -void ejit_ldi_16(struct ejit_func *s, struct ejit_gpr r0, void *p); -void ejit_ldi_32(struct ejit_func *s, struct ejit_gpr r0, void *p); -void ejit_ldi_64(struct ejit_func *s, struct ejit_gpr r0, void *p); +void ejit_ldi_i8(struct ejit_func *s, struct ejit_gpr r0, void *p); +void ejit_ldi_i16(struct ejit_func *s, struct ejit_gpr r0, void *p); +void ejit_ldi_i32(struct ejit_func *s, struct ejit_gpr r0, void *p); +void ejit_ldi_i64(struct ejit_func *s, struct ejit_gpr r0, void *p); void ejit_ldi_u8(struct ejit_func *s, struct ejit_gpr r0, void *p); void ejit_ldi_u16(struct ejit_func *s, struct ejit_gpr r0, void *p); @@ -366,7 +366,8 @@ void ejit_ldxi_f(struct ejit_func *s, struct ejit_fpr r0, struct ejit_gpr r1, void ejit_ldxi_d(struct ejit_func *s, struct ejit_fpr r0, struct ejit_gpr r1, int64_t o); -static inline void ejit_ldxi_ptr(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, int64_t o) +static inline void ejit_ldxi_ptr(struct ejit_func *s, struct ejit_gpr r0, + struct ejit_gpr r1, int64_t o) { if (sizeof(void *) == sizeof(int64_t)) ejit_ldxi_u64(s, r0, r1, o); @@ -376,8 +377,15 @@ static inline void ejit_ldxi_ptr(struct ejit_func *s, struct ejit_gpr r0, struct abort(); } -#define EJIT_LDXI(f, t, r0, r1, o) \ - _Generic((t)(0), \ +static inline void ejit_ldxi_label(struct ejit_func *s, struct ejit_gpr r0, + struct ejit_gpr r1, int64_t o) +{ + /** @todo implement properly */ + ejit_ldxi_ptr(s, r0, r1, o); +} + +#define EJIT_LDXI(f, t, r0, r1, o) \ + _Generic((t)(0), \ int8_t: ejit_ldxi_i8, \ uint8_t: ejit_ldxi_u8, \ int16_t: ejit_ldxi_i16, \ @@ -386,10 +394,72 @@ static inline void ejit_ldxi_ptr(struct ejit_func *s, struct ejit_gpr r0, struct uint32_t: ejit_ldxi_u32, \ int64_t: ejit_ldxi_i64, \ uint64_t: ejit_ldxi_u64, \ - float: ejit_ldxi_f, \ - double: ejit_ldxi_d, \ + float: ejit_ldxi_f, \ + double: ejit_ldxi_d, \ default: ejit_ldxi_ptr)((f), (r0), (r1), (o)) +void ejit_ldxr_i8(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2); + +void ejit_ldxr_i16(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2); + +void ejit_ldxr_i32(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2); + +void ejit_ldxr_i64(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2); + +void ejit_ldxr_u8(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2); + +void ejit_ldxr_u16(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2); + +void ejit_ldxr_u32(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2); + +void ejit_ldxr_u64(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2); + +void ejit_ldxr_f(struct ejit_func *s, struct ejit_fpr r0, struct ejit_gpr r1, + struct ejit_gpr r2); + +void ejit_ldxr_d(struct ejit_func *s, struct ejit_fpr r0, struct ejit_gpr r1, + struct ejit_gpr r2); + +static inline void ejit_ldxr_ptr(struct ejit_func *s, struct ejit_gpr r0, + struct ejit_gpr r1, struct ejit_gpr r2) +{ + if (sizeof(void *) == sizeof(int64_t)) + ejit_ldxr_u64(s, r0, r1, r2); + else if (sizeof(void *) == sizeof(int32_t)) + ejit_ldxr_u32(s, r0, r1, r2); + else + abort(); +} + +static inline void ejit_ldxr_label(struct ejit_func *s, struct ejit_gpr r0, + struct ejit_gpr r1, struct ejit_gpr r2) +{ + /** @todo implement properly */ + ejit_ldxr_ptr(s, r0, r1, r2); +} + +#define EJIT_LDXR(f, t, r0, r1, r2) \ + _Generic((t)(0), \ + int8_t: ejit_ldxr_i8, \ + uint8_t: ejit_ldxr_u8, \ + int16_t: ejit_ldxr_i16, \ + uint16_t: ejit_ldxr_u16, \ + int32_t: ejit_ldxr_i32, \ + uint32_t: ejit_ldxr_u32, \ + int64_t: ejit_ldxr_i64, \ + uint64_t: ejit_ldxr_u64, \ + float: ejit_ldxr_f, \ + double: ejit_ldxr_d, \ + default: ejit_ldxr_ptr)((f), (r0), (r1), (r2)) + void ejit_sti_8(struct ejit_func *s, struct ejit_gpr r0, void *p); void ejit_sti_16(struct ejit_func *s, struct ejit_gpr r0, void *p); void ejit_sti_32(struct ejit_func *s, struct ejit_gpr r0, void *p); @@ -447,6 +517,13 @@ static inline void ejit_stxi_ptr(struct ejit_func *s, struct ejit_gpr r0, double: ejit_stxi_d, \ default: ejit_stxi_ptr)((f), (r0), (r1), (o)) +void ejit_extr_8(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1); +void ejit_extr_16(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1); +void ejit_extr_32(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1); +void ejit_extr_u8(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1); +void ejit_extr_u16(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1); +void ejit_extr_u32(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1); + void ejit_addr(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, struct ejit_gpr r2); @@ -479,6 +556,15 @@ void ejit_divr_u(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, void ejit_divr_f(struct ejit_func *s, struct ejit_fpr r0, struct ejit_fpr r1, struct ejit_fpr r2); +void ejit_lshi(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + int64_t o); +void ejit_lshr(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2); +void ejit_rshi(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + int64_t o); +void ejit_rshr(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2); + void ejit_andr(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, struct ejit_gpr r2); void ejit_andi(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, @@ -490,10 +576,33 @@ void ejit_negr(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1); void ejit_eqr(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, struct ejit_gpr r2); void ejit_eqr_f(struct ejit_func *s, struct ejit_gpr r0, struct ejit_fpr r1, - struct ejit_fpr r2); + struct ejit_fpr r2); + +void ejit_gtr(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2); +void ejit_gtr_u(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2); +void ejit_gtr_f(struct ejit_func *s, struct ejit_gpr r0, struct ejit_fpr r1, + struct ejit_fpr r2); void ejit_ltr(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, struct ejit_gpr r2); +void ejit_ltr_u(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2); +void ejit_ltr_f(struct ejit_func *s, struct ejit_gpr r0, struct ejit_fpr r1, + struct ejit_fpr r2); + +void ejit_ger(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2); +void ejit_ger_u(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2); +void ejit_ger_f(struct ejit_func *s, struct ejit_gpr r0, struct ejit_fpr r1, + struct ejit_fpr r2); + +void ejit_ler(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2); +void ejit_ler_f(struct ejit_func *s, struct ejit_gpr r0, struct ejit_fpr r1, + struct ejit_fpr r2); struct ejit_reloc ejit_bltr(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1); @@ -557,6 +666,7 @@ struct ejit_reloc ejit_bltgtr_f(struct ejit_func *s, struct ejit_fpr r0, struct ejit_fpr r1); struct ejit_reloc ejit_jmp(struct ejit_func *s); +struct ejit_reloc ejit_jmpr(struct ejit_func *s, struct ejit_gpr r0); struct ejit_reloc ejit_bmci(struct ejit_func *s, struct ejit_gpr r0, int64_t o); struct ejit_reloc ejit_bmcr(struct ejit_func *s, struct ejit_gpr r0, diff --git a/src/common.h b/src/common.h index 218b589..e9f0b69 100644 --- a/src/common.h +++ b/src/common.h @@ -31,6 +31,17 @@ enum ejit_opcode { LDXIF, LDXID, + LDXR8, + LDXR16, + LDXR32, + LDXR64, + LDXRU8, + LDXRU16, + LDXRU32, + LDXRU64, + LDXRF, + LDXRD, + STI8, STI16, STI32, @@ -53,6 +64,13 @@ enum ejit_opcode { STXIF, STXID, + EXTR8, + EXTR16, + EXTR32, + EXTRU8, + EXTRU16, + EXTRU32, + ADDR, ADDR_F, ADDI, @@ -73,6 +91,11 @@ enum ejit_opcode { NEGR, COMR, + LSHI, + LSHR, + RSHI, + RSHR, + ANDR, ANDI, @@ -117,6 +140,7 @@ enum ejit_opcode { BLTGTR_F, JMP, + JMPR, BMCI, BMCR, diff --git a/src/ejit.c b/src/ejit.c index c4e82b1..4f407aa 100644 --- a/src/ejit.c +++ b/src/ejit.c @@ -233,8 +233,58 @@ void ejit_stxi_d(struct ejit_func *s, struct ejit_fpr r0, struct ejit_gpr r1, emit_insn_i(s, STXID, r0.f, r1.r, o); } +void ejit_ldi_i8(struct ejit_func *s, struct ejit_gpr r0, void *p) +{ + emit_insn_p(s, LDI8, r0.r, 0, p); +} + +void ejit_ldi_i16(struct ejit_func *s, struct ejit_gpr r0, void *p) +{ + emit_insn_p(s, LDI16, r0.r, 0, p); +} + +void ejit_ldi_i32(struct ejit_func *s, struct ejit_gpr r0, void *p) +{ + emit_insn_p(s, LDI32, r0.r, 0, p); +} + +void ejit_ldi_i64(struct ejit_func *s, struct ejit_gpr r0, void *p) +{ + emit_insn_p(s, LDI64, r0.r, 0, p); +} + +void ejit_ldi_u8(struct ejit_func *s, struct ejit_gpr r0, void *p) +{ + emit_insn_p(s, LDIU8, r0.r, 0, p); +} + +void ejit_ldi_u16(struct ejit_func *s, struct ejit_gpr r0, void *p) +{ + emit_insn_p(s, LDIU16, r0.r, 0, p); +} + +void ejit_ldi_u32(struct ejit_func *s, struct ejit_gpr r0, void *p) +{ + emit_insn_p(s, LDIU32, r0.r, 0, p); +} + +void ejit_ldi_u64(struct ejit_func *s, struct ejit_gpr r0, void *p) +{ + emit_insn_p(s, LDIU64, r0.r, 0, p); +} + +void ejit_ldi_f(struct ejit_func *s, struct ejit_fpr r0, void *p) +{ + emit_insn_p(s, LDIF, r0.f, 0, p); +} + +void ejit_ldi_d(struct ejit_func *s, struct ejit_fpr r0, void *p) +{ + emit_insn_p(s, LDID, r0.f, 0, p); +} + void ejit_ldxi_i8(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, - int64_t o) + int64_t o) { emit_insn_i(s, LDXI8, r0.r, r1.r, o); } @@ -258,7 +308,7 @@ void ejit_ldxi_i64(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, } void ejit_ldxi_u8(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, - int64_t o) + int64_t o) { emit_insn_i(s, LDXIU8, r0.r, r1.r, o); } @@ -282,17 +332,77 @@ void ejit_ldxi_u64(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, } void ejit_ldxi_f(struct ejit_func *s, struct ejit_fpr r0, struct ejit_gpr r1, - int64_t o) + int64_t o) { emit_insn_i(s, LDXIF, r0.f, r1.r, o); } void ejit_ldxi_d(struct ejit_func *s, struct ejit_fpr r0, struct ejit_gpr r1, - int64_t o) + int64_t o) { emit_insn_i(s, LDXID, r0.f, r1.r, o); } +void ejit_ldxr_i8(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2) +{ + emit_insn_r(s, LDXR8, r0.r, r1.r, r2.r); +} + +void ejit_ldxr_i16(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2) +{ + emit_insn_r(s, LDXR16, r0.r, r1.r, r2.r); +} + +void ejit_ldxr_i32(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2) +{ + emit_insn_r(s, LDXR32, r0.r, r1.r, r2.r); +} + +void ejit_ldxr_i64(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2) +{ + emit_insn_r(s, LDXR64, r0.r, r1.r, r2.r); +} + +void ejit_ldxr_u8(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2) +{ + emit_insn_r(s, LDXRU8, r0.r, r1.r, r2.r); +} + +void ejit_ldxr_u16(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2) +{ + emit_insn_r(s, LDXRU16, r0.r, r1.r, r2.r); +} + +void ejit_ldxr_u32(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2) +{ + emit_insn_r(s, LDXRU32, r0.r, r1.r, r2.r); +} + +void ejit_ldxr_u64(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2) +{ + emit_insn_r(s, LDXIU64, r0.r, r1.r, r2.r); +} + +void ejit_ldxr_f(struct ejit_func *s, struct ejit_fpr r0, struct ejit_gpr r1, + struct ejit_gpr r2) +{ + emit_insn_r(s, LDXRF, r0.f, r1.r, r2.r); +} + +void ejit_ldxr_d(struct ejit_func *s, struct ejit_fpr r0, struct ejit_gpr r1, + struct ejit_gpr r2) +{ + emit_insn_r(s, LDXRD, r0.f, r1.r, r2.r); +} + void ejit_retr(struct ejit_func *s, struct ejit_gpr r0) { emit_insn_r(s, RETR, r0.r, 0, 0); @@ -313,6 +423,36 @@ void ejit_reti_f(struct ejit_func *s, double f) emit_insn_f(s, RETI_F, 0, 0, f); } +void ejit_extr_8(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1) +{ + emit_insn_i(s, EXTR8, r0.r, r1.r, 0); +} + +void ejit_extr_16(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1) +{ + emit_insn_i(s, EXTR16, r0.r, r1.r, 0); +} + +void ejit_extr_32(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1) +{ + emit_insn_i(s, EXTR32, r0.r, r1.r, 0); +} + +void ejit_extr_u8(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1) +{ + emit_insn_i(s, EXTRU8, r0.r, r1.r, 0); +} + +void ejit_extr_u16(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1) +{ + emit_insn_i(s, EXTRU16, r0.r, r1.r, 0); +} + +void ejit_extr_u32(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1) +{ + emit_insn_i(s, EXTRU32, r0.r, r1.r, 0); +} + void ejit_addr(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, struct ejit_gpr r2) { @@ -378,6 +518,30 @@ void ejit_divr_f(struct ejit_func *s, struct ejit_fpr r0, struct ejit_fpr r1, emit_insn_r(s, DIVR_F, r0.f, r1.f, r2.f); } +void ejit_lshi(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + int64_t o) +{ + emit_insn_i(s, LSHI, r0.r, r1.r, o); +} + +void ejit_lshr(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2) +{ + emit_insn_r(s, LSHR, r0.r, r1.r, r2.r); +} + +void ejit_rshi(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + int64_t o) +{ + emit_insn_i(s, RSHI, r0.r, r1.r, o); +} + +void ejit_rshr(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2) +{ + emit_insn_r(s, RSHR, r0.r, r1.r, r2.r); +} + void ejit_andr(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, struct ejit_gpr r2) { @@ -420,17 +584,83 @@ void ejit_eqr(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, } void ejit_eqr_f(struct ejit_func *s, struct ejit_gpr r0, struct ejit_fpr r1, - struct ejit_fpr r2) + struct ejit_fpr r2) { emit_insn_r(s, EQR_F, r0.r, r1.f, r2.f); } +void ejit_gtr(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2) +{ + emit_insn_r(s, GTR, r0.r, r1.r, r2.r); +} + +void ejit_gtr_u(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2) +{ + emit_insn_r(s, GTR_U, r0.r, r1.r, r2.r); +} + +void ejit_gtr_f(struct ejit_func *s, struct ejit_gpr r0, struct ejit_fpr r1, + struct ejit_fpr r2) +{ + emit_insn_r(s, GTR_F, r0.r, r1.f, r2.f); +} + void ejit_ltr(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, struct ejit_gpr r2) { emit_insn_r(s, GER, r0.r, r2.r, r1.r); } +void ejit_ltr_u(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2) +{ + emit_insn_r(s, GER_U, r0.r, r2.r, r1.r); +} + +void ejit_ltr_f(struct ejit_func *s, struct ejit_gpr r0, struct ejit_fpr r1, + struct ejit_fpr r2) +{ + emit_insn_r(s, GER_F, r0.r, r2.f, r1.f); +} + +void ejit_ger(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2) +{ + emit_insn_r(s, GER, r0.r, r1.r, r2.r); +} + +void ejit_ger_u(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2) +{ + emit_insn_r(s, GER_U, r0.r, r1.r, r2.r); +} + +void ejit_ger_f(struct ejit_func *s, struct ejit_gpr r0, struct ejit_fpr r1, + struct ejit_fpr r2) +{ + emit_insn_r(s, GER_F, r0.r, r1.f, r2.f); +} + +void ejit_ler(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2) +{ + emit_insn_r(s, GTR, r0.r, r2.r, r1.r); +} + +void ejit_ler_u(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1, + struct ejit_gpr r2) +{ + emit_insn_r(s, GTR_U, r0.r, r2.r, r1.r); +} + +void ejit_ler_f(struct ejit_func *s, struct ejit_gpr r0, struct ejit_fpr r1, + struct ejit_fpr r2) +{ + emit_insn_r(s, GTR_F, r0.r, r2.f, r1.f); +} + struct ejit_reloc ejit_bner(struct ejit_func *s, struct ejit_gpr r0, struct ejit_gpr r1) { @@ -648,6 +878,13 @@ struct ejit_reloc ejit_jmp(struct ejit_func *s) return (struct ejit_reloc){.insn = addr}; } +struct ejit_reloc ejit_jmpr(struct ejit_func *s, struct ejit_gpr r0) +{ + size_t addr = vec_len(&s->insns); + emit_insn_i(s, JMPR, 0, r0.r, 0); + return (struct ejit_reloc){.insn = addr}; +} + struct ejit_reloc ejit_bmci(struct ejit_func *s, struct ejit_gpr r0, int64_t o) { size_t addr = vec_len(&s->insns); diff --git a/src/interp.c b/src/interp.c index 383599e..30a7672 100644 --- a/src/interp.c +++ b/src/interp.c @@ -13,6 +13,13 @@ union interp_ret ejit_interp(struct ejit_func *f, size_t argc, [MOVR] = &&MOVR, [MOVR_F] = &&MOVR_F, + [EXTR8] = &&EXTR8, + [EXTR16] = &&EXTR16, + [EXTR32] = &&EXTR32, + [EXTRU8] = &&EXTRU8, + [EXTRU16] = &&EXTRU16, + [EXTRU32] = &&EXTRU32, + [ADDR] = &&ADDR, [ADDR_F] = &&ADDR_F, [ADDI] = &&ADDI, @@ -29,6 +36,11 @@ union interp_ret ejit_interp(struct ejit_func *f, size_t argc, [DIVR_U] = &&DIVR_U, [DIVR_F] = &&DIVR_F, + [LSHI] = &&LSHI, + [LSHR] = &&LSHR, + [RSHI] = &&RSHI, + [RSHR] = &&RSHR, + [ANDR] = &&ANDR, [ANDI] = &&ANDI, @@ -56,6 +68,17 @@ union interp_ret ejit_interp(struct ejit_func *f, size_t argc, [STXIF] = &&STXIF, [STXID] = &&STXID, + [LDI8] = &&LDI8, + [LDI16] = &&LDI16, + [LDI32] = &&LDI32, + [LDI64] = &&LDI64, + [LDIU8] = &&LDIU8, + [LDIU16] = &&LDIU16, + [LDIU32] = &&LDIU32, + [LDIU64] = &&LDIU64, + [LDIF] = &&LDIF, + [LDID] = &&LDID, + [LDXI8] = &&LDXI8, [LDXI16] = &&LDXI16, [LDXI32] = &&LDXI32, @@ -67,6 +90,17 @@ union interp_ret ejit_interp(struct ejit_func *f, size_t argc, [LDXIF] = &&LDXIF, [LDXID] = &&LDXID, + [LDXR8] = &&LDXR8, + [LDXR16] = &&LDXR16, + [LDXR32] = &&LDXR32, + [LDXR64] = &&LDXR64, + [LDXRU8] = &&LDXRU8, + [LDXRU16] = &&LDXRU16, + [LDXRU32] = &&LDXRU32, + [LDXRU64] = &&LDXRU64, + [LDXRF] = &&LDXRF, + [LDXRD] = &&LDXRD, + [BNER] = &&BNER, [BNEI] = &&BNEI, [BNER_F] = &&BNER_F, @@ -96,6 +130,7 @@ union interp_ret ejit_interp(struct ejit_func *f, size_t argc, [BLTGTR_F] = &&BLTGTR_F, [JMP] = &&JMP, + [JMPR] = &&JMPR, [BMCI] = &&BMCI, [BMCR] = &&BMCR, @@ -175,6 +210,30 @@ union interp_ret ejit_interp(struct ejit_func *f, size_t argc, fpr[i.r0] = fpr[i.r1]; DISPATCH(); + DO(EXTR8); + gpr[i.r0] = (int8_t)gpr[i.r1]; + DISPATCH(); + + DO(EXTR16); + gpr[i.r0] = (int16_t)gpr[i.r1]; + DISPATCH(); + + DO(EXTR32); + gpr[i.r0] = (int32_t)gpr[i.r1]; + DISPATCH(); + + DO(EXTRU8); + gpr[i.r0] = (uint8_t)gpr[i.r1]; + DISPATCH(); + + DO(EXTRU16); + gpr[i.r0] = (uint16_t)gpr[i.r1]; + DISPATCH(); + + DO(EXTRU32); + gpr[i.r0] = (uint32_t)gpr[i.r1]; + DISPATCH(); + DO(ADDR); gpr[i.r0] = gpr[i.r1] + gpr[i.r2]; DISPATCH(); @@ -219,6 +278,22 @@ union interp_ret ejit_interp(struct ejit_func *f, size_t argc, fpr[i.r0] = fpr[i.r1] / fpr[i.r2]; DISPATCH(); + DO(LSHI); + gpr[i.r0] = gpr[i.r1] << i.o; + DISPATCH(); + + DO(LSHR); + gpr[i.r0] = gpr[i.r1] << gpr[i.r2]; + DISPATCH(); + + DO(RSHI); + gpr[i.r0] = gpr[i.r1] >> i.o; + DISPATCH(); + + DO(RSHR); + gpr[i.r0] = gpr[i.r1] >> gpr[i.r2]; + DISPATCH(); + DO(ANDR); gpr[i.r0] = gpr[i.r1] & gpr[i.r2]; DISPATCH(); @@ -305,6 +380,56 @@ union interp_ret ejit_interp(struct ejit_func *f, size_t argc, *addr = fpr[i.r0]; DISPATCH(); + DO(LDI8); + int8_t *addr = (int8_t *)i.p; + gpr[i.r0] = *addr; + DISPATCH(); + + DO(LDI16); + int16_t *addr = (int16_t *)i.p; + gpr[i.r0] = *addr; + DISPATCH(); + + DO(LDI32); + int32_t *addr = (int32_t *)i.p; + gpr[i.r0] = *addr; + DISPATCH(); + + DO(LDI64); + int64_t *addr = (int64_t *)i.p; + gpr[i.r0] = *addr; + DISPATCH(); + + DO(LDIU8); + uint8_t *addr = (uint8_t *)i.p; + gpr[i.r0] = *addr; + DISPATCH(); + + DO(LDIU16); + uint16_t *addr = (uint16_t *)i.p; + gpr[i.r0] = *addr; + DISPATCH(); + + DO(LDIU32); + uint32_t *addr = (uint32_t *)i.p; + gpr[i.r0] = *addr; + DISPATCH(); + + DO(LDIU64); + uint64_t *addr = (uint64_t *)i.p; + gpr[i.r0] = *addr; + DISPATCH(); + + DO(LDIF); + float *addr = (float *)i.p; + fpr[i.r0] = *addr; + DISPATCH(); + + DO(LDID); + double *addr = (double *)i.p; + fpr[i.r0] = *addr; + DISPATCH(); + DO(LDXI8); int8_t *addr = (int8_t *)(gpr[i.r1] + i.o); gpr[i.r0] = *addr; @@ -355,6 +480,56 @@ union interp_ret ejit_interp(struct ejit_func *f, size_t argc, fpr[i.r0] = *addr; DISPATCH(); + DO(LDXR8); + int8_t *addr = (int8_t *)(gpr[i.r1] + gpr[i.r2]); + gpr[i.r0] = *addr; + DISPATCH(); + + DO(LDXR16); + int16_t *addr = (int16_t *)(gpr[i.r1] + gpr[i.r2]); + gpr[i.r0] = *addr; + DISPATCH(); + + DO(LDXR32); + int32_t *addr = (int32_t *)(gpr[i.r1] + gpr[i.r2]); + gpr[i.r0] = *addr; + DISPATCH(); + + DO(LDXR64); + int64_t *addr = (int64_t *)(gpr[i.r1] + gpr[i.r2]); + gpr[i.r0] = *addr; + DISPATCH(); + + DO(LDXRU8); + uint8_t *addr = (uint8_t *)(gpr[i.r1] + gpr[i.r2]); + gpr[i.r0] = *addr; + DISPATCH(); + + DO(LDXRU16); + uint16_t *addr = (uint16_t *)(gpr[i.r1] + gpr[i.r2]); + gpr[i.r0] = *addr; + DISPATCH(); + + DO(LDXRU32); + uint32_t *addr = (uint32_t *)(gpr[i.r1] + gpr[i.r2]); + gpr[i.r0] = *addr; + DISPATCH(); + + DO(LDXRU64); + uint64_t *addr = (uint64_t *)(gpr[i.r1] + gpr[i.r2]); + gpr[i.r0] = *addr; + DISPATCH(); + + DO(LDXRF); + float *addr = (float *)(gpr[i.r1] + gpr[i.r2]); + fpr[i.r0] = *addr; + DISPATCH(); + + DO(LDXRD); + double *addr = (double *)(gpr[i.r1] + gpr[i.r2]); + fpr[i.r0] = *addr; + DISPATCH(); + DO(BNER); if (gpr[i.r1] != gpr[i.r2]) JUMP(i.r0); @@ -491,6 +666,10 @@ union interp_ret ejit_interp(struct ejit_func *f, size_t argc, JUMP(i.r0); DISPATCH(); + DO(JMPR); + JUMP(gpr[i.r1]); + DISPATCH(); + DO(BMSR); if (gpr[i.r1] & gpr[i.r2]) JUMP(i.r0); diff --git a/tests/extr_16.c b/tests/extr_16.c new file mode 100644 index 0000000..5c825a3 --- /dev/null +++ b/tests/extr_16.c @@ -0,0 +1,24 @@ +#include +#include +#include "do_jit.h" + +int main() +{ + struct ejit_operand operands[1] = { + EJIT_OPERAND_GPR(1, EJIT_TYPE(long)) + }; + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 1, operands); + ejit_extr_16(f, EJIT_GPR(0), EJIT_GPR(1)); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 2, 0, EJIT_USE64(long), do_jit); + + assert(erf1(f, EJIT_ARG(0, long)) == 0); + assert(erf1(f, EJIT_ARG(1, long)) == 1); + assert(erf1(f, EJIT_ARG(0xfff, long)) == 0xfff); + assert(erf1(f, EJIT_ARG(0xffff, long)) == -1); + assert(erf1(f, EJIT_ARG(0xfffff, long)) == -1); + assert(erf1(f, EJIT_ARG(0xf0000, long)) == 0); + + ejit_destroy_func(f); +} diff --git a/tests/extr_32.c b/tests/extr_32.c new file mode 100644 index 0000000..8b65f53 --- /dev/null +++ b/tests/extr_32.c @@ -0,0 +1,25 @@ +#include +#include +#include "do_jit.h" + +int main() +{ + struct ejit_operand operands[1] = { + EJIT_OPERAND_GPR(1, EJIT_TYPE(long)) + }; + + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 1, operands); + ejit_extr_32(f, EJIT_GPR(0), EJIT_GPR(1)); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 2, 0, EJIT_USE64(long), do_jit); + + assert(erf1(f, EJIT_ARG(0, long)) == 0); + assert(erf1(f, EJIT_ARG(1, long)) == 1); + assert(erf1(f, EJIT_ARG(0xfffffff, long)) == 0xfffffff); + assert(erf1(f, EJIT_ARG(0xffffffff, long)) == -1); + assert(erf1(f, EJIT_ARG(0xfffffffff, long)) == -1); + assert(erf1(f, EJIT_ARG(0xf00000000, long)) == 0); + + ejit_destroy_func(f); +} diff --git a/tests/extr_8.c b/tests/extr_8.c new file mode 100644 index 0000000..12fe287 --- /dev/null +++ b/tests/extr_8.c @@ -0,0 +1,24 @@ +#include +#include +#include "do_jit.h" + +int main() +{ + struct ejit_operand operands[1] = { + EJIT_OPERAND_GPR(1, EJIT_TYPE(unsigned long)) + }; + struct ejit_func *f = ejit_create_func(EJIT_TYPE(unsigned long), 1, + operands); + ejit_extr_8(f, EJIT_GPR(0), EJIT_GPR(1)); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 2, 0, EJIT_USE64(unsigned long), do_jit); + + assert(erf1(f, EJIT_ARG(0, unsigned long)) == 0); + assert(erf1(f, EJIT_ARG(1, unsigned long)) == 1); + assert(erf1(f, EJIT_ARG(0xf, unsigned long)) == 0xf); + assert(erf1(f, EJIT_ARG(0xff, unsigned long)) == -1); + assert(erf1(f, EJIT_ARG(0xfff, unsigned long)) == -1); + + ejit_destroy_func(f); +} diff --git a/tests/extr_c.c b/tests/extr_c.c deleted file mode 100644 index ff652a7..0000000 --- a/tests/extr_c.c +++ /dev/null @@ -1,27 +0,0 @@ -#include "test.h" - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1)); - - jit_extr_c(j, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL); - - ASSERT(f(0) == 0); - ASSERT(f(1) == 1); - ASSERT(f(0xf) == 0xf); - ASSERT(f(0xff) == -1); - ASSERT(f(0xfff) == -1); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/extr_d_f.c b/tests/extr_d_f.c deleted file mode 100644 index 87ad4a8..0000000 --- a/tests/extr_d_f.c +++ /dev/null @@ -1,26 +0,0 @@ -#include "test.h" - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0)); - - jit_extr_d_f(j, JIT_F0, JIT_F0); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr_f(j, JIT_F0); - - float (*f)(double) = jit_end(j, NULL); - - ASSERT(f(0.0) == 0.0f); - ASSERT(f(0.5) == 0.5f); - ASSERT(f(1.0 / 0.0) == 1.0f / 0.0f); - ASSERT(f(1.25) == 1.25f); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/extr_f.c b/tests/extr_f.c deleted file mode 100644 index 7721127..0000000 --- a/tests/extr_f.c +++ /dev/null @@ -1,25 +0,0 @@ -#include "test.h" - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0)); - - jit_extr_f(j, JIT_F0, JIT_R0); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr_f(j, JIT_F0); - - float (*f)(jit_word_t) = jit_end(j, NULL); - - ASSERT(f(0) == 0.0f); - ASSERT(f(1) == 1.0f); - ASSERT(f(-100) == -100.0f); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/extr_i.c b/tests/extr_i.c deleted file mode 100644 index cf3a2e1..0000000 --- a/tests/extr_i.c +++ /dev/null @@ -1,30 +0,0 @@ -#include "test.h" - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ -#if EJIT_WORDSIZE > 32 - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1)); - - jit_extr_i(j, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL); - - ASSERT(f(0) == 0); - ASSERT(f(1) == 1); - ASSERT(f(0xfffffff) == 0xfffffff); - ASSERT(f(0xffffffff) == -1); - ASSERT(f(0xfffffffff) == -1); - ASSERT(f(0xf00000000) == 0); -#endif -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/extr_s.c b/tests/extr_s.c deleted file mode 100644 index 08ea42e..0000000 --- a/tests/extr_s.c +++ /dev/null @@ -1,28 +0,0 @@ -#include "test.h" - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1)); - - jit_extr_s(j, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL); - - ASSERT(f(0) == 0); - ASSERT(f(1) == 1); - ASSERT(f(0xfff) == 0xfff); - ASSERT(f(0xffff) == -1); - ASSERT(f(0xfffff) == -1); - ASSERT(f(0xf0000) == 0); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/extr_u16.c b/tests/extr_u16.c new file mode 100644 index 0000000..3063e33 --- /dev/null +++ b/tests/extr_u16.c @@ -0,0 +1,24 @@ +#include +#include +#include "do_jit.h" + +int main() +{ + struct ejit_operand operands[1] = { + EJIT_OPERAND_GPR(1, EJIT_TYPE(long)) + }; + + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 1, operands); + ejit_extr_u16(f, EJIT_GPR(0), EJIT_GPR(1)); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 2, 0, EJIT_USE64(long), do_jit); + + assert(erf1(f, EJIT_ARG(0, long)) == 0); + assert(erf1(f, EJIT_ARG(1, long)) == 1); + assert(erf1(f, EJIT_ARG(0xffff, long)) == 0xffff); + assert(erf1(f, EJIT_ARG(0xfffff, long)) == 0xffff); + assert(erf1(f, EJIT_ARG(0xf0000, long)) == 0); + + ejit_destroy_func(f); +} diff --git a/tests/extr_u32.c b/tests/extr_u32.c new file mode 100644 index 0000000..5897d2f --- /dev/null +++ b/tests/extr_u32.c @@ -0,0 +1,24 @@ +#include +#include +#include "do_jit.h" + +int main() +{ + struct ejit_operand operands[1] = { + EJIT_OPERAND_GPR(1, EJIT_TYPE(long)) + }; + + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 1, operands); + ejit_extr_u32(f, EJIT_GPR(0), EJIT_GPR(1)); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 2, 0, EJIT_USE64(long), do_jit); + + assert(erf1(f, EJIT_ARG(0, long)) == 0); + assert(erf1(f, EJIT_ARG(1, long)) == 1); + assert(erf1(f, EJIT_ARG(0xffffffff, long)) == 0xffffffff); + assert(erf1(f, EJIT_ARG(0xfffffffff, long)) == 0xffffffff); + assert(erf1(f, EJIT_ARG(0xf00000000, long)) == 0); + + ejit_destroy_func(f); +} diff --git a/tests/extr_u8.c b/tests/extr_u8.c new file mode 100644 index 0000000..ee677a9 --- /dev/null +++ b/tests/extr_u8.c @@ -0,0 +1,24 @@ +#include +#include +#include "do_jit.h" + +int main() +{ + struct ejit_operand operands[1] = { + EJIT_OPERAND_GPR(1, EJIT_TYPE(unsigned long)) + }; + struct ejit_func *f = ejit_create_func(EJIT_TYPE(unsigned long), 1, + operands); + ejit_extr_u8(f, EJIT_GPR(0), EJIT_GPR(1)); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 2, 0, EJIT_USE64(unsigned long), do_jit); + + assert(erf1(f, EJIT_ARG(0, unsigned long)) == 0); + assert(erf1(f, EJIT_ARG(1, unsigned long)) == 1); + assert(erf1(f, EJIT_ARG(0xff, unsigned long)) == 0xff); + assert(erf1(f, EJIT_ARG(0xfff, unsigned long)) == 0xff); + assert(erf1(f, EJIT_ARG(0xf00, unsigned long)) == 0); + + ejit_destroy_func(f); +} diff --git a/tests/extr_uc.c b/tests/extr_uc.c deleted file mode 100644 index 063962b..0000000 --- a/tests/extr_uc.c +++ /dev/null @@ -1,27 +0,0 @@ -#include "test.h" - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1)); - - jit_extr_uc(j, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL); - - ASSERT(f(0) == 0); - ASSERT(f(1) == 1); - ASSERT(f(0xff) == 0xff); - ASSERT(f(0xfff) == 0xff); - ASSERT(f(0xf00) == 0); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/extr_ui.c b/tests/extr_ui.c deleted file mode 100644 index 457e8f8..0000000 --- a/tests/extr_ui.c +++ /dev/null @@ -1,29 +0,0 @@ -#include "test.h" - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ -#if EJIT_WORDSIZE > 32 - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1)); - - jit_extr_ui(j, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL); - - ASSERT(f(0) == 0); - ASSERT(f(1) == 1); - ASSERT(f(0xffffffff) == 0xffffffff); - ASSERT(f(0xfffffffff) == 0xffffffff); - ASSERT(f(0xf00000000) == 0); -#endif -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/extr_us.c b/tests/extr_us.c deleted file mode 100644 index 61374cc..0000000 --- a/tests/extr_us.c +++ /dev/null @@ -1,27 +0,0 @@ -#include "test.h" - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1)); - - jit_extr_us(j, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL); - - ASSERT(f(0) == 0); - ASSERT(f(1) == 1); - ASSERT(f(0xffff) == 0xffff); - ASSERT(f(0xfffff) == 0xffff); - ASSERT(f(0xf0000) == 0); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ger.c b/tests/ger.c index 195d4c1..5192aac 100644 --- a/tests/ger.c +++ b/tests/ger.c @@ -5,26 +5,26 @@ int main() { struct ejit_operand operands[2] = { - EJIT_OPERAND_GPR(0, EJIT_TYPE(long)) + EJIT_OPERAND_GPR(0, EJIT_TYPE(long)), EJIT_OPERAND_GPR(1, EJIT_TYPE(long)) }; struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 2, operands); - ejit_gtr(f, EJIT_GPR(0), EJIT_GPR(0), EJIT_GPR(1)); + ejit_ger(f, EJIT_GPR(0), EJIT_GPR(0), EJIT_GPR(1)); ejit_retr(f, EJIT_GPR(0)); ejit_select_compile_func(f, 2, 0, EJIT_USE64(long), do_jit); assert(ejit_run_func_2(f, EJIT_ARG(1, long), EJIT_ARG(1, long)) == 1); - assert(ejit_run_func_2(f, EJIT_ARG(0, long), EJIT_ARG(1, long)) == 1); + assert(ejit_run_func_2(f, EJIT_ARG(0, long), EJIT_ARG(1, long)) == 0); assert(ejit_run_func_2(f, EJIT_ARG(0x0fffffffffffffff, long), - EJIT_ARG(0x0ffffffffffffff0, long)) == 0); + EJIT_ARG(0x0ffffffffffffff0, long)) == 1); assert(ejit_run_func_2(f, EJIT_ARG(0x7fffffffffffffff, long), - EJIT_ARG(0x6fffffffffffffff, long)) == 1); + EJIT_ARG(0x6ffffffffffffff0, long)) == 1); ejit_destroy_func(f); } diff --git a/tests/ger_u.c b/tests/ger_u.c new file mode 100644 index 0000000..96d2ddd --- /dev/null +++ b/tests/ger_u.c @@ -0,0 +1,33 @@ +#include +#include +#include "do_jit.h" + +int main() +{ + struct ejit_operand operands[2] = { + EJIT_OPERAND_GPR(0, EJIT_TYPE(long)), + EJIT_OPERAND_GPR(1, EJIT_TYPE(long)) + }; + + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 2, operands); + + ejit_ger_u(f, EJIT_GPR(0), EJIT_GPR(0), EJIT_GPR(1)); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 2, 0, EJIT_USE64(long), do_jit); + + assert(ejit_run_func_2(f, EJIT_ARG(1, long), EJIT_ARG(1, long)) == 1); + assert(ejit_run_func_2(f, EJIT_ARG(1, long), EJIT_ARG(0, long)) == 1); + + assert(ejit_run_func_2(f, EJIT_ARG(-1, long), EJIT_ARG(1, long)) == 1); + assert(ejit_run_func_2(f, EJIT_ARG(-1, long), EJIT_ARG(0, long)) == 1); + + assert(ejit_run_func_2(f, + EJIT_ARG(0x0fffffffffffffff, long), + EJIT_ARG(0x0ffffffffffffff0, long)) == 1); + + assert(ejit_run_func_2(f, + EJIT_ARG(0x7fffffffffffffff, long), + EJIT_ARG(0x6fffffffffffffff, long)) == 1); + ejit_destroy_func(f); +} diff --git a/tests/gtr.c b/tests/gtr.c index 34dfd39..967d944 100644 --- a/tests/gtr.c +++ b/tests/gtr.c @@ -5,7 +5,7 @@ int main() { struct ejit_operand operands[2] = { - EJIT_OPERAND_GPR(0, EJIT_TYPE(long)) + EJIT_OPERAND_GPR(0, EJIT_TYPE(long)), EJIT_OPERAND_GPR(1, EJIT_TYPE(long)) }; @@ -17,14 +17,14 @@ int main() ejit_select_compile_func(f, 2, 0, EJIT_USE64(long), do_jit); assert(ejit_run_func_2(f, EJIT_ARG(1, long), EJIT_ARG(1, long)) == 0); - assert(ejit_run_func_2(f, EJIT_ARG(0, long), EJIT_ARG(1, long)) == 1); + assert(ejit_run_func_2(f, EJIT_ARG(1, long), EJIT_ARG(0, long)) == 1); assert(ejit_run_func_2(f, EJIT_ARG(0x0fffffffffffffff, long), - EJIT_ARG(0x0ffffffffffffff0, long)) == 0); + EJIT_ARG(0x0ffffffffffffff0, long)) == 1); assert(ejit_run_func_2(f, EJIT_ARG(0x7fffffffffffffff, long), - EJIT_ARG(0x6fffffffffffffff, long)) == 1); + EJIT_ARG(0x6ffffffffffffff0, long)) == 1); ejit_destroy_func(f); } diff --git a/tests/gtr_f.c b/tests/gtr_f.c index 4c07bfe..2fb2834 100644 --- a/tests/gtr_f.c +++ b/tests/gtr_f.c @@ -5,21 +5,19 @@ int main() { struct ejit_operand operands[2] = { - EJIT_OPERAND_FPR(0, EJIT_TYPE(double)) + EJIT_OPERAND_FPR(0, EJIT_TYPE(double)), EJIT_OPERAND_FPR(1, EJIT_TYPE(double)) }; struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 2, operands); - ejit_gtr(f, EJIT_GPR(0), EJIT_FPR(0), EJIT_FPR(1)); + ejit_gtr_f(f, EJIT_GPR(0), EJIT_FPR(0), EJIT_FPR(1)); ejit_retr(f, EJIT_GPR(0)); ejit_select_compile_func(f, 1, 2, EJIT_USE64(long), do_jit); - assert(ejit_run_func_2(f, EJIT_ARG(1, double), - EJIT_ARG(1, double)) == 0); - assert(ejit_run_func_2(f, EJIT_ARG(0, double), - EJIT_ARG(1, double)) == 1); + assert(erf2(f, EJIT_ARG(1, double), EJIT_ARG(1, double)) == 0); + assert(erf2(f, EJIT_ARG(1, double), EJIT_ARG(0, double)) == 1); ejit_destroy_func(f); } diff --git a/tests/gtr_u.c b/tests/gtr_u.c new file mode 100644 index 0000000..6c4f5b3 --- /dev/null +++ b/tests/gtr_u.c @@ -0,0 +1,32 @@ +#include +#include +#include "do_jit.h" + +int main() +{ + struct ejit_operand operands[2] = { + EJIT_OPERAND_GPR(0, EJIT_TYPE(long)), + EJIT_OPERAND_GPR(1, EJIT_TYPE(long)) + }; + + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 2, operands); + + ejit_gtr_u(f, EJIT_GPR(0), EJIT_GPR(0), EJIT_GPR(1)); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 2, 0, EJIT_USE64(long), do_jit); + + assert(ejit_run_func_2(f, EJIT_ARG(1, long), EJIT_ARG(1, long)) == 0); + assert(ejit_run_func_2(f, EJIT_ARG(1, long), EJIT_ARG(0, long)) == 1); + assert(ejit_run_func_2(f, EJIT_ARG(-1, long), EJIT_ARG(1, long)) == 1); + assert(ejit_run_func_2(f, EJIT_ARG(-1, long), EJIT_ARG(0, long)) == 1); + + assert(ejit_run_func_2(f, + EJIT_ARG(0x0fffffffffffffff, long), + EJIT_ARG(0x0ffffffffffffff0, long)) == 1); + + assert(ejit_run_func_2(f, + EJIT_ARG(0x7fffffffffffffff, long), + EJIT_ARG(0x6ffffffffffffff0, long)) == 1); + ejit_destroy_func(f); +} diff --git a/tests/jmp0.c b/tests/jmp0.c index 0f86fe6..c5fda98 100644 --- a/tests/jmp0.c +++ b/tests/jmp0.c @@ -1,24 +1,23 @@ -#include "test.h" +#include +#include +#include "do_jit.h" -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) +int main() { - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0)); + struct ejit_operand operands[1] = { + EJIT_OPERAND_GPR(0, EJIT_TYPE(long)) + }; - jit_reloc_t r = jit_jmp(j); - jit_patch_here(j, r); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 1, operands); + struct ejit_reloc r = ejit_jmp(f); + struct ejit_label l = ejit_label(f); + ejit_patch(f, r, l); + ejit_retr(f, EJIT_GPR(0)); - jit_word_t (*f)(jit_word_t) = jit_end(j, NULL); - ASSERT(f(42) == 42); - ASSERT(f(-1) == -1); -} + ejit_select_compile_func(f, 1, 0, EJIT_USE64(long), do_jit); -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); + assert(erf1(f, EJIT_ARG(42, long)) == 42); + assert(erf1(f, EJIT_ARG(-1, long)) == -1); + + ejit_destroy_func(f); } diff --git a/tests/jmp_table.c b/tests/jmp_table.c index 2ea14cd..10f9226 100644 --- a/tests/jmp_table.c +++ b/tests/jmp_table.c @@ -1,61 +1,57 @@ -#include "test.h" +#include +#include +#include "do_jit.h" -#define NTARGETS ((size_t) 4) +#define NTARGETS 4 +struct ejit_label targets[NTARGETS]; -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) +int main() { - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0)); - - jit_reloc_t default_target = jit_bgei_u(j, JIT_R0, NTARGETS); - - // FIXME: need ldxr with word stride, then can eliminate lshi. - jit_lshi(j, JIT_R0, JIT_R0, sizeof(intptr_t) == 4 ? 2 : 3); - jit_reloc_t table = jit_mov_addr(j, JIT_R1); - jit_ldxr(j, JIT_R1, JIT_R1, JIT_R0); - jit_jmpr(j, JIT_R1); - - jit_begin_data (j, (NTARGETS + 1) * sizeof(intptr_t)); - jit_align(j, sizeof(intptr_t)); - jit_patch_here(j, table); - jit_reloc_t targets[NTARGETS]; - jit_reloc_t tails[NTARGETS]; - for (size_t i = 0; i < NTARGETS; i++) { - targets[i] = jit_emit_addr(j); - } - jit_end_data (j); + struct ejit_operand operands[1] = { + EJIT_OPERAND_GPR(0, EJIT_POINTER) + }; + + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 1, operands); + struct ejit_reloc default_target = ejit_bgei_u(f, EJIT_GPR(0), + NTARGETS); + + ejit_lshi(f, EJIT_GPR(0), EJIT_GPR(0), + sizeof(struct ejit_label) == 4 ? 2 : 3); + +#warning \ + "Label rewriting is not currently working so this will fail the jit test" + ejit_ldxi_label(f, EJIT_GPR(1), EJIT_GPR(0), (int64_t)targets); + ejit_jmpr(f, EJIT_GPR(1)); + struct ejit_reloc tails[NTARGETS]; for (size_t i = 0; i < NTARGETS; i++) { - jit_patch_here(j, targets[i]); - jit_movi(j, JIT_R0, i * i); - tails[i] = jit_jmp(j); + targets[i] = ejit_label(f); + ejit_movi(f, EJIT_GPR(0), i * i); + tails[i] = ejit_jmp(f); } - jit_patch_here(j, default_target); - jit_movi(j, JIT_R0, 42); + struct ejit_label default_label = ejit_label(f); + ejit_patch(f, default_target, default_label); + ejit_movi(f, EJIT_GPR(0), 42); + + struct ejit_label dst = ejit_label(f); for (int i = 0; i < NTARGETS; i++) { - jit_patch_here(j, tails[i]); + ejit_patch(f, tails[i], dst); } - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - jit_word_t (*f)(jit_word_t) = jit_end(j, NULL); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 2, 0, EJIT_USE64(long), do_jit); for (int i = -2; i < ((int) NTARGETS) + 2; i++) { if (i < 0) { - ASSERT(f(i) == 42); + assert(erf1(f, EJIT_ARG(i, long)) == 42); } else if (i < NTARGETS) { - ASSERT(f(i) == i * i); + assert(erf1(f, EJIT_ARG(i, long)) == i * i); } else { - ASSERT(f(i) == 42); + assert(erf1(f, EJIT_ARG(i, long)) == 42); } } -} -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); + ejit_destroy_func(f); } diff --git a/tests/jmpi_local.c b/tests/jmpi_local.c index 1131997..76cba7c 100644 --- a/tests/jmpi_local.c +++ b/tests/jmpi_local.c @@ -1,25 +1,25 @@ -#include "test.h" +#include +#include +#include "do_jit.h" -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) +int main() { - jit_begin(j, arena_base, arena_size); + struct ejit_func *f = ejit_create_func(EJIT_TYPE(int), 0, NULL); + struct ejit_reloc r = ejit_jmp(f); + ejit_reti(f, 0); - jit_reloc_t r = jit_jmp (j); - jit_reti (j, 0); - jit_pointer_t addr = jit_address (j); - jit_reti (j, 1); - jit_patch_here (j, r); - jit_jmpi (j, addr); - jit_reti (j, 2); + struct ejit_label l = ejit_label(f); + ejit_reti(f, 1); - int (*f)(void) = jit_end(j, NULL); + ejit_patch(f, r, l); - ASSERT(f() == 1); -} + struct ejit_reloc j = ejit_jmp(f); + ejit_patch(f, j, l); + ejit_reti(f, 2); -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); + ejit_select_compile_func(f, 0, 0, EJIT_USE64(long), do_jit); + + assert(ejit_run_func(f, 0, NULL) == 1); + + ejit_destroy_func(f); } diff --git a/tests/ldi_c.c b/tests/ldi_c.c deleted file mode 100644 index c6539c0..0000000 --- a/tests/ldi_c.c +++ /dev/null @@ -1,24 +0,0 @@ -#include "test.h" - -static uint8_t data[] = { 0xff, 0x00, 0x42 }; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - - jit_ldi_c(j, JIT_R0, &data[0]); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(void) = jit_end(j, NULL); - - ASSERT(f() == -1); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldi_d.c b/tests/ldi_d.c index c7574dc..7c9b36c 100644 --- a/tests/ldi_d.c +++ b/tests/ldi_d.c @@ -1,24 +1,18 @@ -#include "test.h" +#include +#include +#include "do_jit.h" static double data = -1.5; -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) +int main() { - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); + struct ejit_func *f = ejit_create_func(EJIT_TYPE(double), 0, NULL); + ejit_ldi_d(f, EJIT_FPR(0), &data); + ejit_retr_f(f, EJIT_FPR(0)); - jit_ldi_d(j, JIT_F0, &data); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr_d(j, JIT_F0); + ejit_select_compile_func(f, 1, 0, EJIT_USE64(double), do_jit); - double (*f)(void) = jit_end(j, NULL); + assert(ejit_run_func_f(f, 0, NULL) == data); - ASSERT(f() == data); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); + ejit_destroy_func(f); } diff --git a/tests/ldi_f.c b/tests/ldi_f.c index d5cd095..48974d2 100644 --- a/tests/ldi_f.c +++ b/tests/ldi_f.c @@ -1,24 +1,18 @@ -#include "test.h" +#include +#include +#include "do_jit.h" -static float data = -1.5f; +static float data = -1.5; -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) +int main() { - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); + struct ejit_func *f = ejit_create_func(EJIT_TYPE(float), 0, NULL); + ejit_ldi_f(f, EJIT_FPR(0), &data); + ejit_retr_f(f, EJIT_FPR(0)); - jit_ldi_f(j, JIT_F0, &data); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr_f(j, JIT_F0); + ejit_select_compile_func(f, 1, 0, EJIT_USE64(float), do_jit); - float (*f)(void) = jit_end(j, NULL); + assert(ejit_run_func_f(f, 0, NULL) == data); - ASSERT(f() == data); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); + ejit_destroy_func(f); } diff --git a/tests/ldi_i.c b/tests/ldi_i.c deleted file mode 100644 index 72035d4..0000000 --- a/tests/ldi_i.c +++ /dev/null @@ -1,24 +0,0 @@ -#include "test.h" - -static uint32_t data = 0xffffffff; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - - jit_ldi_i(j, JIT_R0, &data); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(void) = jit_end(j, NULL); - - ASSERT(f() == -1); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldi_i16.c b/tests/ldi_i16.c new file mode 100644 index 0000000..32c8b33 --- /dev/null +++ b/tests/ldi_i16.c @@ -0,0 +1,20 @@ +#include +#include +#include "do_jit.h" + +static uint16_t data = 0xffff; + +int main() +{ + struct ejit_func *f = ejit_create_func(EJIT_TYPE(unsigned long), 0, + NULL); + + ejit_ldi_i16(f, EJIT_GPR(0), &data); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 1, 0, false, do_jit); + + assert(ejit_run_func(f, 0, NULL) == -1); + + ejit_destroy_func(f); +} diff --git a/tests/ldi_i32.c b/tests/ldi_i32.c new file mode 100644 index 0000000..60eee1a --- /dev/null +++ b/tests/ldi_i32.c @@ -0,0 +1,19 @@ +#include +#include +#include "do_jit.h" + +int main() +{ + static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 }; + + struct ejit_func *f = ejit_create_func(EJIT_TYPE(unsigned long), 0, + NULL); + ejit_ldi_u32(f, EJIT_GPR(0), data); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 1, 0, false, do_jit); + + assert(ejit_run_func(f, 0, NULL) == data[0]); + + ejit_destroy_func(f); +} diff --git a/tests/ldi_i64.c b/tests/ldi_i64.c new file mode 100644 index 0000000..a7a8c98 --- /dev/null +++ b/tests/ldi_i64.c @@ -0,0 +1,20 @@ +#include +#include +#include "do_jit.h" + +int main() +{ + static uint64_t data[] = { 0xffffffffffffffff, 0x00000000, + 0x42424242 }; + + struct ejit_func *f = ejit_create_func(EJIT_TYPE(unsigned long), 0, + NULL); + ejit_ldi_i64(f, EJIT_GPR(0), data); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 1, 0, true, do_jit); + + assert(ejit_run_func(f, 0, NULL) == -1); + + ejit_destroy_func(f); +} diff --git a/tests/ldi_i8.c b/tests/ldi_i8.c new file mode 100644 index 0000000..2d3c55a --- /dev/null +++ b/tests/ldi_i8.c @@ -0,0 +1,19 @@ +#include +#include +#include "do_jit.h" + +static uint8_t data[] = { 0xff, 0x00, 0x42 }; + +int main() +{ + struct ejit_func *f = ejit_create_func(EJIT_TYPE(unsigned long), 0, + NULL); + ejit_ldi_i8(f, EJIT_GPR(0), &data[0]); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 1, 0, EJIT_USE64(unsigned long), do_jit); + + assert(ejit_run_func(f, 0, NULL) == -1); + + ejit_destroy_func(f); +} diff --git a/tests/ldi_l.c b/tests/ldi_l.c deleted file mode 100644 index 58a8099..0000000 --- a/tests/ldi_l.c +++ /dev/null @@ -1,26 +0,0 @@ -#include "test.h" - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ -#if EJIT_WORDSIZE > 32 - static uint64_t data = 0xffffffffffffffff; - - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - - jit_ldi_l(j, JIT_R0, &data); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(void) = jit_end(j, NULL); - - ASSERT(f() == -1); -#endif -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldi_s.c b/tests/ldi_s.c deleted file mode 100644 index 7d10106..0000000 --- a/tests/ldi_s.c +++ /dev/null @@ -1,24 +0,0 @@ -#include "test.h" - -static uint16_t data = 0xffff; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - - jit_ldi_s(j, JIT_R0, &data); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(void) = jit_end(j, NULL); - - ASSERT(f() == -1); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldi_u16.c b/tests/ldi_u16.c new file mode 100644 index 0000000..b73c1da --- /dev/null +++ b/tests/ldi_u16.c @@ -0,0 +1,20 @@ +#include +#include +#include "do_jit.h" + +static uint16_t data[] = { 0xffff, 0x0000, 0x4242 }; + +int main() +{ + struct ejit_func *f = ejit_create_func(EJIT_TYPE(unsigned long), 0, + NULL); + + ejit_ldi_u16(f, EJIT_GPR(0), data); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 1, 0, EJIT_USE64(unsigned long), do_jit); + + assert(ejit_run_func(f, 0, NULL) == data[0]); + + ejit_destroy_func(f); +} diff --git a/tests/ldi_u64.c b/tests/ldi_u64.c new file mode 100644 index 0000000..633f5dc --- /dev/null +++ b/tests/ldi_u64.c @@ -0,0 +1,19 @@ +#include +#include +#include "do_jit.h" + +int main() +{ + static uint64_t data[] = { 0x12345678ffffffff, 0x00000000, 0x42424242 }; + + struct ejit_func *f = ejit_create_func(EJIT_TYPE(unsigned long), 0, + NULL); + ejit_ldi_u64(f, EJIT_GPR(0), data); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 1, 0, true, do_jit); + + assert(ejit_run_func(f, 0, NULL) == (int64_t)data[0]); + + ejit_destroy_func(f); +} diff --git a/tests/ldi_u8.c b/tests/ldi_u8.c new file mode 100644 index 0000000..19aa555 --- /dev/null +++ b/tests/ldi_u8.c @@ -0,0 +1,19 @@ +#include +#include +#include "do_jit.h" + +static uint8_t data[] = { 0xff, 0x00, 0x42 }; + +int main() +{ + struct ejit_func *f = ejit_create_func(EJIT_TYPE(unsigned long), 0, + NULL); + ejit_ldi_u8(f, EJIT_GPR(0), &data[0]); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 1, 0, EJIT_USE64(unsigned long), do_jit); + + assert(ejit_run_func(f, 0, NULL) == 0xff); + + ejit_destroy_func(f); +} diff --git a/tests/ldi_uc.c b/tests/ldi_uc.c deleted file mode 100644 index d5c80ac..0000000 --- a/tests/ldi_uc.c +++ /dev/null @@ -1,24 +0,0 @@ -#include "test.h" - -static uint8_t data[] = { 0xff, 0x00, 0x42 }; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - - jit_ldi_uc(j, JIT_R0, data); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(void) = jit_end(j, NULL); - - ASSERT(f() == 0xff); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldi_ui.c b/tests/ldi_ui.c deleted file mode 100644 index bfccc30..0000000 --- a/tests/ldi_ui.c +++ /dev/null @@ -1,26 +0,0 @@ -#include "test.h" - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ -#if EJIT_WORDSIZE > 32 - static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 }; - - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - - jit_ldi_ui(j, JIT_R0, data); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(void) = jit_end(j, NULL); - - ASSERT(f() == data[0]); -#endif -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldi_us.c b/tests/ldi_us.c deleted file mode 100644 index 970db9c..0000000 --- a/tests/ldi_us.c +++ /dev/null @@ -1,24 +0,0 @@ -#include "test.h" - -static uint16_t data[] = { 0xffff, 0x0000, 0x4242 }; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - - jit_ldi_us(j, JIT_R0, data); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(void) = jit_end(j, NULL); - - ASSERT(f() == data[0]); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldr_atomic.c b/tests/ldr_atomic.c deleted file mode 100644 index 339ba56..0000000 --- a/tests/ldr_atomic.c +++ /dev/null @@ -1,28 +0,0 @@ -#include "test.h" - -static long data[] = { 0x0f0f0f0f, 0x00000000, 0x42424242 }; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1)); - - /* atm does not test for actual atomicity, just that no segfaults etc happen */ - jit_ldr_atomic(j, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(void*) = jit_end(j, NULL); - - ASSERT(f(&data[0]) == 0x0f0f0f0f); - ASSERT(f(&data[1]) == 0); - ASSERT(f(&data[2]) == 0x42424242); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldr_c.c b/tests/ldr_c.c deleted file mode 100644 index a630123..0000000 --- a/tests/ldr_c.c +++ /dev/null @@ -1,27 +0,0 @@ -#include "test.h" - -static uint8_t data[] = { 0xff, 0x00, 0x42 }; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1)); - - jit_ldr_c(j, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(void*) = jit_end(j, NULL); - - ASSERT(f(&data[0]) == -1); - ASSERT(f(&data[1]) == 0); - ASSERT(f(&data[2]) == 0x42); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldr_d.c b/tests/ldr_d.c deleted file mode 100644 index 6a4c1bd..0000000 --- a/tests/ldr_d.c +++ /dev/null @@ -1,27 +0,0 @@ -#include "test.h" - -static double data[] = { -1.0, 0.0, 0.5 }; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1)); - - jit_ldr_d(j, JIT_F0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr_d(j, JIT_F0); - - double (*f)(void*) = jit_end(j, NULL); - - ASSERT(f(&data[0]) == data[0]); - ASSERT(f(&data[1]) == data[1]); - ASSERT(f(&data[2]) == data[2]); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldr_f.c b/tests/ldr_f.c deleted file mode 100644 index 4ea978d..0000000 --- a/tests/ldr_f.c +++ /dev/null @@ -1,27 +0,0 @@ -#include "test.h" - -static float data[] = { -1.0, 0.0, 0.5 }; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1)); - - jit_ldr_f(j, JIT_F0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr_f(j, JIT_F0); - - float (*f)(void*) = jit_end(j, NULL); - - ASSERT(f(&data[0]) == data[0]); - ASSERT(f(&data[1]) == data[1]); - ASSERT(f(&data[2]) == data[2]); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldr_i.c b/tests/ldr_i.c deleted file mode 100644 index a7a4cd0..0000000 --- a/tests/ldr_i.c +++ /dev/null @@ -1,27 +0,0 @@ -#include "test.h" - -static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 }; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1)); - - jit_ldr_i(j, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(void*) = jit_end(j, NULL); - - ASSERT(f(&data[0]) == -1); - ASSERT(f(&data[1]) == 0); - ASSERT(f(&data[2]) == 0x42424242); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldr_l.c b/tests/ldr_l.c deleted file mode 100644 index d689d47..0000000 --- a/tests/ldr_l.c +++ /dev/null @@ -1,29 +0,0 @@ -#include "test.h" - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ -#if EJIT_WORDSIZE > 32 - static uint64_t data[] = { 0xffffffffffffffff, 0, 0x4242424212345678 }; - - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1)); - - jit_ldr_l(j, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(void*) = jit_end(j, NULL); - - ASSERT(f(&data[0]) == -1); - ASSERT(f(&data[1]) == 0); - ASSERT(f(&data[2]) == data[2]); -#endif -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldr_s.c b/tests/ldr_s.c deleted file mode 100644 index cbb72ab..0000000 --- a/tests/ldr_s.c +++ /dev/null @@ -1,27 +0,0 @@ -#include "test.h" - -static uint16_t data[] = { 0xffff, 0x0000, 0x4242 }; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1)); - - jit_ldr_s(j, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(void*) = jit_end(j, NULL); - - ASSERT(f(&data[0]) == -1); - ASSERT(f(&data[1]) == 0); - ASSERT(f(&data[2]) == 0x4242); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldr_uc.c b/tests/ldr_uc.c deleted file mode 100644 index 65d56cf..0000000 --- a/tests/ldr_uc.c +++ /dev/null @@ -1,27 +0,0 @@ -#include "test.h" - -static uint8_t data[] = { 0xff, 0x00, 0x42 }; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1)); - - jit_ldr_uc(j, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(void*) = jit_end(j, NULL); - - ASSERT(f(&data[0]) == 0xff); - ASSERT(f(&data[1]) == 0); - ASSERT(f(&data[2]) == 0x42); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldr_ui.c b/tests/ldr_ui.c deleted file mode 100644 index 92ace34..0000000 --- a/tests/ldr_ui.c +++ /dev/null @@ -1,29 +0,0 @@ -#include "test.h" - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ -#if EJIT_WORDSIZE > 32 - static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 }; - - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1)); - - jit_ldr_ui(j, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(void*) = jit_end(j, NULL); - - ASSERT(f(&data[0]) == data[0]); - ASSERT(f(&data[1]) == data[1]); - ASSERT(f(&data[2]) == data[2]); -#endif -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldr_us.c b/tests/ldr_us.c deleted file mode 100644 index 5d1a67d..0000000 --- a/tests/ldr_us.c +++ /dev/null @@ -1,27 +0,0 @@ -#include "test.h" - -static uint16_t data[] = { 0xffff, 0x0000, 0x4242 }; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1)); - - jit_ldr_us(j, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(void*) = jit_end(j, NULL); - - ASSERT(f(&data[0]) == data[0]); - ASSERT(f(&data[1]) == data[1]); - ASSERT(f(&data[2]) == data[2]); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldxi_c.c b/tests/ldxi_c.c deleted file mode 100644 index cc40ddb..0000000 --- a/tests/ldxi_c.c +++ /dev/null @@ -1,27 +0,0 @@ -#include "test.h" - -static uint8_t data[] = { 0xff, 0x00, 0x42 }; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0)); - - jit_ldxi_c(j, JIT_R0, JIT_R0, (uintptr_t)&data); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL); - - ASSERT(f(0) == -1); - ASSERT(f(1) == 0); - ASSERT(f(2) == 0x42); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldxi_d.c b/tests/ldxi_d.c index a93e582..da3ed0a 100644 --- a/tests/ldxi_d.c +++ b/tests/ldxi_d.c @@ -1,27 +1,25 @@ -#include "test.h" +#include +#include +#include "do_jit.h" static double data[] = { -1.0, 0.0, 0.5 }; -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) +int main() { - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0)); + struct ejit_operand operands[1] = { + EJIT_OPERAND_GPR(0, EJIT_TYPE(long)) + }; - jit_ldxi_d(j, JIT_F0, JIT_R0, (uintptr_t)data); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr_d(j, JIT_F0); + struct ejit_func *f = ejit_create_func(EJIT_TYPE(double), 1, operands); - double (*f)(jit_uword_t) = jit_end(j, NULL); + ejit_ldxi_d(f, EJIT_FPR(0), EJIT_GPR(0), (uintptr_t)data); + ejit_retr_f(f, EJIT_FPR(0)); - ASSERT(f(0) == data[0]); - ASSERT(f(8) == data[1]); - ASSERT(f(16) == data[2]); -} + ejit_select_compile_func(f, 1, 1, EJIT_USE64(long), do_jit); -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); + assert(erff1(f, EJIT_ARG(sizeof(double) * 0, long)) == data[0]); + assert(erff1(f, EJIT_ARG(sizeof(double) * 1, long)) == data[1]); + assert(erff1(f, EJIT_ARG(sizeof(double) * 2, long)) == data[2]); + + ejit_destroy_func(f); } diff --git a/tests/ldxi_f.c b/tests/ldxi_f.c index 015d816..eb2ad58 100644 --- a/tests/ldxi_f.c +++ b/tests/ldxi_f.c @@ -1,27 +1,25 @@ -#include "test.h" +#include +#include +#include "do_jit.h" static float data[] = { -1.0, 0.0, 0.5 }; -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) +int main() { - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0)); + struct ejit_operand operands[1] = { + EJIT_OPERAND_GPR(0, EJIT_TYPE(long)) + }; - jit_ldxi_f(j, JIT_F0, JIT_R0, (uintptr_t)data); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr_f(j, JIT_F0); + struct ejit_func *f = ejit_create_func(EJIT_TYPE(float), 1, operands); - float (*f)(jit_uword_t) = jit_end(j, NULL); + ejit_ldxi_d(f, EJIT_FPR(0), EJIT_GPR(0), (uintptr_t)data); + ejit_retr_f(f, EJIT_FPR(0)); - ASSERT(f(0) == data[0]); - ASSERT(f(4) == data[1]); - ASSERT(f(8) == data[2]); -} + ejit_select_compile_func(f, 1, 1, EJIT_USE64(long), do_jit); -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); + assert(erff1(f, EJIT_ARG(sizeof(float) * 0, long)) == data[0]); + assert(erff1(f, EJIT_ARG(sizeof(float) * 1, long)) == data[1]); + assert(erff1(f, EJIT_ARG(sizeof(float) * 2, long)) == data[2]); + + ejit_destroy_func(f); } diff --git a/tests/ldxi_i.c b/tests/ldxi_i.c deleted file mode 100644 index 7e53001..0000000 --- a/tests/ldxi_i.c +++ /dev/null @@ -1,27 +0,0 @@ -#include "test.h" - -static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 }; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0)); - - jit_ldxi_i(j, JIT_R0, JIT_R0, (uintptr_t)data); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL); - - ASSERT(f(0) == -1); - ASSERT(f(4) == 0); - ASSERT(f(8) == 0x42424242); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldxi_i16.c b/tests/ldxi_i16.c new file mode 100644 index 0000000..e2af936 --- /dev/null +++ b/tests/ldxi_i16.c @@ -0,0 +1,24 @@ +#include +#include +#include "do_jit.h" + +static uint16_t data[] = { 0xffff, 0x0000, 0x4242 }; + +int main() +{ + struct ejit_operand operands[1] = { + EJIT_OPERAND_GPR(0, EJIT_TYPE(long)) + }; + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 1, operands); + + ejit_ldxi_i16(f, EJIT_GPR(0), EJIT_GPR(0), (uintptr_t)&data); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 1, 0, EJIT_USE64(long), do_jit); + + assert(erf1(f, EJIT_ARG(0, long)) == -1); + assert(erf1(f, EJIT_ARG(1, long)) == 0); + assert(erf1(f, EJIT_ARG(2, long)) == 0x4242); + + ejit_destroy_func(f); +} diff --git a/tests/ldxi_i32.c b/tests/ldxi_i32.c new file mode 100644 index 0000000..dac93ae --- /dev/null +++ b/tests/ldxi_i32.c @@ -0,0 +1,24 @@ +#include +#include +#include "do_jit.h" + +static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 }; + +int main() +{ + struct ejit_operand operands[1] = { + EJIT_OPERAND_GPR(0, EJIT_TYPE(long)) + }; + + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 1, operands); + ejit_ldxi_i32(f, EJIT_GPR(0), EJIT_GPR(0), (uintptr_t)data); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 1, 0, EJIT_USE64(long), do_jit); + + assert(erf1(f, EJIT_ARG(sizeof(int32_t) * 0, long)) == -1); + assert(erf1(f, EJIT_ARG(sizeof(int32_t) * 1, long)) == 0); + assert(erf1(f, EJIT_ARG(sizeof(int32_t) * 2, long)) == 0x42424242); + + ejit_destroy_func(f); +} diff --git a/tests/ldxi_i64.c b/tests/ldxi_i64.c new file mode 100644 index 0000000..72112dd --- /dev/null +++ b/tests/ldxi_i64.c @@ -0,0 +1,25 @@ +#include +#include +#include "do_jit.h" + +static uint64_t data[] = { 0xffffffffffffffff, 0, 0x4242424212345678 }; + +int main() +{ + struct ejit_operand operands[1] = { + EJIT_OPERAND_GPR(0, EJIT_TYPE(long)) + }; + + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 1, operands); + ejit_ldxi_i64(f, EJIT_GPR(0), EJIT_GPR(0), (uintptr_t)data); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 1, 0, true, do_jit); + + assert(erf1(f, EJIT_ARG(sizeof(int32_t) * 0, long)) == -1); + assert(erf1(f, EJIT_ARG(sizeof(int32_t) * 1, long)) == 0); + assert((uint64_t)erf1(f, + EJIT_ARG(sizeof(int32_t) * 2, long)) == data[2]); + + ejit_destroy_func(f); +} diff --git a/tests/ldxi_i8.c b/tests/ldxi_i8.c new file mode 100644 index 0000000..a7d0629 --- /dev/null +++ b/tests/ldxi_i8.c @@ -0,0 +1,24 @@ +#include +#include +#include "do_jit.h" + +static uint8_t data[] = { 0xff, 0x00, 0x42 }; + +int main() +{ + struct ejit_operand operands[1] = { + EJIT_OPERAND_GPR(0, EJIT_TYPE(long)) + }; + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 1, operands); + + ejit_ldxi_i8(f, EJIT_GPR(0), EJIT_GPR(0), (uintptr_t)&data); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 1, 0, EJIT_USE64(long), do_jit); + + assert(erf1(f, EJIT_ARG(0, long)) == -1); + assert(erf1(f, EJIT_ARG(1, long)) == 0); + assert(erf1(f, EJIT_ARG(2, long)) == 0x42); + + ejit_destroy_func(f); +} diff --git a/tests/ldxi_l.c b/tests/ldxi_l.c deleted file mode 100644 index 3a4454f..0000000 --- a/tests/ldxi_l.c +++ /dev/null @@ -1,29 +0,0 @@ -#include "test.h" - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ -#if EJIT_WORDSIZE > 32 - static uint64_t data[] = { 0xffffffffffffffff, 0, 0x4242424212345678 }; - - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0)); - - jit_ldxi_l(j, JIT_R0, JIT_R0, (uintptr_t)data); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL); - - ASSERT(f(0) == -1); - ASSERT(f(8) == 0); - ASSERT(f(16) == data[2]); -#endif -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldxi_s.c b/tests/ldxi_s.c deleted file mode 100644 index 05125da..0000000 --- a/tests/ldxi_s.c +++ /dev/null @@ -1,27 +0,0 @@ -#include "test.h" - -static uint16_t data[] = { 0xffff, 0x0000, 0x4242 }; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0)); - - jit_ldxi_s(j, JIT_R0, JIT_R0, (uintptr_t)data); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL); - - ASSERT(f(0) == -1); - ASSERT(f(2) == 0); - ASSERT(f(4) == 0x4242); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldxi_u16.c b/tests/ldxi_u16.c new file mode 100644 index 0000000..a5d8fca --- /dev/null +++ b/tests/ldxi_u16.c @@ -0,0 +1,24 @@ +#include +#include +#include "do_jit.h" + +static uint16_t data[] = { 0xffff, 0x0000, 0x4242 }; + +int main() +{ + struct ejit_operand operands[1] = { + EJIT_OPERAND_GPR(0, EJIT_TYPE(long)) + }; + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 1, operands); + + ejit_ldxi_i16(f, EJIT_GPR(0), EJIT_GPR(0), (uintptr_t)&data); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 1, 0, EJIT_USE64(long), do_jit); + + assert(erf1(f, EJIT_ARG(0, long)) == 0xffff); + assert(erf1(f, EJIT_ARG(1, long)) == 0); + assert(erf1(f, EJIT_ARG(2, long)) == 0x4242); + + ejit_destroy_func(f); +} diff --git a/tests/ldxi_u32.c b/tests/ldxi_u32.c new file mode 100644 index 0000000..04b8df8 --- /dev/null +++ b/tests/ldxi_u32.c @@ -0,0 +1,24 @@ +#include +#include +#include "do_jit.h" + +static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 }; + +int main() +{ + struct ejit_operand operands[1] = { + EJIT_OPERAND_GPR(0, EJIT_TYPE(long)) + }; + + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 1, operands); + ejit_ldxi_u32(f, EJIT_GPR(0), EJIT_GPR(0), (uintptr_t)data); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 1, 0, EJIT_USE64(long), do_jit); + + assert(erf1(f, EJIT_ARG(sizeof(int32_t) * 0, long)) == 0xffffffff); + assert(erf1(f, EJIT_ARG(sizeof(int32_t) * 1, long)) == 0); + assert(erf1(f, EJIT_ARG(sizeof(int32_t) * 2, long)) == 0x42424242); + + ejit_destroy_func(f); +} diff --git a/tests/ldxi_u64.c b/tests/ldxi_u64.c new file mode 100644 index 0000000..193fcf3 --- /dev/null +++ b/tests/ldxi_u64.c @@ -0,0 +1,26 @@ +#include +#include +#include "do_jit.h" + +static uint64_t data[] = { 0xffffffffffffffff, 0, 0x4242424212345678 }; + +int main() +{ + struct ejit_operand operands[1] = { + EJIT_OPERAND_GPR(0, EJIT_TYPE(long)) + }; + + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 1, operands); + ejit_ldxi_u64(f, EJIT_GPR(0), EJIT_GPR(0), (uintptr_t)data); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 1, 0, true, do_jit); + + assert((uint64_t)erf1(f, + EJIT_ARG(sizeof(int32_t) * 0, long)) == data[0]); + assert((uint64_t)erf1(f, EJIT_ARG(sizeof(int32_t) * 1, long)) == 0); + assert((uint64_t)erf1(f, + EJIT_ARG(sizeof(int32_t) * 2, long)) == data[2]); + + ejit_destroy_func(f); +} diff --git a/tests/ldxi_u8.c b/tests/ldxi_u8.c new file mode 100644 index 0000000..1942441 --- /dev/null +++ b/tests/ldxi_u8.c @@ -0,0 +1,24 @@ +#include +#include +#include "do_jit.h" + +static uint8_t data[] = { 0xff, 0x00, 0x42 }; + +int main() +{ + struct ejit_operand operands[1] = { + EJIT_OPERAND_GPR(0, EJIT_TYPE(long)) + }; + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 1, operands); + + ejit_ldxi_u8(f, EJIT_GPR(0), EJIT_GPR(0), (uintptr_t)&data); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 1, 0, EJIT_USE64(long), do_jit); + + assert(erf1(f, EJIT_ARG(0, long)) == 0xff); + assert(erf1(f, EJIT_ARG(1, long)) == 0); + assert(erf1(f, EJIT_ARG(2, long)) == 0x42); + + ejit_destroy_func(f); +} diff --git a/tests/ldxi_uc.c b/tests/ldxi_uc.c deleted file mode 100644 index dc82aa2..0000000 --- a/tests/ldxi_uc.c +++ /dev/null @@ -1,27 +0,0 @@ -#include "test.h" - -static uint8_t data[] = { 0xff, 0x00, 0x42 }; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0)); - - jit_ldxi_uc(j, JIT_R0, JIT_R0, (uintptr_t)data); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL); - - ASSERT(f(0) == 0xff); - ASSERT(f(1) == 0); - ASSERT(f(2) == 0x42); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldxi_ui.c b/tests/ldxi_ui.c deleted file mode 100644 index 4500507..0000000 --- a/tests/ldxi_ui.c +++ /dev/null @@ -1,29 +0,0 @@ -#include "test.h" - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ -#if EJIT_WORDSIZE > 32 - static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 }; - - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0)); - - jit_ldxi_ui(j, JIT_R0, JIT_R0, (uintptr_t)data); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL); - - ASSERT(f(0) == data[0]); - ASSERT(f(4) == data[1]); - ASSERT(f(8) == data[2]); -#endif -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldxi_us.c b/tests/ldxi_us.c deleted file mode 100644 index db2d8c8..0000000 --- a/tests/ldxi_us.c +++ /dev/null @@ -1,27 +0,0 @@ -#include "test.h" - -static uint16_t data[] = { 0xffff, 0x0000, 0x4242 }; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0)); - - jit_ldxi_us(j, JIT_R0, JIT_R0, (uintptr_t)data); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL); - - ASSERT(f(0) == data[0]); - ASSERT(f(2) == data[1]); - ASSERT(f(4) == data[2]); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldxr_c.c b/tests/ldxr_c.c deleted file mode 100644 index b691b58..0000000 --- a/tests/ldxr_c.c +++ /dev/null @@ -1,28 +0,0 @@ -#include "test.h" - -static uint8_t data[] = { 0xff, 0x00, 0x42 }; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0), - jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1)); - - jit_ldxr_c(j, JIT_R0, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(void*, jit_uword_t) = jit_end(j, NULL); - - ASSERT(f(data, 0) == -1); - ASSERT(f(data, 1) == 0); - ASSERT(f(data, 2) == 0x42); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldxr_d.c b/tests/ldxr_d.c index e8bb45e..3a9edc0 100644 --- a/tests/ldxr_d.c +++ b/tests/ldxr_d.c @@ -1,28 +1,31 @@ -#include "test.h" +#include +#include +#include "do_jit.h" static double data[] = { -1.0, 0.0, 0.5 }; -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) +int main() { - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0), - jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1)); + struct ejit_operand operands[2] = { + EJIT_OPERAND_GPR(0, EJIT_POINTER), + EJIT_OPERAND_GPR(1, EJIT_TYPE(unsigned)) + }; + struct ejit_func *f = ejit_create_func(EJIT_TYPE(double), 2, operands); - jit_ldxr_d(j, JIT_F0, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr_d(j, JIT_F0); + ejit_ldxr_d(f, EJIT_FPR(0), EJIT_GPR(0), EJIT_GPR(1)); + ejit_retr_f(f, EJIT_FPR(0)); - double (*f)(void*, jit_uword_t) = jit_end(j, NULL); + ejit_select_compile_func(f, 2, 1, false, do_jit); - ASSERT(f(data, 0) == data[0]); - ASSERT(f(data, 8) == data[1]); - ASSERT(f(data, 16) == data[2]); -} + assert(erff2(f, + EJIT_ARG(data, void *), + EJIT_ARG(0 * sizeof(double), unsigned)) == data[0]); -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); + assert(erff2(f, + EJIT_ARG(data, void *), + EJIT_ARG(1 * sizeof(double), unsigned)) == data[1]); + + assert(erff2(f, + EJIT_ARG(data, void *), + EJIT_ARG(2 * sizeof(double), unsigned)) == data[2]); } diff --git a/tests/ldxr_f.c b/tests/ldxr_f.c index c6dacba..202a4a1 100644 --- a/tests/ldxr_f.c +++ b/tests/ldxr_f.c @@ -1,28 +1,33 @@ -#include "test.h" +#include +#include +#include "do_jit.h" static float data[] = { -1.0, 0.0, 0.5 }; -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) +int main() { - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0), - jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1)); + struct ejit_operand operands[2] = { + EJIT_OPERAND_GPR(0, EJIT_POINTER), + EJIT_OPERAND_GPR(1, EJIT_TYPE(unsigned)) + }; + struct ejit_func *f = ejit_create_func(EJIT_TYPE(float), 2, operands); - jit_ldxr_f(j, JIT_F0, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr_f(j, JIT_F0); + ejit_ldxr_f(f, EJIT_FPR(0), EJIT_GPR(0), EJIT_GPR(1)); + ejit_retr_f(f, EJIT_FPR(0)); - float (*f)(void*, jit_uword_t) = jit_end(j, NULL); + ejit_select_compile_func(f, 2, 1, false, do_jit); - ASSERT(f(data, 0) == data[0]); - ASSERT(f(data, 4) == data[1]); - ASSERT(f(data, 8) == data[2]); -} + assert(erff2(f, + EJIT_ARG(data, void *), + EJIT_ARG(0 * sizeof(float), unsigned)) == data[0]); -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); + assert(erff2(f, + EJIT_ARG(data, void *), + EJIT_ARG(1 * sizeof(float), unsigned)) == data[1]); + + assert(erff2(f, + EJIT_ARG(data, void *), + EJIT_ARG(2 * sizeof(float), unsigned)) == data[2]); + + ejit_destroy_func(f); } diff --git a/tests/ldxr_i.c b/tests/ldxr_i.c deleted file mode 100644 index e035438..0000000 --- a/tests/ldxr_i.c +++ /dev/null @@ -1,28 +0,0 @@ -#include "test.h" - -static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 }; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0), - jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1)); - - jit_ldxr_i(j, JIT_R0, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(void*, jit_uword_t) = jit_end(j, NULL); - - ASSERT(f(data, 0) == -1); - ASSERT(f(data, 4) == 0); - ASSERT(f(data, 8) == 0x42424242); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldxr_i32.c b/tests/ldxr_i32.c new file mode 100644 index 0000000..719280a --- /dev/null +++ b/tests/ldxr_i32.c @@ -0,0 +1,26 @@ +#include +#include +#include "do_jit.h" + +static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 }; + +int main() +{ + struct ejit_operand operands[2] = { + EJIT_OPERAND_GPR(0, EJIT_POINTER), + EJIT_OPERAND_GPR(1, EJIT_TYPE(unsigned)) + }; + + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 2, operands); + ejit_ldxr_i32(f, EJIT_GPR(0), EJIT_GPR(0), EJIT_GPR(1)); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 2, 0, false, do_jit); + + assert(erf2(f, EJIT_ARG(data, void *), EJIT_ARG(0, unsigned)) == -1); + assert(erf2(f, EJIT_ARG(data, void *), EJIT_ARG(4, unsigned)) == 0); + assert(erf2(f, EJIT_ARG(data, void *), + EJIT_ARG(8, unsigned)) == 0x42424242); + + ejit_destroy_func(f); +} diff --git a/tests/ldxr_i64.c b/tests/ldxr_i64.c new file mode 100644 index 0000000..96333d9 --- /dev/null +++ b/tests/ldxr_i64.c @@ -0,0 +1,26 @@ +#include +#include +#include "do_jit.h" + +static uint64_t data[] = { 0xffffffffffffffff, 0, 0x4242424212345678 }; + +int main() +{ + struct ejit_operand operands[2] = { + EJIT_OPERAND_GPR(0, EJIT_POINTER), + EJIT_OPERAND_GPR(1, EJIT_TYPE(unsigned)) + }; + + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 2, operands); + ejit_ldxr_i64(f, EJIT_GPR(0), EJIT_GPR(0), EJIT_GPR(1)); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 2, 0, true, do_jit); + + assert(erf2(f, EJIT_ARG(data, void *), EJIT_ARG(0, unsigned)) == -1); + assert(erf2(f, EJIT_ARG(data, void *), EJIT_ARG(8, unsigned)) == 0); + assert(erf2(f, EJIT_ARG(data, void *), + EJIT_ARG(16, unsigned)) == (int64_t)data[2]); + + ejit_destroy_func(f); +} diff --git a/tests/ldxr_i8.c b/tests/ldxr_i8.c new file mode 100644 index 0000000..c5de17e --- /dev/null +++ b/tests/ldxr_i8.c @@ -0,0 +1,25 @@ +#include +#include +#include "do_jit.h" + +static uint8_t data[] = { 0xff, 0x00, 0x42 }; + +int main() +{ + struct ejit_operand operands[2] = { + EJIT_OPERAND_GPR(0, EJIT_POINTER), + EJIT_OPERAND_GPR(1, EJIT_TYPE(unsigned)) + }; + + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 2, operands); + ejit_ldxr_i8(f, EJIT_GPR(0), EJIT_GPR(0), EJIT_GPR(1)); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 2, 0, false, do_jit); + + assert(erf2(f, EJIT_ARG(data, void *), EJIT_ARG(0, unsigned)) == -1); + assert(erf2(f, EJIT_ARG(data, void *), EJIT_ARG(4, unsigned)) == 0); + assert(erf2(f, EJIT_ARG(data, void *), EJIT_ARG(8, unsigned)) == 0x42); + + ejit_destroy_func(f); +} diff --git a/tests/ldxr_l.c b/tests/ldxr_l.c deleted file mode 100644 index 6dcb5c7..0000000 --- a/tests/ldxr_l.c +++ /dev/null @@ -1,30 +0,0 @@ -#include "test.h" - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ -#if EJIT_WORDSIZE > 32 - static uint64_t data[] = { 0xffffffffffffffff, 0, 0x4242424212345678 }; - - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0), - jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1)); - - jit_ldxr_l(j, JIT_R0, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(void*, jit_uword_t) = jit_end(j, NULL); - - ASSERT(f(data, 0) == -1); - ASSERT(f(data, 8) == 0); - ASSERT(f(data, 16) == data[2]); -#endif -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldxr_s.c b/tests/ldxr_s.c deleted file mode 100644 index cea155f..0000000 --- a/tests/ldxr_s.c +++ /dev/null @@ -1,28 +0,0 @@ -#include "test.h" - -static uint16_t data[] = { 0xffff, 0x0000, 0x4242 }; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0), - jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1)); - - jit_ldxr_s(j, JIT_R0, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(void*, jit_uword_t) = jit_end(j, NULL); - - ASSERT(f(data, 0) == -1); - ASSERT(f(data, 2) == 0); - ASSERT(f(data, 4) == 0x4242); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldxr_u16.c b/tests/ldxr_u16.c new file mode 100644 index 0000000..38b6492 --- /dev/null +++ b/tests/ldxr_u16.c @@ -0,0 +1,27 @@ +#include +#include +#include "do_jit.h" + +static uint16_t data[] = { 0xffff, 0x0000, 0x4242 }; + +int main() +{ + struct ejit_operand operands[2] = { + EJIT_OPERAND_GPR(0, EJIT_POINTER), + EJIT_OPERAND_GPR(1, EJIT_TYPE(unsigned)) + }; + + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 2, operands); + ejit_ldxr_u16(f, EJIT_GPR(0), EJIT_GPR(0), EJIT_GPR(1)); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 2, 0, false, do_jit); + + assert(erf2(f, EJIT_ARG(data, void *), + EJIT_ARG(0, unsigned)) == 0xffff); + assert(erf2(f, EJIT_ARG(data, void *), EJIT_ARG(2, unsigned)) == 0); + assert(erf2(f, EJIT_ARG(data, void *), + EJIT_ARG(4, unsigned)) == 0x4242); + + ejit_destroy_func(f); +} diff --git a/tests/ldxr_u32.c b/tests/ldxr_u32.c new file mode 100644 index 0000000..212ae75 --- /dev/null +++ b/tests/ldxr_u32.c @@ -0,0 +1,27 @@ +#include +#include +#include "do_jit.h" + +static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 }; + +int main() +{ + struct ejit_operand operands[2] = { + EJIT_OPERAND_GPR(0, EJIT_POINTER), + EJIT_OPERAND_GPR(1, EJIT_TYPE(unsigned)) + }; + + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 2, operands); + ejit_ldxr_u32(f, EJIT_GPR(0), EJIT_GPR(0), EJIT_GPR(1)); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 2, 0, false, do_jit); + + assert(erf2(f, EJIT_ARG(data, void *), + EJIT_ARG(0, unsigned)) == 0xffffffff); + assert(erf2(f, EJIT_ARG(data, void *), EJIT_ARG(4, unsigned)) == 0); + assert(erf2(f, EJIT_ARG(data, void *), + EJIT_ARG(8, unsigned)) == 0x42424242); + + ejit_destroy_func(f); +} diff --git a/tests/ldxr_u8.c b/tests/ldxr_u8.c new file mode 100644 index 0000000..d1f5023 --- /dev/null +++ b/tests/ldxr_u8.c @@ -0,0 +1,25 @@ +#include +#include +#include "do_jit.h" + +static uint8_t data[] = { 0xff, 0x00, 0x42 }; + +int main() +{ + struct ejit_operand operands[2] = { + EJIT_OPERAND_GPR(0, EJIT_POINTER), + EJIT_OPERAND_GPR(1, EJIT_TYPE(unsigned)) + }; + + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 2, operands); + ejit_ldxr_u8(f, EJIT_GPR(0), EJIT_GPR(0), EJIT_GPR(1)); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 2, 0, false, do_jit); + + assert(erf2(f, EJIT_ARG(data, void *), EJIT_ARG(0, unsigned)) == 0xff); + assert(erf2(f, EJIT_ARG(data, void *), EJIT_ARG(4, unsigned)) == 0); + assert(erf2(f, EJIT_ARG(data, void *), EJIT_ARG(8, unsigned)) == 0x42); + + ejit_destroy_func(f); +} diff --git a/tests/ldxr_uc.c b/tests/ldxr_uc.c deleted file mode 100644 index 3b6ab3e..0000000 --- a/tests/ldxr_uc.c +++ /dev/null @@ -1,28 +0,0 @@ -#include "test.h" - -static uint8_t data[] = { 0xff, 0x00, 0x42 }; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0), - jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1)); - - jit_ldxr_uc(j, JIT_R0, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(void*, jit_uword_t) = jit_end(j, NULL); - - ASSERT(f(data, 0) == 0xff); - ASSERT(f(data, 1) == 0); - ASSERT(f(data, 2) == 0x42); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldxr_ui.c b/tests/ldxr_ui.c deleted file mode 100644 index eddb56b..0000000 --- a/tests/ldxr_ui.c +++ /dev/null @@ -1,30 +0,0 @@ -#include "test.h" - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ -#if EJIT_WORDSIZE > 32 - static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 }; - - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0), - jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1)); - - jit_ldxr_ui(j, JIT_R0, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(void*, jit_uword_t) = jit_end(j, NULL); - - ASSERT(f(data, 0) == data[0]); - ASSERT(f(data, 4) == data[1]); - ASSERT(f(data, 8) == data[2]); -#endif -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ldxr_us.c b/tests/ldxr_us.c deleted file mode 100644 index d18c133..0000000 --- a/tests/ldxr_us.c +++ /dev/null @@ -1,28 +0,0 @@ -#include "test.h" - -static uint16_t data[] = { 0xffff, 0x0000, 0x4242 }; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0), - jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1)); - - jit_ldxr_us(j, JIT_R0, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - jit_uword_t (*f)(void*, jit_uword_t) = jit_end(j, NULL); - - ASSERT(f(data, 0) == data[0]); - ASSERT(f(data, 2) == data[1]); - ASSERT(f(data, 4) == data[2]); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} diff --git a/tests/ler.c b/tests/ler.c index 0bd6e26..90c4c4c 100644 --- a/tests/ler.c +++ b/tests/ler.c @@ -5,7 +5,7 @@ int main() { struct ejit_operand operands[2] = { - EJIT_OPERAND_GPR(0, EJIT_TYPE(long)) + EJIT_OPERAND_GPR(0, EJIT_TYPE(long)), EJIT_OPERAND_GPR(1, EJIT_TYPE(long)) }; diff --git a/tests/ler_f.c b/tests/ler_f.c index 00fe9ef..ecb4b3f 100644 --- a/tests/ler_f.c +++ b/tests/ler_f.c @@ -5,13 +5,13 @@ int main() { struct ejit_operand operands[2] = { - EJIT_OPERAND_FPR(0, EJIT_TYPE(double)) + EJIT_OPERAND_FPR(0, EJIT_TYPE(double)), EJIT_OPERAND_FPR(1, EJIT_TYPE(double)) }; struct ejit_func *f = ejit_create_func(EJIT_TYPE(double), 2, operands); - ejit_ler(f, EJIT_GPR(0), EJIT_FPR(0), EJIT_FPR(1)); + ejit_ler_f(f, EJIT_GPR(0), EJIT_FPR(0), EJIT_FPR(1)); ejit_retr(f, EJIT_GPR(0)); ejit_select_compile_func(f, 1, 2, EJIT_USE64(long), do_jit); diff --git a/tests/lshi.c b/tests/lshi.c index 772c0ed..92550a5 100644 --- a/tests/lshi.c +++ b/tests/lshi.c @@ -1,27 +1,21 @@ -#include "test.h" +#include +#include +#include "do_jit.h" -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) +int main() { - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0)); + struct ejit_operand operands[2] = { + EJIT_OPERAND_GPR(0, EJIT_TYPE(long)) + }; - jit_lshi(j, JIT_R0, JIT_R0, 31); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 1, operands); - jit_word_t (*f)(jit_word_t) = jit_end(j, NULL); + ejit_lshi(f, EJIT_GPR(0), EJIT_GPR(0), 31); + ejit_retr(f, EJIT_GPR(0)); -#if EJIT_WORDSIZE == 32 - ASSERT(f(-0x7f) == 0x80000000); -#else - ASSERT(f(-0x7f) == 0xffffffc080000000); -#endif -} + ejit_select_compile_func(f, 1, 0, false, do_jit); -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); + assert(erf1(f, EJIT_ARG(-0x7f, long)) == (int64_t)0xffffffc080000000); + + ejit_destroy_func(f); } diff --git a/tests/lshr.c b/tests/lshr.c index 89b9084..4bfef86 100644 --- a/tests/lshr.c +++ b/tests/lshr.c @@ -1,69 +1,144 @@ -#include "test.h" +#include +#include +#include "do_jit.h" -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) +int main() { - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0), - jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1)); - - jit_lshr(j, JIT_R0, JIT_R0, JIT_R1); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - size_t size = 0; - void* ret = jit_end(j, &size); - - jit_word_t (*f)(jit_word_t, jit_word_t) = ret; - - ASSERT(f(0x7f, 1) == 0xfe); - ASSERT(f(0x7fff, 2) == 0x1fffc); - ASSERT(f(0x81, 16) == 0x810000); - ASSERT(f(0xff, 15) == 0x7f8000); - ASSERT(f(0x7fffffff, 0) == 0x7fffffff); -#if EJIT_WORDSIZE == 32 - ASSERT(f(0xffffffff, 8) == 0xffffff00); - ASSERT(f(0x7fffffff, 3) == 0xfffffff8); - ASSERT(f(-0x7f, 31) == 0x80000000); - ASSERT(f(-0x7fff, 30) == 0x40000000); - ASSERT(f(-0x7fffffff, 29) == 0x20000000); - ASSERT(f(0x80000001, 28) == 0x10000000); - ASSERT(f(0x8001, 17) == 0x20000); - ASSERT(f(0x80000001, 18) == 0x40000); - ASSERT(f(-0xffff, 24) == 0x1000000); -#else - ASSERT(f(0xffffffff, 8) == 0xffffffff00); - ASSERT(f(0x7fffffff, 3) == 0x3fffffff8); - ASSERT(f(-0x7f, 31) == 0xffffffc080000000); - ASSERT(f(-0x7fff, 30) == 0xffffe00040000000); - ASSERT(f(-0x7fffffff, 29) == 0xf000000020000000); - ASSERT(f(0x80000001, 28) == 0x800000010000000); - ASSERT(f(0x8001, 17) == 0x100020000); - ASSERT(f(0x80000001, 18) == 0x2000000040000); - ASSERT(f(-0xffff, 24) == 0xffffff0001000000); - ASSERT(f(0x7f, 33) == 0xfe00000000); - ASSERT(f(0x7ffff, 34) == 0x1ffffc00000000); - ASSERT(f(0x7fffffff, 35) == 0xfffffff800000000); - ASSERT(f(-0x7f, 63) == 0x8000000000000000); - ASSERT(f(-0x7fff, 62) == 0x4000000000000000); - ASSERT(f(-0x7fffffff, 61) == 0x2000000000000000); - ASSERT(f(0x80000001, 60) == 0x1000000000000000); - ASSERT(f(0x81, 48) == 0x81000000000000); - ASSERT(f(0x8001, 49) == 0x2000000000000); - ASSERT(f(0x80000001, 40) == 0x10000000000); - ASSERT(f(0xff, 47) == 0x7f800000000000); - ASSERT(f(0xffff0001, 56) == 0x100000000000000); - ASSERT(f(0xffffffff, 40) == 0xffffff0000000000); - ASSERT(f(0x7fffffffff, 33) == 0xfffffffe00000000); - ASSERT(f(-0x7fffffffff, 63) == 0x8000000000000000); - ASSERT(f(0x8000000001, 48) == 0x1000000000000); - ASSERT(f(0xffffffffff, 47) == 0xffff800000000000); -#endif -} + struct ejit_operand operands[2] = { + EJIT_OPERAND_GPR(0, EJIT_TYPE(long)), + EJIT_OPERAND_GPR(1, EJIT_TYPE(long)) + }; -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); + struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 2, operands); + + ejit_lshr(f, EJIT_GPR(0), EJIT_GPR(0), EJIT_GPR(1)); + ejit_retr(f, EJIT_GPR(0)); + + ejit_select_compile_func(f, 2, 0, EJIT_USE64(long), do_jit); + + assert(erf2(f, + EJIT_ARG(0x7f, long), + EJIT_ARG(1, long)) == 0xfe); + + assert(erf2(f, + EJIT_ARG(0x7fff, long), + EJIT_ARG(2, long)) == 0x1fffc); + + assert(erf2(f, + EJIT_ARG(0x81, long), + EJIT_ARG(16, long)) == 0x810000); + + assert(erf2(f, + EJIT_ARG(0xff, long), + EJIT_ARG(15, long)) == 0x7f8000); + + assert(erf2(f, + EJIT_ARG(0x7fffffff, long), + EJIT_ARG(0, long)) == 0x7fffffff); + + assert(erf2(f, + EJIT_ARG(0xffffffff, long), + EJIT_ARG(8, long)) == 0xffffffff00); + + assert(erf2(f, + EJIT_ARG(0x7fffffff, long), + EJIT_ARG(3, long)) == 0x3fffffff8); + + assert(erf2(f, + EJIT_ARG(-0x7f, long), + EJIT_ARG(31, long)) == (int64_t)0xffffffc080000000); + + assert(erf2(f, + EJIT_ARG(-0x7fff, long), + EJIT_ARG(30, long)) == (int64_t)0xffffe00040000000); + + assert(erf2(f, + EJIT_ARG(-0x7fffffff, long), + EJIT_ARG(29, long)) == (int64_t)0xf000000020000000); + + assert(erf2(f, + EJIT_ARG(0x80000001, long), + EJIT_ARG(28, long)) == (int64_t)0x800000010000000); + + assert(erf2(f, + EJIT_ARG(0x8001, long), + EJIT_ARG(17, long)) == 0x100020000); + + assert(erf2(f, + EJIT_ARG(0x80000001, long), + EJIT_ARG(18, long)) == (int64_t)0x2000000040000); + + assert(erf2(f, + EJIT_ARG(-0xffff, long), + EJIT_ARG(24, long)) == (int64_t)0xffffff0001000000); + + assert(erf2(f, + EJIT_ARG(0x7f, long), + EJIT_ARG(33, long)) == 0xfe00000000); + + assert(erf2(f, + EJIT_ARG(0x7ffff, long), + EJIT_ARG(34, long)) == 0x1ffffc00000000); + + assert(erf2(f, + EJIT_ARG(0x7fffffff, long), + EJIT_ARG(35, long)) == (int64_t)0xfffffff800000000); + + assert(erf2(f, + EJIT_ARG(-0x7f, long), + EJIT_ARG(63, long)) == (int64_t)0x8000000000000000); + + assert(erf2(f, + EJIT_ARG(-0x7fff, long), + EJIT_ARG(62, long)) == 0x4000000000000000); + + assert(erf2(f, + EJIT_ARG(-0x7fffffff, long), + EJIT_ARG(61, long)) == 0x2000000000000000); + + assert(erf2(f, + EJIT_ARG(0x80000001, long), + EJIT_ARG(60, long)) == 0x1000000000000000); + + assert(erf2(f, + EJIT_ARG(0x81, long), + EJIT_ARG(48, long)) == 0x81000000000000); + + assert(erf2(f, + EJIT_ARG(0x8001, long), + EJIT_ARG(49, long)) == 0x2000000000000); + + assert(erf2(f, + EJIT_ARG(0x80000001, long), + EJIT_ARG(40, long)) == 0x10000000000); + + assert(erf2(f, + EJIT_ARG(0xff, long), + EJIT_ARG(47, long)) == 0x7f800000000000); + + assert(erf2(f, + EJIT_ARG(0xffff0001, long), + EJIT_ARG(56, long)) == 0x100000000000000); + + assert(erf2(f, + EJIT_ARG(0xffffffff, long), + EJIT_ARG(40, long)) == (int64_t)0xffffff0000000000); + + assert(erf2(f, + EJIT_ARG(0x7fffffffff, long), + EJIT_ARG(33, long)) == (int64_t)0xfffffffe00000000); + + assert(erf2(f, + EJIT_ARG(-0x7fffffffff, long), + EJIT_ARG(63, long)) == (int64_t)0x8000000000000000); + + assert(erf2(f, + EJIT_ARG(0x8000000001, long), + EJIT_ARG(48, long)) == 0x1000000000000); + + assert(erf2(f, + EJIT_ARG(0xffffffffff, long), + EJIT_ARG(47, long)) == (int64_t)0xffff800000000000); + + ejit_destroy_func(f); } diff --git a/tests/ltr.c b/tests/ltr.c index 2deb6ae..85f7af0 100644 --- a/tests/ltr.c +++ b/tests/ltr.c @@ -5,7 +5,7 @@ int main() { struct ejit_operand operands[2] = { - EJIT_OPERAND_GPR(0, EJIT_TYPE(long)) + EJIT_OPERAND_GPR(0, EJIT_TYPE(long)), EJIT_OPERAND_GPR(1, EJIT_TYPE(long)) }; diff --git a/tests/ltr_f.c b/tests/ltr_f.c index 5e5a98b..f925c4f 100644 --- a/tests/ltr_f.c +++ b/tests/ltr_f.c @@ -5,7 +5,7 @@ int main() { struct ejit_operand operands[2] = { - EJIT_OPERAND_FPR(0, EJIT_TYPE(double)) + EJIT_OPERAND_FPR(0, EJIT_TYPE(double)), EJIT_OPERAND_FPR(1, EJIT_TYPE(double)) }; diff --git a/tests/mov_addr.c b/tests/mov_addr.c deleted file mode 100644 index 01a0e7e..0000000 --- a/tests/mov_addr.c +++ /dev/null @@ -1,25 +0,0 @@ -#include "test.h" - -static uint64_t thing = 0x123456789abcdef0; - -static void -run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) -{ - jit_begin(j, arena_base, arena_size); - size_t align = jit_enter_jit_abi(j, 0, 0, 0); - - jit_patch_there(j, jit_mov_addr(j, JIT_R0), &thing); - jit_leave_jit_abi(j, 0, 0, align); - jit_retr(j, JIT_R0); - - void* (*f)(void) = jit_end(j, NULL); - - ASSERT(f() == &thing); - ASSERT(*(uint64_t*)f() == thing); -} - -int -main (int argc, char *argv[]) -{ - return main_helper(argc, argv, run_test); -} -- cgit v1.2.3