Commit | Line | Data |
---|---|---|
c906108c SS |
1 | #include <stdio.h> |
2 | #include <ctype.h> | |
3 | #include "ansidecl.h" | |
4 | #include "callback.h" | |
5 | #include "opcode/mn10200.h" | |
6 | #include <limits.h> | |
7 | #include "remote-sim.h" | |
8 | ||
9 | #ifndef INLINE | |
10 | #ifdef __GNUC__ | |
11 | #define INLINE inline | |
12 | #else | |
13 | #define INLINE | |
14 | #endif | |
15 | #endif | |
16 | ||
17 | extern host_callback *mn10200_callback; | |
18 | ||
19 | #define DEBUG_TRACE 0x00000001 | |
20 | #define DEBUG_VALUES 0x00000002 | |
21 | ||
22 | extern int mn10200_debug; | |
23 | ||
24 | #ifdef __STDC__ | |
25 | #define SIGNED signed | |
26 | #else | |
27 | #define SIGNED | |
28 | #endif | |
29 | ||
30 | #if UCHAR_MAX == 255 | |
31 | typedef unsigned char uint8; | |
32 | typedef SIGNED char int8; | |
33 | #else | |
34 | error "Char is not an 8-bit type" | |
35 | #endif | |
36 | ||
37 | #if SHRT_MAX == 32767 | |
38 | typedef unsigned short uint16; | |
39 | typedef SIGNED short int16; | |
40 | #else | |
41 | error "Short is not a 16-bit type" | |
42 | #endif | |
43 | ||
44 | #if INT_MAX == 2147483647 | |
45 | ||
46 | typedef unsigned int uint32; | |
47 | typedef SIGNED int int32; | |
48 | ||
49 | #else | |
50 | # if LONG_MAX == 2147483647 | |
51 | ||
52 | typedef unsigned long uint32; | |
53 | typedef SIGNED long int32; | |
54 | ||
55 | # else | |
56 | error "Neither int nor long is a 32-bit type" | |
57 | # endif | |
58 | #endif | |
59 | ||
60 | typedef uint32 reg_t; | |
61 | ||
62 | struct simops | |
63 | { | |
64 | long opcode; | |
65 | long mask; | |
66 | void (*func)(); | |
67 | int length; | |
68 | int format; | |
69 | int numops; | |
70 | int operands[16]; | |
71 | }; | |
72 | ||
73 | /* The current state of the processor; registers, memory, etc. */ | |
74 | ||
75 | struct _state | |
76 | { | |
77 | reg_t regs[11]; /* registers, d0-d3, a0-a3, pc, mdr, psw */ | |
78 | uint8 *mem; /* main memory */ | |
79 | int exception; /* Actually a signal number. */ | |
80 | int exited; /* Did the program exit? */ | |
81 | } State; | |
82 | ||
83 | extern uint32 OP[4]; | |
84 | extern struct simops Simops[]; | |
85 | ||
86 | #define PC (State.regs[8]) | |
87 | ||
88 | #define PSW (State.regs[10]) | |
89 | #define PSW_ZF 0x1 | |
90 | #define PSW_NF 0x2 | |
91 | #define PSW_CF 0x4 | |
92 | #define PSW_VF 0x8 | |
93 | #define PSW_ZX 0x10 | |
94 | #define PSW_NX 0x20 | |
95 | #define PSW_CX 0x40 | |
96 | #define PSW_VX 0x80 | |
97 | ||
98 | #define REG_D0 0 | |
99 | #define REG_A0 4 | |
100 | #define REG_SP 7 | |
101 | #define REG_PC 8 | |
102 | #define REG_MDR 9 | |
103 | #define REG_PSW 10 | |
104 | ||
105 | #define SEXT3(x) ((((x)&0x7)^(~0x3))+0x4) | |
106 | ||
107 | /* sign-extend a 4-bit number */ | |
108 | #define SEXT4(x) ((((x)&0xf)^(~0x7))+0x8) | |
109 | ||
110 | /* sign-extend a 5-bit number */ | |
111 | #define SEXT5(x) ((((x)&0x1f)^(~0xf))+0x10) | |
112 | ||
113 | /* sign-extend an 8-bit number */ | |
114 | #define SEXT8(x) ((((x)&0xff)^(~0x7f))+0x80) | |
115 | ||
116 | /* sign-extend a 9-bit number */ | |
117 | #define SEXT9(x) ((((x)&0x1ff)^(~0xff))+0x100) | |
118 | ||
119 | /* sign-extend a 16-bit number */ | |
120 | #define SEXT16(x) ((((x)&0xffff)^(~0x7fff))+0x8000) | |
121 | ||
122 | /* sign-extend a 22-bit number */ | |
123 | #define SEXT22(x) ((((x)&0x3fffff)^(~0x1fffff))+0x200000) | |
124 | ||
125 | /* sign-extend a 24-bit number */ | |
126 | #define SEXT24(x) ((((x)&0xffffff)^(~0x7fffff))+0x800000) | |
127 | ||
128 | #ifdef _WIN32 | |
129 | #define SIGTRAP 5 | |
130 | #define SIGQUIT 3 | |
131 | #endif | |
132 | ||
133 | extern int max_mem; | |
134 | ||
135 | #define load_mem_big(addr,len) \ | |
136 | (len == 1 ? *(((addr) & 0xffffff) + State.mem) : \ | |
137 | len == 2 ? ((*(((addr) & 0xffffff) + State.mem) << 8) \ | |
138 | | *((((addr) + 1) & 0xffffff) + State.mem)) : \ | |
139 | ((*(((addr) & 0xffffff) + State.mem) << 16) \ | |
140 | | (*((((addr) + 1) & 0xffffff) + State.mem) << 8) \ | |
141 | | *((((addr) + 2) & 0xffffff) + State.mem))) | |
142 | ||
143 | static INLINE uint32 | |
144 | load_byte (addr) | |
145 | SIM_ADDR addr; | |
146 | { | |
147 | uint8 *p = (addr & 0xffffff) + State.mem; | |
148 | ||
149 | #ifdef CHECK_ADDR | |
150 | if ((addr & 0xffffff) > max_mem) | |
151 | abort (); | |
152 | #endif | |
153 | ||
154 | return p[0]; | |
155 | } | |
156 | ||
157 | static INLINE uint32 | |
158 | load_half (addr) | |
159 | SIM_ADDR addr; | |
160 | { | |
161 | uint8 *p = (addr & 0xffffff) + State.mem; | |
162 | ||
163 | #ifdef CHECK_ADDR | |
164 | if ((addr & 0xffffff) > max_mem) | |
165 | abort (); | |
166 | #endif | |
167 | ||
168 | return p[1] << 8 | p[0]; | |
169 | } | |
170 | ||
171 | static INLINE uint32 | |
172 | load_3_byte (addr) | |
173 | SIM_ADDR addr; | |
174 | { | |
175 | uint8 *p = (addr & 0xffffff) + State.mem; | |
176 | ||
177 | #ifdef CHECK_ADDR | |
178 | if ((addr & 0xffffff) > max_mem) | |
179 | abort (); | |
180 | #endif | |
181 | ||
182 | return p[2] << 16 | p[1] << 8 | p[0]; | |
183 | } | |
184 | ||
185 | static INLINE uint32 | |
186 | load_word (addr) | |
187 | SIM_ADDR addr; | |
188 | { | |
189 | uint8 *p = (addr & 0xffffff) + State.mem; | |
190 | ||
191 | #ifdef CHECK_ADDR | |
192 | if ((addr & 0xffffff) > max_mem) | |
193 | abort (); | |
194 | #endif | |
195 | ||
196 | return p[3] << 24 | p[2] << 16 | p[1] << 8 | p[0]; | |
197 | } | |
198 | ||
199 | static INLINE uint32 | |
200 | load_mem (addr, len) | |
201 | SIM_ADDR addr; | |
202 | int len; | |
203 | { | |
204 | uint8 *p = (addr & 0xffffff) + State.mem; | |
205 | ||
206 | #ifdef CHECK_ADDR | |
207 | if ((addr & 0xffffff) > max_mem) | |
208 | abort (); | |
209 | #endif | |
210 | ||
211 | switch (len) | |
212 | { | |
213 | case 1: | |
214 | return p[0]; | |
215 | case 2: | |
216 | return p[1] << 8 | p[0]; | |
217 | case 3: | |
218 | return p[2] << 16 | p[1] << 8 | p[0]; | |
219 | case 4: | |
220 | return p[3] << 24 | p[2] << 16 | p[1] << 8 | p[0]; | |
221 | default: | |
222 | abort (); | |
223 | } | |
224 | } | |
225 | ||
226 | static INLINE void | |
227 | store_byte (addr, data) | |
228 | SIM_ADDR addr; | |
229 | uint32 data; | |
230 | { | |
231 | uint8 *p = (addr & 0xffffff) + State.mem; | |
232 | ||
233 | #ifdef CHECK_ADDR | |
234 | if ((addr & 0xffffff) > max_mem) | |
235 | abort (); | |
236 | #endif | |
237 | ||
238 | p[0] = data; | |
239 | } | |
240 | ||
241 | static INLINE void | |
242 | store_half (addr, data) | |
243 | SIM_ADDR addr; | |
244 | uint32 data; | |
245 | { | |
246 | uint8 *p = (addr & 0xffffff) + State.mem; | |
247 | ||
248 | #ifdef CHECK_ADDR | |
249 | if ((addr & 0xffffff) > max_mem) | |
250 | abort (); | |
251 | #endif | |
252 | ||
253 | p[0] = data; | |
254 | p[1] = data >> 8; | |
255 | } | |
256 | ||
257 | static INLINE void | |
258 | store_3_byte (addr, data) | |
259 | SIM_ADDR addr; | |
260 | uint32 data; | |
261 | { | |
262 | uint8 *p = (addr & 0xffffff) + State.mem; | |
263 | ||
264 | #ifdef CHECK_ADDR | |
265 | if ((addr & 0xffffff) > max_mem) | |
266 | abort (); | |
267 | #endif | |
268 | ||
269 | p[0] = data; | |
270 | p[1] = data >> 8; | |
271 | p[2] = data >> 16; | |
272 | } | |
273 | ||
274 | static INLINE void | |
275 | store_word (addr, data) | |
276 | SIM_ADDR addr; | |
277 | uint32 data; | |
278 | { | |
279 | uint8 *p = (addr & 0xffffff) + State.mem; | |
280 | ||
281 | #ifdef CHECK_ADDR | |
282 | if ((addr & 0xffffff) > max_mem) | |
283 | abort (); | |
284 | #endif | |
285 | ||
286 | p[0] = data; | |
287 | p[1] = data >> 8; | |
288 | p[2] = data >> 16; | |
289 | p[3] = data >> 24; | |
290 | } | |
291 | ||
292 | /* Function declarations. */ | |
293 | ||
294 | uint32 get_word PARAMS ((uint8 *)); | |
295 | void put_word PARAMS ((uint8 *, uint32)); | |
296 | ||
297 | extern uint8 *map PARAMS ((SIM_ADDR addr)); |