repos/blastem: backend_x86.c annotate

annotate backend_x86.c @ 2131:d90d92ce5cab

Improve CDC decode timing accuracy

author	Michael Pavone <pavone@retrodev.com>
date	Wed, 16 Mar 2022 00:16:36 -0700
parents	0013362c320c
children	8554751f17b5

rev	line source
567 8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	1 #include "backend.h"
8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	2 #include "gen_x86.h"
1465 5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	3 #include <string.h>
567 8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	4
8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	5 void cycles(cpu_options *opts, uint32_t num)
8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	6 {
1047 6b07af1515b5 Change cycle tracking code for Z80 core to only use a single register. Store low 7 bits of R in a reg and increment it appropriately. Michael Pavone <pavone@retrodev.com> parents: 987 diff changeset	7 if (opts->limit < 0) {
6b07af1515b5 Change cycle tracking code for Z80 core to only use a single register. Store low 7 bits of R in a reg and increment it appropriately. Michael Pavone <pavone@retrodev.com> parents: 987 diff changeset	8 sub_ir(&opts->code, num*opts->clock_divider, opts->cycles, SZ_D);
6b07af1515b5 Change cycle tracking code for Z80 core to only use a single register. Store low 7 bits of R in a reg and increment it appropriately. Michael Pavone <pavone@retrodev.com> parents: 987 diff changeset	9 } else {
6b07af1515b5 Change cycle tracking code for Z80 core to only use a single register. Store low 7 bits of R in a reg and increment it appropriately. Michael Pavone <pavone@retrodev.com> parents: 987 diff changeset	10 add_ir(&opts->code, num*opts->clock_divider, opts->cycles, SZ_D);
6b07af1515b5 Change cycle tracking code for Z80 core to only use a single register. Store low 7 bits of R in a reg and increment it appropriately. Michael Pavone <pavone@retrodev.com> parents: 987 diff changeset	11 }
567 8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	12 }
8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	13
8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	14 void check_cycles_int(cpu_options *opts, uint32_t address)
8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	15 {
8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	16 code_info *code = &opts->code;
1109 4bc27caa6e20 Fix a subtle bug in interrupt handling introduced with the move to a single cycle register in the Z80 core. Fixes regression in Puyo Puyo 2 Michael Pavone <pavone@retrodev.com> parents: 1107 diff changeset	17 uint8_t cc;
1047 6b07af1515b5 Change cycle tracking code for Z80 core to only use a single register. Store low 7 bits of R in a reg and increment it appropriately. Michael Pavone <pavone@retrodev.com> parents: 987 diff changeset	18 if (opts->limit < 0) {
1109 4bc27caa6e20 Fix a subtle bug in interrupt handling introduced with the move to a single cycle register in the Z80 core. Fixes regression in Puyo Puyo 2 Michael Pavone <pavone@retrodev.com> parents: 1107 diff changeset	19 cmp_ir(code, 1, opts->cycles, SZ_D);
4bc27caa6e20 Fix a subtle bug in interrupt handling introduced with the move to a single cycle register in the Z80 core. Fixes regression in Puyo Puyo 2 Michael Pavone <pavone@retrodev.com> parents: 1107 diff changeset	20 cc = CC_NS;
1047 6b07af1515b5 Change cycle tracking code for Z80 core to only use a single register. Store low 7 bits of R in a reg and increment it appropriately. Michael Pavone <pavone@retrodev.com> parents: 987 diff changeset	21 } else {
6b07af1515b5 Change cycle tracking code for Z80 core to only use a single register. Store low 7 bits of R in a reg and increment it appropriately. Michael Pavone <pavone@retrodev.com> parents: 987 diff changeset	22 cmp_rr(code, opts->cycles, opts->limit, SZ_D);
1109 4bc27caa6e20 Fix a subtle bug in interrupt handling introduced with the move to a single cycle register in the Z80 core. Fixes regression in Puyo Puyo 2 Michael Pavone <pavone@retrodev.com> parents: 1107 diff changeset	23 cc = CC_A;
1047 6b07af1515b5 Change cycle tracking code for Z80 core to only use a single register. Store low 7 bits of R in a reg and increment it appropriately. Michael Pavone <pavone@retrodev.com> parents: 987 diff changeset	24 }
567 8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	25 code_ptr jmp_off = code->cur+1;
1109 4bc27caa6e20 Fix a subtle bug in interrupt handling introduced with the move to a single cycle register in the Z80 core. Fixes regression in Puyo Puyo 2 Michael Pavone <pavone@retrodev.com> parents: 1107 diff changeset	26 jcc(code, cc, jmp_off+1);
567 8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	27 mov_ir(code, address, opts->scratch1, SZ_D);
8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	28 call(code, opts->handle_cycle_limit_int);
8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	29 *jmp_off = code->cur - (jmp_off+1);
8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	30 }
8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	31
1465 5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	32 void retranslate_calc(cpu_options *opts)
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	33 {
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	34 code_info *code = &opts->code;
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	35 code_info tmp = *code;
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	36 uint8_t cc;
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	37 if (opts->limit < 0) {
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	38 cmp_ir(code, 1, opts->cycles, SZ_D);
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	39 cc = CC_NS;
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	40 } else {
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	41 cmp_rr(code, opts->cycles, opts->limit, SZ_D);
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	42 cc = CC_A;
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	43 }
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	44 jcc(code, cc, code->cur+2);
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	45 opts->move_pc_off = code->cur - tmp.cur;
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	46 mov_ir(code, 0x1234, opts->scratch1, SZ_D);
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	47 opts->move_pc_size = code->cur - tmp.cur - opts->move_pc_off;
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	48 *code = tmp;
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	49 }
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	50
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	51 void patch_for_retranslate(cpu_options *opts, code_ptr native_address, code_ptr handler)
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	52 {
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	53 if (!is_mov_ir(native_address)) {
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	54 //instruction is not already patched for either retranslation or a breakpoint
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	55 //copy original mov_ir instruction containing PC to beginning of native code area
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	56 memmove(native_address, native_address + opts->move_pc_off, opts->move_pc_size);
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	57 }
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	58 //jump to the retranslation handler
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	59 code_info tmp = {
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	60 .cur = native_address + opts->move_pc_size,
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	61 .last = native_address + 256,
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	62 .stack_off = 0
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	63 };
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	64 jmp(&tmp, handler);
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	65 }
5d41d0574863 Preserve original address when retranslating instructions instead of switching to the lowest alias Michael Pavone <pavone@retrodev.com> parents: 1145 diff changeset	66
567 8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	67 void check_cycles(cpu_options * opts)
8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	68 {
8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	69 code_info *code = &opts->code;
1109 4bc27caa6e20 Fix a subtle bug in interrupt handling introduced with the move to a single cycle register in the Z80 core. Fixes regression in Puyo Puyo 2 Michael Pavone <pavone@retrodev.com> parents: 1107 diff changeset	70 uint8_t cc;
1047 6b07af1515b5 Change cycle tracking code for Z80 core to only use a single register. Store low 7 bits of R in a reg and increment it appropriately. Michael Pavone <pavone@retrodev.com> parents: 987 diff changeset	71 if (opts->limit < 0) {
1109 4bc27caa6e20 Fix a subtle bug in interrupt handling introduced with the move to a single cycle register in the Z80 core. Fixes regression in Puyo Puyo 2 Michael Pavone <pavone@retrodev.com> parents: 1107 diff changeset	72 cmp_ir(code, 1, opts->cycles, SZ_D);
4bc27caa6e20 Fix a subtle bug in interrupt handling introduced with the move to a single cycle register in the Z80 core. Fixes regression in Puyo Puyo 2 Michael Pavone <pavone@retrodev.com> parents: 1107 diff changeset	73 cc = CC_NS;
1047 6b07af1515b5 Change cycle tracking code for Z80 core to only use a single register. Store low 7 bits of R in a reg and increment it appropriately. Michael Pavone <pavone@retrodev.com> parents: 987 diff changeset	74 } else {
6b07af1515b5 Change cycle tracking code for Z80 core to only use a single register. Store low 7 bits of R in a reg and increment it appropriately. Michael Pavone <pavone@retrodev.com> parents: 987 diff changeset	75 cmp_rr(code, opts->cycles, opts->limit, SZ_D);
1109 4bc27caa6e20 Fix a subtle bug in interrupt handling introduced with the move to a single cycle register in the Z80 core. Fixes regression in Puyo Puyo 2 Michael Pavone <pavone@retrodev.com> parents: 1107 diff changeset	76 cc = CC_A;
1047 6b07af1515b5 Change cycle tracking code for Z80 core to only use a single register. Store low 7 bits of R in a reg and increment it appropriately. Michael Pavone <pavone@retrodev.com> parents: 987 diff changeset	77 }
567 8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	78 check_alloc_code(code, MAX_INST_LEN*2);
8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	79 code_ptr jmp_off = code->cur+1;
1109 4bc27caa6e20 Fix a subtle bug in interrupt handling introduced with the move to a single cycle register in the Z80 core. Fixes regression in Puyo Puyo 2 Michael Pavone <pavone@retrodev.com> parents: 1107 diff changeset	80 jcc(code, cc, jmp_off+1);
567 8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	81 call(code, opts->handle_cycle_limit);
8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	82 *jmp_off = code->cur - (jmp_off+1);
8e395210f50f Refactor gen_x86 to use an interface more like gen_arm and to remove the need for the caller to decide whether an 8-bit or 32-bit displacement is needed in the rdisp functions. Update m68k_to_x86 to use the new version of the gen_x86 functions and do some minor refactoring there in the process Michael Pavone <pavone@retrodev.com> parents: diff changeset	83 }
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	84
697 7f96bd1cb1be Sync fixes and logging to fix more sync issues Michael Pavone <pavone@retrodev.com> parents: 692 diff changeset	85 void log_address(cpu_options opts, uint32_t address, char format)
7f96bd1cb1be Sync fixes and logging to fix more sync issues Michael Pavone <pavone@retrodev.com> parents: 692 diff changeset	86 {
7f96bd1cb1be Sync fixes and logging to fix more sync issues Michael Pavone <pavone@retrodev.com> parents: 692 diff changeset	87 code_info *code = &opts->code;
7f96bd1cb1be Sync fixes and logging to fix more sync issues Michael Pavone <pavone@retrodev.com> parents: 692 diff changeset	88 call(code, opts->save_context);
7f96bd1cb1be Sync fixes and logging to fix more sync issues Michael Pavone <pavone@retrodev.com> parents: 692 diff changeset	89 push_r(code, opts->context_reg);
7f96bd1cb1be Sync fixes and logging to fix more sync issues Michael Pavone <pavone@retrodev.com> parents: 692 diff changeset	90 mov_rr(code, opts->cycles, RDX, SZ_D);
7f96bd1cb1be Sync fixes and logging to fix more sync issues Michael Pavone <pavone@retrodev.com> parents: 692 diff changeset	91 mov_ir(code, (int64_t)format, RDI, SZ_PTR);
7f96bd1cb1be Sync fixes and logging to fix more sync issues Michael Pavone <pavone@retrodev.com> parents: 692 diff changeset	92 mov_ir(code, address, RSI, SZ_D);
7f96bd1cb1be Sync fixes and logging to fix more sync issues Michael Pavone <pavone@retrodev.com> parents: 692 diff changeset	93 call_args_abi(code, (code_ptr)printf, 3, RDI, RSI, RDX);
7f96bd1cb1be Sync fixes and logging to fix more sync issues Michael Pavone <pavone@retrodev.com> parents: 692 diff changeset	94 pop_r(code, opts->context_reg);
7f96bd1cb1be Sync fixes and logging to fix more sync issues Michael Pavone <pavone@retrodev.com> parents: 692 diff changeset	95 call(code, opts->load_context);
7f96bd1cb1be Sync fixes and logging to fix more sync issues Michael Pavone <pavone@retrodev.com> parents: 692 diff changeset	96 }
7f96bd1cb1be Sync fixes and logging to fix more sync issues Michael Pavone <pavone@retrodev.com> parents: 692 diff changeset	97
601 f0061e3d2ad9 Fix a few bugs introduced in the Z80 core from the adjustments to fit with the code gen refactor Michael Pavone <pavone@retrodev.com> parents: 595 diff changeset	98 void check_code_prologue(code_info *code)
f0061e3d2ad9 Fix a few bugs introduced in the Z80 core from the adjustments to fit with the code gen refactor Michael Pavone <pavone@retrodev.com> parents: 595 diff changeset	99 {
f0061e3d2ad9 Fix a few bugs introduced in the Z80 core from the adjustments to fit with the code gen refactor Michael Pavone <pavone@retrodev.com> parents: 595 diff changeset	100 check_alloc_code(code, MAX_INST_LEN*4);
f0061e3d2ad9 Fix a few bugs introduced in the Z80 core from the adjustments to fit with the code gen refactor Michael Pavone <pavone@retrodev.com> parents: 595 diff changeset	101 }
f0061e3d2ad9 Fix a few bugs introduced in the Z80 core from the adjustments to fit with the code gen refactor Michael Pavone <pavone@retrodev.com> parents: 595 diff changeset	102
593 5ef3fe516da9 Z80 core is sort of working again Michael Pavone <pavone@retrodev.com> parents: 590 diff changeset	103 code_ptr gen_mem_fun(cpu_options * opts, memmap_chunk const * memmap, uint32_t num_chunks, ftype fun_type, code_ptr *after_inc)
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	104 {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	105 code_info *code = &opts->code;
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	106 code_ptr start = code->cur;
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	107 check_cycles(opts);
987 1f09994e92c5 Initial stab at implementing address error exceptions. Need to fill in the value of IR, undefined bits of last stack frame word and properly deal with address errors that occur during exception processing. Michael Pavone <pavone@retrodev.com> parents: 894 diff changeset	108 uint8_t is_write = fun_type == WRITE_16 \|\| fun_type == WRITE_8;
1f09994e92c5 Initial stab at implementing address error exceptions. Need to fill in the value of IR, undefined bits of last stack frame word and properly deal with address errors that occur during exception processing. Michael Pavone <pavone@retrodev.com> parents: 894 diff changeset	109 uint8_t adr_reg = is_write ? opts->scratch2 : opts->scratch1;
1f09994e92c5 Initial stab at implementing address error exceptions. Need to fill in the value of IR, undefined bits of last stack frame word and properly deal with address errors that occur during exception processing. Michael Pavone <pavone@retrodev.com> parents: 894 diff changeset	110 uint8_t size = (fun_type == READ_16 \|\| fun_type == WRITE_16) ? SZ_W : SZ_B;
1f09994e92c5 Initial stab at implementing address error exceptions. Need to fill in the value of IR, undefined bits of last stack frame word and properly deal with address errors that occur during exception processing. Michael Pavone <pavone@retrodev.com> parents: 894 diff changeset	111 if (size != SZ_B && opts->align_error_mask) {
1f09994e92c5 Initial stab at implementing address error exceptions. Need to fill in the value of IR, undefined bits of last stack frame word and properly deal with address errors that occur during exception processing. Michael Pavone <pavone@retrodev.com> parents: 894 diff changeset	112 test_ir(code, opts->align_error_mask, adr_reg, SZ_D);
1f09994e92c5 Initial stab at implementing address error exceptions. Need to fill in the value of IR, undefined bits of last stack frame word and properly deal with address errors that occur during exception processing. Michael Pavone <pavone@retrodev.com> parents: 894 diff changeset	113 jcc(code, CC_NZ, is_write ? opts->handle_align_error_write : opts->handle_align_error_read);
1f09994e92c5 Initial stab at implementing address error exceptions. Need to fill in the value of IR, undefined bits of last stack frame word and properly deal with address errors that occur during exception processing. Michael Pavone <pavone@retrodev.com> parents: 894 diff changeset	114 }
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	115 cycles(opts, opts->bus_cycles);
590 ea80559c67cb WIP effort to update z80 core for code gen changes Michael Pavone <pavone@retrodev.com> parents: 589 diff changeset	116 if (after_inc) {
ea80559c67cb WIP effort to update z80 core for code gen changes Michael Pavone <pavone@retrodev.com> parents: 589 diff changeset	117 *after_inc = code->cur;
ea80559c67cb WIP effort to update z80 core for code gen changes Michael Pavone <pavone@retrodev.com> parents: 589 diff changeset	118 }
2054 8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	119
750 59b499f6b24f Fix handling of address mask in gen_mem_fun Michael Pavone <pavone@retrodev.com> parents: 697 diff changeset	120 if (opts->address_size == SZ_D && opts->address_mask != 0xFFFFFFFF) {
59b499f6b24f Fix handling of address mask in gen_mem_fun Michael Pavone <pavone@retrodev.com> parents: 697 diff changeset	121 and_ir(code, opts->address_mask, adr_reg, SZ_D);
1116 fe8c79f82c22 More cleanup in preparation for SMS/Mark III support Michael Pavone <pavone@retrodev.com> parents: 1109 diff changeset	122 } else if (opts->address_size == SZ_W && opts->address_mask != 0xFFFF) {
fe8c79f82c22 More cleanup in preparation for SMS/Mark III support Michael Pavone <pavone@retrodev.com> parents: 1109 diff changeset	123 and_ir(code, opts->address_mask, adr_reg, SZ_W);
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	124 }
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	125 code_ptr lb_jcc = NULL, ub_jcc = NULL;
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	126 uint16_t access_flag = is_write ? MMAP_WRITE : MMAP_READ;
690 fc04781f4d28 Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM Michael Pavone <pavone@retrodev.com> parents: 667 diff changeset	127 uint32_t ram_flags_off = opts->ram_flags_off;
1086 f0a1e0a2263c Made some optimizations to gen_mem_fun to keep the size of chunk handler sections within range of a single byte displacement Michael Pavone <pavone@retrodev.com> parents: 1084 diff changeset	128 uint32_t min_address = 0;
f0a1e0a2263c Made some optimizations to gen_mem_fun to keep the size of chunk handler sections within range of a single byte displacement Michael Pavone <pavone@retrodev.com> parents: 1084 diff changeset	129 uint32_t max_address = opts->max_address;
2054 8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	130 uint8_t need_wide_jcc = 0;
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	131 for (uint32_t chunk = 0; chunk < num_chunks; chunk++)
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	132 {
2054 8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	133 code_info chunk_start = *code;
1086 f0a1e0a2263c Made some optimizations to gen_mem_fun to keep the size of chunk handler sections within range of a single byte displacement Michael Pavone <pavone@retrodev.com> parents: 1084 diff changeset	134 if (memmap[chunk].start > min_address) {
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	135 cmp_ir(code, memmap[chunk].start, adr_reg, opts->address_size);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	136 lb_jcc = code->cur + 1;
2054 8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	137 if (need_wide_jcc) {
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	138 jcc(code, CC_C, code->cur + 130);
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	139 lb_jcc++;
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	140 } else {
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	141 jcc(code, CC_C, code->cur + 2);
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	142 }
1086 f0a1e0a2263c Made some optimizations to gen_mem_fun to keep the size of chunk handler sections within range of a single byte displacement Michael Pavone <pavone@retrodev.com> parents: 1084 diff changeset	143 } else {
f0a1e0a2263c Made some optimizations to gen_mem_fun to keep the size of chunk handler sections within range of a single byte displacement Michael Pavone <pavone@retrodev.com> parents: 1084 diff changeset	144 min_address = memmap[chunk].end;
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	145 }
1086 f0a1e0a2263c Made some optimizations to gen_mem_fun to keep the size of chunk handler sections within range of a single byte displacement Michael Pavone <pavone@retrodev.com> parents: 1084 diff changeset	146 if (memmap[chunk].end < max_address) {
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	147 cmp_ir(code, memmap[chunk].end, adr_reg, opts->address_size);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	148 ub_jcc = code->cur + 1;
2054 8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	149 if (need_wide_jcc) {
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	150 jcc(code, CC_NC, code->cur + 130);
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	151 ub_jcc++;
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	152 } else {
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	153 jcc(code, CC_NC, code->cur + 2);
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	154 }
1086 f0a1e0a2263c Made some optimizations to gen_mem_fun to keep the size of chunk handler sections within range of a single byte displacement Michael Pavone <pavone@retrodev.com> parents: 1084 diff changeset	155 } else {
f0a1e0a2263c Made some optimizations to gen_mem_fun to keep the size of chunk handler sections within range of a single byte displacement Michael Pavone <pavone@retrodev.com> parents: 1084 diff changeset	156 max_address = memmap[chunk].start;
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	157 }
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	158
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	159 if (memmap[chunk].mask != opts->address_mask) {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	160 and_ir(code, memmap[chunk].mask, adr_reg, opts->address_size);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	161 }
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	162 void * cfun;
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	163 switch (fun_type)
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	164 {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	165 case READ_16:
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	166 cfun = memmap[chunk].read_16;
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	167 break;
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	168 case READ_8:
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	169 cfun = memmap[chunk].read_8;
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	170 break;
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	171 case WRITE_16:
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	172 cfun = memmap[chunk].write_16;
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	173 break;
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	174 case WRITE_8:
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	175 cfun = memmap[chunk].write_8;
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	176 break;
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	177 default:
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	178 cfun = NULL;
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	179 }
604 39d7d463ed5b Get Z80 banked access sort of working again Michael Pavone <pavone@retrodev.com> parents: 601 diff changeset	180 if(memmap[chunk].flags & access_flag) {
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	181 if (memmap[chunk].flags & MMAP_PTR_IDX) {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	182 if (memmap[chunk].flags & MMAP_FUNC_NULL) {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	183 cmp_irdisp(code, 0, opts->context_reg, opts->mem_ptr_off + sizeof(void) memmap[chunk].ptr_index, SZ_PTR);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	184 code_ptr not_null = code->cur + 1;
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	185 jcc(code, CC_NZ, code->cur + 2);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	186 call(code, opts->save_context);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	187 if (is_write) {
658 6aa29ac33f1a Use call_args and call_args_abi inside gen_mem_fun Michael Pavone <pavone@retrodev.com> parents: 620 diff changeset	188 call_args_abi(code, cfun, 3, opts->scratch2, opts->context_reg, opts->scratch1);
6aa29ac33f1a Use call_args and call_args_abi inside gen_mem_fun Michael Pavone <pavone@retrodev.com> parents: 620 diff changeset	189 mov_rr(code, RAX, opts->context_reg, SZ_PTR);
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	190 } else {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	191 push_r(code, opts->context_reg);
658 6aa29ac33f1a Use call_args and call_args_abi inside gen_mem_fun Michael Pavone <pavone@retrodev.com> parents: 620 diff changeset	192 call_args_abi(code, cfun, 2, opts->scratch1, opts->context_reg);
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	193 pop_r(code, opts->context_reg);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	194 mov_rr(code, RAX, opts->scratch1, size);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	195 }
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	196 jmp(code, opts->load_context);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	197
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	198 *not_null = code->cur - (not_null + 1);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	199 }
604 39d7d463ed5b Get Z80 banked access sort of working again Michael Pavone <pavone@retrodev.com> parents: 601 diff changeset	200 if ((opts->byte_swap \|\| memmap[chunk].flags & MMAP_BYTESWAP) && size == SZ_B) {
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	201 xor_ir(code, 1, adr_reg, opts->address_size);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	202 }
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	203 if (opts->address_size != SZ_D) {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	204 movzx_rr(code, adr_reg, adr_reg, opts->address_size, SZ_D);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	205 }
1081 89cc20cf1ad3 Fix handling of MMAP_CODE chunks that also have MMAP_PTR_IDX set Michael Pavone <pavone@retrodev.com> parents: 1047 diff changeset	206 if (is_write && (memmap[chunk].flags & MMAP_CODE)) {
89cc20cf1ad3 Fix handling of MMAP_CODE chunks that also have MMAP_PTR_IDX set Michael Pavone <pavone@retrodev.com> parents: 1047 diff changeset	207 push_r(code, adr_reg);
89cc20cf1ad3 Fix handling of MMAP_CODE chunks that also have MMAP_PTR_IDX set Michael Pavone <pavone@retrodev.com> parents: 1047 diff changeset	208 }
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	209 add_rdispr(code, opts->context_reg, opts->mem_ptr_off + sizeof(void) memmap[chunk].ptr_index, adr_reg, SZ_PTR);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	210 if (is_write) {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	211 mov_rrind(code, opts->scratch1, opts->scratch2, size);
1081 89cc20cf1ad3 Fix handling of MMAP_CODE chunks that also have MMAP_PTR_IDX set Michael Pavone <pavone@retrodev.com> parents: 1047 diff changeset	212 if (memmap[chunk].flags & MMAP_CODE) {
89cc20cf1ad3 Fix handling of MMAP_CODE chunks that also have MMAP_PTR_IDX set Michael Pavone <pavone@retrodev.com> parents: 1047 diff changeset	213 pop_r(code, adr_reg);
89cc20cf1ad3 Fix handling of MMAP_CODE chunks that also have MMAP_PTR_IDX set Michael Pavone <pavone@retrodev.com> parents: 1047 diff changeset	214 }
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	215 } else {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	216 mov_rindr(code, opts->scratch1, opts->scratch1, size);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	217 }
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	218 } else {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	219 uint8_t tmp_size = size;
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	220 if (size == SZ_B) {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	221 if ((memmap[chunk].flags & MMAP_ONLY_ODD) \|\| (memmap[chunk].flags & MMAP_ONLY_EVEN)) {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	222 bt_ir(code, 0, adr_reg, opts->address_size);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	223 code_ptr good_addr = code->cur + 1;
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	224 jcc(code, (memmap[chunk].flags & MMAP_ONLY_ODD) ? CC_C : CC_NC, code->cur + 2);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	225 if (!is_write) {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	226 mov_ir(code, 0xFF, opts->scratch1, SZ_B);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	227 }
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	228 retn(code);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	229 *good_addr = code->cur - (good_addr + 1);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	230 shr_ir(code, 1, adr_reg, opts->address_size);
604 39d7d463ed5b Get Z80 banked access sort of working again Michael Pavone <pavone@retrodev.com> parents: 601 diff changeset	231 } else if (opts->byte_swap \|\| memmap[chunk].flags & MMAP_BYTESWAP) {
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	232 xor_ir(code, 1, adr_reg, opts->address_size);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	233 }
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	234 } else if ((memmap[chunk].flags & MMAP_ONLY_ODD) \|\| (memmap[chunk].flags & MMAP_ONLY_EVEN)) {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	235 tmp_size = SZ_B;
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	236 shr_ir(code, 1, adr_reg, opts->address_size);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	237 if ((memmap[chunk].flags & MMAP_ONLY_EVEN) && is_write) {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	238 shr_ir(code, 8, opts->scratch1, SZ_W);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	239 }
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	240 }
595 68f86ca4bb32 Add a couple of missing checks for the byte_swap and address_size parameters in gen_mem_fun Michael Pavone <pavone@retrodev.com> parents: 593 diff changeset	241 if (opts->address_size != SZ_D) {
68f86ca4bb32 Add a couple of missing checks for the byte_swap and address_size parameters in gen_mem_fun Michael Pavone <pavone@retrodev.com> parents: 593 diff changeset	242 movzx_rr(code, adr_reg, adr_reg, opts->address_size, SZ_D);
68f86ca4bb32 Add a couple of missing checks for the byte_swap and address_size parameters in gen_mem_fun Michael Pavone <pavone@retrodev.com> parents: 593 diff changeset	243 }
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	244 if ((intptr_t)memmap[chunk].buffer <= 0x7FFFFFFF && (intptr_t)memmap[chunk].buffer >= -2147483648) {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	245 if (is_write) {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	246 mov_rrdisp(code, opts->scratch1, opts->scratch2, (intptr_t)memmap[chunk].buffer, tmp_size);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	247 } else {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	248 mov_rdispr(code, opts->scratch1, (intptr_t)memmap[chunk].buffer, opts->scratch1, tmp_size);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	249 }
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	250 } else {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	251 if (is_write) {
760 656b1fded67f Fix self modifying code checks on platforms like OS X on which guest RAM ends up at an address unreachable with a 32-bit displacement Michael Pavone <pavone@retrodev.com> parents: 756 diff changeset	252 push_r(code, opts->scratch2);
656b1fded67f Fix self modifying code checks on platforms like OS X on which guest RAM ends up at an address unreachable with a 32-bit displacement Michael Pavone <pavone@retrodev.com> parents: 756 diff changeset	253 mov_ir(code, (intptr_t)memmap[chunk].buffer, opts->scratch2, SZ_PTR);
656b1fded67f Fix self modifying code checks on platforms like OS X on which guest RAM ends up at an address unreachable with a 32-bit displacement Michael Pavone <pavone@retrodev.com> parents: 756 diff changeset	254 add_rdispr(code, RSP, 0, opts->scratch2, SZ_PTR);
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	255 mov_rrind(code, opts->scratch1, opts->scratch2, tmp_size);
760 656b1fded67f Fix self modifying code checks on platforms like OS X on which guest RAM ends up at an address unreachable with a 32-bit displacement Michael Pavone <pavone@retrodev.com> parents: 756 diff changeset	256 if (is_write && (memmap[chunk].flags & MMAP_CODE)) {
656b1fded67f Fix self modifying code checks on platforms like OS X on which guest RAM ends up at an address unreachable with a 32-bit displacement Michael Pavone <pavone@retrodev.com> parents: 756 diff changeset	257 pop_r(code, opts->scratch2);
656b1fded67f Fix self modifying code checks on platforms like OS X on which guest RAM ends up at an address unreachable with a 32-bit displacement Michael Pavone <pavone@retrodev.com> parents: 756 diff changeset	258 } else {
1511 2a5649a767e7 Fix accidental add to RSP with SZ_D and SZ_PTR. Using SZ_D breakse when the stack is located outside of the 32-bit addressable range Michael Pavone <pavone@retrodev.com> parents: 1465 diff changeset	259 add_ir(code, sizeof(void*), RSP, SZ_PTR);
894 a7774fc2de4b Partially working change to do proper stack alignment rather than doing a lame alignment check when calling a C compile dfunction. 68K core seems okay, but Z80 is busted. Michael Pavone <pavone@retrodev.com> parents: 892 diff changeset	260 code->stack_off -= sizeof(void *);
760 656b1fded67f Fix self modifying code checks on platforms like OS X on which guest RAM ends up at an address unreachable with a 32-bit displacement Michael Pavone <pavone@retrodev.com> parents: 756 diff changeset	261 }
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	262 } else {
756 e1dc98f7ed9f Preserve scratch2 when using it as a temporary in memory read functions. This fixes a bunch of issues with the Z80 core and possibly some issues with the 68K core as well Michael Pavone <pavone@retrodev.com> parents: 750 diff changeset	263 push_r(code, opts->scratch2);
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	264 mov_ir(code, (intptr_t)memmap[chunk].buffer, opts->scratch2, SZ_PTR);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	265 mov_rindexr(code, opts->scratch2, opts->scratch1, 1, opts->scratch1, tmp_size);
756 e1dc98f7ed9f Preserve scratch2 when using it as a temporary in memory read functions. This fixes a bunch of issues with the Z80 core and possibly some issues with the 68K core as well Michael Pavone <pavone@retrodev.com> parents: 750 diff changeset	266 pop_r(code, opts->scratch2);
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	267 }
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	268 }
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	269 if (size != tmp_size && !is_write) {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	270 if (memmap[chunk].flags & MMAP_ONLY_EVEN) {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	271 shl_ir(code, 8, opts->scratch1, SZ_W);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	272 mov_ir(code, 0xFF, opts->scratch1, SZ_B);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	273 } else {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	274 or_ir(code, 0xFF00, opts->scratch1, SZ_W);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	275 }
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	276 }
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	277 }
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	278 if (is_write && (memmap[chunk].flags & MMAP_CODE)) {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	279 mov_rr(code, opts->scratch2, opts->scratch1, opts->address_size);
620 9d6fed6501ba Fix handling of code writes for Z80 core. This seems to get things close to being back to where they were before the big refactor that broke the Z80 core. Some problems remain. Notably the sound driver in Sonic 2 is still quite broken. Michael Pavone <pavone@retrodev.com> parents: 604 diff changeset	280 shr_ir(code, opts->ram_flags_shift, opts->scratch1, opts->address_size);
690 fc04781f4d28 Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM Michael Pavone <pavone@retrodev.com> parents: 667 diff changeset	281 bt_rrdisp(code, opts->scratch1, opts->context_reg, ram_flags_off, opts->address_size);
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	282 code_ptr not_code = code->cur + 1;
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	283 jcc(code, CC_NC, code->cur + 2);
1084 193db42e702b Remove hacky assumption about Genesis memory map in M68K core Michael Pavone <pavone@retrodev.com> parents: 1081 diff changeset	284 if (memmap[chunk].mask != opts->address_mask) {
1107 fc125af5e4f1 Fix to the fix of handling of self modifying code. Was ORing the base address with the wrong register before calling the modified code handler Michael Pavone <pavone@retrodev.com> parents: 1086 diff changeset	285 or_ir(code, memmap[chunk].start, opts->scratch2, opts->address_size);
1084 193db42e702b Remove hacky assumption about Genesis memory map in M68K core Michael Pavone <pavone@retrodev.com> parents: 1081 diff changeset	286 }
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	287 call(code, opts->save_context);
658 6aa29ac33f1a Use call_args and call_args_abi inside gen_mem_fun Michael Pavone <pavone@retrodev.com> parents: 620 diff changeset	288 call_args(code, opts->handle_code_write, 2, opts->scratch2, opts->context_reg);
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	289 mov_rr(code, RAX, opts->context_reg, SZ_PTR);
1086 f0a1e0a2263c Made some optimizations to gen_mem_fun to keep the size of chunk handler sections within range of a single byte displacement Michael Pavone <pavone@retrodev.com> parents: 1084 diff changeset	290 jmp(code, opts->load_context);
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	291 *not_code = code->cur - (not_code+1);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	292 }
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	293 retn(code);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	294 } else if (cfun) {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	295 call(code, opts->save_context);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	296 if (is_write) {
658 6aa29ac33f1a Use call_args and call_args_abi inside gen_mem_fun Michael Pavone <pavone@retrodev.com> parents: 620 diff changeset	297 call_args_abi(code, cfun, 3, opts->scratch2, opts->context_reg, opts->scratch1);
6aa29ac33f1a Use call_args and call_args_abi inside gen_mem_fun Michael Pavone <pavone@retrodev.com> parents: 620 diff changeset	298 mov_rr(code, RAX, opts->context_reg, SZ_PTR);
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	299 } else {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	300 push_r(code, opts->context_reg);
658 6aa29ac33f1a Use call_args and call_args_abi inside gen_mem_fun Michael Pavone <pavone@retrodev.com> parents: 620 diff changeset	301 call_args_abi(code, cfun, 2, opts->scratch1, opts->context_reg);
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	302 pop_r(code, opts->context_reg);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	303 mov_rr(code, RAX, opts->scratch1, size);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	304 }
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	305 jmp(code, opts->load_context);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	306 } else {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	307 //Not sure the best course of action here
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	308 if (!is_write) {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	309 mov_ir(code, size == SZ_B ? 0xFF : 0xFFFF, opts->scratch1, size);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	310 }
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	311 retn(code);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	312 }
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	313 if (lb_jcc) {
2054 8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	314 if (need_wide_jcc) {
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	315 ((int32_t)lb_jcc) = code->cur - (lb_jcc+4);
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	316 } else if (code->cur - (lb_jcc+1) > 0x7f) {
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	317 need_wide_jcc = 1;
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	318 chunk--;
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	319 *code = chunk_start;
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	320 continue;
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	321 } else {
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	322 *lb_jcc = code->cur - (lb_jcc+1);
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	323 }
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	324 lb_jcc = NULL;
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	325 }
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	326 if (ub_jcc) {
2054 8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	327 if (need_wide_jcc) {
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	328 ((int32_t)ub_jcc) = code->cur - (ub_jcc+4);
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	329 } else if (code->cur - (ub_jcc+1) > 0x7f) {
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	330 need_wide_jcc = 1;
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	331 chunk--;
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	332 *code = chunk_start;
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	333 continue;
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	334 } else {
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	335 *ub_jcc = code->cur - (ub_jcc+1);
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	336 }
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	337
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	338 ub_jcc = NULL;
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	339 }
2070 afc54649ebed Fix error in code write detection introduced from "wide" jcc change Michael Pavone <pavone@retrodev.com> parents: 2054 diff changeset	340 if (memmap[chunk].flags & MMAP_CODE) {
2113 0013362c320c Fix handling of ram code flag offset calculation for ranges that are not an even multiple of the code flag page size Michael Pavone <pavone@retrodev.com> parents: 2070 diff changeset	341 uint32_t size = chunk_size(opts, memmap + chunk);
0013362c320c Fix handling of ram code flag offset calculation for ranges that are not an even multiple of the code flag page size Michael Pavone <pavone@retrodev.com> parents: 2070 diff changeset	342 uint32_t size_round_mask = (1 << (opts->ram_flags_shift + 3)) - 1;
0013362c320c Fix handling of ram code flag offset calculation for ranges that are not an even multiple of the code flag page size Michael Pavone <pavone@retrodev.com> parents: 2070 diff changeset	343 if (size & size_round_mask) {
0013362c320c Fix handling of ram code flag offset calculation for ranges that are not an even multiple of the code flag page size Michael Pavone <pavone@retrodev.com> parents: 2070 diff changeset	344 size &= ~size_round_mask;
0013362c320c Fix handling of ram code flag offset calculation for ranges that are not an even multiple of the code flag page size Michael Pavone <pavone@retrodev.com> parents: 2070 diff changeset	345 size += size_round_mask + 1;
2070 afc54649ebed Fix error in code write detection introduced from "wide" jcc change Michael Pavone <pavone@retrodev.com> parents: 2054 diff changeset	346 }
2113 0013362c320c Fix handling of ram code flag offset calculation for ranges that are not an even multiple of the code flag page size Michael Pavone <pavone@retrodev.com> parents: 2070 diff changeset	347 ram_flags_off += size >> (opts->ram_flags_shift + 3);
2070 afc54649ebed Fix error in code write detection introduced from "wide" jcc change Michael Pavone <pavone@retrodev.com> parents: 2054 diff changeset	348 }
2054 8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	349 if (need_wide_jcc) {
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	350 need_wide_jcc = 0;
8ee7ecbf3f21 Implement enough of Sega CD gate array and Sub CPU to pass Sik's Mode 1 test ROM Michael Pavone <pavone@retrodev.com> parents: 2036 diff changeset	351 }
589 2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	352 }
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	353 if (!is_write) {
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	354 mov_ir(code, size == SZ_B ? 0xFF : 0xFFFF, opts->scratch1, size);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	355 }
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	356 retn(code);
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	357 return start;
2dde38c1744f Split gen_mem_fun out of m68k_core_x86 and make it more generic so it can be used by the Z80 core Michael Pavone <pavone@retrodev.com> parents: 567 diff changeset	358 }

Mercurial > repos > blastem

annotate backend_x86.c @ 2131:d90d92ce5cab