Mercurial > repos > blastem
annotate backend.c @ 2047:275da208aa75 proprietary
Backed out changeset 96323d73b8ab
author | Michael Pavone <pavone@retrodev.com> |
---|---|
date | Tue, 21 Sep 2021 23:23:52 -0700 |
parents | 3142602d21d8 |
children |
rev | line source |
---|---|
467
140af5509ce7
Added copyright notice to source files and added GPL license text in COPYING
Mike Pavone <pavone@retrodev.com>
parents:
282
diff
changeset
|
1 /* |
140af5509ce7
Added copyright notice to source files and added GPL license text in COPYING
Mike Pavone <pavone@retrodev.com>
parents:
282
diff
changeset
|
2 Copyright 2013 Michael Pavone |
557
acec5464fa1e
Rename x86_backend.h and x86_backend.c to backend.h and backend.c respectively
Mike Pavone <pavone@retrodev.com>
parents:
467
diff
changeset
|
3 This file is part of BlastEm. |
467
140af5509ce7
Added copyright notice to source files and added GPL license text in COPYING
Mike Pavone <pavone@retrodev.com>
parents:
282
diff
changeset
|
4 BlastEm is free software distributed under the terms of the GNU General Public License version 3 or greater. See COPYING for full license text. |
140af5509ce7
Added copyright notice to source files and added GPL license text in COPYING
Mike Pavone <pavone@retrodev.com>
parents:
282
diff
changeset
|
5 */ |
557
acec5464fa1e
Rename x86_backend.h and x86_backend.c to backend.h and backend.c respectively
Mike Pavone <pavone@retrodev.com>
parents:
467
diff
changeset
|
6 #include "backend.h" |
235
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
7 #include <stdlib.h> |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
8 |
1931 | 9 #ifndef NEW_CORE |
235
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
10 deferred_addr * defer_address(deferred_addr * old_head, uint32_t address, uint8_t *dest) |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
11 { |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
12 deferred_addr * new_head = malloc(sizeof(deferred_addr)); |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
13 new_head->next = old_head; |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
14 new_head->address = address & 0xFFFFFF; |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
15 new_head->dest = dest; |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
16 return new_head; |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
17 } |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
18 |
282
7b8a49220e3b
Remove deferred address entries from abandoned translations inside z80_retrans_inst
Mike Pavone <pavone@retrodev.com>
parents:
235
diff
changeset
|
19 void remove_deferred_until(deferred_addr **head_ptr, deferred_addr * remove_to) |
7b8a49220e3b
Remove deferred address entries from abandoned translations inside z80_retrans_inst
Mike Pavone <pavone@retrodev.com>
parents:
235
diff
changeset
|
20 { |
7b8a49220e3b
Remove deferred address entries from abandoned translations inside z80_retrans_inst
Mike Pavone <pavone@retrodev.com>
parents:
235
diff
changeset
|
21 for(deferred_addr *cur = *head_ptr; cur && cur != remove_to; cur = *head_ptr) |
7b8a49220e3b
Remove deferred address entries from abandoned translations inside z80_retrans_inst
Mike Pavone <pavone@retrodev.com>
parents:
235
diff
changeset
|
22 { |
7b8a49220e3b
Remove deferred address entries from abandoned translations inside z80_retrans_inst
Mike Pavone <pavone@retrodev.com>
parents:
235
diff
changeset
|
23 *head_ptr = cur->next; |
7b8a49220e3b
Remove deferred address entries from abandoned translations inside z80_retrans_inst
Mike Pavone <pavone@retrodev.com>
parents:
235
diff
changeset
|
24 free(cur); |
7b8a49220e3b
Remove deferred address entries from abandoned translations inside z80_retrans_inst
Mike Pavone <pavone@retrodev.com>
parents:
235
diff
changeset
|
25 } |
7b8a49220e3b
Remove deferred address entries from abandoned translations inside z80_retrans_inst
Mike Pavone <pavone@retrodev.com>
parents:
235
diff
changeset
|
26 } |
7b8a49220e3b
Remove deferred address entries from abandoned translations inside z80_retrans_inst
Mike Pavone <pavone@retrodev.com>
parents:
235
diff
changeset
|
27 |
235
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
28 void process_deferred(deferred_addr ** head_ptr, void * context, native_addr_func get_native) |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
29 { |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
30 deferred_addr * cur = *head_ptr; |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
31 deferred_addr **last_next = head_ptr; |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
32 while(cur) |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
33 { |
558
dc9f178085a0
Use a typedef code_ptr in place of uint8_t * in 68K core to better support host instruction sets with different instruction word sizes. Make x86_68k_options contain a cpu_options so that gen_mem_fun can eventually be shared with the Z80 core.
Mike Pavone <pavone@retrodev.com>
parents:
557
diff
changeset
|
34 code_ptr native = get_native(context, cur->address);//get_native_address(opts->native_code_map, cur->address); |
235
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
35 if (native) { |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
36 int32_t disp = native - (cur->dest + 4); |
558
dc9f178085a0
Use a typedef code_ptr in place of uint8_t * in 68K core to better support host instruction sets with different instruction word sizes. Make x86_68k_options contain a cpu_options so that gen_mem_fun can eventually be shared with the Z80 core.
Mike Pavone <pavone@retrodev.com>
parents:
557
diff
changeset
|
37 code_ptr out = cur->dest; |
235
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
38 *(out++) = disp; |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
39 disp >>= 8; |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
40 *(out++) = disp; |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
41 disp >>= 8; |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
42 *(out++) = disp; |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
43 disp >>= 8; |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
44 *out = disp; |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
45 *last_next = cur->next; |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
46 free(cur); |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
47 cur = *last_next; |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
48 } else { |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
49 last_next = &(cur->next); |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
50 cur = cur->next; |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
51 } |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
52 } |
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
53 } |
1507
2455662378ed
Added MAME Z80 core, re-enabled 68K tracing in Musashi core, disabled a bunch of code gen stuff when using interpreters from MAME
Michael Pavone <pavone@retrodev.com>
parents:
1506
diff
changeset
|
54 #endif |
235
d9bf8e61c33c
Get Z80 core working for simple programs
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
55 |
1130
8f14767661fa
Remove memory map assumptions from Z80 core and move a little bit of logic to the generic backend.c so it can be shared between CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
1079
diff
changeset
|
56 memmap_chunk const *find_map_chunk(uint32_t address, cpu_options *opts, uint16_t flags, uint32_t *size_sum) |
8f14767661fa
Remove memory map assumptions from Z80 core and move a little bit of logic to the generic backend.c so it can be shared between CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
1079
diff
changeset
|
57 { |
8f14767661fa
Remove memory map assumptions from Z80 core and move a little bit of logic to the generic backend.c so it can be shared between CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
1079
diff
changeset
|
58 if (size_sum) { |
8f14767661fa
Remove memory map assumptions from Z80 core and move a little bit of logic to the generic backend.c so it can be shared between CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
1079
diff
changeset
|
59 *size_sum = 0; |
8f14767661fa
Remove memory map assumptions from Z80 core and move a little bit of logic to the generic backend.c so it can be shared between CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
1079
diff
changeset
|
60 } |
2042
3142602d21d8
Fix compile error post-merge
Michael Pavone <pavone@retrodev.com>
parents:
2041
diff
changeset
|
61 #ifndef NEW_CORE |
2036
45c4b74e7676
Fix bug in handling of MMAP_CODE regions smaller than 16KB
Michael Pavone <pavone@retrodev.com>
parents:
1964
diff
changeset
|
62 uint32_t minsize; |
45c4b74e7676
Fix bug in handling of MMAP_CODE regions smaller than 16KB
Michael Pavone <pavone@retrodev.com>
parents:
1964
diff
changeset
|
63 if (flags == MMAP_CODE) { |
45c4b74e7676
Fix bug in handling of MMAP_CODE regions smaller than 16KB
Michael Pavone <pavone@retrodev.com>
parents:
1964
diff
changeset
|
64 minsize = 1 << (opts->ram_flags_shift + 3); |
45c4b74e7676
Fix bug in handling of MMAP_CODE regions smaller than 16KB
Michael Pavone <pavone@retrodev.com>
parents:
1964
diff
changeset
|
65 } else { |
45c4b74e7676
Fix bug in handling of MMAP_CODE regions smaller than 16KB
Michael Pavone <pavone@retrodev.com>
parents:
1964
diff
changeset
|
66 minsize = 0; |
45c4b74e7676
Fix bug in handling of MMAP_CODE regions smaller than 16KB
Michael Pavone <pavone@retrodev.com>
parents:
1964
diff
changeset
|
67 } |
2042
3142602d21d8
Fix compile error post-merge
Michael Pavone <pavone@retrodev.com>
parents:
2041
diff
changeset
|
68 #endif |
1130
8f14767661fa
Remove memory map assumptions from Z80 core and move a little bit of logic to the generic backend.c so it can be shared between CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
1079
diff
changeset
|
69 address &= opts->address_mask; |
8f14767661fa
Remove memory map assumptions from Z80 core and move a little bit of logic to the generic backend.c so it can be shared between CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
1079
diff
changeset
|
70 for (memmap_chunk const *cur = opts->memmap, *end = opts->memmap + opts->memmap_chunks; cur != end; cur++) |
8f14767661fa
Remove memory map assumptions from Z80 core and move a little bit of logic to the generic backend.c so it can be shared between CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
1079
diff
changeset
|
71 { |
8f14767661fa
Remove memory map assumptions from Z80 core and move a little bit of logic to the generic backend.c so it can be shared between CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
1079
diff
changeset
|
72 if (address >= cur->start && address < cur->end) { |
8f14767661fa
Remove memory map assumptions from Z80 core and move a little bit of logic to the generic backend.c so it can be shared between CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
1079
diff
changeset
|
73 return cur; |
8f14767661fa
Remove memory map assumptions from Z80 core and move a little bit of logic to the generic backend.c so it can be shared between CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
1079
diff
changeset
|
74 } else if (size_sum && (cur->flags & flags) == flags) { |
2036
45c4b74e7676
Fix bug in handling of MMAP_CODE regions smaller than 16KB
Michael Pavone <pavone@retrodev.com>
parents:
1964
diff
changeset
|
75 uint32_t size = chunk_size(opts, cur); |
2042
3142602d21d8
Fix compile error post-merge
Michael Pavone <pavone@retrodev.com>
parents:
2041
diff
changeset
|
76 #ifndef NEW_CORE |
2036
45c4b74e7676
Fix bug in handling of MMAP_CODE regions smaller than 16KB
Michael Pavone <pavone@retrodev.com>
parents:
1964
diff
changeset
|
77 if (size < minsize) { |
45c4b74e7676
Fix bug in handling of MMAP_CODE regions smaller than 16KB
Michael Pavone <pavone@retrodev.com>
parents:
1964
diff
changeset
|
78 size = minsize; |
45c4b74e7676
Fix bug in handling of MMAP_CODE regions smaller than 16KB
Michael Pavone <pavone@retrodev.com>
parents:
1964
diff
changeset
|
79 } |
2042
3142602d21d8
Fix compile error post-merge
Michael Pavone <pavone@retrodev.com>
parents:
2041
diff
changeset
|
80 #endif |
2036
45c4b74e7676
Fix bug in handling of MMAP_CODE regions smaller than 16KB
Michael Pavone <pavone@retrodev.com>
parents:
1964
diff
changeset
|
81 *size_sum += size; |
1130
8f14767661fa
Remove memory map assumptions from Z80 core and move a little bit of logic to the generic backend.c so it can be shared between CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
1079
diff
changeset
|
82 } |
8f14767661fa
Remove memory map assumptions from Z80 core and move a little bit of logic to the generic backend.c so it can be shared between CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
1079
diff
changeset
|
83 } |
8f14767661fa
Remove memory map assumptions from Z80 core and move a little bit of logic to the generic backend.c so it can be shared between CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
1079
diff
changeset
|
84 return NULL; |
8f14767661fa
Remove memory map assumptions from Z80 core and move a little bit of logic to the generic backend.c so it can be shared between CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
1079
diff
changeset
|
85 } |
8f14767661fa
Remove memory map assumptions from Z80 core and move a little bit of logic to the generic backend.c so it can be shared between CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
1079
diff
changeset
|
86 |
653
a18e3923481e
Remove some of the hard coded assumptions about the memory map from the CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
558
diff
changeset
|
87 void * get_native_pointer(uint32_t address, void ** mem_pointers, cpu_options * opts) |
a18e3923481e
Remove some of the hard coded assumptions about the memory map from the CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
558
diff
changeset
|
88 { |
654
98927f1b005b
Fix some issues with 68K instruction retranslation
Michael Pavone <pavone@retrodev.com>
parents:
653
diff
changeset
|
89 memmap_chunk const * memmap = opts->memmap; |
653
a18e3923481e
Remove some of the hard coded assumptions about the memory map from the CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
558
diff
changeset
|
90 address &= opts->address_mask; |
a18e3923481e
Remove some of the hard coded assumptions about the memory map from the CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
558
diff
changeset
|
91 for (uint32_t chunk = 0; chunk < opts->memmap_chunks; chunk++) |
a18e3923481e
Remove some of the hard coded assumptions about the memory map from the CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
558
diff
changeset
|
92 { |
a18e3923481e
Remove some of the hard coded assumptions about the memory map from the CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
558
diff
changeset
|
93 if (address >= memmap[chunk].start && address < memmap[chunk].end) { |
1519
1f745318f10a
Made the NOR flash emulation a bit more flexible, but not yet flexible enough to properly support the flash chip in the MegaWiFi cart
Michael Pavone <pavone@retrodev.com>
parents:
1419
diff
changeset
|
94 if (!(memmap[chunk].flags & (MMAP_READ|MMAP_READ_CODE))) { |
653
a18e3923481e
Remove some of the hard coded assumptions about the memory map from the CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
558
diff
changeset
|
95 return NULL; |
a18e3923481e
Remove some of the hard coded assumptions about the memory map from the CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
558
diff
changeset
|
96 } |
a18e3923481e
Remove some of the hard coded assumptions about the memory map from the CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
558
diff
changeset
|
97 uint8_t * base = memmap[chunk].flags & MMAP_PTR_IDX |
a18e3923481e
Remove some of the hard coded assumptions about the memory map from the CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
558
diff
changeset
|
98 ? mem_pointers[memmap[chunk].ptr_index] |
a18e3923481e
Remove some of the hard coded assumptions about the memory map from the CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
558
diff
changeset
|
99 : memmap[chunk].buffer; |
a18e3923481e
Remove some of the hard coded assumptions about the memory map from the CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
558
diff
changeset
|
100 if (!base) { |
1079
329ff62ea391
Add a new memory map flag to support an auxilliary buffer for translating code from MMAP_PTR_IDX chunks for which the pointer is null
Michael Pavone <pavone@retrodev.com>
parents:
690
diff
changeset
|
101 if (memmap[chunk].flags & MMAP_AUX_BUFF) { |
1952
42c12d141f6e
Remove usage of GCC pointer arithmetic on void * extension
Michael Pavone <pavone@retrodev.com>
parents:
1838
diff
changeset
|
102 return ((uint8_t *)memmap[chunk].buffer) + (address & memmap[chunk].aux_mask); |
1079
329ff62ea391
Add a new memory map flag to support an auxilliary buffer for translating code from MMAP_PTR_IDX chunks for which the pointer is null
Michael Pavone <pavone@retrodev.com>
parents:
690
diff
changeset
|
103 } |
653
a18e3923481e
Remove some of the hard coded assumptions about the memory map from the CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
558
diff
changeset
|
104 return NULL; |
a18e3923481e
Remove some of the hard coded assumptions about the memory map from the CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
558
diff
changeset
|
105 } |
a18e3923481e
Remove some of the hard coded assumptions about the memory map from the CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
558
diff
changeset
|
106 return base + (address & memmap[chunk].mask); |
a18e3923481e
Remove some of the hard coded assumptions about the memory map from the CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
558
diff
changeset
|
107 } |
a18e3923481e
Remove some of the hard coded assumptions about the memory map from the CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
558
diff
changeset
|
108 } |
a18e3923481e
Remove some of the hard coded assumptions about the memory map from the CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
558
diff
changeset
|
109 return NULL; |
a18e3923481e
Remove some of the hard coded assumptions about the memory map from the CPU cores
Michael Pavone <pavone@retrodev.com>
parents:
558
diff
changeset
|
110 } |
690
fc04781f4d28
Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM
Michael Pavone <pavone@retrodev.com>
parents:
654
diff
changeset
|
111 |
1753
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
112 void * get_native_write_pointer(uint32_t address, void ** mem_pointers, cpu_options * opts) |
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
113 { |
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
114 memmap_chunk const * memmap = opts->memmap; |
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
115 address &= opts->address_mask; |
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
116 for (uint32_t chunk = 0; chunk < opts->memmap_chunks; chunk++) |
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
117 { |
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
118 if (address >= memmap[chunk].start && address < memmap[chunk].end) { |
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
119 if (!(memmap[chunk].flags & (MMAP_WRITE))) { |
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
120 return NULL; |
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
121 } |
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
122 uint8_t * base = memmap[chunk].flags & MMAP_PTR_IDX |
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
123 ? mem_pointers[memmap[chunk].ptr_index] |
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
124 : memmap[chunk].buffer; |
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
125 if (!base) { |
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
126 if (memmap[chunk].flags & MMAP_AUX_BUFF) { |
1952
42c12d141f6e
Remove usage of GCC pointer arithmetic on void * extension
Michael Pavone <pavone@retrodev.com>
parents:
1838
diff
changeset
|
127 return ((uint8_t *)memmap[chunk].buffer) + (address & memmap[chunk].aux_mask); |
1753
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
128 } |
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
129 return NULL; |
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
130 } |
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
131 return base + (address & memmap[chunk].mask); |
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
132 } |
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
133 } |
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
134 return NULL; |
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
135 } |
33ec5df77fac
Integration of new Z80 core is sort of working now
Michael Pavone <pavone@retrodev.com>
parents:
1703
diff
changeset
|
136 |
1313
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
137 uint16_t read_word(uint32_t address, void **mem_pointers, cpu_options *opts, void *context) |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
138 { |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
139 memmap_chunk const *chunk = find_map_chunk(address, opts, 0, NULL); |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
140 if (!chunk) { |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
141 return 0xFFFF; |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
142 } |
1678
d377d6037dd9
Don't subtract chunk start from address in read_word as this is inconsistent with other consumers of memory map definitions. Fixes graphical corruption in NBA Jam TE and possibly other titles that use the Acclaim mapper with a 32Mbit ROM
Michael Pavone <pavone@retrodev.com>
parents:
1519
diff
changeset
|
143 uint32_t offset = address & chunk->mask; |
1313
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
144 if (chunk->flags & MMAP_READ) { |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
145 uint8_t *base; |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
146 if (chunk->flags & MMAP_PTR_IDX) { |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
147 base = mem_pointers[chunk->ptr_index]; |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
148 } else { |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
149 base = chunk->buffer; |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
150 } |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
151 if (base) { |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
152 uint16_t val; |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
153 if ((chunk->flags & MMAP_ONLY_ODD) || (chunk->flags & MMAP_ONLY_EVEN)) { |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
154 offset /= 2; |
1419
92e7dafcc0dc
Fix a silly variable shadowing bug in read_word
Michael Pavone <pavone@retrodev.com>
parents:
1313
diff
changeset
|
155 val = base[offset]; |
1313
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
156 if (chunk->flags & MMAP_ONLY_ODD) { |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
157 val |= 0xFF00; |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
158 } else { |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
159 val = val << 8 | 0xFF; |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
160 } |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
161 } else { |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
162 val = *(uint16_t *)(base + offset); |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
163 } |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
164 return val; |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
165 } |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
166 } |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
167 if ((!(chunk->flags & MMAP_READ) || (chunk->flags & MMAP_FUNC_NULL)) && chunk->read_16) { |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
168 return chunk->read_16(offset, context); |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
169 } |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
170 return 0xFFFF; |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
171 } |
b27d7bf1107e
Improved printing of word at absolute address to support reading from all address types. Implemented support for printing the value pointed to by a register. Removed abuse of read_dma_value in internal debugger.
Michael Pavone <pavone@retrodev.com>
parents:
1142
diff
changeset
|
172 |
1838
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
173 void write_word(uint32_t address, uint16_t value, void **mem_pointers, cpu_options *opts, void *context) |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
174 { |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
175 memmap_chunk const *chunk = find_map_chunk(address, opts, 0, NULL); |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
176 if (!chunk) { |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
177 return; |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
178 } |
1964
9d35ce5012a6
Apply fixes to helper functions in backend.c from interp branch
Michael Pavone <pavone@retrodev.com>
parents:
1952
diff
changeset
|
179 uint32_t offset = address & chunk->mask; |
1838
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
180 if (chunk->flags & MMAP_WRITE) { |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
181 uint8_t *base; |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
182 if (chunk->flags & MMAP_PTR_IDX) { |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
183 base = mem_pointers[chunk->ptr_index]; |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
184 } else { |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
185 base = chunk->buffer; |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
186 } |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
187 if (base) { |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
188 if ((chunk->flags & MMAP_ONLY_ODD) || (chunk->flags & MMAP_ONLY_EVEN)) { |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
189 offset /= 2; |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
190 if (chunk->flags & MMAP_ONLY_EVEN) { |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
191 value >>= 16; |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
192 } |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
193 base[offset] = value; |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
194 } else { |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
195 *(uint16_t *)(base + offset) = value; |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
196 } |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
197 return; |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
198 } |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
199 } |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
200 if ((!(chunk->flags & MMAP_WRITE) || (chunk->flags & MMAP_FUNC_NULL)) && chunk->write_16) { |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
201 chunk->write_16(offset, context, value); |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
202 } |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
203 } |
0c1491818f4b
WIP new 68K core using CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1753
diff
changeset
|
204 |
1703
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
205 uint8_t read_byte(uint32_t address, void **mem_pointers, cpu_options *opts, void *context) |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
206 { |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
207 memmap_chunk const *chunk = find_map_chunk(address, opts, 0, NULL); |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
208 if (!chunk) { |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
209 return 0xFF; |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
210 } |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
211 uint32_t offset = address & chunk->mask; |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
212 if (chunk->flags & MMAP_READ) { |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
213 uint8_t *base; |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
214 if (chunk->flags & MMAP_PTR_IDX) { |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
215 base = mem_pointers[chunk->ptr_index]; |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
216 } else { |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
217 base = chunk->buffer; |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
218 } |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
219 if (base) { |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
220 if ((chunk->flags & MMAP_ONLY_ODD) || (chunk->flags & MMAP_ONLY_EVEN)) { |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
221 if (address & 1) { |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
222 if (chunk->flags & MMAP_ONLY_EVEN) { |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
223 return 0xFF; |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
224 } |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
225 } else if (chunk->flags & MMAP_ONLY_ODD) { |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
226 return 0xFF; |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
227 } |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
228 offset /= 2; |
1964
9d35ce5012a6
Apply fixes to helper functions in backend.c from interp branch
Michael Pavone <pavone@retrodev.com>
parents:
1952
diff
changeset
|
229 } else if(opts->byte_swap) { |
9d35ce5012a6
Apply fixes to helper functions in backend.c from interp branch
Michael Pavone <pavone@retrodev.com>
parents:
1952
diff
changeset
|
230 offset ^= 1; |
1703
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
231 } |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
232 return base[offset]; |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
233 } |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
234 } |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
235 if ((!(chunk->flags & MMAP_READ) || (chunk->flags & MMAP_FUNC_NULL)) && chunk->read_8) { |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
236 return chunk->read_8(offset, context); |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
237 } |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
238 return 0xFF; |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
239 } |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
240 |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
241 void write_byte(uint32_t address, uint8_t value, void **mem_pointers, cpu_options *opts, void *context) |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
242 { |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
243 memmap_chunk const *chunk = find_map_chunk(address, opts, 0, NULL); |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
244 if (!chunk) { |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
245 return; |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
246 } |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
247 uint32_t offset = address & chunk->mask; |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
248 if (chunk->flags & MMAP_WRITE) { |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
249 uint8_t *base; |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
250 if (chunk->flags & MMAP_PTR_IDX) { |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
251 base = mem_pointers[chunk->ptr_index]; |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
252 } else { |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
253 base = chunk->buffer; |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
254 } |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
255 if (base) { |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
256 if ((chunk->flags & MMAP_ONLY_ODD) || (chunk->flags & MMAP_ONLY_EVEN)) { |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
257 if (address & 1) { |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
258 if (chunk->flags & MMAP_ONLY_EVEN) { |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
259 return; |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
260 } |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
261 } else if (chunk->flags & MMAP_ONLY_ODD) { |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
262 return; |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
263 } |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
264 offset /= 2; |
1964
9d35ce5012a6
Apply fixes to helper functions in backend.c from interp branch
Michael Pavone <pavone@retrodev.com>
parents:
1952
diff
changeset
|
265 } else if(opts->byte_swap) { |
9d35ce5012a6
Apply fixes to helper functions in backend.c from interp branch
Michael Pavone <pavone@retrodev.com>
parents:
1952
diff
changeset
|
266 offset ^= 1; |
1703
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
267 } |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
268 base[offset] = value; |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
269 } |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
270 } |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
271 if ((!(chunk->flags & MMAP_WRITE) || (chunk->flags & MMAP_FUNC_NULL)) && chunk->write_8) { |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
272 chunk->write_8(offset, context, value); |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
273 } |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
274 } |
49a52c737bf0
Fix zero flag calculation in CPU DSL
Michael Pavone <pavone@retrodev.com>
parents:
1678
diff
changeset
|
275 |
690
fc04781f4d28
Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM
Michael Pavone <pavone@retrodev.com>
parents:
654
diff
changeset
|
276 uint32_t chunk_size(cpu_options *opts, memmap_chunk const *chunk) |
fc04781f4d28
Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM
Michael Pavone <pavone@retrodev.com>
parents:
654
diff
changeset
|
277 { |
fc04781f4d28
Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM
Michael Pavone <pavone@retrodev.com>
parents:
654
diff
changeset
|
278 if (chunk->mask == opts->address_mask) { |
fc04781f4d28
Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM
Michael Pavone <pavone@retrodev.com>
parents:
654
diff
changeset
|
279 return chunk->end - chunk->start; |
fc04781f4d28
Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM
Michael Pavone <pavone@retrodev.com>
parents:
654
diff
changeset
|
280 } else { |
fc04781f4d28
Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM
Michael Pavone <pavone@retrodev.com>
parents:
654
diff
changeset
|
281 return chunk->mask + 1; |
fc04781f4d28
Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM
Michael Pavone <pavone@retrodev.com>
parents:
654
diff
changeset
|
282 } |
fc04781f4d28
Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM
Michael Pavone <pavone@retrodev.com>
parents:
654
diff
changeset
|
283 } |
fc04781f4d28
Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM
Michael Pavone <pavone@retrodev.com>
parents:
654
diff
changeset
|
284 |
fc04781f4d28
Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM
Michael Pavone <pavone@retrodev.com>
parents:
654
diff
changeset
|
285 uint32_t ram_size(cpu_options *opts) |
fc04781f4d28
Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM
Michael Pavone <pavone@retrodev.com>
parents:
654
diff
changeset
|
286 { |
fc04781f4d28
Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM
Michael Pavone <pavone@retrodev.com>
parents:
654
diff
changeset
|
287 uint32_t size = 0; |
2042
3142602d21d8
Fix compile error post-merge
Michael Pavone <pavone@retrodev.com>
parents:
2041
diff
changeset
|
288 #ifndef NEW_CORE |
2036
45c4b74e7676
Fix bug in handling of MMAP_CODE regions smaller than 16KB
Michael Pavone <pavone@retrodev.com>
parents:
1964
diff
changeset
|
289 uint32_t minsize = 1 << (opts->ram_flags_shift + 3); |
2042
3142602d21d8
Fix compile error post-merge
Michael Pavone <pavone@retrodev.com>
parents:
2041
diff
changeset
|
290 #endif |
690
fc04781f4d28
Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM
Michael Pavone <pavone@retrodev.com>
parents:
654
diff
changeset
|
291 for (int i = 0; i < opts->memmap_chunks; i++) |
fc04781f4d28
Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM
Michael Pavone <pavone@retrodev.com>
parents:
654
diff
changeset
|
292 { |
1142
5c8b1c33ca10
Invalidate translated code on a cartridge bank change in SMS mode. Fix handling of bank 0
Michael Pavone <pavone@retrodev.com>
parents:
1130
diff
changeset
|
293 if (opts->memmap[i].flags & MMAP_CODE) { |
2036
45c4b74e7676
Fix bug in handling of MMAP_CODE regions smaller than 16KB
Michael Pavone <pavone@retrodev.com>
parents:
1964
diff
changeset
|
294 uint32_t cursize = chunk_size(opts, opts->memmap + i); |
2042
3142602d21d8
Fix compile error post-merge
Michael Pavone <pavone@retrodev.com>
parents:
2041
diff
changeset
|
295 #ifndef NEW_CORE |
2036
45c4b74e7676
Fix bug in handling of MMAP_CODE regions smaller than 16KB
Michael Pavone <pavone@retrodev.com>
parents:
1964
diff
changeset
|
296 if (cursize < minsize) { |
45c4b74e7676
Fix bug in handling of MMAP_CODE regions smaller than 16KB
Michael Pavone <pavone@retrodev.com>
parents:
1964
diff
changeset
|
297 size += minsize; |
690
fc04781f4d28
Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM
Michael Pavone <pavone@retrodev.com>
parents:
654
diff
changeset
|
298 } else { |
2042
3142602d21d8
Fix compile error post-merge
Michael Pavone <pavone@retrodev.com>
parents:
2041
diff
changeset
|
299 #endif |
2036
45c4b74e7676
Fix bug in handling of MMAP_CODE regions smaller than 16KB
Michael Pavone <pavone@retrodev.com>
parents:
1964
diff
changeset
|
300 size += cursize; |
2042
3142602d21d8
Fix compile error post-merge
Michael Pavone <pavone@retrodev.com>
parents:
2041
diff
changeset
|
301 #ifndef NEW_CORE |
690
fc04781f4d28
Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM
Michael Pavone <pavone@retrodev.com>
parents:
654
diff
changeset
|
302 } |
2042
3142602d21d8
Fix compile error post-merge
Michael Pavone <pavone@retrodev.com>
parents:
2041
diff
changeset
|
303 #endif |
690
fc04781f4d28
Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM
Michael Pavone <pavone@retrodev.com>
parents:
654
diff
changeset
|
304 } |
fc04781f4d28
Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM
Michael Pavone <pavone@retrodev.com>
parents:
654
diff
changeset
|
305 } |
fc04781f4d28
Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM
Michael Pavone <pavone@retrodev.com>
parents:
654
diff
changeset
|
306 return size; |
fc04781f4d28
Removed hardcoded assumptions in M68K core about which parts of the memory map are RAM
Michael Pavone <pavone@retrodev.com>
parents:
654
diff
changeset
|
307 } |