ShuriZma
/
redream
mirror of https://github.com/inolen/redream.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

use c-style casts in x64 backend

This commit is contained in:
Anthony Pesch 2017-07-03 11:47:41 -04:00
parent 74710d15b6
commit 1178631ed4
3 changed files with 72 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
src/jit/backend/x64/x64_backend.cc
View File

@ -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<const Xbyak::Reg *>(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:

80
src/jit/backend/x64/x64_emitters.cc
View File

@ -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<uint64_t>(userdata));
e.mov(arg0, (uint64_t)userdata);
e.mov(arg1, offset);
e.mov(arg2, data_mask);
e.call(reinterpret_cast<void *>(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<void *>(guest->r8);
fn = (void *)guest->r8;
break;
case VALUE_I16:
fn = reinterpret_cast<void *>(guest->r16);
fn = (void *)guest->r16;
break;
case VALUE_I32:
fn = reinterpret_cast<void *>(guest->r32);
fn = (void *)guest->r32;
break;
case VALUE_I64:
fn = reinterpret_cast<void *>(guest->r64);
fn = (void *)guest->r64;
break;
default:
LOG_FATAL("unexpected load result type");
break;
}
e.mov(arg0, reinterpret_cast<uint64_t>(guest->space));
e.mov(arg0, (uint64_t)guest->space);
e.mov(arg1, ra);
e.call(reinterpret_cast<void *>(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<uint64_t>(userdata));
e.mov(arg0, (uint64_t)userdata);
e.mov(arg1, offset);
e.mov(arg2, rb);
e.mov(arg3, data_mask);
e.call(reinterpret_cast<void *>(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<void *>(guest->w8);
fn = (void *)guest->w8;
break;
case VALUE_I16:
fn = reinterpret_cast<void *>(guest->w16);
fn = (void *)guest->w16;
break;
case VALUE_I32:
fn = reinterpret_cast<void *>(guest->w32);
fn = (void *)guest->w32;
break;
case VALUE_I64:
fn = reinterpret_cast<void *>(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<uint64_t>(guest->space));
e.mov(arg0, (uint64_t)guest->space);
e.mov(arg1, ra);
x64_backend_mov_value(backend, arg2, data);
e.call(reinterpret_cast<void *>(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<uint32_t>(ir_zext_constant(ARG1)));
e.cmp(ra, (uint32_t)ir_zext_constant(ARG1));
} else {
Xbyak::Reg rb = ARG1_REG;
e.cmp(ra, rb);

9
src/jit/backend/x64/x64_local.h
View File

@ -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);