From 1178631ed4221f6c0bd1b611e5b3b530377bd7ab Mon Sep 17 00:00:00 2001 From: Anthony Pesch Date: Mon, 3 Jul 2017 11:47:41 -0400 Subject: [PATCH] use c-style casts in x64 backend --- src/jit/backend/x64/x64_backend.cc | 58 ++++++++++----------- src/jit/backend/x64/x64_emitters.cc | 80 ++++++++++++++--------------- src/jit/backend/x64/x64_local.h | 9 ++-- 3 files changed, 72 insertions(+), 75 deletions(-) diff --git a/src/jit/backend/x64/x64_backend.cc b/src/jit/backend/x64/x64_backend.cc index 770fcf84..9879cbd2 100644 --- a/src/jit/backend/x64/x64_backend.cc +++ b/src/jit/backend/x64/x64_backend.cc @@ -94,12 +94,10 @@ const int x64_num_registers = array_size(x64_registers); const Xbyak::Reg x64_backend_reg(struct x64_backend *backend, const struct ir_value *v) { - auto &e = *backend->codegen; - int i = v->reg; CHECK_NE(i, NO_REGISTER); - Xbyak::Reg reg = *reinterpret_cast(x64_registers[i].data); + Xbyak::Reg reg = *(const Xbyak::Reg *)x64_registers[i].data; CHECK(reg.isREG()); switch (v->type) { @@ -125,8 +123,6 @@ const Xbyak::Reg x64_backend_reg(struct x64_backend *backend, const Xbyak::Xmm x64_backend_xmm(struct x64_backend *backend, const struct ir_value *v) { - auto &e = *backend->codegen; - int i = v->reg; CHECK_NE(i, NO_REGISTER); @@ -138,41 +134,41 @@ const Xbyak::Xmm x64_backend_xmm(struct x64_backend *backend, void x64_backend_load_mem(struct x64_backend *backend, const struct ir_value *dst, - const Xbyak::RegExp &srcExp) { + const Xbyak::RegExp &src_exp) { auto &e = *backend->codegen; switch (dst->type) { case VALUE_I8: - e.mov(x64_backend_reg(backend, dst), e.byte[srcExp]); + e.mov(x64_backend_reg(backend, dst), e.byte[src_exp]); break; case VALUE_I16: - e.mov(x64_backend_reg(backend, dst), e.word[srcExp]); + e.mov(x64_backend_reg(backend, dst), e.word[src_exp]); break; case VALUE_I32: - e.mov(x64_backend_reg(backend, dst), e.dword[srcExp]); + e.mov(x64_backend_reg(backend, dst), e.dword[src_exp]); break; case VALUE_I64: - e.mov(x64_backend_reg(backend, dst), e.qword[srcExp]); + e.mov(x64_backend_reg(backend, dst), e.qword[src_exp]); break; case VALUE_F32: if (X64_USE_AVX) { - e.vmovss(x64_backend_xmm(backend, dst), e.dword[srcExp]); + e.vmovss(x64_backend_xmm(backend, dst), e.dword[src_exp]); } else { - e.movss(x64_backend_xmm(backend, dst), e.dword[srcExp]); + e.movss(x64_backend_xmm(backend, dst), e.dword[src_exp]); } break; case VALUE_F64: if (X64_USE_AVX) { - e.vmovsd(x64_backend_xmm(backend, dst), e.qword[srcExp]); + e.vmovsd(x64_backend_xmm(backend, dst), e.qword[src_exp]); } else { - e.movsd(x64_backend_xmm(backend, dst), e.qword[srcExp]); + e.movsd(x64_backend_xmm(backend, dst), e.qword[src_exp]); } break; case VALUE_V128: if (X64_USE_AVX) { - e.vmovups(x64_backend_xmm(backend, dst), e.ptr[srcExp]); + e.vmovups(x64_backend_xmm(backend, dst), e.ptr[src_exp]); } else { - e.movups(x64_backend_xmm(backend, dst), e.ptr[srcExp]); + e.movups(x64_backend_xmm(backend, dst), e.ptr[src_exp]); } break; default: @@ -182,25 +178,25 @@ void x64_backend_load_mem(struct x64_backend *backend, } void x64_backend_store_mem(struct x64_backend *backend, - const Xbyak::RegExp &dstExp, + const Xbyak::RegExp &dst_exp, const struct ir_value *src) { auto &e = *backend->codegen; if (ir_is_constant(src)) { switch (src->type) { case VALUE_I8: - e.mov(e.byte[dstExp], src->i8); + e.mov(e.byte[dst_exp], src->i8); break; case VALUE_I16: - e.mov(e.word[dstExp], src->i16); + e.mov(e.word[dst_exp], src->i16); break; case VALUE_I32: case VALUE_F32: - e.mov(e.dword[dstExp], src->i32); + e.mov(e.dword[dst_exp], src->i32); break; case VALUE_I64: case VALUE_F64: - e.mov(e.qword[dstExp], src->i64); + e.mov(e.qword[dst_exp], src->i64); break; default: LOG_FATAL("unexpected value type"); @@ -211,36 +207,36 @@ void x64_backend_store_mem(struct x64_backend *backend, switch (src->type) { case VALUE_I8: - e.mov(e.byte[dstExp], x64_backend_reg(backend, src)); + e.mov(e.byte[dst_exp], x64_backend_reg(backend, src)); break; case VALUE_I16: - e.mov(e.word[dstExp], x64_backend_reg(backend, src)); + e.mov(e.word[dst_exp], x64_backend_reg(backend, src)); break; case VALUE_I32: - e.mov(e.dword[dstExp], x64_backend_reg(backend, src)); + e.mov(e.dword[dst_exp], x64_backend_reg(backend, src)); break; case VALUE_I64: - e.mov(e.qword[dstExp], x64_backend_reg(backend, src)); + e.mov(e.qword[dst_exp], x64_backend_reg(backend, src)); break; case VALUE_F32: if (X64_USE_AVX) { - e.vmovss(e.dword[dstExp], x64_backend_xmm(backend, src)); + e.vmovss(e.dword[dst_exp], x64_backend_xmm(backend, src)); } else { - e.movss(e.dword[dstExp], x64_backend_xmm(backend, src)); + e.movss(e.dword[dst_exp], x64_backend_xmm(backend, src)); } break; case VALUE_F64: if (X64_USE_AVX) { - e.vmovsd(e.qword[dstExp], x64_backend_xmm(backend, src)); + e.vmovsd(e.qword[dst_exp], x64_backend_xmm(backend, src)); } else { - e.movsd(e.qword[dstExp], x64_backend_xmm(backend, src)); + e.movsd(e.qword[dst_exp], x64_backend_xmm(backend, src)); } break; case VALUE_V128: if (X64_USE_AVX) { - e.vmovups(e.ptr[dstExp], x64_backend_xmm(backend, src)); + e.vmovups(e.ptr[dst_exp], x64_backend_xmm(backend, src)); } else { - e.movups(e.ptr[dstExp], x64_backend_xmm(backend, src)); + e.movups(e.ptr[dst_exp], x64_backend_xmm(backend, src)); } break; default: diff --git a/src/jit/backend/x64/x64_emitters.cc b/src/jit/backend/x64/x64_emitters.cc index 7a230e59..17146bac 100644 --- a/src/jit/backend/x64/x64_emitters.cc +++ b/src/jit/backend/x64/x64_emitters.cc @@ -5,26 +5,6 @@ extern "C" { #include "jit/jit.h" } -enum { - NONE = 0, - REG_ARG0 = JIT_REG_I64 | JIT_REUSE_ARG0, - REG_I64 = JIT_REG_I64, - REG_F64 = JIT_REG_F64, - REG_V128 = JIT_REG_V128, - REG_ALL = REG_I64 | REG_F64 | REG_V128, - IMM_I32 = JIT_IMM_I32, - IMM_I64 = JIT_IMM_I64, - IMM_F32 = JIT_IMM_F32, - IMM_F64 = JIT_IMM_F64, - IMM_ALL = IMM_I32 | IMM_I64 | IMM_F32 | IMM_F64, - VAL_I64 = REG_I64 | IMM_I64, - VAL_ALL = REG_ALL | IMM_ALL, - OPT = JIT_OPTIONAL, - OPT_I64 = OPT | VAL_I64, -}; - -struct jit_emitter x64_emitters[IR_NUM_OPS]; - #define EMITTER(op, constraints) \ void x64_emit_##op(struct x64_backend *, Xbyak::CodeGenerator &, \ const struct ir_instr *); \ @@ -59,6 +39,26 @@ struct jit_emitter x64_emitters[IR_NUM_OPS]; #define ARG2_XMM x64_backend_xmm(backend, ARG2) #define ARG3_XMM x64_backend_xmm(backend, ARG3) +enum { + NONE = 0, + REG_ARG0 = JIT_REG_I64 | JIT_REUSE_ARG0, + REG_I64 = JIT_REG_I64, + REG_F64 = JIT_REG_F64, + REG_V128 = JIT_REG_V128, + REG_ALL = REG_I64 | REG_F64 | REG_V128, + IMM_I32 = JIT_IMM_I32, + IMM_I64 = JIT_IMM_I64, + IMM_F32 = JIT_IMM_F32, + IMM_F64 = JIT_IMM_F64, + IMM_ALL = IMM_I32 | IMM_I64 | IMM_F32 | IMM_F64, + VAL_I64 = REG_I64 | IMM_I64, + VAL_ALL = REG_ALL | IMM_ALL, + OPT = JIT_OPTIONAL, + OPT_I64 = OPT | VAL_I64, +}; + +struct jit_emitter x64_emitters[IR_NUM_OPS]; + EMITTER(FALLBACK, CONSTRAINTS(NONE, IMM_I64, IMM_I32, IMM_I32)) { struct jit_guest *guest = backend->base.jit->guest; void *fallback = (void *)ARG0->i64; @@ -107,10 +107,10 @@ EMITTER(LOAD_GUEST, CONSTRAINTS(REG_ALL, REG_I64 | IMM_I32)) { int data_size = ir_type_size(RES->type); uint32_t data_mask = (1 << (data_size * 8)) - 1; - e.mov(arg0, reinterpret_cast(userdata)); + e.mov(arg0, (uint64_t)userdata); e.mov(arg1, offset); e.mov(arg2, data_mask); - e.call(reinterpret_cast(read)); + e.call((void *)read); e.mov(dst, e.rax); } } else { @@ -119,25 +119,25 @@ EMITTER(LOAD_GUEST, CONSTRAINTS(REG_ALL, REG_I64 | IMM_I32)) { void *fn = nullptr; switch (RES->type) { case VALUE_I8: - fn = reinterpret_cast(guest->r8); + fn = (void *)guest->r8; break; case VALUE_I16: - fn = reinterpret_cast(guest->r16); + fn = (void *)guest->r16; break; case VALUE_I32: - fn = reinterpret_cast(guest->r32); + fn = (void *)guest->r32; break; case VALUE_I64: - fn = reinterpret_cast(guest->r64); + fn = (void *)guest->r64; break; default: LOG_FATAL("unexpected load result type"); break; } - e.mov(arg0, reinterpret_cast(guest->space)); + e.mov(arg0, (uint64_t)guest->space); e.mov(arg1, ra); - e.call(reinterpret_cast(fn)); + e.call((void *)fn); e.mov(dst, e.rax); } } @@ -165,11 +165,11 @@ EMITTER(STORE_GUEST, CONSTRAINTS(NONE, REG_I64 | IMM_I32, VAL_ALL)) { int data_size = ir_type_size(data->type); uint32_t data_mask = (1 << (data_size * 8)) - 1; - e.mov(arg0, reinterpret_cast(userdata)); + e.mov(arg0, (uint64_t)userdata); e.mov(arg1, offset); e.mov(arg2, rb); e.mov(arg3, data_mask); - e.call(reinterpret_cast(write)); + e.call((void *)write); } } else { Xbyak::Reg ra = x64_backend_reg(backend, addr); @@ -177,26 +177,26 @@ EMITTER(STORE_GUEST, CONSTRAINTS(NONE, REG_I64 | IMM_I32, VAL_ALL)) { void *fn = nullptr; switch (data->type) { case VALUE_I8: - fn = reinterpret_cast(guest->w8); + fn = (void *)guest->w8; break; case VALUE_I16: - fn = reinterpret_cast(guest->w16); + fn = (void *)guest->w16; break; case VALUE_I32: - fn = reinterpret_cast(guest->w32); + fn = (void *)guest->w32; break; case VALUE_I64: - fn = reinterpret_cast(guest->w64); + fn = (void *)guest->w64; break; default: - LOG_FATAL("Unexpected store value type"); + LOG_FATAL("unexpected store value type"); break; } - e.mov(arg0, reinterpret_cast(guest->space)); + e.mov(arg0, (uint64_t)guest->space); e.mov(arg1, ra); x64_backend_mov_value(backend, arg2, data); - e.call(reinterpret_cast(fn)); + e.call((void *)fn); } } @@ -230,13 +230,13 @@ EMITTER(STORE_CONTEXT, CONSTRAINTS(NONE, IMM_I32, VAL_ALL)) { EMITTER(LOAD_LOCAL, CONSTRAINTS(REG_ALL, IMM_I32)) { struct ir_value *dst = RES; - int offset = X64_STACK_OFFSET_LOCALS + ARG0->i32; + int offset = X64_STACK_LOCALS + ARG0->i32; x64_backend_load_mem(backend, dst, e.rsp + offset); } EMITTER(STORE_LOCAL, CONSTRAINTS(NONE, IMM_I32, VAL_ALL)) { - int offset = X64_STACK_OFFSET_LOCALS + ARG0->i32; + int offset = X64_STACK_LOCALS + ARG0->i32; struct ir_value *data = ARG1; x64_backend_store_mem(backend, e.rsp + offset, data); @@ -381,7 +381,7 @@ EMITTER(CMP, CONSTRAINTS(REG_I64, REG_I64, REG_I64 | IMM_I32, IMM_I32)) { Xbyak::Reg ra = ARG0_REG; if (ir_is_constant(ARG1)) { - e.cmp(ra, static_cast(ir_zext_constant(ARG1))); + e.cmp(ra, (uint32_t)ir_zext_constant(ARG1)); } else { Xbyak::Reg rb = ARG1_REG; e.cmp(ra, rb); diff --git a/src/jit/backend/x64/x64_local.h b/src/jit/backend/x64/x64_local.h index 9fc07382..d6fc0c7a 100644 --- a/src/jit/backend/x64/x64_local.h +++ b/src/jit/backend/x64/x64_local.h @@ -50,14 +50,15 @@ struct x64_backend { * backend functionality used by emitters */ #define X64_THUNK_SIZE 1024 +#define X64_STACK_SIZE 1024 #if PLATFORM_WINDOWS #define X64_STACK_SHADOW_SPACE 32 #else #define X64_STACK_SHADOW_SPACE 0 #endif -#define X64_STACK_OFFSET_LOCALS (X64_STACK_SHADOW_SPACE + 8) -#define X64_STACK_SIZE 1024 + +#define X64_STACK_LOCALS (X64_STACK_SHADOW_SPACE + 8) #define X64_USE_AVX backend->use_avx @@ -78,9 +79,9 @@ const Xbyak::Xmm x64_backend_xmm(struct x64_backend *backend, const struct ir_value *v); void x64_backend_load_mem(struct x64_backend *backend, const struct ir_value *dst, - const Xbyak::RegExp &srcExp); + const Xbyak::RegExp &src_exp); void x64_backend_store_mem(struct x64_backend *backend, - const Xbyak::RegExp &dstExp, + const Xbyak::RegExp &dst_exp, const struct ir_value *src); void x64_backend_mov_value(struct x64_backend *backend, Xbyak::Reg dst, const struct ir_value *v);