X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=source%2Fmupen64plus-core%2Fsrc%2Fr4300%2Fx86_64%2Fassemble.c;fp=source%2Fmupen64plus-core%2Fsrc%2Fr4300%2Fx86_64%2Fassemble.c;h=eabb136752ea99d1819c0680b2fdd14fc8cb5d52;hb=451ab91e3827a6384981b3300e2a7000d2eaba58;hp=0000000000000000000000000000000000000000;hpb=a2ab25365b5b0dddbee476d695d8a31151407581;p=mupen64plus-pandora.git diff --git a/source/mupen64plus-core/src/r4300/x86_64/assemble.c b/source/mupen64plus-core/src/r4300/x86_64/assemble.c new file mode 100644 index 0000000..eabb136 --- /dev/null +++ b/source/mupen64plus-core/src/r4300/x86_64/assemble.c @@ -0,0 +1,219 @@ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * Mupen64plus - assemble.c * + * Mupen64Plus homepage: http://code.google.com/p/mupen64plus/ * + * Copyright (C) 2007 Richard Goedeken (Richard42) * + * Copyright (C) 2002 Hacktarux * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the * + * Free Software Foundation, Inc., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + +#include +#include + +#include "assemble.h" + +#include "api/m64p_types.h" +#include "api/callbacks.h" +#include "r4300/recomph.h" +#include "r4300/recomp.h" +#include "r4300/r4300.h" + +/* Placeholder for RIP-relative offsets is maxmimum 32-bit signed value. + * So, if recompiled code is run without running passe2() first, it will + * cause an exception. +*/ +#define REL_PLACEHOLDER 0x7fffffff + +typedef struct _jump_table +{ + unsigned int mi_addr; + unsigned int pc_addr; + unsigned int absolute64; +} jump_table; + +static jump_table *jumps_table = NULL; +static int jumps_number = 0, max_jumps_number = 0; + +typedef struct _riprelative_table +{ + unsigned int pc_addr; /* index in bytes from start of x86_64 code block to the displacement value to write */ + unsigned int extra_bytes; /* number of remaining instruction bytes (immediate data) after 4-byte displacement */ + unsigned char *global_dst; /* 64-bit pointer to the data object */ +} riprelative_table; + +static riprelative_table *riprel_table = NULL; +static int riprel_number = 0, max_riprel_number = 0; + +/* Static Functions */ + +void add_jump(unsigned int pc_addr, unsigned int mi_addr, unsigned int absolute64) +{ + if (jumps_number == max_jumps_number) + { + max_jumps_number += 512; + jumps_table = realloc(jumps_table, max_jumps_number*sizeof(jump_table)); + } + jumps_table[jumps_number].pc_addr = pc_addr; + jumps_table[jumps_number].mi_addr = mi_addr; + jumps_table[jumps_number].absolute64 = absolute64; + jumps_number++; +} + +/* Global Functions */ + +void init_assembler(void *block_jumps_table, int block_jumps_number, void *block_riprel_table, int block_riprel_number) +{ + if (block_jumps_table) + { + jumps_table = block_jumps_table; + jumps_number = block_jumps_number; + if (jumps_number <= 512) + max_jumps_number = 512; + else + max_jumps_number = (jumps_number + 511) & 0xfffffe00; + } + else + { + jumps_table = malloc(512*sizeof(jump_table)); + jumps_number = 0; + max_jumps_number = 512; + } + + if (block_riprel_table) + { + riprel_table = block_riprel_table; + riprel_number = block_riprel_number; + if (riprel_number <= 512) + max_riprel_number = 512; + else + max_riprel_number = (riprel_number + 511) & 0xfffffe00; + } + else + { + riprel_table = malloc(512 * sizeof(riprelative_table)); + riprel_number = 0; + max_riprel_number = 512; + } +} + +void free_assembler(void **block_jumps_table, int *block_jumps_number, void **block_riprel_table, int *block_riprel_number) +{ + *block_jumps_table = jumps_table; + *block_jumps_number = jumps_number; + *block_riprel_table = riprel_table; + *block_riprel_number = riprel_number; +} + +void passe2(precomp_instr *dest, int start, int end, precomp_block *block) +{ + unsigned int i; + + build_wrappers(dest, start, end, block); + + /* First, fix up all the jumps. This involves a table lookup to find the offset into the block of x86_64 code for + * for start of a recompiled r4300i instruction corresponding to the given jump destination address in the N64 + * address space. Next, the relative offset between this destination and the location of the jump instruction is + * computed and stored in memory, so that the jump will branch to the right place in the recompiled code. + */ + for (i = 0; i < jumps_number; i++) + { + precomp_instr *jump_instr = dest + ((jumps_table[i].mi_addr - dest[0].addr) / 4); + unsigned int jmp_offset_loc = jumps_table[i].pc_addr; + unsigned char *addr_dest = NULL; + /* calculate the destination address to jump to */ + if (jump_instr->reg_cache_infos.need_map) + { + addr_dest = jump_instr->reg_cache_infos.jump_wrapper; + } + else + { + addr_dest = block->code + jump_instr->local_addr; + } + /* write either a 32-bit IP-relative offset or a 64-bit absolute address */ + if (jumps_table[i].absolute64) + { + *((unsigned long long *) (block->code + jmp_offset_loc)) = (unsigned long long) addr_dest; + } + else + { + long jump_rel_offset = (long) (addr_dest - (block->code + jmp_offset_loc + 4)); + *((int *) (block->code + jmp_offset_loc)) = (int) jump_rel_offset; + if (jump_rel_offset >= 0x7fffffffLL || jump_rel_offset < -0x80000000LL) + { + DebugMessage(M64MSG_ERROR, "assembler pass2 error: offset too big for relative jump from %p to %p", + (block->code + jmp_offset_loc + 4), addr_dest); + asm(" int $3; "); + } + } + } + + /* Next, fix up all of the RIP-relative memory accesses. This is unique to the x86_64 architecture, because + * the 32-bit absolute displacement addressing mode is not available (and there's no 64-bit absolute displacement + * mode either). + */ + for (i = 0; i < riprel_number; i++) + { + unsigned char *rel_offset_ptr = block->code + riprel_table[i].pc_addr; + long rip_rel_offset = (long) (riprel_table[i].global_dst - (rel_offset_ptr + 4 + riprel_table[i].extra_bytes)); + if (rip_rel_offset >= 0x7fffffffLL || rip_rel_offset < -0x80000000LL) + { + DebugMessage(M64MSG_ERROR, "assembler pass2 error: offset too big between mem target: %p and code position: %p", + riprel_table[i].global_dst, rel_offset_ptr); + asm(" int $3; "); + } + *((int *) rel_offset_ptr) = (int) rip_rel_offset; + } + +} + +static unsigned int g_jump_start8 = 0; +static unsigned int g_jump_start32 = 0; + +void jump_start_rel8(void) +{ + g_jump_start8 = code_length; +} + +void jump_start_rel32(void) +{ + g_jump_start32 = code_length; +} + +void jump_end_rel8(void) +{ + unsigned int jump_end = code_length; + int jump_vec = jump_end - g_jump_start8; + + if (jump_vec > 127 || jump_vec < -128) + { + DebugMessage(M64MSG_ERROR, "Error: 8-bit relative jump too long! From %x to %x", g_jump_start8, jump_end); + asm(" int $3; "); + } + + code_length = g_jump_start8 - 1; + put8(jump_vec); + code_length = jump_end; +} + +void jump_end_rel32(void) +{ + unsigned int jump_end = code_length; + int jump_vec = jump_end - g_jump_start32; + + code_length = g_jump_start32 - 4; + put32(jump_vec); + code_length = jump_end; +}