1 // license:BSD-3-Clause
2 // copyright-holders:Farfetch'd, R. Belmont
3
4 #include "emu.h"
5 #include "v60d.h"
6
7 // Register names
8 const char *const v60_disassembler::v60_reg_names[69] = {
9 "R0", "R1", "R2", "R3",
10 "R4", "R5", "R6", "R7",
11 "R8", "R9", "R10", "R11",
12 "R12", "R13", "R14", "R15",
13 "R16", "R17", "R18", "R19",
14 "R20", "R21", "R22", "R23",
15 "R24", "R25", "R26", "R27",
16 "R28", "AP", "FP", "SP",
17 "PC", "PSW","Unk","Unk",
18 "ISP", "L0SP", "L1SP", "L2SP",
19 "L3SP", "SBR","TR","SYCW",
20 "TKCW", "PIR", "Reserved","Reserved",
21 "Reserved","Reserved","Reserved","PSW2",
22 "ATBR0", "ATLR0", "ATBR1", "ATLR1",
23 "ATBR2", "ATLR2", "ATBR3", "ATLR3",
24 "TRMODE", "ADTR0", "ADTR1","ADTMR0",
25 "ADTMR1","Reserved","Reserved","Reserved"
26 };
27
out_AM_Register(int reg,std::ostream & stream)28 void v60_disassembler::out_AM_Register(int reg, std::ostream &stream)
29 {
30 stream << v60_reg_names[reg];
31 }
32
out_AM_RegisterIndirect(int reg,int opsize,std::ostream & stream)33 void v60_disassembler::out_AM_RegisterIndirect(int reg, int opsize, std::ostream &stream)
34 {
35 if(opsize & 0x80)
36 stream << '@';
37 util::stream_format(stream, "[%s]", v60_reg_names[reg]);
38 }
39
out_AM_RegisterIndirectIndexed(int rn,int rx,int opsize,std::ostream & stream)40 void v60_disassembler::out_AM_RegisterIndirectIndexed(int rn, int rx, int opsize, std::ostream &stream)
41 {
42 if(opsize & 0x80)
43 util::stream_format(stream, "%s@[%s]", v60_reg_names[rx], v60_reg_names[rn]);
44 else
45 util::stream_format(stream, "[%s](%s)", v60_reg_names[rn], v60_reg_names[rx]);
46
47 }
48
out_AM_Autoincrement(int reg,int opsize,std::ostream & stream)49 void v60_disassembler::out_AM_Autoincrement(int reg, int opsize, std::ostream &stream)
50 {
51 if(opsize & 0x80)
52 stream << '@';
53 util::stream_format(stream, "[%s+]", v60_reg_names[reg]);
54 }
55
out_AM_Autodecrement(int reg,int opsize,std::ostream & stream)56 void v60_disassembler::out_AM_Autodecrement(int reg, int opsize, std::ostream &stream)
57 {
58 if(opsize & 0x80)
59 stream << '@';
60 util::stream_format(stream, "[-%s]", v60_reg_names[reg]);
61 }
62
out_AM_Displacement(int reg,int disp,int opsize,std::ostream & stream)63 void v60_disassembler::out_AM_Displacement(int reg, int disp, int opsize, std::ostream &stream)
64 {
65 util::stream_format(stream, "%s%X%s[%s]",
66 disp >= 0 ? "" : "-", disp >= 0 ? disp : -disp,
67 opsize & 0x80 ? "@" : "",
68 v60_reg_names[reg]);
69 }
70
out_AM_DisplacementIndexed(int rn,int rx,int disp,int opsize,std::ostream & stream)71 void v60_disassembler::out_AM_DisplacementIndexed(int rn, int rx, int disp, int opsize, std::ostream &stream)
72 {
73 if(opsize & 0x80)
74 util::stream_format(stream, "%s@%s%X[%s]", v60_reg_names[rx], disp >= 0 ? "" : "-", disp >= 0 ? disp : -disp,v60_reg_names[rn]);
75 else
76 util::stream_format(stream, "%s%X[%s](%s)", disp >= 0 ? "" : "-", disp >= 0 ? disp : -disp,v60_reg_names[rn], v60_reg_names[rx]);
77 }
78
out_AM_PCDisplacement(offs_t pc,int disp,int opsize,std::ostream & stream)79 void v60_disassembler::out_AM_PCDisplacement(offs_t pc, int disp, int opsize, std::ostream &stream)
80 {
81 util::stream_format(stream, "%X%s[PC]", pc+disp, opsize & 0x80 ? "@" : "");
82 }
83
out_AM_PCDisplacementIndexed(offs_t pc,int disp,int rx,int opsize,std::ostream & stream)84 void v60_disassembler::out_AM_PCDisplacementIndexed(offs_t pc, int disp, int rx, int opsize, std::ostream &stream)
85 {
86 if(opsize & 0x80)
87 util::stream_format(stream, "%s@%X[PC]", v60_reg_names[rx], pc+disp);
88 else
89 util::stream_format(stream, "%X[PC](%s)", pc+disp, v60_reg_names[rx]);
90 }
91
out_AM_DisplacementIndirect(int reg,int disp,int opsize,std::ostream & stream)92 void v60_disassembler::out_AM_DisplacementIndirect(int reg, int disp, int opsize, std::ostream &stream)
93 {
94 util::stream_format(stream, "%s[%s%X[%s]]",
95 opsize & 0x80 ? "@" : "",
96 disp >= 0 ? "" : "-", disp >= 0 ? disp : -disp,
97 v60_reg_names[reg]);
98 }
99
out_AM_DisplacementIndirectIndexed(int rn,int rx,int disp,int opsize,std::ostream & stream)100 void v60_disassembler::out_AM_DisplacementIndirectIndexed(int rn, int rx, int disp, int opsize, std::ostream &stream)
101 {
102 if(opsize & 0x80)
103 util::stream_format(stream, "%s@[%s%X[%s]]", v60_reg_names[rx], disp >= 0 ? "" : "-", disp >= 0 ? disp : -disp,v60_reg_names[rn]);
104 else
105 util::stream_format(stream, "[%s%X[%s]](%s)", disp >= 0 ? "" : "-", disp >= 0 ? disp : -disp,v60_reg_names[rn], v60_reg_names[rx]);
106 }
107
out_AM_PCDisplacementIndirect(offs_t pc,int disp,int opsize,std::ostream & stream)108 void v60_disassembler::out_AM_PCDisplacementIndirect(offs_t pc, int disp, int opsize, std::ostream &stream)
109 {
110 util::stream_format(stream, "%s[%X[PC]]", opsize & 0x80 ? "@" : "", pc+disp);
111 }
112
out_AM_PCDisplacementIndirectIndexed(offs_t pc,int disp,int rx,int opsize,std::ostream & stream)113 void v60_disassembler::out_AM_PCDisplacementIndirectIndexed(offs_t pc, int disp, int rx, int opsize, std::ostream &stream)
114 {
115 if(opsize & 0x80)
116 util::stream_format(stream, "%s@[%X[PC]]", v60_reg_names[rx], pc+disp);
117 else
118 util::stream_format(stream, "[%X[PC]](%s)", pc+disp, v60_reg_names[rx]);
119 }
120
out_AM_DoubleDisplacement(int reg,int disp2,int disp1,int opsize,std::ostream & stream)121 void v60_disassembler::out_AM_DoubleDisplacement(int reg, int disp2, int disp1, int opsize, std::ostream &stream)
122 {
123 util::stream_format(stream, "%s%X%s[%s%X[%s]]",
124 disp1 >= 0 ? "" : "-", disp1 >= 0 ? disp1 : -disp1,
125 opsize & 0x80 ? "@" : "",
126 disp2 >= 0 ? "" : "-", disp2 >= 0 ? disp2 : -disp2,
127 v60_reg_names[reg]);
128 }
129
out_AM_PCDoubleDisplacement(offs_t pc,int disp2,int disp1,int opsize,std::ostream & stream)130 void v60_disassembler::out_AM_PCDoubleDisplacement(offs_t pc, int disp2, int disp1, int opsize, std::ostream &stream)
131 {
132 util::stream_format(stream, "%s%X%s[%X[PC]]",
133 disp1 >= 0 ? "" : "-", disp1 >= 0 ? disp1 : -disp1,
134 opsize & 0x80 ? "@" : "",
135 disp2 + pc);
136 }
137
out_AM_DirectAddress(unsigned addr,int opsize,std::ostream & stream)138 void v60_disassembler::out_AM_DirectAddress(unsigned addr, int opsize, std::ostream &stream)
139 {
140 if(opsize & 0x80)
141 stream << '@';
142 util::stream_format(stream, "%X", addr);
143 }
144
out_AM_DirectAddressIndexed(unsigned addr,int rx,int opsize,std::ostream & stream)145 void v60_disassembler::out_AM_DirectAddressIndexed(unsigned addr, int rx, int opsize, std::ostream &stream)
146 {
147 if(opsize & 0x80)
148 util::stream_format(stream, "%s@%X", v60_reg_names[rx], addr);
149 else
150 util::stream_format(stream, "%X(%s)", addr, v60_reg_names[rx]);
151 }
152
out_AM_DirectAddressDeferred(unsigned addr,int opsize,std::ostream & stream)153 void v60_disassembler::out_AM_DirectAddressDeferred(unsigned addr, int opsize, std::ostream &stream)
154 {
155 if(opsize & 0x80)
156 stream << '@';
157 util::stream_format(stream, "[%X]", addr);
158 }
159
out_AM_DirectAddressDeferredIndexed(unsigned addr,int rx,int opsize,std::ostream & stream)160 void v60_disassembler::out_AM_DirectAddressDeferredIndexed(unsigned addr, int rx, int opsize, std::ostream &stream)
161 {
162 if(opsize & 0x80)
163 util::stream_format(stream, "%s@[%X]", v60_reg_names[rx], addr);
164 else
165 util::stream_format(stream, "[%X](%s)", addr, v60_reg_names[rx]);
166 }
167
out_AM_Immediate(unsigned value,int opsize,std::ostream & stream)168 void v60_disassembler::out_AM_Immediate(unsigned value, int opsize, std::ostream &stream)
169 {
170 if(opsize == 0)
171 value &= 0xff;
172 else if(opsize == 1)
173 value &= 0xffff;
174
175 util::stream_format(stream, "#%X", value);
176 }
177
decode_AM(unsigned ipc,offs_t pc,int m,int opsize,const data_buffer & opcodes,std::ostream & stream)178 u32 v60_disassembler::decode_AM(unsigned ipc, offs_t pc, int m, int opsize, const data_buffer &opcodes, std::ostream &stream)
179 {
180 unsigned char mod = opcodes.r8(pc);
181 if(m) {
182 switch(mod>>5) {
183 case 0: // Double displacement (8 bit)
184 out_AM_DoubleDisplacement(mod&0x1F, int8_t(opcodes.r8(pc+1)), int8_t(opcodes.r8(pc+2)), opsize, stream);
185 return 3;
186
187 case 1: // Double displacement (16 bit)
188 out_AM_DoubleDisplacement(mod&0x1F, int16_t(opcodes.r16(pc+1)), int16_t(opcodes.r16(pc+3)), opsize, stream);
189 return 5;
190
191 case 2: // Double displacement (32 bit)
192 out_AM_DoubleDisplacement(mod&0x1F, int32_t(opcodes.r32(pc+1)), int32_t(opcodes.r32(pc+5)), opsize, stream);
193 return 9;
194
195 case 3: // Register
196 out_AM_Register(mod&0x1F, stream);
197 return 1;
198
199 case 4: // Autoincrement
200 out_AM_Autoincrement(mod&0x1F, opsize, stream);
201 return 1;
202
203 case 5: // Autodecrement
204 out_AM_Autodecrement(mod&0x1F, opsize, stream);
205 return 1;
206
207 case 6:
208 switch (opcodes.r8(pc+1)>>5)
209 {
210 case 0: // Displacement indexed (8 bit)
211 out_AM_DisplacementIndexed(opcodes.r8(pc+1)&0x1F, mod&0x1F, int8_t(opcodes.r8(pc+2)), opsize, stream);
212 return 3;
213
214 case 1: // Displacement indexed (16 bit)
215 out_AM_DisplacementIndexed(opcodes.r8(pc+1)&0x1F, mod&0x1F, int16_t(opcodes.r16(pc+2)), opsize, stream);
216 return 4;
217
218 case 2: // Displacement indexed (32 bit)
219 out_AM_DisplacementIndexed(opcodes.r8(pc+1)&0x1F, mod&0x1F, int32_t(opcodes.r32(pc+2)), opsize, stream);
220 return 6;
221
222 case 3: // Register indirect indexed
223 out_AM_RegisterIndirectIndexed(opcodes.r8(pc+1)&0x1F, mod&0x1F, opsize, stream);
224 return 2;
225
226 case 4: // Displacement indirect indexed (8 bit)
227 out_AM_DisplacementIndirectIndexed(opcodes.r8(pc+1)&0x1F, mod&0x1F, int8_t(opcodes.r8(pc+2)), opsize, stream);
228 return 3;
229
230 case 5: // Displacement indirect indexed (16 bit)
231 out_AM_DisplacementIndirectIndexed(opcodes.r8(pc+1)&0x1F, mod&0x1F, int16_t(opcodes.r16(pc+2)), opsize, stream);
232 return 4;
233
234 case 6: // Displacement indirect indexed (32 bit)
235 out_AM_DisplacementIndirectIndexed(opcodes.r8(pc+1)&0x1F, mod&0x1F, int32_t(opcodes.r32(pc+2)), opsize, stream);
236 return 6;
237
238 case 7:
239 switch (opcodes.r8(pc+1)&0x1F)
240 {
241 case 16: // PC Displacement Indexed (8 bit)
242 out_AM_PCDisplacementIndexed(ipc, int8_t(opcodes.r8(pc+2)), mod&0x1F, opsize, stream);
243 return 3;
244
245 case 17: // PC Displacement Indexed (16 bit)
246 out_AM_PCDisplacementIndexed(ipc, int16_t(opcodes.r16(pc+2)), mod&0x1F, opsize, stream);
247 return 4;
248
249 case 18: // PC Displacement Indexed (32 bit)
250 out_AM_PCDisplacementIndexed(ipc, int32_t(opcodes.r32(pc+2)), mod&0x1F, opsize, stream);
251 return 6;
252
253 case 19: // Direct Address Indexed
254 out_AM_DirectAddressIndexed(opcodes.r32(pc+2), mod&0x1F, opsize, stream);
255 return 6;
256
257 case 24: // PC Displacement Indirect Indexed(8 bit)
258 out_AM_PCDisplacementIndirectIndexed(ipc, int8_t(opcodes.r8(pc+2)), mod&0x1F, opsize, stream);
259 return 3;
260
261 case 25: // PC Displacement Indirect Indexed (16 bit)
262 out_AM_PCDisplacementIndirectIndexed(ipc, int16_t(opcodes.r16(pc+2)), mod&0x1F, opsize, stream);
263 return 4;
264
265 case 26: // PC Displacement Indirect Indexed (32 bit)
266 out_AM_PCDisplacementIndirectIndexed(ipc, int32_t(opcodes.r32(pc+2)), mod&0x1F, opsize, stream);
267 return 6;
268
269 case 27: // Direct Address Deferred Indexed
270 out_AM_DirectAddressDeferredIndexed(opcodes.r32(pc+2), mod&0x1F, opsize, stream);
271 return 6;
272
273 default:
274 stream << "!ERRAM3";
275 return 1;
276 }
277
278 default:
279 stream << "!ERRAM2";
280 return 1;
281 }
282
283 default:
284 stream << "!ERRAM1";
285 return 1;
286 }
287 } else {
288 switch(mod>>5) {
289 case 0: // Displacement (8 bit)
290 out_AM_Displacement(mod&0x1F, int8_t(opcodes.r8(pc+1)), opsize, stream);
291 return 2;
292
293 case 1: // Displacement (16 bit)
294 out_AM_Displacement(mod&0x1F, int16_t(opcodes.r16(pc+1)), opsize, stream);
295 return 3;
296
297 case 2: // Displacement (32 bit)
298 out_AM_Displacement(mod&0x1F, int32_t(opcodes.r32(pc+1)), opsize, stream);
299 return 5;
300
301 case 3: // Register indirect
302 out_AM_RegisterIndirect(mod&0x1F, opsize, stream);
303 return 1;
304
305 case 4: // Displacement indirect (8 bit)
306 out_AM_DisplacementIndirect(mod&0x1F, int8_t(opcodes.r8(pc+1)), opsize, stream);
307 return 2;
308
309 case 5: // Displacement indirect (16 bit)
310 out_AM_DisplacementIndirect(mod&0x1F, int16_t(opcodes.r16(pc+1)), opsize, stream);
311 return 3;
312
313 case 6: // Displacement indirect (32 bit)
314 out_AM_DisplacementIndirect(mod&0x1F, int32_t(opcodes.r32(pc+1)), opsize, stream);
315 return 5;
316
317 case 7:
318 switch(mod&0x1F) {
319 case 0:
320 case 1:
321 case 2:
322 case 3:
323 case 4:
324 case 5:
325 case 6:
326 case 7:
327 case 8:
328 case 9:
329 case 10:
330 case 11:
331 case 12:
332 case 13:
333 case 14:
334 case 15:
335 out_AM_Immediate(mod&0x1F, opsize, stream);
336 return 1;
337
338 case 16: // PC Displacement (8 bit)
339 out_AM_PCDisplacement(ipc, int8_t(opcodes.r8(pc+1)), opsize, stream);
340 return 2;
341
342 case 17: // PC Displacement (16 bit)
343 out_AM_PCDisplacement(ipc, int16_t(opcodes.r16(pc+1)), opsize, stream);
344 return 3;
345
346 case 18: // PC Displacement (32 bit)
347 out_AM_PCDisplacement(ipc, int32_t(opcodes.r32(pc+1)), opsize, stream);
348 return 5;
349
350 case 19: // Direct Address
351 out_AM_DirectAddress(opcodes.r32(pc+1), opsize, stream);
352 return 5;
353
354
355 case 20:
356 switch(opsize&0x7F) {
357 case 0: // Immediate (8 bit)
358 out_AM_Immediate(opcodes.r8(pc+1), opsize, stream);
359 return 2;
360
361 case 1: // Immediate (16 bit)
362 out_AM_Immediate(opcodes.r16(pc+1), opsize, stream);
363 return 3;
364
365 case 2: // Immediate (32 bit)
366 out_AM_Immediate(opcodes.r32(pc+1), opsize, stream);
367 return 5;
368
369 default:
370 stream << "!ERRAM6";
371 return 1;
372 }
373
374 case 24: // PC Displacement Indirect (8 bit)
375 out_AM_PCDisplacementIndirect(ipc, int8_t(opcodes.r8(pc+1)), opsize, stream);
376 return 2;
377
378 case 25: // PC Displacement Indirect (16 bit)
379 out_AM_PCDisplacementIndirect(ipc, int16_t(opcodes.r16(pc+1)), opsize, stream);
380 return 3;
381
382 case 26: // PC Displacement Indirect (32 bit)
383 out_AM_PCDisplacementIndirect(ipc, int32_t(opcodes.r32(pc+1)), opsize, stream);
384 return 5;
385
386 case 27: // Direct Address Deferred
387 out_AM_DirectAddressDeferred(opcodes.r32(pc+1), opsize, stream);
388 return 5;
389
390 case 28: // PC Double Displacement (8 bit)
391 out_AM_PCDoubleDisplacement(ipc, int8_t(opcodes.r8(pc+1)), int8_t(opcodes.r8(pc+2)), opsize, stream);
392 return 3;
393
394 case 29: // PC Double Displacement (16 bit)
395 out_AM_PCDoubleDisplacement(ipc, int16_t(opcodes.r16(pc+1)), int16_t(opcodes.r16(pc+3)), opsize, stream);
396 return 5;
397
398 case 30: // PC Double Displacement (32 bit)
399 out_AM_PCDoubleDisplacement(ipc, int32_t(opcodes.r32(pc+1)), int32_t(opcodes.r32(pc+5)), opsize, stream);
400 return 9;
401
402 default:
403 stream << "!ERRAM5";
404 return 1;
405 }
406
407 default:
408 stream << "!ERRAM4";
409 return 1;
410 }
411 }
412 }
413
414
decode_F1(const char * opnm,int opsize1,int opsize2,unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)415 u32 v60_disassembler::decode_F1(const char *opnm, int opsize1, int opsize2, unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
416 {
417 unsigned char code = opcodes.r8(pc);
418 util::stream_format(stream, "%-8s", opnm);
419 if(code & 0x20) {
420 int ret = decode_AM(ipc, pc+1, code & 0x40, opsize1, opcodes, stream) + 2;
421 stream << ", ";
422 out_AM_Register(code & 0x1f, stream);
423 return ret;
424 } else {
425 out_AM_Register(code & 0x1f, stream);
426 stream << ", ";
427 return decode_AM(ipc, pc+1, code & 0x40, opsize1, opcodes, stream) + 2;
428 }
429 }
430
decode_F2(const char * opnm,int opsize1,int opsize2,unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)431 u32 v60_disassembler::decode_F2(const char *opnm, int opsize1, int opsize2, unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
432 {
433 int ret;
434 unsigned char code = opcodes.r8(pc);
435 util::stream_format(stream, "%-8s", opnm);
436 ret = decode_AM(ipc, pc+1, code & 0x40, opsize1, opcodes, stream);
437 stream << ", ";
438 ret += decode_AM(ipc, pc+1+ret, code & 0x20, opsize2, opcodes, stream);
439 return ret+2;
440 }
441
decode_F1F2(const char * opnm,int opsize1,int opsize2,unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)442 u32 v60_disassembler::decode_F1F2(const char *opnm, int opsize1, int opsize2, unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
443 {
444 if(opcodes.r8(pc) & 0x80)
445 return decode_F2(opnm, opsize1, opsize2, ipc, pc, opcodes, stream);
446 else
447 return decode_F1(opnm, opsize1, opsize2, ipc, pc, opcodes, stream);
448 }
449
decode_F3(const char * opnm,int opsize1,int opsize2,unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)450 u32 v60_disassembler::decode_F3(const char *opnm, int opsize1, int opsize2, unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
451 {
452 util::stream_format(stream, "%-8s", opnm);
453 return decode_AM(ipc, pc, opcodes.r8(pc-1) & 1, opsize1, opcodes, stream) + 1;
454 }
455
decode_F4a(const char * opnm,int opsize1,int opsize2,unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)456 u32 v60_disassembler::decode_F4a(const char *opnm, int opsize1, int opsize2, unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
457 {
458 util::stream_format(stream, "%-8s%X", opnm, ipc + int8_t(opcodes.r8(pc)));
459 return 2;
460 }
461
decode_F4b(const char * opnm,int opsize1,int opsize2,unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)462 u32 v60_disassembler::decode_F4b(const char *opnm, int opsize1, int opsize2, unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
463 {
464 util::stream_format(stream, "%-8s%X", opnm, ipc + int16_t(opcodes.r16(pc)));
465 return 3;
466 }
467
decode_F5(const char * opnm,int opsize1,int opsize2,unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)468 u32 v60_disassembler::decode_F5(const char *opnm, int opsize1, int opsize2, unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
469 {
470 stream << opnm;
471 return 1;
472 }
473
decode_F6(const char * opnm,int opsize1,int opsize2,unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)474 u32 v60_disassembler::decode_F6(const char *opnm, int opsize1, int opsize2, unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
475 {
476 util::stream_format(stream, "%-8s%s, %X[PC]", opnm, v60_reg_names[opcodes.r8(pc) & 0x1f], ipc + int16_t(opcodes.r16(pc+1)));
477 return 4;
478 }
479
decode_F7a(const char * opnm,int opsize1,int opsize2,unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)480 u32 v60_disassembler::decode_F7a(const char *opnm, int opsize1, int opsize2, unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
481 {
482 int ret;
483 unsigned char code = opcodes.r8(pc);
484 unsigned char code2;
485
486 util::stream_format(stream, "%-8s", opnm);
487 ret = decode_AM(ipc, pc+1, code & 0x40, opsize1, opcodes, stream);
488 stream << ", ";
489
490 code2 = opcodes.r8(pc+1+ret);
491 if(code2 & 0x80)
492 out_AM_Register(code2 & 0x1f, stream);
493 else
494 out_AM_Immediate(code2, 1, stream);
495 stream << ", ";
496
497 ret += decode_AM(ipc, pc+2+ret, code & 0x20, opsize2, opcodes, stream);
498 stream << ", ";
499
500 code2 = opcodes.r8(pc+2+ret);
501 if(code2 & 0x80)
502 out_AM_Register(code2 & 0x1f, stream);
503 else
504 out_AM_Immediate(code2, 1, stream);
505
506 return ret+4;
507 }
508
decode_F7b(const char * opnm,int opsize1,int opsize2,unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)509 u32 v60_disassembler::decode_F7b(const char *opnm, int opsize1, int opsize2, unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
510 {
511 int ret;
512 unsigned char code = opcodes.r8(pc);
513 unsigned char code2;
514
515 util::stream_format(stream, "%-8s", opnm);
516 ret = decode_AM(ipc, pc+1, code & 0x40, opsize1, opcodes, stream);
517 stream << ", ";
518
519 code2 = opcodes.r8(pc+1+ret);
520 if(code2 & 0x80)
521 out_AM_Register(code2 & 0x1f, stream);
522 else
523 out_AM_Immediate(code2, 1, stream);
524 stream << ", ";
525
526 ret += decode_AM(ipc, pc+2+ret, code & 0x20, opsize2, opcodes, stream);
527
528 return ret+3;
529 }
530
decode_F7c(const char * opnm,int opsize1,int opsize2,unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)531 u32 v60_disassembler::decode_F7c(const char *opnm, int opsize1, int opsize2, unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
532 {
533 int ret;
534 unsigned char code = opcodes.r8(pc);
535 unsigned char code2;
536
537 util::stream_format(stream, "%-8s", opnm);
538 ret = decode_AM(ipc, pc+1, code & 0x40, opsize1, opcodes, stream);
539 stream << ", ";
540
541 ret += decode_AM(ipc, pc+1+ret, code & 0x20, opsize2, opcodes, stream);
542 stream << ", ";
543
544 code2 = opcodes.r8(pc+1+ret);
545 if(code2 & 0x80)
546 out_AM_Register(code2 & 0x1f, stream);
547 else
548 out_AM_Immediate(code2, 1, stream);
549
550 return ret+3;
551 }
552
dopUNHANDLED(unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)553 u32 v60_disassembler::dopUNHANDLED(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
554 {
555 util::stream_format(stream, "$%02X", opcodes.r8(pc));
556 return 1;
557 }
558
dop58UNHANDLED(unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)559 u32 v60_disassembler::dop58UNHANDLED(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
560 {
561 util::stream_format(stream, "$58");
562 return 1;
563 }
564
dop59UNHANDLED(unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)565 u32 v60_disassembler::dop59UNHANDLED(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
566 {
567 util::stream_format(stream, "$59");
568 return 1;
569 }
570
dop5AUNHANDLED(unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)571 u32 v60_disassembler::dop5AUNHANDLED(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
572 {
573 util::stream_format(stream, "$5A");
574 return 1;
575 }
576
dop5BUNHANDLED(unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)577 u32 v60_disassembler::dop5BUNHANDLED(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
578 {
579 util::stream_format(stream, "$5B");
580 return 1;
581 }
582
dop5CUNHANDLED(unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)583 u32 v60_disassembler::dop5CUNHANDLED(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
584 {
585 util::stream_format(stream, "$5C");
586 return 1;
587 }
588
dop5DUNHANDLED(unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)589 u32 v60_disassembler::dop5DUNHANDLED(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
590 {
591 util::stream_format(stream, "$5D");
592 return 1;
593 }
594
dop5EUNHANDLED(unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)595 u32 v60_disassembler::dop5EUNHANDLED(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
596 {
597 util::stream_format(stream, "$5E");
598 return 1;
599 }
600
dop5FUNHANDLED(unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)601 u32 v60_disassembler::dop5FUNHANDLED(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
602 {
603 util::stream_format(stream, "$5F");
604 return 1;
605 }
606
607 #define DEFINE_EASY_OPCODE(name, opnm, ftype, opsize1, opsize2) \
608 u32 v60_disassembler::dop ## name(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream) \
609 { \
610 return decode_ ## ftype(opnm, opsize1, opsize2, ipc, pc, opcodes, stream); \
611 }
612
613 #define DEFINE_EASY_OPCODE_EX(name, opnm, ftype, opsize1, opsize2, flags) \
614 u32 v60_disassembler::dop ## name(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream) \
615 { \
616 return decode_ ## ftype(opnm, opsize1, opsize2, ipc, pc, opcodes, stream) | (flags); \
617 }
618
619 #define DEFINE_TRIPLE_OPCODE(name, string, ftype) \
620 DEFINE_EASY_OPCODE(name##B,string ".b", ftype, 0, 0) \
621 DEFINE_EASY_OPCODE(name##H,string ".h", ftype, 1, 1) \
622 DEFINE_EASY_OPCODE(name##W,string ".w", ftype, 2, 2)
623
624 #define DEFINE_DOUBLE_OPCODE(name, string, ftype) \
625 DEFINE_EASY_OPCODE(name##B,string ".b", ftype, 0, 0) \
626 DEFINE_EASY_OPCODE(name##H,string ".h", ftype, 1, 1)
627
628 #define DEFINE_FPU_OPCODE(name,string,ftype) \
629 DEFINE_EASY_OPCODE(name##S,string ".s", ftype, 2, 2) \
630 DEFINE_EASY_OPCODE(name##L,string ".l", ftype, 2, 2)
631
632
633 DEFINE_FPU_OPCODE(ABSF, "absf", F2)
634 DEFINE_TRIPLE_OPCODE(ADD, "add", F1F2)
635 DEFINE_TRIPLE_OPCODE(ADDC, "addc", F1F2)
636 DEFINE_EASY_OPCODE(ADDDC, "adddc", F7c, 0, 0)
637 DEFINE_FPU_OPCODE(ADDF, "addf", F2)
638 DEFINE_TRIPLE_OPCODE(AND, "and", F1F2)
639 DEFINE_EASY_OPCODE(ANDBSU, "andbsu", F7b, 0x80, 0x80)
640 DEFINE_EASY_OPCODE(ANDBSD, "andbsd", F7b, 0x80, 0x80)
641 DEFINE_EASY_OPCODE(ANDNBSU, "andnbsu", F7b, 0x80, 0x80)
642 DEFINE_EASY_OPCODE(ANDNBSD, "andnbsd", F7b, 0x80, 0x80)
643 DEFINE_EASY_OPCODE(BGT8, "bgt", F4a, 0, 0)
644 DEFINE_EASY_OPCODE(BGT16, "bgt", F4b, 0, 0)
645 DEFINE_EASY_OPCODE(BGE8, "bge", F4a, 0, 0)
646 DEFINE_EASY_OPCODE(BGE16, "bge", F4b, 0, 0)
647 DEFINE_EASY_OPCODE(BLT8, "blt", F4a, 0, 0)
648 DEFINE_EASY_OPCODE(BLT16, "blt", F4b, 0, 0)
649 DEFINE_EASY_OPCODE(BLE8, "ble", F4a, 0, 0)
650 DEFINE_EASY_OPCODE(BLE16, "ble", F4b, 0, 0)
651 DEFINE_EASY_OPCODE(BH8, "bh", F4a, 0, 0)
652 DEFINE_EASY_OPCODE(BH16, "bh", F4b, 0, 0)
653 DEFINE_EASY_OPCODE(BNL8, "bnl", F4a, 0, 0)
654 DEFINE_EASY_OPCODE(BNL16, "bnl", F4b, 0, 0)
655 DEFINE_EASY_OPCODE(BL8, "bl", F4a, 0, 0)
656 DEFINE_EASY_OPCODE(BL16, "bl", F4b, 0, 0)
657 DEFINE_EASY_OPCODE(BNH8, "bnh", F4a, 0, 0)
658 DEFINE_EASY_OPCODE(BNH16, "bnh", F4b, 0, 0)
659 DEFINE_EASY_OPCODE(BE8, "be", F4a, 0, 0)
660 DEFINE_EASY_OPCODE(BE16, "be", F4b, 0, 0)
661 DEFINE_EASY_OPCODE(BNE8, "bne", F4a, 0, 0)
662 DEFINE_EASY_OPCODE(BNE16, "bne", F4b, 0, 0)
663 DEFINE_EASY_OPCODE(BV8, "bv", F4a, 0, 0)
664 DEFINE_EASY_OPCODE(BV16, "bv", F4b, 0, 0)
665 DEFINE_EASY_OPCODE(BNV8, "bnv", F4a, 0, 0)
666 DEFINE_EASY_OPCODE(BNV16, "bnv", F4b, 0, 0)
667 DEFINE_EASY_OPCODE(BN8, "bn", F4a, 0, 0)
668 DEFINE_EASY_OPCODE(BN16, "bn", F4b, 0, 0)
669 DEFINE_EASY_OPCODE(BP8, "bp", F4a, 0, 0)
670 DEFINE_EASY_OPCODE(BP16, "bp", F4b, 0, 0)
671 DEFINE_EASY_OPCODE(BR8, "br", F4a, 0, 0)
672 DEFINE_EASY_OPCODE(BR16, "br", F4b, 0, 0)
673 DEFINE_EASY_OPCODE(BRK, "brk", F5, 0, 0)
674 DEFINE_EASY_OPCODE(BRKV, "brkv", F5, 0, 0)
675 DEFINE_EASY_OPCODE_EX(BSR, "bsr", F4b, 0, 0, STEP_OVER)
676 DEFINE_EASY_OPCODE_EX(CALL, "call", F1F2, 0, 2, STEP_OVER)
677 DEFINE_EASY_OPCODE(CAXI, "caxi", F1, 2, 2)
678 DEFINE_EASY_OPCODE(CHKAR, "chkar", F1F2, 0, 0) // ?
679 DEFINE_EASY_OPCODE(CHKAW, "chkaw", F1F2, 0, 0) // ?
680 DEFINE_EASY_OPCODE(CHKAE, "chkae", F1F2, 0, 0)
681 DEFINE_EASY_OPCODE(CHLVL, "chlvl", F1F2, 0, 0)
682 DEFINE_EASY_OPCODE(CLR1, "clr1", F1F2, 2, 2)
683 DEFINE_EASY_OPCODE(CLRTLB, "clrtlb", F3, 0, 0) // ?
684 DEFINE_EASY_OPCODE(CLRTLBA, "clrtlba", F5, 0, 0)
685 DEFINE_TRIPLE_OPCODE(CMP, "cmp", F1F2)
686 DEFINE_EASY_OPCODE(CMPBFS, "cmpbfs", F7b, 0x82, 2)
687 DEFINE_EASY_OPCODE(CMPBFZ, "cmpbfz", F7b, 0x82, 2)
688 DEFINE_EASY_OPCODE(CMPBFL, "cmpbfl", F7b, 0x82, 2)
689 DEFINE_DOUBLE_OPCODE(CMPC, "cmpc", F7a)
690 DEFINE_DOUBLE_OPCODE(CMPCF, "cmpcf", F7a)
691 DEFINE_DOUBLE_OPCODE(CMPCS, "cmpcs", F7a)
692 DEFINE_FPU_OPCODE(CMPF, "cmpf", F2)
693 DEFINE_EASY_OPCODE(CVTSL, "cvt.sl", F2, 0, 1)
694 DEFINE_EASY_OPCODE(CVTLS, "cvt.ls", F2, 1, 0)
695 DEFINE_EASY_OPCODE(CVTWS, "cvt.ws", F2, 2, 0)
696 DEFINE_EASY_OPCODE(CVTWL, "cvt.wl", F2, 2, 1)
697 DEFINE_EASY_OPCODE(CVTSW, "cvt.sw", F2, 0, 2)
698 DEFINE_EASY_OPCODE(CVTLW, "cvt.lw", F2, 1, 2)
699 DEFINE_EASY_OPCODE(CVTDPZ, "cvtd.pz", F7c, 0, 1)
700 DEFINE_EASY_OPCODE(CVTDZP, "cvtd.zp", F7c, 1, 0)
701 DEFINE_EASY_OPCODE_EX(DBGT, "dbgt", F6, 0, 0, STEP_OVER)
702 DEFINE_EASY_OPCODE_EX(DBGE, "dbge", F6, 0, 0, STEP_OVER)
703 DEFINE_EASY_OPCODE_EX(DBLT, "dbgt", F6, 0, 0, STEP_OVER)
704 DEFINE_EASY_OPCODE_EX(DBLE, "dbge", F6, 0, 0, STEP_OVER)
705 DEFINE_EASY_OPCODE_EX(DBH, "dbh", F6, 0, 0, STEP_OVER)
706 DEFINE_EASY_OPCODE_EX(DBNL, "dbnl", F6, 0, 0, STEP_OVER)
707 DEFINE_EASY_OPCODE_EX(DBL, "dbl", F6, 0, 0, STEP_OVER)
708 DEFINE_EASY_OPCODE_EX(DBNH, "dbnh", F6, 0, 0, STEP_OVER)
709 DEFINE_EASY_OPCODE_EX(DBE, "dbe", F6, 0, 0, STEP_OVER)
710 DEFINE_EASY_OPCODE_EX(DBNE, "dbne", F6, 0, 0, STEP_OVER)
711 DEFINE_EASY_OPCODE_EX(DBV, "dbe", F6, 0, 0, STEP_OVER)
712 DEFINE_EASY_OPCODE_EX(DBNV, "dbne", F6, 0, 0, STEP_OVER)
713 DEFINE_EASY_OPCODE_EX(DBN, "dbn", F6, 0, 0, STEP_OVER)
714 DEFINE_EASY_OPCODE_EX(DBP, "dbp", F6, 0, 0, STEP_OVER)
715 DEFINE_EASY_OPCODE_EX(DBR, "dbr", F6, 0, 0, STEP_OVER)
716 DEFINE_TRIPLE_OPCODE(DEC, "dec", F3)
717 DEFINE_EASY_OPCODE(DISPOSE, "dispose", F5, 0, 0)
718 DEFINE_TRIPLE_OPCODE(DIV, "div", F1F2)
719 DEFINE_FPU_OPCODE(DIVF, "divf", F2)
720 DEFINE_TRIPLE_OPCODE(DIVU, "divu", F1F2)
721 DEFINE_EASY_OPCODE(DIVX, "divx", F1F2, 2, 3)
722 DEFINE_EASY_OPCODE(DIVUX, "divux", F1F2, 2, 3)
723 DEFINE_EASY_OPCODE(EXTBFS, "extbfs", F7b, 0x82, 2)
724 DEFINE_EASY_OPCODE(EXTBFZ, "extbfz", F7b, 0x82, 2)
725 DEFINE_EASY_OPCODE(EXTBFL, "extbfl", F7b, 0x82, 2)
726 DEFINE_EASY_OPCODE(GETATE, "getate", F1F2, 0, 3) // ?
727 DEFINE_EASY_OPCODE(GETPSW, "getpsw", F3, 2, 0)
728 DEFINE_EASY_OPCODE(GETPTE, "getpte", F1F2, 0, 2) // ?
729 DEFINE_EASY_OPCODE(GETRA, "getra", F1F2, 0, 2) // ?
730 DEFINE_EASY_OPCODE(HALT, "halt", F5, 0, 0)
731 DEFINE_TRIPLE_OPCODE(IN, "in", F1F2)
732 DEFINE_TRIPLE_OPCODE(INC, "inc", F3)
733 DEFINE_EASY_OPCODE(INSBFL, "insbfl", F7c, 2, 0x82)
734 DEFINE_EASY_OPCODE(INSBFR, "insbfr", F7c, 2, 0x82)
735 DEFINE_EASY_OPCODE(JMP, "jmp", F3, 0, 0)
736 DEFINE_EASY_OPCODE_EX(JSR, "jsr", F3, 0, 0, STEP_OVER)
737 DEFINE_EASY_OPCODE(LDPR, "ldpr", F1F2, 2, 2)
738 DEFINE_EASY_OPCODE(LDTASK, "ldtask", F1F2, 2, 2)
739 DEFINE_TRIPLE_OPCODE(MOV, "mov", F1F2)
740 DEFINE_EASY_OPCODE(MOVBSU, "movbsu", F7b, 0x80, 0x80)
741 DEFINE_EASY_OPCODE(MOVBSD, "movbsd", F7b, 0x80, 0x80)
742 DEFINE_DOUBLE_OPCODE(MOVCU, "movcu", F7a)
743 DEFINE_DOUBLE_OPCODE(MOVCD, "movcd", F7a)
744 DEFINE_DOUBLE_OPCODE(MOVCFU, "movcfu", F7a)
745 DEFINE_DOUBLE_OPCODE(MOVCFD, "movcfd", F7a)
746 DEFINE_DOUBLE_OPCODE(MOVCS, "movcs", F7a)
747 DEFINE_EASY_OPCODE(MOVD, "mov.d", F1F2, 3, 3)
748 DEFINE_EASY_OPCODE(MOVEAB, "movea.b", F1F2, 0, 2)
749 DEFINE_EASY_OPCODE(MOVEAH, "movea.h", F1F2, 1, 2)
750 DEFINE_EASY_OPCODE(MOVEAW, "movea.w", F1F2, 2, 2)
751 DEFINE_FPU_OPCODE(MOVF, "movf", F2)
752 DEFINE_EASY_OPCODE(MOVSBH, "movs.bh", F1F2, 0, 1)
753 DEFINE_EASY_OPCODE(MOVSBW, "movs.bw", F1F2, 0, 2)
754 DEFINE_EASY_OPCODE(MOVSHW, "movs.hw", F1F2, 1, 2)
755 DEFINE_EASY_OPCODE(MOVTHB, "movt.hb", F1F2, 1, 0)
756 DEFINE_EASY_OPCODE(MOVTWB, "movt.wb", F1F2, 2, 0)
757 DEFINE_EASY_OPCODE(MOVTWH, "movt.wh", F1F2, 2, 1)
758 DEFINE_EASY_OPCODE(MOVZBH, "movz.bh", F1F2, 0, 1)
759 DEFINE_EASY_OPCODE(MOVZBW, "movz.bw", F1F2, 0, 2)
760 DEFINE_EASY_OPCODE(MOVZHW, "movz.hw", F1F2, 1, 2)
761 DEFINE_TRIPLE_OPCODE(MUL, "mul", F1F2)
762 DEFINE_FPU_OPCODE(MULF, "mulf", F2)
763 DEFINE_TRIPLE_OPCODE(MULU, "mulu", F1F2)
764 DEFINE_EASY_OPCODE(MULX, "mulx", F1F2, 2, 3)
765 DEFINE_EASY_OPCODE(MULUX, "mulux", F1F2, 2, 3)
766 DEFINE_TRIPLE_OPCODE(NEG, "neg", F1F2)
767 DEFINE_FPU_OPCODE(NEGF, "negf", F2)
768 DEFINE_EASY_OPCODE(NOP, "nop", F5, 0, 0)
769 DEFINE_TRIPLE_OPCODE(NOT, "not", F1F2)
770 DEFINE_EASY_OPCODE(NOT1, "not1", F1F2, 2, 2)
771 DEFINE_EASY_OPCODE(NOTBSU, "notbsu", F7b, 0x80, 0x80)
772 DEFINE_EASY_OPCODE(NOTBSD, "notbsd", F7b, 0x80, 0x80)
773 DEFINE_TRIPLE_OPCODE(OR, "or", F1F2)
774 DEFINE_EASY_OPCODE(ORBSU, "orbsu", F7b, 0x80, 0x80)
775 DEFINE_EASY_OPCODE(ORBSD, "orbsd", F7b, 0x80, 0x80)
776 DEFINE_EASY_OPCODE(ORNBSU, "ornbsu", F7b, 0x80, 0x80)
777 DEFINE_EASY_OPCODE(ORNBSD, "ornbsd", F7b, 0x80, 0x80)
778 DEFINE_TRIPLE_OPCODE(OUT, "out", F1F2)
779 DEFINE_EASY_OPCODE(POP, "pop", F3, 2, 0)
780 DEFINE_EASY_OPCODE(POPM, "popm", F3, 2, 0)
781 DEFINE_EASY_OPCODE(PREPARE, "prepare", F3, 2, 0)
782 DEFINE_EASY_OPCODE(PUSH, "push", F3, 2, 0)
783 DEFINE_EASY_OPCODE(PUSHM, "pushm", F3, 2, 0)
784 DEFINE_TRIPLE_OPCODE(REM, "rem", F1F2)
785 DEFINE_TRIPLE_OPCODE(REMU, "remu", F1F2)
786 DEFINE_EASY_OPCODE_EX(RET, "ret", F3, 2, 0, STEP_OUT)
787 DEFINE_EASY_OPCODE_EX(RETIU, "retiu", F3, 1, 0, STEP_OUT)
788 DEFINE_EASY_OPCODE_EX(RETIS, "retis", F3, 1, 0, STEP_OUT)
789 DEFINE_EASY_OPCODE(ROTB, "rot.b", F1F2, 0, 0)
790 DEFINE_EASY_OPCODE(ROTH, "rot.h", F1F2, 0, 1)
791 DEFINE_EASY_OPCODE(ROTW, "rot.w", F1F2, 0, 2)
792 DEFINE_EASY_OPCODE(ROTCB, "rotc.b", F1F2, 0, 0)
793 DEFINE_EASY_OPCODE(ROTCH, "rotc.h", F1F2, 0, 1)
794 DEFINE_EASY_OPCODE(ROTCW, "rotc.w", F1F2, 0, 2)
795 DEFINE_EASY_OPCODE_EX(RSR, "rsr", F5, 0, 0, STEP_OUT)
796 DEFINE_EASY_OPCODE(RVBIT, "rvbit", F1F2, 0, 0)
797 DEFINE_EASY_OPCODE(RVBYT, "rvbyt", F1F2, 2, 2)
798 DEFINE_EASY_OPCODE(SCH0BSU, "sch0bsu", F7b, 0x80, 2)
799 DEFINE_EASY_OPCODE(SCH0BSD, "sch0bsd", F7b, 0x80, 2)
800 DEFINE_EASY_OPCODE(SCH1BSU, "sch1bsu", F7b, 0x80, 2)
801 DEFINE_EASY_OPCODE(SCH1BSD, "sch1bsd", F7b, 0x80, 2)
802 DEFINE_EASY_OPCODE(SCHCUB, "schcu.b", F7b, 0, 0)
803 DEFINE_EASY_OPCODE(SCHCDB, "schcd.b", F7b, 0, 0)
804 DEFINE_EASY_OPCODE(SCHCUH, "schcu.h", F7b, 1, 1)
805 DEFINE_EASY_OPCODE(SCHCDH, "schcd.h", F7b, 1, 1)
806 DEFINE_EASY_OPCODE(SCLFS, "sclf.s", F2, 1, 2)
807 DEFINE_EASY_OPCODE(SCLFL, "sclf.l", F2, 1, 2)
808 DEFINE_EASY_OPCODE(SET1, "set1", F1F2, 2, 2)
809 DEFINE_EASY_OPCODE(SETF, "setf", F1F2, 0, 0)
810 DEFINE_EASY_OPCODE(SHAB, "sha.b", F1F2, 0, 0)
811 DEFINE_EASY_OPCODE(SHAH, "sha.h", F1F2, 0, 1)
812 DEFINE_EASY_OPCODE(SHAW, "sha.w", F1F2, 0, 2)
813 DEFINE_EASY_OPCODE(SHLB, "shl.b", F1F2, 0, 0)
814 DEFINE_EASY_OPCODE(SHLH, "shl.h", F1F2, 0, 1)
815 DEFINE_EASY_OPCODE(SHLW, "shl.w", F1F2, 0, 2)
816 DEFINE_EASY_OPCODE(SKPCUB, "skpcu.b", F7b, 0, 0)
817 DEFINE_EASY_OPCODE(SKPCDB, "skpcd.b", F7b, 0, 0)
818 DEFINE_EASY_OPCODE(SKPCUH, "skpcu.h", F7b, 1, 1)
819 DEFINE_EASY_OPCODE(SKPCDH, "skpcd.h", F7b, 1, 1)
820 DEFINE_EASY_OPCODE(STPR, "stpr", F1F2, 2, 2)
821 DEFINE_EASY_OPCODE(STTASK, "sttask", F3, 2, 0)
822 DEFINE_TRIPLE_OPCODE(SUB, "sub", F1F2)
823 DEFINE_TRIPLE_OPCODE(SUBC, "subc", F1F2)
824 DEFINE_EASY_OPCODE(SUBDC, "subdc", F7c, 0, 0)
825 DEFINE_EASY_OPCODE(SUBRDC, "subrdc", F7c, 0, 0)
826 DEFINE_FPU_OPCODE(SUBF, "subf", F2)
827 DEFINE_EASY_OPCODE(TASI, "tasi", F3, 0, 0)
828 DEFINE_EASY_OPCODE(TB, "tb", F6, 0, 0)
829 DEFINE_TRIPLE_OPCODE(TEST, "test", F3)
830 DEFINE_EASY_OPCODE(TEST1, "test1", F1F2, 2, 2)
831 DEFINE_EASY_OPCODE_EX(TRAP, "trap", F3, 0, 0, STEP_OVER)
832 DEFINE_EASY_OPCODE(TRAPFL, "trapfl", F5, 0, 0)
833 DEFINE_EASY_OPCODE(UPDATE, "update", F1F2, 0, 3) // ?
834 DEFINE_EASY_OPCODE(UPDPSWH, "updpsw.h", F1F2, 2, 2)
835 DEFINE_EASY_OPCODE(UPDPSWW, "updpsw.w", F1F2, 2, 2)
836 DEFINE_EASY_OPCODE(UPDPTE, "updpte", F1F2, 0, 2) // ?
837 DEFINE_TRIPLE_OPCODE(XCH, "xch", F1)
838 DEFINE_TRIPLE_OPCODE(XOR, "xor", F1F2)
839 DEFINE_EASY_OPCODE(XORBSU, "xorbsu", F7b, 0x80, 0x80)
840 DEFINE_EASY_OPCODE(XORBSD, "xorbsd", F7b, 0x80, 0x80)
841 DEFINE_EASY_OPCODE(XORNBSU, "xornbsu", F7b, 0x80, 0x80)
842 DEFINE_EASY_OPCODE(XORNBSD, "xornbsd", F7b, 0x80, 0x80)
843
844 u32 (v60_disassembler::*const v60_disassembler::dasm_optable_58[32])(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream) =
845 {
846 /* 0x00 */ &v60_disassembler::dopCMPCB,
847 /* 0x01 */ &v60_disassembler::dopCMPCFB,
848 /* 0x02 */ &v60_disassembler::dopCMPCSB,
849 /* 0x03 */ &v60_disassembler::dop58UNHANDLED,
850 /* 0x04 */ &v60_disassembler::dop58UNHANDLED,
851 /* 0x05 */ &v60_disassembler::dop58UNHANDLED,
852 /* 0x06 */ &v60_disassembler::dop58UNHANDLED,
853 /* 0x07 */ &v60_disassembler::dop58UNHANDLED,
854 /* 0x08 */ &v60_disassembler::dopMOVCUB,
855 /* 0x09 */ &v60_disassembler::dopMOVCDB,
856 /* 0x0A */ &v60_disassembler::dopMOVCFUB,
857 /* 0x0B */ &v60_disassembler::dopMOVCFDB,
858 /* 0x0C */ &v60_disassembler::dopMOVCSB,
859 /* 0x0D */ &v60_disassembler::dop58UNHANDLED,
860 /* 0x0E */ &v60_disassembler::dop58UNHANDLED,
861 /* 0x0F */ &v60_disassembler::dop58UNHANDLED,
862 /* 0x10 */ &v60_disassembler::dop58UNHANDLED,
863 /* 0x11 */ &v60_disassembler::dop58UNHANDLED,
864 /* 0x12 */ &v60_disassembler::dop58UNHANDLED,
865 /* 0x13 */ &v60_disassembler::dop58UNHANDLED,
866 /* 0x14 */ &v60_disassembler::dop58UNHANDLED,
867 /* 0x15 */ &v60_disassembler::dop58UNHANDLED,
868 /* 0x16 */ &v60_disassembler::dop58UNHANDLED,
869 /* 0x17 */ &v60_disassembler::dop58UNHANDLED,
870 /* 0x18 */ &v60_disassembler::dopSCHCUB,
871 /* 0x19 */ &v60_disassembler::dopSCHCDB,
872 /* 0x1A */ &v60_disassembler::dopSKPCUB,
873 /* 0x1B */ &v60_disassembler::dopSKPCDB,
874 /* 0x1C */ &v60_disassembler::dop58UNHANDLED,
875 /* 0x1D */ &v60_disassembler::dop58UNHANDLED,
876 /* 0x1E */ &v60_disassembler::dop58UNHANDLED,
877 /* 0x1F */ &v60_disassembler::dop58UNHANDLED
878 };
879
880 u32 (v60_disassembler::*const v60_disassembler::dasm_optable_59[32])(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream) =
881 {
882 /* 0x00 */ &v60_disassembler::dopADDDC,
883 /* 0x01 */ &v60_disassembler::dopSUBDC,
884 /* 0x02 */ &v60_disassembler::dopSUBRDC,
885 /* 0x03 */ &v60_disassembler::dop59UNHANDLED,
886 /* 0x04 */ &v60_disassembler::dop59UNHANDLED,
887 /* 0x05 */ &v60_disassembler::dop59UNHANDLED,
888 /* 0x06 */ &v60_disassembler::dop59UNHANDLED,
889 /* 0x07 */ &v60_disassembler::dop59UNHANDLED,
890 /* 0x08 */ &v60_disassembler::dop59UNHANDLED,
891 /* 0x09 */ &v60_disassembler::dop59UNHANDLED,
892 /* 0x0A */ &v60_disassembler::dop59UNHANDLED,
893 /* 0x0B */ &v60_disassembler::dop59UNHANDLED,
894 /* 0x0C */ &v60_disassembler::dop59UNHANDLED,
895 /* 0x0D */ &v60_disassembler::dop59UNHANDLED,
896 /* 0x0E */ &v60_disassembler::dop59UNHANDLED,
897 /* 0x0F */ &v60_disassembler::dop59UNHANDLED,
898 /* 0x10 */ &v60_disassembler::dopCVTDPZ,
899 /* 0x11 */ &v60_disassembler::dop59UNHANDLED,
900 /* 0x12 */ &v60_disassembler::dop59UNHANDLED,
901 /* 0x13 */ &v60_disassembler::dop59UNHANDLED,
902 /* 0x14 */ &v60_disassembler::dop59UNHANDLED,
903 /* 0x15 */ &v60_disassembler::dop59UNHANDLED,
904 /* 0x16 */ &v60_disassembler::dop59UNHANDLED,
905 /* 0x17 */ &v60_disassembler::dop59UNHANDLED,
906 /* 0x18 */ &v60_disassembler::dopCVTDZP,
907 /* 0x19 */ &v60_disassembler::dop59UNHANDLED,
908 /* 0x1A */ &v60_disassembler::dop59UNHANDLED,
909 /* 0x1B */ &v60_disassembler::dop59UNHANDLED,
910 /* 0x1C */ &v60_disassembler::dop59UNHANDLED,
911 /* 0x1D */ &v60_disassembler::dop59UNHANDLED,
912 /* 0x1E */ &v60_disassembler::dop59UNHANDLED,
913 /* 0x1F */ &v60_disassembler::dop59UNHANDLED
914 };
915
916 u32 (v60_disassembler::*const v60_disassembler::dasm_optable_5A[32])(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream) =
917 {
918 /* 0x00 */ &v60_disassembler::dopCMPCH,
919 /* 0x01 */ &v60_disassembler::dopCMPCFH,
920 /* 0x02 */ &v60_disassembler::dopCMPCSH,
921 /* 0x03 */ &v60_disassembler::dop5AUNHANDLED,
922 /* 0x04 */ &v60_disassembler::dop5AUNHANDLED,
923 /* 0x05 */ &v60_disassembler::dop5AUNHANDLED,
924 /* 0x06 */ &v60_disassembler::dop5AUNHANDLED,
925 /* 0x07 */ &v60_disassembler::dop5AUNHANDLED,
926 /* 0x08 */ &v60_disassembler::dopMOVCUH,
927 /* 0x09 */ &v60_disassembler::dopMOVCDH,
928 /* 0x0A */ &v60_disassembler::dopMOVCFUH,
929 /* 0x0B */ &v60_disassembler::dopMOVCFDH,
930 /* 0x0C */ &v60_disassembler::dopMOVCSH,
931 /* 0x0D */ &v60_disassembler::dop5AUNHANDLED,
932 /* 0x0E */ &v60_disassembler::dop5AUNHANDLED,
933 /* 0x0F */ &v60_disassembler::dop5AUNHANDLED,
934 /* 0x10 */ &v60_disassembler::dop5AUNHANDLED,
935 /* 0x11 */ &v60_disassembler::dop5AUNHANDLED,
936 /* 0x12 */ &v60_disassembler::dop5AUNHANDLED,
937 /* 0x13 */ &v60_disassembler::dop5AUNHANDLED,
938 /* 0x14 */ &v60_disassembler::dop5AUNHANDLED,
939 /* 0x15 */ &v60_disassembler::dop5AUNHANDLED,
940 /* 0x16 */ &v60_disassembler::dop5AUNHANDLED,
941 /* 0x17 */ &v60_disassembler::dop5AUNHANDLED,
942 /* 0x18 */ &v60_disassembler::dopSCHCUH,
943 /* 0x19 */ &v60_disassembler::dopSCHCDH,
944 /* 0x1A */ &v60_disassembler::dopSKPCUH,
945 /* 0x1B */ &v60_disassembler::dopSKPCDH,
946 /* 0x1C */ &v60_disassembler::dop5AUNHANDLED,
947 /* 0x1D */ &v60_disassembler::dop5AUNHANDLED,
948 /* 0x1E */ &v60_disassembler::dop5AUNHANDLED,
949 /* 0x1F */ &v60_disassembler::dop5AUNHANDLED
950 };
951
952 u32 (v60_disassembler::*const v60_disassembler::dasm_optable_5B[32])(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream) =
953 {
954 /* 0x00 */ &v60_disassembler::dopSCH0BSU,
955 /* 0x01 */ &v60_disassembler::dopSCH0BSD,
956 /* 0x02 */ &v60_disassembler::dopSCH1BSU,
957 /* 0x03 */ &v60_disassembler::dopSCH1BSD,
958 /* 0x04 */ &v60_disassembler::dop5BUNHANDLED,
959 /* 0x05 */ &v60_disassembler::dop5BUNHANDLED,
960 /* 0x06 */ &v60_disassembler::dop5BUNHANDLED,
961 /* 0x07 */ &v60_disassembler::dop5BUNHANDLED,
962 /* 0x08 */ &v60_disassembler::dopMOVBSU,
963 /* 0x09 */ &v60_disassembler::dopMOVBSD,
964 /* 0x0A */ &v60_disassembler::dopNOTBSU,
965 /* 0x0B */ &v60_disassembler::dopNOTBSD,
966 /* 0x0C */ &v60_disassembler::dop5BUNHANDLED,
967 /* 0x0D */ &v60_disassembler::dop5BUNHANDLED,
968 /* 0x0E */ &v60_disassembler::dop5BUNHANDLED,
969 /* 0x0F */ &v60_disassembler::dop5BUNHANDLED,
970 /* 0x10 */ &v60_disassembler::dopANDBSU,
971 /* 0x11 */ &v60_disassembler::dopANDBSD,
972 /* 0x12 */ &v60_disassembler::dopANDNBSU,
973 /* 0x13 */ &v60_disassembler::dopANDNBSD,
974 /* 0x14 */ &v60_disassembler::dopORBSU,
975 /* 0x15 */ &v60_disassembler::dopORBSD,
976 /* 0x16 */ &v60_disassembler::dopORNBSU,
977 /* 0x17 */ &v60_disassembler::dopORNBSD,
978 /* 0x18 */ &v60_disassembler::dopXORBSU,
979 /* 0x19 */ &v60_disassembler::dopXORBSD,
980 /* 0x1A */ &v60_disassembler::dopXORNBSU,
981 /* 0x1B */ &v60_disassembler::dopXORNBSD,
982 /* 0x1C */ &v60_disassembler::dop5BUNHANDLED,
983 /* 0x1D */ &v60_disassembler::dop5BUNHANDLED,
984 /* 0x1E */ &v60_disassembler::dop5BUNHANDLED,
985 /* 0x1F */ &v60_disassembler::dop5BUNHANDLED
986 };
987
988 u32 (v60_disassembler::*const v60_disassembler::dasm_optable_5C[32])(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream) =
989 {
990 /* 0x00 */ &v60_disassembler::dopCMPFS,
991 /* 0x01 */ &v60_disassembler::dop5CUNHANDLED,
992 /* 0x02 */ &v60_disassembler::dop5CUNHANDLED,
993 /* 0x03 */ &v60_disassembler::dop5CUNHANDLED,
994 /* 0x04 */ &v60_disassembler::dop5CUNHANDLED,
995 /* 0x05 */ &v60_disassembler::dop5CUNHANDLED,
996 /* 0x06 */ &v60_disassembler::dop5CUNHANDLED,
997 /* 0x07 */ &v60_disassembler::dop5CUNHANDLED,
998 /* 0x08 */ &v60_disassembler::dopMOVFS,
999 /* 0x09 */ &v60_disassembler::dopNEGFS,
1000 /* 0x0A */ &v60_disassembler::dopABSFS,
1001 /* 0x0B */ &v60_disassembler::dop5CUNHANDLED,
1002 /* 0x0C */ &v60_disassembler::dop5CUNHANDLED,
1003 /* 0x0D */ &v60_disassembler::dop5CUNHANDLED,
1004 /* 0x0E */ &v60_disassembler::dop5CUNHANDLED,
1005 /* 0x0F */ &v60_disassembler::dop5CUNHANDLED,
1006 /* 0x10 */ &v60_disassembler::dopSCLFS,
1007 /* 0x11 */ &v60_disassembler::dop5CUNHANDLED,
1008 /* 0x12 */ &v60_disassembler::dop5CUNHANDLED,
1009 /* 0x13 */ &v60_disassembler::dop5CUNHANDLED,
1010 /* 0x14 */ &v60_disassembler::dop5CUNHANDLED,
1011 /* 0x15 */ &v60_disassembler::dop5CUNHANDLED,
1012 /* 0x16 */ &v60_disassembler::dop5CUNHANDLED,
1013 /* 0x17 */ &v60_disassembler::dop5CUNHANDLED,
1014 /* 0x18 */ &v60_disassembler::dopADDFS,
1015 /* 0x19 */ &v60_disassembler::dopSUBFS,
1016 /* 0x1A */ &v60_disassembler::dopMULFS,
1017 /* 0x1B */ &v60_disassembler::dopDIVFS,
1018 /* 0x1C */ &v60_disassembler::dop5CUNHANDLED,
1019 /* 0x1D */ &v60_disassembler::dop5CUNHANDLED,
1020 /* 0x1E */ &v60_disassembler::dop5CUNHANDLED,
1021 /* 0x1F */ &v60_disassembler::dop5CUNHANDLED
1022 };
1023
1024 u32 (v60_disassembler::*const v60_disassembler::dasm_optable_5D[32])(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream) =
1025 {
1026 /* 0x00 */ &v60_disassembler::dopCMPBFS,
1027 /* 0x01 */ &v60_disassembler::dopCMPBFZ,
1028 /* 0x02 */ &v60_disassembler::dopCMPBFL,
1029 /* 0x03 */ &v60_disassembler::dop5DUNHANDLED,
1030 /* 0x04 */ &v60_disassembler::dop5DUNHANDLED,
1031 /* 0x05 */ &v60_disassembler::dop5DUNHANDLED,
1032 /* 0x06 */ &v60_disassembler::dop5DUNHANDLED,
1033 /* 0x07 */ &v60_disassembler::dop5DUNHANDLED,
1034 /* 0x08 */ &v60_disassembler::dopEXTBFS,
1035 /* 0x09 */ &v60_disassembler::dopEXTBFZ,
1036 /* 0x0A */ &v60_disassembler::dopEXTBFL,
1037 /* 0x0B */ &v60_disassembler::dop5DUNHANDLED,
1038 /* 0x0C */ &v60_disassembler::dop5DUNHANDLED,
1039 /* 0x0D */ &v60_disassembler::dop5DUNHANDLED,
1040 /* 0x0E */ &v60_disassembler::dop5DUNHANDLED,
1041 /* 0x0F */ &v60_disassembler::dop5DUNHANDLED,
1042 /* 0x10 */ &v60_disassembler::dop5DUNHANDLED,
1043 /* 0x11 */ &v60_disassembler::dop5DUNHANDLED,
1044 /* 0x12 */ &v60_disassembler::dop5DUNHANDLED,
1045 /* 0x13 */ &v60_disassembler::dop5DUNHANDLED,
1046 /* 0x14 */ &v60_disassembler::dop5DUNHANDLED,
1047 /* 0x15 */ &v60_disassembler::dop5DUNHANDLED,
1048 /* 0x16 */ &v60_disassembler::dop5DUNHANDLED,
1049 /* 0x17 */ &v60_disassembler::dop5DUNHANDLED,
1050 /* 0x18 */ &v60_disassembler::dopINSBFR,
1051 /* 0x19 */ &v60_disassembler::dopINSBFL,
1052 /* 0x1A */ &v60_disassembler::dop5DUNHANDLED,
1053 /* 0x1B */ &v60_disassembler::dop5DUNHANDLED,
1054 /* 0x1C */ &v60_disassembler::dop5DUNHANDLED,
1055 /* 0x1D */ &v60_disassembler::dop5DUNHANDLED,
1056 /* 0x1E */ &v60_disassembler::dop5DUNHANDLED,
1057 /* 0x1F */ &v60_disassembler::dop5DUNHANDLED
1058 };
1059
1060 u32 (v60_disassembler::*const v60_disassembler::dasm_optable_5E[32])(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream) =
1061 {
1062 /* 0x00 */ &v60_disassembler::dopCMPFL,
1063 /* 0x01 */ &v60_disassembler::dop5EUNHANDLED,
1064 /* 0x02 */ &v60_disassembler::dop5EUNHANDLED,
1065 /* 0x03 */ &v60_disassembler::dop5EUNHANDLED,
1066 /* 0x04 */ &v60_disassembler::dop5EUNHANDLED,
1067 /* 0x05 */ &v60_disassembler::dop5EUNHANDLED,
1068 /* 0x06 */ &v60_disassembler::dop5EUNHANDLED,
1069 /* 0x07 */ &v60_disassembler::dop5EUNHANDLED,
1070 /* 0x08 */ &v60_disassembler::dopMOVFL,
1071 /* 0x09 */ &v60_disassembler::dopNEGFL,
1072 /* 0x0A */ &v60_disassembler::dopABSFL,
1073 /* 0x0B */ &v60_disassembler::dop5EUNHANDLED,
1074 /* 0x0C */ &v60_disassembler::dop5EUNHANDLED,
1075 /* 0x0D */ &v60_disassembler::dop5EUNHANDLED,
1076 /* 0x0E */ &v60_disassembler::dop5EUNHANDLED,
1077 /* 0x0F */ &v60_disassembler::dop5EUNHANDLED,
1078 /* 0x10 */ &v60_disassembler::dopSCLFL,
1079 /* 0x11 */ &v60_disassembler::dop5EUNHANDLED,
1080 /* 0x12 */ &v60_disassembler::dop5EUNHANDLED,
1081 /* 0x13 */ &v60_disassembler::dop5EUNHANDLED,
1082 /* 0x14 */ &v60_disassembler::dop5EUNHANDLED,
1083 /* 0x15 */ &v60_disassembler::dop5EUNHANDLED,
1084 /* 0x16 */ &v60_disassembler::dop5EUNHANDLED,
1085 /* 0x17 */ &v60_disassembler::dop5EUNHANDLED,
1086 /* 0x18 */ &v60_disassembler::dopADDFL,
1087 /* 0x19 */ &v60_disassembler::dopSUBFL,
1088 /* 0x1A */ &v60_disassembler::dopMULFL,
1089 /* 0x1B */ &v60_disassembler::dopDIVFL,
1090 /* 0x1C */ &v60_disassembler::dop5EUNHANDLED,
1091 /* 0x1D */ &v60_disassembler::dop5EUNHANDLED,
1092 /* 0x1E */ &v60_disassembler::dop5EUNHANDLED,
1093 /* 0x1F */ &v60_disassembler::dop5EUNHANDLED
1094 };
1095
1096 u32 (v60_disassembler::*const v60_disassembler::dasm_optable_5F[32])(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream) =
1097 {
1098 /* 0x00 */ &v60_disassembler::dopCVTWS,
1099 /* 0x01 */ &v60_disassembler::dopCVTSW,
1100 /* 0x02 */ &v60_disassembler::dop5FUNHANDLED,
1101 /* 0x03 */ &v60_disassembler::dop5FUNHANDLED,
1102 /* 0x04 */ &v60_disassembler::dop5FUNHANDLED,
1103 /* 0x05 */ &v60_disassembler::dop5FUNHANDLED,
1104 /* 0x06 */ &v60_disassembler::dop5FUNHANDLED,
1105 /* 0x07 */ &v60_disassembler::dop5FUNHANDLED,
1106 /* 0x08 */ &v60_disassembler::dopCVTLS,
1107 /* 0x09 */ &v60_disassembler::dopCVTLW,
1108 /* 0x0A */ &v60_disassembler::dop5FUNHANDLED,
1109 /* 0x0B */ &v60_disassembler::dop5FUNHANDLED,
1110 /* 0x0C */ &v60_disassembler::dop5FUNHANDLED,
1111 /* 0x0D */ &v60_disassembler::dop5FUNHANDLED,
1112 /* 0x0E */ &v60_disassembler::dop5FUNHANDLED,
1113 /* 0x0F */ &v60_disassembler::dop5FUNHANDLED,
1114 /* 0x10 */ &v60_disassembler::dopCVTSL,
1115 /* 0x11 */ &v60_disassembler::dopCVTWL,
1116 /* 0x12 */ &v60_disassembler::dop5FUNHANDLED,
1117 /* 0x13 */ &v60_disassembler::dop5FUNHANDLED,
1118 /* 0x14 */ &v60_disassembler::dop5FUNHANDLED,
1119 /* 0x15 */ &v60_disassembler::dop5FUNHANDLED,
1120 /* 0x16 */ &v60_disassembler::dop5FUNHANDLED,
1121 /* 0x17 */ &v60_disassembler::dop5FUNHANDLED,
1122 /* 0x18 */ &v60_disassembler::dop5FUNHANDLED,
1123 /* 0x19 */ &v60_disassembler::dop5FUNHANDLED,
1124 /* 0x1A */ &v60_disassembler::dop5FUNHANDLED,
1125 /* 0x1B */ &v60_disassembler::dop5FUNHANDLED,
1126 /* 0x1C */ &v60_disassembler::dop5FUNHANDLED,
1127 /* 0x1D */ &v60_disassembler::dop5FUNHANDLED,
1128 /* 0x1E */ &v60_disassembler::dop5FUNHANDLED,
1129 /* 0x1F */ &v60_disassembler::dop5FUNHANDLED
1130 };
1131
1132 u32 (v60_disassembler::*const v60_disassembler::dasm_optable_C6[8])(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream) =
1133 {
1134 /* 0x0 */ &v60_disassembler::dopDBV,
1135 /* 0x1 */ &v60_disassembler::dopDBL,
1136 /* 0x2 */ &v60_disassembler::dopDBE,
1137 /* 0x3 */ &v60_disassembler::dopDBNH,
1138 /* 0x4 */ &v60_disassembler::dopDBN,
1139 /* 0x5 */ &v60_disassembler::dopDBR,
1140 /* 0x6 */ &v60_disassembler::dopDBLT,
1141 /* 0x7 */ &v60_disassembler::dopDBLE
1142 };
1143
1144 u32 (v60_disassembler::*const v60_disassembler::dasm_optable_C7[8])(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream) =
1145 {
1146 /* 0x0 */ &v60_disassembler::dopDBNV,
1147 /* 0x1 */ &v60_disassembler::dopDBNL,
1148 /* 0x2 */ &v60_disassembler::dopDBNE,
1149 /* 0x3 */ &v60_disassembler::dopDBH,
1150 /* 0x4 */ &v60_disassembler::dopDBP,
1151 /* 0x5 */ &v60_disassembler::dopTB,
1152 /* 0x6 */ &v60_disassembler::dopDBGE,
1153 /* 0x7 */ &v60_disassembler::dopDBGT
1154 };
1155
dop58(unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)1156 u32 v60_disassembler::dop58(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
1157 {
1158 return (this->*dasm_optable_58[opcodes.r8(pc) & 0x1f])(ipc, pc, opcodes, stream);
1159 }
1160
dop59(unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)1161 u32 v60_disassembler::dop59(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
1162 {
1163 return (this->*dasm_optable_59[opcodes.r8(pc) & 0x1f])(ipc, pc, opcodes, stream);
1164 }
1165
dop5A(unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)1166 u32 v60_disassembler::dop5A(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
1167 {
1168 return (this->*dasm_optable_5A[opcodes.r8(pc) & 0x1f])(ipc, pc, opcodes, stream);
1169 }
1170
dop5B(unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)1171 u32 v60_disassembler::dop5B(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
1172 {
1173 return (this->*dasm_optable_5B[opcodes.r8(pc) & 0x1f])(ipc, pc, opcodes, stream);
1174 }
1175
dop5C(unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)1176 u32 v60_disassembler::dop5C(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
1177 {
1178 return (this->*dasm_optable_5C[opcodes.r8(pc) & 0x1f])(ipc, pc, opcodes, stream);
1179 }
1180
dop5D(unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)1181 u32 v60_disassembler::dop5D(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
1182 {
1183 return (this->*dasm_optable_5D[opcodes.r8(pc) & 0x1f])(ipc, pc, opcodes, stream);
1184 }
1185
dop5E(unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)1186 u32 v60_disassembler::dop5E(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
1187 {
1188 return (this->*dasm_optable_5E[opcodes.r8(pc) & 0x1f])(ipc, pc, opcodes, stream);
1189 }
1190
dop5F(unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)1191 u32 v60_disassembler::dop5F(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
1192 {
1193 return (this->*dasm_optable_5F[opcodes.r8(pc) & 0x1f])(ipc, pc, opcodes, stream);
1194 }
1195
dopC6(unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)1196 u32 v60_disassembler::dopC6(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
1197 {
1198 return (this->*dasm_optable_C6[opcodes.r8(pc) >> 5])(ipc, pc, opcodes, stream);
1199 }
1200
dopC7(unsigned ipc,offs_t pc,const data_buffer & opcodes,std::ostream & stream)1201 u32 v60_disassembler::dopC7(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream)
1202 {
1203 return (this->*dasm_optable_C7[opcodes.r8(pc) >> 5])(ipc, pc, opcodes, stream);
1204 }
1205
1206 u32 (v60_disassembler::*const v60_disassembler::dasm_optable[256])(unsigned ipc, offs_t pc, const data_buffer &opcodes, std::ostream &stream) =
1207 {
1208 /* 0x00 */ &v60_disassembler::dopHALT,
1209 /* 0x01 */ &v60_disassembler::dopLDTASK,
1210 /* 0x02 */ &v60_disassembler::dopSTPR,
1211 /* 0x03 */ &v60_disassembler::dopGETRA,
1212 /* 0x04 */ &v60_disassembler::dopGETPTE,
1213 /* 0x05 */ &v60_disassembler::dopGETATE,
1214 /* 0x06 */ &v60_disassembler::dopUNHANDLED,
1215 /* 0x07 */ &v60_disassembler::dopUNHANDLED,
1216 /* 0x08 */ &v60_disassembler::dopRVBIT,
1217 /* 0x09 */ &v60_disassembler::dopMOVB,
1218 /* 0x0A */ &v60_disassembler::dopMOVSBH,
1219 /* 0x0B */ &v60_disassembler::dopMOVZBH,
1220 /* 0x0C */ &v60_disassembler::dopMOVSBW,
1221 /* 0x0D */ &v60_disassembler::dopMOVZBW,
1222 /* 0x0E */ &v60_disassembler::dopUNHANDLED,
1223 /* 0x0F */ &v60_disassembler::dopUNHANDLED,
1224 /* 0x10 */ &v60_disassembler::dopCLRTLBA,
1225 /* 0x11 */ &v60_disassembler::dopUNHANDLED,
1226 /* 0x12 */ &v60_disassembler::dopLDPR,
1227 /* 0x13 */ &v60_disassembler::dopUPDPSWW,
1228 /* 0x14 */ &v60_disassembler::dopUPDPTE,
1229 /* 0x15 */ &v60_disassembler::dopUPDATE,
1230 /* 0x16 */ &v60_disassembler::dopUNHANDLED,
1231 /* 0x17 */ &v60_disassembler::dopUNHANDLED,
1232 /* 0x18 */ &v60_disassembler::dopUNHANDLED,
1233 /* 0x19 */ &v60_disassembler::dopMOVTHB,
1234 /* 0x1A */ &v60_disassembler::dopUNHANDLED,
1235 /* 0x1B */ &v60_disassembler::dopMOVH,
1236 /* 0x1C */ &v60_disassembler::dopMOVSHW,
1237 /* 0x1D */ &v60_disassembler::dopMOVZHW,
1238 /* 0x1E */ &v60_disassembler::dopUNHANDLED,
1239 /* 0x1F */ &v60_disassembler::dopUNHANDLED,
1240 /* 0x20 */ &v60_disassembler::dopINB,
1241 /* 0x21 */ &v60_disassembler::dopOUTB,
1242 /* 0x22 */ &v60_disassembler::dopINH,
1243 /* 0x23 */ &v60_disassembler::dopOUTH,
1244 /* 0x24 */ &v60_disassembler::dopINW,
1245 /* 0x25 */ &v60_disassembler::dopOUTW,
1246 /* 0x26 */ &v60_disassembler::dopUNHANDLED,
1247 /* 0x27 */ &v60_disassembler::dopUNHANDLED,
1248 /* 0x28 */ &v60_disassembler::dopUNHANDLED,
1249 /* 0x29 */ &v60_disassembler::dopMOVTWB,
1250 /* 0x2A */ &v60_disassembler::dopUNHANDLED,
1251 /* 0x2B */ &v60_disassembler::dopMOVTWH,
1252 /* 0x2C */ &v60_disassembler::dopRVBYT,
1253 /* 0x2D */ &v60_disassembler::dopMOVW,
1254 /* 0x2E */ &v60_disassembler::dopUNHANDLED,
1255 /* 0x2F */ &v60_disassembler::dopUNHANDLED,
1256 /* 0x30 */ &v60_disassembler::dopUNHANDLED,
1257 /* 0x31 */ &v60_disassembler::dopUNHANDLED,
1258 /* 0x32 */ &v60_disassembler::dopUNHANDLED,
1259 /* 0x33 */ &v60_disassembler::dopUNHANDLED,
1260 /* 0x34 */ &v60_disassembler::dopUNHANDLED,
1261 /* 0x35 */ &v60_disassembler::dopUNHANDLED,
1262 /* 0x36 */ &v60_disassembler::dopUNHANDLED,
1263 /* 0x37 */ &v60_disassembler::dopUNHANDLED,
1264 /* 0x38 */ &v60_disassembler::dopNOTB,
1265 /* 0x39 */ &v60_disassembler::dopNEGB,
1266 /* 0x3A */ &v60_disassembler::dopNOTH,
1267 /* 0x3B */ &v60_disassembler::dopNEGH,
1268 /* 0x3C */ &v60_disassembler::dopNOTW,
1269 /* 0x3D */ &v60_disassembler::dopNEGW,
1270 /* 0x3E */ &v60_disassembler::dopUNHANDLED,
1271 /* 0x3F */ &v60_disassembler::dopMOVD,
1272 /* 0x40 */ &v60_disassembler::dopMOVEAB,
1273 /* 0x41 */ &v60_disassembler::dopXCHB,
1274 /* 0x42 */ &v60_disassembler::dopMOVEAH,
1275 /* 0x43 */ &v60_disassembler::dopXCHH,
1276 /* 0x44 */ &v60_disassembler::dopMOVEAW,
1277 /* 0x45 */ &v60_disassembler::dopXCHW,
1278 /* 0x46 */ &v60_disassembler::dopUNHANDLED,
1279 /* 0x47 */ &v60_disassembler::dopSETF,
1280 /* 0x48 */ &v60_disassembler::dopBSR,
1281 /* 0x49 */ &v60_disassembler::dopCALL,
1282 /* 0x4A */ &v60_disassembler::dopUPDPSWH,
1283 /* 0x4B */ &v60_disassembler::dopCHLVL,
1284 /* 0x4C */ &v60_disassembler::dopCAXI,
1285 /* 0x4D */ &v60_disassembler::dopCHKAR,
1286 /* 0x4E */ &v60_disassembler::dopCHKAW,
1287 /* 0x4F */ &v60_disassembler::dopCHKAE,
1288 /* 0x50 */ &v60_disassembler::dopREMB,
1289 /* 0x51 */ &v60_disassembler::dopREMUB,
1290 /* 0x52 */ &v60_disassembler::dopREMH,
1291 /* 0x53 */ &v60_disassembler::dopREMUH,
1292 /* 0x54 */ &v60_disassembler::dopREMW,
1293 /* 0x55 */ &v60_disassembler::dopREMUW,
1294 /* 0x56 */ &v60_disassembler::dopUNHANDLED,
1295 /* 0x57 */ &v60_disassembler::dopUNHANDLED,
1296 /* 0x58 */ &v60_disassembler::dop58,
1297 /* 0x59 */ &v60_disassembler::dop59,
1298 /* 0x5A */ &v60_disassembler::dop5A,
1299 /* 0x5B */ &v60_disassembler::dop5B,
1300 /* 0x5C */ &v60_disassembler::dop5C,
1301 /* 0x5D */ &v60_disassembler::dop5D,
1302 /* 0x5E */ &v60_disassembler::dop5E,
1303 /* 0x5F */ &v60_disassembler::dop5F,
1304 /* 0x60 */ &v60_disassembler::dopBV8,
1305 /* 0x61 */ &v60_disassembler::dopBNV8,
1306 /* 0x62 */ &v60_disassembler::dopBL8,
1307 /* 0x63 */ &v60_disassembler::dopBNL8,
1308 /* 0x64 */ &v60_disassembler::dopBE8,
1309 /* 0x65 */ &v60_disassembler::dopBNE8,
1310 /* 0x66 */ &v60_disassembler::dopBNH8,
1311 /* 0x67 */ &v60_disassembler::dopBH8,
1312 /* 0x68 */ &v60_disassembler::dopBN8,
1313 /* 0x69 */ &v60_disassembler::dopBP8,
1314 /* 0x6A */ &v60_disassembler::dopBR8,
1315 /* 0x6B */ &v60_disassembler::dopUNHANDLED,
1316 /* 0x6C */ &v60_disassembler::dopBLT8,
1317 /* 0x6D */ &v60_disassembler::dopBGE8,
1318 /* 0x6E */ &v60_disassembler::dopBLE8,
1319 /* 0x6F */ &v60_disassembler::dopBGT8,
1320 /* 0x70 */ &v60_disassembler::dopBV16,
1321 /* 0x71 */ &v60_disassembler::dopBNV16,
1322 /* 0x72 */ &v60_disassembler::dopBL16,
1323 /* 0x73 */ &v60_disassembler::dopBNL16,
1324 /* 0x74 */ &v60_disassembler::dopBE16,
1325 /* 0x75 */ &v60_disassembler::dopBNE16,
1326 /* 0x76 */ &v60_disassembler::dopBNH16,
1327 /* 0x77 */ &v60_disassembler::dopBH16,
1328 /* 0x78 */ &v60_disassembler::dopBN16,
1329 /* 0x79 */ &v60_disassembler::dopBP16,
1330 /* 0x7A */ &v60_disassembler::dopBR16,
1331 /* 0x7B */ &v60_disassembler::dopUNHANDLED,
1332 /* 0x7C */ &v60_disassembler::dopBLT16,
1333 /* 0x7D */ &v60_disassembler::dopBGE16,
1334 /* 0x7E */ &v60_disassembler::dopBLE16,
1335 /* 0x7F */ &v60_disassembler::dopBGT16,
1336 /* 0x80 */ &v60_disassembler::dopADDB,
1337 /* 0x81 */ &v60_disassembler::dopMULB,
1338 /* 0x82 */ &v60_disassembler::dopADDH,
1339 /* 0x83 */ &v60_disassembler::dopMULH,
1340 /* 0x84 */ &v60_disassembler::dopADDW,
1341 /* 0x85 */ &v60_disassembler::dopMULW,
1342 /* 0x86 */ &v60_disassembler::dopMULX,
1343 /* 0x87 */ &v60_disassembler::dopTEST1,
1344 /* 0x88 */ &v60_disassembler::dopORB,
1345 /* 0x89 */ &v60_disassembler::dopROTB,
1346 /* 0x8A */ &v60_disassembler::dopORH,
1347 /* 0x8B */ &v60_disassembler::dopROTH,
1348 /* 0x8C */ &v60_disassembler::dopORW,
1349 /* 0x8D */ &v60_disassembler::dopROTW,
1350 /* 0x8E */ &v60_disassembler::dopUNHANDLED,
1351 /* 0x8F */ &v60_disassembler::dopUNHANDLED,
1352 /* 0x90 */ &v60_disassembler::dopADDCB,
1353 /* 0x91 */ &v60_disassembler::dopMULUB,
1354 /* 0x92 */ &v60_disassembler::dopADDCH,
1355 /* 0x93 */ &v60_disassembler::dopMULUH,
1356 /* 0x94 */ &v60_disassembler::dopADDCW,
1357 /* 0x95 */ &v60_disassembler::dopMULUW,
1358 /* 0x96 */ &v60_disassembler::dopMULUX,
1359 /* 0x97 */ &v60_disassembler::dopSET1,
1360 /* 0x98 */ &v60_disassembler::dopSUBCB,
1361 /* 0x99 */ &v60_disassembler::dopROTCB,
1362 /* 0x9A */ &v60_disassembler::dopSUBCH,
1363 /* 0x9B */ &v60_disassembler::dopROTCH,
1364 /* 0x9C */ &v60_disassembler::dopSUBCW,
1365 /* 0x9D */ &v60_disassembler::dopROTCW,
1366 /* 0x9E */ &v60_disassembler::dopUNHANDLED,
1367 /* 0x9F */ &v60_disassembler::dopUNHANDLED,
1368 /* 0xA0 */ &v60_disassembler::dopANDB,
1369 /* 0xA1 */ &v60_disassembler::dopDIVB,
1370 /* 0xA2 */ &v60_disassembler::dopANDH,
1371 /* 0xA3 */ &v60_disassembler::dopDIVH,
1372 /* 0xA4 */ &v60_disassembler::dopANDW,
1373 /* 0xA5 */ &v60_disassembler::dopDIVW,
1374 /* 0xA6 */ &v60_disassembler::dopDIVX,
1375 /* 0xA7 */ &v60_disassembler::dopCLR1,
1376 /* 0xA8 */ &v60_disassembler::dopSUBB,
1377 /* 0xA9 */ &v60_disassembler::dopSHLB,
1378 /* 0xAA */ &v60_disassembler::dopSUBH,
1379 /* 0xAB */ &v60_disassembler::dopSHLH,
1380 /* 0xAC */ &v60_disassembler::dopSUBW,
1381 /* 0xAD */ &v60_disassembler::dopSHLW,
1382 /* 0xAE */ &v60_disassembler::dopUNHANDLED,
1383 /* 0xAF */ &v60_disassembler::dopUNHANDLED,
1384 /* 0xB0 */ &v60_disassembler::dopXORB,
1385 /* 0xB1 */ &v60_disassembler::dopDIVUB,
1386 /* 0xB2 */ &v60_disassembler::dopXORH,
1387 /* 0xB3 */ &v60_disassembler::dopDIVUH,
1388 /* 0xB4 */ &v60_disassembler::dopXORW,
1389 /* 0xB5 */ &v60_disassembler::dopDIVUW,
1390 /* 0xB6 */ &v60_disassembler::dopDIVUX,
1391 /* 0xB7 */ &v60_disassembler::dopNOT1,
1392 /* 0xB8 */ &v60_disassembler::dopCMPB,
1393 /* 0xB9 */ &v60_disassembler::dopSHAB,
1394 /* 0xBA */ &v60_disassembler::dopCMPH,
1395 /* 0xBB */ &v60_disassembler::dopSHAH,
1396 /* 0xBC */ &v60_disassembler::dopCMPW,
1397 /* 0xBD */ &v60_disassembler::dopSHAW,
1398 /* 0xBE */ &v60_disassembler::dopUNHANDLED,
1399 /* 0xBF */ &v60_disassembler::dopUNHANDLED,
1400 /* 0xC0 */ &v60_disassembler::dopUNHANDLED,
1401 /* 0xC1 */ &v60_disassembler::dopUNHANDLED,
1402 /* 0xC2 */ &v60_disassembler::dopUNHANDLED,
1403 /* 0xC3 */ &v60_disassembler::dopUNHANDLED,
1404 /* 0xC4 */ &v60_disassembler::dopUNHANDLED,
1405 /* 0xC5 */ &v60_disassembler::dopUNHANDLED,
1406 /* 0xC6 */ &v60_disassembler::dopC6,
1407 /* 0xC7 */ &v60_disassembler::dopC7,
1408 /* 0xC8 */ &v60_disassembler::dopBRK,
1409 /* 0xC9 */ &v60_disassembler::dopBRKV,
1410 /* 0xCA */ &v60_disassembler::dopRSR,
1411 /* 0xCB */ &v60_disassembler::dopTRAPFL,
1412 /* 0xCC */ &v60_disassembler::dopDISPOSE,
1413 /* 0xCD */ &v60_disassembler::dopNOP,
1414 /* 0xCE */ &v60_disassembler::dopUNHANDLED,
1415 /* 0xCF */ &v60_disassembler::dopUNHANDLED,
1416 /* 0xD0 */ &v60_disassembler::dopDECB,
1417 /* 0xD1 */ &v60_disassembler::dopDECB,
1418 /* 0xD2 */ &v60_disassembler::dopDECH,
1419 /* 0xD3 */ &v60_disassembler::dopDECH,
1420 /* 0xD4 */ &v60_disassembler::dopDECW,
1421 /* 0xD5 */ &v60_disassembler::dopDECW,
1422 /* 0xD6 */ &v60_disassembler::dopJMP,
1423 /* 0xD7 */ &v60_disassembler::dopJMP,
1424 /* 0xD8 */ &v60_disassembler::dopINCB,
1425 /* 0xD9 */ &v60_disassembler::dopINCB,
1426 /* 0xDA */ &v60_disassembler::dopINCH,
1427 /* 0xDB */ &v60_disassembler::dopINCH,
1428 /* 0xDC */ &v60_disassembler::dopINCW,
1429 /* 0xDD */ &v60_disassembler::dopINCW,
1430 /* 0xDE */ &v60_disassembler::dopPREPARE,
1431 /* 0xDF */ &v60_disassembler::dopPREPARE,
1432 /* 0xE0 */ &v60_disassembler::dopTASI,
1433 /* 0xE1 */ &v60_disassembler::dopTASI,
1434 /* 0xE2 */ &v60_disassembler::dopRET,
1435 /* 0xE3 */ &v60_disassembler::dopRET,
1436 /* 0xE4 */ &v60_disassembler::dopPOPM,
1437 /* 0xE5 */ &v60_disassembler::dopPOPM,
1438 /* 0xE6 */ &v60_disassembler::dopPOP,
1439 /* 0xE7 */ &v60_disassembler::dopPOP,
1440 /* 0xE8 */ &v60_disassembler::dopJSR,
1441 /* 0xE9 */ &v60_disassembler::dopJSR,
1442 /* 0xEA */ &v60_disassembler::dopRETIU,
1443 /* 0xEB */ &v60_disassembler::dopRETIU,
1444 /* 0xEC */ &v60_disassembler::dopPUSHM,
1445 /* 0xED */ &v60_disassembler::dopPUSHM,
1446 /* 0xEE */ &v60_disassembler::dopPUSH,
1447 /* 0xEF */ &v60_disassembler::dopPUSH,
1448 /* 0xF0 */ &v60_disassembler::dopTESTB,
1449 /* 0xF1 */ &v60_disassembler::dopTESTB,
1450 /* 0xF2 */ &v60_disassembler::dopTESTH,
1451 /* 0xF3 */ &v60_disassembler::dopTESTH,
1452 /* 0xF4 */ &v60_disassembler::dopTESTW,
1453 /* 0xF5 */ &v60_disassembler::dopTESTW,
1454 /* 0xF6 */ &v60_disassembler::dopGETPSW,
1455 /* 0xF7 */ &v60_disassembler::dopGETPSW,
1456 /* 0xF8 */ &v60_disassembler::dopTRAP,
1457 /* 0xF9 */ &v60_disassembler::dopTRAP,
1458 /* 0xFA */ &v60_disassembler::dopRETIS,
1459 /* 0xFB */ &v60_disassembler::dopRETIS,
1460 /* 0xFC */ &v60_disassembler::dopSTTASK,
1461 /* 0xFD */ &v60_disassembler::dopSTTASK,
1462 /* 0xFE */ &v60_disassembler::dopCLRTLB,
1463 /* 0xFF */ &v60_disassembler::dopCLRTLB
1464 };
1465
disassemble(std::ostream & stream,offs_t pc,const data_buffer & opcodes,const data_buffer & params)1466 offs_t v60_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_buffer &opcodes, const data_buffer ¶ms)
1467 {
1468 return (this->*dasm_optable[opcodes.r8(pc)])(pc, pc+1, opcodes, stream) | SUPPORTED;
1469 }
1470
opcode_alignment() const1471 u32 v60_disassembler::opcode_alignment() const
1472 {
1473 return 1;
1474 }
1475