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

don't copy jit memory interface struct

This commit is contained in:
Anthony Pesch 2016-07-08 00:09:20 -07:00
parent 0907a66cd5
commit b32ffe7a68
6 changed files with 45 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
src/hw/sh4/sh4.c
View File

@ -11,7 +11,6 @@
#include "hw/memory.h"
#include "hw/scheduler.h"
#include "hw/sh4/sh4_code_cache.h"
#include "jit/backend/backend.h"
#include "jit/frontend/sh4/sh4_analyze.h"
#include "sys/time.h"
#include "ui/nuklear.h"
@ -703,19 +702,19 @@ static bool sh4_init(struct device *dev) {
sh4->scheduler = dc->scheduler;
sh4->space = sh4->base.memory->space;
struct jit_memory_interface memory_if = {
&sh4->ctx,
sh4->base.memory->space->protected_base,
sh4->base.memory->space,
&as_read8,
&as_read16,
&as_read32,
&as_read64,
&as_write8,
&as_write16,
&as_write32,
&as_write64};
sh4->code_cache = sh4_cache_create(&memory_if, &sh4_compile_pc);
sh4->memory_if =
(struct jit_memory_interface){&sh4->ctx,
sh4->base.memory->space->protected_base,
sh4->base.memory->space,
&as_read8,
&as_read16,
&as_read32,
&as_read64,
&as_write8,
&as_write16,
&as_write32,
&as_write64};
sh4->code_cache = sh4_cache_create(&sh4->memory_if, &sh4_compile_pc);
// initialize context
sh4->ctx.sh4 = sh4;

2
src/hw/sh4/sh4.h
View File

@ -4,6 +4,7 @@
#include "hw/dreamcast.h"
#include "hw/memory.h"
#include "hw/sh4/sh4_types.h"
#include "jit/backend/backend.h"
#include "jit/frontend/sh4/sh4_context.h"
struct dreamcast;
@ -37,6 +38,7 @@ struct sh4 {
struct scheduler *scheduler;
struct address_space *space;
struct jit_memory_interface memory_if;
struct sh4_cache *code_cache;
struct sh4_ctx ctx;
uint8_t cache[0x2000]; // 8kb cache

2
src/hw/sh4/sh4_code_cache.c
View File

@ -281,7 +281,7 @@ code_pointer_t sh4_cache_compile_code(struct sh4_cache *cache,
return code;
}
struct sh4_cache *sh4_cache_create(const struct jit_memory_interface *memory_if,
struct sh4_cache *sh4_cache_create(struct jit_memory_interface *memory_if,
code_pointer_t default_code) {
struct sh4_cache *cache = calloc(1, sizeof(struct sh4_cache));

2
src/hw/sh4/sh4_code_cache.h
View File

@ -57,7 +57,7 @@ code_pointer_t sh4_cache_compile_code(struct sh4_cache *cache,
uint32_t guest_addr, uint8_t *guest_ptr,
int flags);
struct sh4_cache *sh4_cache_create(const struct jit_memory_interface *memory_if,
struct sh4_cache *sh4_cache_create(struct jit_memory_interface *memory_if,
code_pointer_t default_code);
void sh4_cache_destroy(struct sh4_cache *cache);

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

@ -151,7 +151,7 @@ enum xmm_constant {
struct x64_backend {
struct jit_backend base;
struct jit_memory_interface memory_if;
struct jit_memory_interface *memory_if;
Xbyak::CodeGenerator *codegen;
csh capstone_handle;
@ -351,8 +351,8 @@ static void x64_backend_emit_prolog(struct x64_backend *backend, struct ir *ir,
e.sub(e.rsp, stack_size);
// copy guest context and memory base to argument registers
e.mov(e.r14, reinterpret_cast<uint64_t>(backend->memory_if.ctx_base));
e.mov(e.r15, reinterpret_cast<uint64_t>(backend->memory_if.mem_base));
e.mov(e.r14, reinterpret_cast<uint64_t>(backend->memory_if->ctx_base));
e.mov(e.r15, reinterpret_cast<uint64_t>(backend->memory_if->mem_base));
*out_stack_size = stack_size;
}
@ -518,7 +518,7 @@ static bool x64_backend_handle_exception(struct jit_backend *base,
// figure out the guest address that was being accessed
const uint8_t *fault_addr = reinterpret_cast<const uint8_t *>(ex->fault_addr);
const uint8_t *protected_start =
reinterpret_cast<const uint8_t *>(backend->memory_if.mem_base);
reinterpret_cast<const uint8_t *>(backend->memory_if->mem_base);
uint32_t guest_addr = static_cast<uint32_t>(fault_addr - protected_start);
// instead of handling the dynamic callback from inside of the exception
@ -537,26 +537,26 @@ static bool x64_backend_handle_exception(struct jit_backend *base,
if (mov.is_load) {
// prep argument registers (memory object, guest_addr) for read function
ex->thread_state.r[x64_arg0_idx] =
reinterpret_cast<uint64_t>(backend->memory_if.mem_self);
reinterpret_cast<uint64_t>(backend->memory_if->mem_self);
ex->thread_state.r[x64_arg1_idx] = static_cast<uint64_t>(guest_addr);
// prep function call address for thunk
switch (mov.operand_size) {
case 1:
ex->thread_state.rax =
reinterpret_cast<uint64_t>(backend->memory_if.r8);
reinterpret_cast<uint64_t>(backend->memory_if->r8);
break;
case 2:
ex->thread_state.rax =
reinterpret_cast<uint64_t>(backend->memory_if.r16);
reinterpret_cast<uint64_t>(backend->memory_if->r16);
break;
case 4:
ex->thread_state.rax =
reinterpret_cast<uint64_t>(backend->memory_if.r32);
reinterpret_cast<uint64_t>(backend->memory_if->r32);
break;
case 8:
ex->thread_state.rax =
reinterpret_cast<uint64_t>(backend->memory_if.r64);
reinterpret_cast<uint64_t>(backend->memory_if->r64);
break;
}
@ -567,7 +567,7 @@ static bool x64_backend_handle_exception(struct jit_backend *base,
// prep argument registers (memory object, guest_addr, value) for write
// function
ex->thread_state.r[x64_arg0_idx] =
reinterpret_cast<uint64_t>(backend->memory_if.mem_self);
reinterpret_cast<uint64_t>(backend->memory_if->mem_self);
ex->thread_state.r[x64_arg1_idx] = static_cast<uint64_t>(guest_addr);
ex->thread_state.r[x64_arg2_idx] = ex->thread_state.r[mov.reg];
@ -575,19 +575,19 @@ static bool x64_backend_handle_exception(struct jit_backend *base,
switch (mov.operand_size) {
case 1:
ex->thread_state.rax =
reinterpret_cast<uint64_t>(backend->memory_if.w8);
reinterpret_cast<uint64_t>(backend->memory_if->w8);
break;
case 2:
ex->thread_state.rax =
reinterpret_cast<uint64_t>(backend->memory_if.w16);
reinterpret_cast<uint64_t>(backend->memory_if->w16);
break;
case 4:
ex->thread_state.rax =
reinterpret_cast<uint64_t>(backend->memory_if.w32);
reinterpret_cast<uint64_t>(backend->memory_if->w32);
break;
case 8:
ex->thread_state.rax =
reinterpret_cast<uint64_t>(backend->memory_if.w64);
reinterpret_cast<uint64_t>(backend->memory_if->w64);
break;
}
@ -731,23 +731,23 @@ EMITTER(LOAD_SLOW) {
void *fn = nullptr;
switch (instr->result->type) {
case VALUE_I8:
fn = reinterpret_cast<void *>(backend->memory_if.r8);
fn = reinterpret_cast<void *>(backend->memory_if->r8);
break;
case VALUE_I16:
fn = reinterpret_cast<void *>(backend->memory_if.r16);
fn = reinterpret_cast<void *>(backend->memory_if->r16);
break;
case VALUE_I32:
fn = reinterpret_cast<void *>(backend->memory_if.r32);
fn = reinterpret_cast<void *>(backend->memory_if->r32);
break;
case VALUE_I64:
fn = reinterpret_cast<void *>(backend->memory_if.r64);
fn = reinterpret_cast<void *>(backend->memory_if->r64);
break;
default:
LOG_FATAL("Unexpected load result type");
break;
}
e.mov(arg0, reinterpret_cast<uint64_t>(backend->memory_if.mem_self));
e.mov(arg0, reinterpret_cast<uint64_t>(backend->memory_if->mem_self));
e.mov(arg1, a);
e.call(reinterpret_cast<void *>(fn));
e.mov(result, e.rax);
@ -760,23 +760,23 @@ EMITTER(STORE_SLOW) {
void *fn = nullptr;
switch (instr->arg[1]->type) {
case VALUE_I8:
fn = reinterpret_cast<void *>(backend->memory_if.w8);
fn = reinterpret_cast<void *>(backend->memory_if->w8);
break;
case VALUE_I16:
fn = reinterpret_cast<void *>(backend->memory_if.w16);
fn = reinterpret_cast<void *>(backend->memory_if->w16);
break;
case VALUE_I32:
fn = reinterpret_cast<void *>(backend->memory_if.w32);
fn = reinterpret_cast<void *>(backend->memory_if->w32);
break;
case VALUE_I64:
fn = reinterpret_cast<void *>(backend->memory_if.w64);
fn = reinterpret_cast<void *>(backend->memory_if->w64);
break;
default:
LOG_FATAL("Unexpected store value type");
break;
}
e.mov(arg0, reinterpret_cast<uint64_t>(backend->memory_if.mem_self));
e.mov(arg0, reinterpret_cast<uint64_t>(backend->memory_if->mem_self));
e.mov(arg1, a);
e.mov(arg2, b);
e.call(reinterpret_cast<void *>(fn));
@ -1648,7 +1648,7 @@ EMITTER(BRANCH_COND) {
EMITTER(CALL_EXTERNAL) {
const Xbyak::Reg addr = x64_backend_register(backend, instr->arg[0]);
e.mov(arg0, reinterpret_cast<uint64_t>(backend->memory_if.ctx_base));
e.mov(arg0, reinterpret_cast<uint64_t>(backend->memory_if->ctx_base));
if (instr->arg[1]) {
const Xbyak::Reg arg = x64_backend_register(backend, instr->arg[1]);
e.mov(arg1, arg);
@ -1657,8 +1657,7 @@ EMITTER(CALL_EXTERNAL) {
e.call(e.rax);
}
struct jit_backend *x64_backend_create(
const struct jit_memory_interface *memory_if) {
struct jit_backend *x64_backend_create(struct jit_memory_interface *memory_if) {
struct x64_backend *backend = reinterpret_cast<struct x64_backend *>(
calloc(1, sizeof(struct x64_backend)));
@ -1669,7 +1668,7 @@ struct jit_backend *x64_backend_create(
backend->base.dump_code = &x64_backend_dump_code;
backend->base.handle_exception = &x64_backend_handle_exception;
backend->memory_if = *memory_if;
backend->memory_if = memory_if;
backend->codegen = new Xbyak::CodeGenerator(x64_code_size, x64_code);

3
src/jit/backend/x64/x64_backend.h
View File

@ -6,8 +6,7 @@
extern const struct jit_register x64_registers[];
extern const int x64_num_registers;
struct jit_backend *x64_backend_create(
const struct jit_memory_interface *memory_if);
struct jit_backend *x64_backend_create(struct jit_memory_interface *memory_if);
void x64_backend_destroy(struct jit_backend *b);
#endif