![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to makez80.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Generator SEGA Genesis emulator] / generator / src / .extra / z80-mame|
Return to makez80.c CVS log | Up to [Generator SEGA Genesis emulator] / generator / src / .extra / z80-mame |
1.1 root 1: /*****************************************************************************
2: *
3: * makez80.c
4: * 486++ asm emitter for a Z80 cpu core
5: * supports GNU assembler and NASM
6: *
7: * Copyright (c) 1999 Juergen Buchmueller, all rights reserved.
8: *
9: * - This source code is released as freeware for non-commercial purposes.
10: * - You are free to use and redistribute this code in modified or
11: * unmodified form, provided you list me in the credits.
12: * - If you modify this source code, you must add a notice to each modified
13: * source file that it has been changed. If you're a nice person, you
14: * will clearly mark each change too. :)
15: * - If you wish to use this for commercial purposes, please contact me at
16: * [email protected]
17: * - The author of this copywritten work reserves the right to change the
18: * terms of its usage and license at any time, including retroactively
19: * - This entire notice must remain in the source code.
20: *
21: *****************************************************************************/
22:
23: #include <stdio.h>
24: #include <stdarg.h>
25: #include <string.h>
26: #include <signal.h>
27: #include "cpuintrf.h"
28: #include "osd_cpu.h"
29:
30: #define FAST_MEMORY 1
31: #define INLINE_IOPORTS 0 /* inline cpu_readport/cpu_writeport functions */
32: #define BUSY_LOOP_HACKS 1 /* break out of tight loops waiting for an interrupt */
33: #define WBYTE_EA4_EDX 1 /* use one writeback function for DD/FD CB <ofs8> xx opcodes */
34: #define EARLY_CTC 1
35: #define CALC_PREVPC 0 /* calculate previouspc */
36:
37: #define ABITS 4 /* ABITS2_16 + ABITS_MIN_16 */
38:
39: #define GLOBL 0
40:
41: #define GAS 0
42: #define NASM 1
43: #define TASM 2
44:
45: typedef unsigned char byte;
46: typedef unsigned short word;
47: typedef unsigned long dword;
48:
49: FILE *output;
50: int as = GAS;
51: int verbose = 0, mame_debug = 0, optimize = 0;
52: int opcodes = 0;
53: int rbyte = 0, rword = 0, wbyte = 0, wword = 0;
54: int align_funcs = 2, align_jumps = 2, align_loops = 1;
55:
56: typedef enum {
57: none=0,
58: al, ah, cl, ch, dl, dh, bl, bh,
59: ax, cx, dx, bx, si, di, bp, sp,
60: eax, ecx, edx, ebx, esi, edi, ebp, esp
61: } x86_regs;
62:
63: typedef enum {
64: dm, db, dw, dd, align, extrn, globl, text,
65: data, aaa, aad, aam, aas, adc, adcb, adcl,
66: adcw, add, addb, addl, addw, and, andb, andl,
67: andw, bswap, bt, btc, btr, bts, call, callf,
68: cbw, cdq, clc, cld, cli, clts, cmc, cmp,
69: cmpb, cmpl, cmpsb, cmpsd, cmpsw, cmpw, cpuid, cwd,
70: cwde, daa, das, dec, decb, decl, decw, div,
71: divb, divd, divw, fwait, hlt, idiv, idivb, idivd,
72: idivw, imul, imulb, imuld, imulw, in, inc, incb,
73: incl, incw, insb, insd, insw, intr, into, iret,
74: iretd, ja, jae, jael, jal, jb, jbe, jbel,
75: jbl, jc, jcl, jcxz, je, jecxz, jel, jg,
76: jge, jgel, jgl, jl, jle, jlel, jll, jmp,
77: jmpf, jmpl, jna, jnae, jnael, jnal, jnb, jnbe,
78: jnbel, jnbl, jnc, jncl, jne, jnel, jng, jnge,
79: jngel, jngl, jnl, jnle, jnlel, jnll, jno, jnol,
80: jnp, jnpl, jns, jnsl, jnz, jnzl, jo, jol,
81: jp, jpe, jpel, jpl, jpo, jpol, js, jsl,
82: jz, jzl, lahf, lds, lea, leave, les, lfs,
83: lgdt, lgs, lidt, lldt, lmsw, lock, lodsb, lodsd,
84: lodsw, loop, loope, loopne, loopnz, loopz, lss, ltr,
85: mov, movb, movl, movsb, movsbl, movsbw, movsd, movsw,
86: movswl, movw, movzbl, movzbw, movzwl, mul, mulb, muld,
87: mulw, neg, negb, negw, negl, nop, not, notb,
88: notw, notl, or, orb, orl, orw, out, outsb,
89: outsd, outsw, pop, popa, popad, popl, popf, popfd,
90: popw, push, pusha, pushad, pushl, pushf, pushfd, pushw,
91: rclb, rcll, rclw, rcrb, rcrl, rcrw, rep, repe,
92: repne, repnz, repz, ret, retd, retf, retfd, rolb,
93: roll, rolw, rorb, rorl, rorw, sahf, salb, sall,
94: salw, sarb, sarl, sarw, sbbb, sbbl, sbbw, scasb,
95: scasd, scasw, seta, setae, setb, setbe, setc, sete,
96: setg, setge, setl, setle, setna, setnae, setnb, setnbe,
97: setnc, setne, setng, setnge, setnl, setnle, setno, setnp,
98: setns, setnz, seto, setp, setpe, setpo, sets, setz,
99: sgdt, shlb, shld, shll, shlw, shrb, shrd, shrl,
100: shrw, sidt, sldt, smsw, stc, std, sti, stosb,
101: stosd, stosw, subb, subl, subw, testb, testl, testw,
102: verr, verw, wait, xchg, xchgb, xchgw, xchgl, xlat,
103: xlatb, xorb, xorl, xorw
104: } x86_token;
105:
106: #define AL R(al)
107: #define AH R(ah)
108: #define CL R(cl)
109: #define CH R(ch)
110: #define DL R(dl)
111: #define DH R(dh)
112: #define BL R(bl)
113: #define BH R(bh)
114: #define AX R(ax)
115: #define CX R(cx)
116: #define DX R(dx)
117: #define BX R(bx)
118: #define SI R(si)
119: #define DI R(di)
120: #define BP R(bp)
121: #define EAX R(eax)
122: #define ECX R(ecx)
123: #define EDX R(edx)
124: #define EBX R(ebx)
125: #define ESI R(esi)
126: #define EDI R(edi)
127: #define EBP R(ebp)
128: #define ESP R(esp)
129:
130: void emit(const char *fmt, ...) __attribute__((format(printf,1,2)));
131:
132: void com(const char *fmt, ...);
133:
134: const char *O(const char *symbol);
135:
136: int str(char *dst, const char *src);
137:
138: const char *x86_rstr[][3] = {
139: {"", "", "" },
140: {"%al", "al", "al" },
141: {"%ah", "ah", "ah" },
142: {"%cl", "cl", "cl" },
143: {"%ch", "ch", "ch" },
144: {"%dl", "dl", "dl" },
145: {"%dh", "dh", "dh" },
146: {"%bl", "bl", "bl" },
147: {"%bh", "bh", "bh" },
148: {"%ax", "ax", "ax" },
149: {"%cx", "cx", "cx" },
150: {"%dx", "dx", "dx" },
151: {"%bx", "bx", "bx" },
152: {"%si", "si", "si" },
153: {"%di", "di", "di" },
154: {"%bp", "bp", "bp" },
155: {"%sp", "sp", "sp" },
156: {"%eax","eax","eax" },
157: {"%ecx","ecx","ecx" },
158: {"%edx","edx","edx" },
159: {"%ebx","ebx","ebx" },
160: {"%esi","esi","esi" },
161: {"%edi","edi","edi" },
162: {"%ebp","ebp","ebp" },
163: {"%esp","esp","esp" },
164: };
165:
166: const char *x86_token_str[][3] = {
167: {".ascii", "db", "db", },
168: {".byte", "db", "db", },
169: {".short", "dw", "dw", },
170: {".long", "dd", "dd", },
171: {".align", "align", "align", },
172: {".extern", "extern", "extern", },
173: {".global", "global", "global", },
174: {".text", "section\t.text", ".code", },
175: {".data", "section\t.data", ".data", },
176: {"aaa", "aaa", "aaa", },
177: {"aad", "aad", "aad", },
178: {"aam", "aam", "aam", },
179: {"aas", "aas", "aas", },
180: {"adc", "adc", "adc", },
181: {"adcb", "adc", "adc", },
182: {"adcl", "adc", "adc", },
183: {"adcw", "adc", "adc", },
184: {"add", "add", "add", },
185: {"addb", "add", "add", },
186: {"addl", "add", "add", },
187: {"addw", "add", "add", },
188: {"and", "and", "and", },
189: {"andb", "and", "and", },
190: {"andl", "and", "and", },
191: {"andw", "and", "and", },
192: {"bswap", "bswap", "bswap", },
193: {"bt", "bt", "bt", },
194: {"btc", "btc", "btc", },
195: {"btr", "btr", "btr", },
196: {"bts", "bts", "bts", },
197: {"call", "call", "call", },
198: {"callf", "callf", "callf", },
199: {"cbw", "cbw", "cbw", },
200: {"cdq", "cdq", "cdq", },
201: {"clc", "clc", "clc", },
202: {"cld", "cld", "cld", },
203: {"cli", "cli", "cli", },
204: {"clts", "clts", "clts", },
205: {"cmc", "cmc", "cmc", },
206: {"cmp", "cmp", "cmp", },
207: {"cmpb", "cmp", "cmp", },
208: {"cmpl", "cmp", "cmp", },
209: {"cmpsb", "cmpsb", "cmpsb", },
210: {"cmpsd", "cmpsd", "cmpsd", },
211: {"cmpsw", "cmpsw", "cmpsw", },
212: {"cmpw", "cmp", "cmp", },
213: {"cpuid", "cpuid", "cpuid", },
214: {"cwd", "cwd", "cwd", },
215: {"cwde", "cwde", "cwde", },
216: {"daa", "daa", "daa", },
217: {"das", "das", "das", },
218: {"dec", "dec", "dec", },
219: {"decb", "dec", "dec", },
220: {"decl", "dec", "dec", },
221: {"decw", "dec", "dec", },
222: {"div", "div", "div", },
223: {"divb", "div", "div", },
224: {"divd", "div", "div", },
225: {"divw", "div", "div", },
226: {"fwait", "fwait", "fwait", },
227: {"hlt", "hlt", "hlt", },
228: {"idiv", "idiv", "idiv", },
229: {"idivb", "idiv", "idiv", },
230: {"idivd", "idiv", "idiv", },
231: {"idivw", "idiv", "idiv", },
232: {"imul", "imul", "imul", },
233: {"imulb", "imul", "imul", },
234: {"imuld", "imul", "imul", },
235: {"imulw", "imul", "imul", },
236: {"in", "in", "in", },
237: {"inc", "inc", "inc", },
238: {"incb", "inc", "inc", },
239: {"incl", "inc", "inc", },
240: {"incw", "inc", "inc", },
241: {"insb", "insb", "insb", },
242: {"insd", "insd", "insd", },
243: {"insw", "insw", "insw", },
244: {"int", "int", "int", },
245: {"into", "into", "into", },
246: {"iret", "iret", "iret", },
247: {"iretd", "iretf", "iretf", },
248: {"ja", "ja", "ja", },
249: {"jae", "jae", "jae", },
250: {"jael", "jae", "jae", },
251: {"jal", "ja", "ja", },
252: {"jb", "jb", "jb", },
253: {"jbe", "jbe", "jbe", },
254: {"jbel", "jbe", "jbe", },
255: {"jbl", "jb", "jb", },
256: {"jc", "jc", "jc", },
257: {"jcl", "jc", "jc", },
258: {"jcxz", "jcxz", "jcxz", },
259: {"je", "je", "je", },
260: {"jecxz", "jecxz", "jecxz", },
261: {"jel", "je", "je", },
262: {"jg", "jg", "jg", },
263: {"jge", "jge", "jge", },
264: {"jgel", "jge", "jge", },
265: {"jgl", "jg", "jg", },
266: {"jl", "jl", "jl", },
267: {"jle", "jle", "jle", },
268: {"jlel", "jle", "jle", },
269: {"jll", "jl", "jl", },
270: {"jmp", "jmp", "jmp", },
271: {"jmpf", "jmpf", "jmpf", },
272: {"jmpl", "jmp", "jmp", },
273: {"jna", "jna", "jna", },
274: {"jnae", "jnae", "jnae", },
275: {"jnael", "jnae", "jnae", },
276: {"jnal", "jna", "jna", },
277: {"jnb", "jnb", "jnb", },
278: {"jnbe", "jnbe", "jnbe", },
279: {"jnbel", "jnbe", "jnbe", },
280: {"jnbl", "jnb", "jnb", },
281: {"jnc", "jnc", "jnc", },
282: {"jncl", "jnc", "jnc", },
283: {"jne", "jne", "jne", },
284: {"jnel", "jne", "jne", },
285: {"jng", "jng", "jng", },
286: {"jnge", "jnge", "jnge", },
287: {"jngel", "jnge", "jnge", },
288: {"jngl", "jng", "jng", },
289: {"jnl", "jnl", "jnl", },
290: {"jnle", "jnle", "jnle", },
291: {"jnlel", "jnle", "jnle", },
292: {"jnll", "jnl", "jnl", },
293: {"jno", "jno", "jno", },
294: {"jnol", "jno", "jno", },
295: {"jnp", "jnp", "jnp", },
296: {"jnpl", "jnp", "jnp", },
297: {"jns", "jns", "jns", },
298: {"jnsl", "jns", "jns", },
299: {"jnz", "jnz", "jnz", },
300: {"jnzl", "jnz", "jnz", },
301: {"jo", "jo", "jo", },
302: {"jol", "jo", "jo", },
303: {"jp", "jp", "jp", },
304: {"jpe", "jpe", "jpe", },
305: {"jpel", "jpe", "jpe", },
306: {"jpl", "jp", "jp", },
307: {"jpo", "jpo", "jpo", },
308: {"jpol", "jpo", "jpo", },
309: {"js", "js", "js", },
310: {"jsl", "js", "js", },
311: {"jz", "jz", "jz", },
312: {"jzl", "jz", "jz", },
313: {"lahf", "lahf", "lahf", },
314: {"lds", "lds", "lds", },
315: {"lea", "lea", "lea", },
316: {"leave", "leave", "leave", },
317: {"les", "les", "les", },
318: {"lfs", "lfs", "lfs", },
319: {"lgdt", "lgdt", "lgdt", },
320: {"lgs", "lgs", "lgs", },
321: {"lidt", "lidt", "lidt", },
322: {"lldt", "lldt", "lldt", },
323: {"lmsw", "lmsw", "lmsw", },
324: {"lock", "lock", "lock", },
325: {"lodsb", "lodsb", "lodsb", },
326: {"lodsd", "lodsd", "lodsd", },
327: {"lodsw", "lodsw", "lodsw", },
328: {"loop", "loop", "loop", },
329: {"loope", "loope", "loope", },
330: {"loopne", "loopne", "loopne" },
331: {"loopnz", "loopnz", "loopnz" },
332: {"loopz", "loopz", "loopz", },
333: {"lss", "lss", "lss", },
334: {"ltr", "ltr", "ltr", },
335: {"mov", "mov", "mov", },
336: {"movb", "mov", "mov", },
337: {"movl", "mov", "mov", },
338: {"movsb", "movsb", "movsb", },
339: {"movsbl", "movsx", "movsx", },
340: {"movsbw", "movsx", "movsx", },
341: {"movsl", "movsd", "movsd", },
342: {"movsw", "movsw", "movsw", },
343: {"movswl", "movsx", "movsx", },
344: {"movw", "mov", "mov", },
345: {"movzbl", "movzx", "movzx", },
346: {"movzbw", "movzx", "movzx", },
347: {"movzwl", "movzx", "movzx", },
348: {"mul", "mul", "mul", },
349: {"mulb", "mul", "mul", },
350: {"muld", "mul", "mul", },
351: {"mulw", "mul", "mul", },
352: {"neg", "neg", "neg", },
353: {"negb", "neg", "neg", },
354: {"negw", "neg", "neg", },
355: {"negl", "neg", "neg", },
356: {"nop", "nop", "nop", },
357: {"not", "not", "not", },
358: {"notb", "not", "not", },
359: {"notw", "not", "not", },
360: {"notl", "not", "not", },
361: {"or", "or", "or", },
362: {"orb", "or", "or", },
363: {"orl", "or", "or", },
364: {"orw", "or", "or", },
365: {"out", "out", "out", },
366: {"outsb", "outsb", "outsb", },
367: {"outsd", "outsd", "outsd", },
368: {"outsw", "outsw", "outsw", },
369: {"pop", "pop", "pop", },
370: {"popa", "popa", "popa", },
371: {"popal", "popad", "popad", },
372: {"popl", "pop", "pop", },
373: {"popf", "popf", "popf", },
374: {"popfl", "popfd", "popfd", },
375: {"popw", "pop", "pop", },
376: {"push", "push", "push", },
377: {"pusha", "pusha", "pusha", },
378: {"pushal", "pushad", "pushad" },
379: {"pushl", "push\tdword", "push\tdword", },
380: {"pushf", "pushf", "pushf", },
381: {"pushfl", "pushfd", "pushfd" },
382: {"pushw", "push\tword", "push\tword", },
383: {"rclb", "rcl", "rcl", },
384: {"rcll", "rcl", "rcl", },
385: {"rclw", "rcl", "rcl", },
386: {"rcrb", "rcr", "rcr", },
387: {"rcrl", "rcr", "rcr", },
388: {"rcrw", "rcr", "rcr", },
389: {"rep", "rep", "rep", },
390: {"repe", "repe", "repe", },
391: {"repne", "repne", "repne", },
392: {"repnz", "repnz", "repnz", },
393: {"repz", "repz", "repz", },
394: {"ret", "ret", "ret", },
395: {"retd", "retd", "retd", },
396: {"retf", "retf", "retf", },
397: {"retfd", "retfd", "retfd", },
398: {"rolb", "rol", "rol", },
399: {"roll", "rol", "rol", },
400: {"rolw", "rol", "rol", },
401: {"rorb", "ror", "ror", },
402: {"rorl", "ror", "ror", },
403: {"rorw", "ror", "ror", },
404: {"sahf", "sahf", "sahf", },
405: {"salb", "sal", "sal", },
406: {"sall", "sal", "sal", },
407: {"salw", "sal", "sal", },
408: {"sarb", "sar", "sar", },
409: {"sarl", "sar", "sar", },
410: {"sarw", "sar", "sar", },
411: {"sbbb", "sbb ", "sbb ", },
412: {"sbbl", "sbb ", "sbb ", },
413: {"sbbw", "sbb ", "sbb ", },
414: {"scasb", "scasb", "scasb", },
415: {"scasd", "scasd", "scasd", },
416: {"scasw", "scasw", "scasw", },
417: {"seta", "seta", "seta", },
418: {"setae", "setae", "setae", },
419: {"setb", "setb", "setb", },
420: {"setbe", "setbe", "setbe", },
421: {"setc", "setc", "setc", },
422: {"sete", "sete", "sete", },
423: {"setg", "setg", "setg", },
424: {"setge", "setge", "setge", },
425: {"setl", "setl", "setl", },
426: {"setle", "setle", "setle", },
427: {"setna", "setna", "setna", },
428: {"setnae", "setnae", "setnae" },
429: {"setnb", "setnb", "setnb", },
430: {"setnbe", "setnbe", "setnbe" },
431: {"setnc", "setnc", "setnc", },
432: {"setne", "setne", "setne", },
433: {"setng", "setng", "setng", },
434: {"setnge", "setnge", "setnge" },
435: {"setnl", "setnl", "setnl", },
436: {"setnle", "setnle", "setnle" },
437: {"setno", "setno", "setno", },
438: {"setnp", "setnp", "setnp", },
439: {"setns", "setns", "setns", },
440: {"setnz", "setnz", "setnz", },
441: {"seto", "seto", "seto", },
442: {"setp", "setp", "setp", },
443: {"setpe", "setpe", "setpe", },
444: {"setpo", "setpo", "setpo", },
445: {"sets", "sets", "sets", },
446: {"setz", "setz", "setz", },
447: {"sgdt", "sgdt", "sgdt", },
448: {"shlb", "shl", "shl", },
449: {"shld", "shld", "shld", },
450: {"shll", "shl", "shl", },
451: {"shlw", "shl", "shl", },
452: {"shrb", "shr", "shr", },
453: {"shrd", "shrd", "shrd", },
454: {"shrl", "shr", "shr", },
455: {"shrw", "shr", "shr", },
456: {"sidt", "sidt", "sidt", },
457: {"sldt", "sldt", "sldt", },
458: {"smsw", "smsw", "smsw", },
459: {"stc", "stc", "stc", },
460: {"std", "std", "std", },
461: {"sti", "sti", "sti", },
462: {"stosb", "stosb", "stosb", },
463: {"stosl", "stosd", "stosd", },
464: {"stosw", "stosw", "stosw", },
465: {"subb", "sub", "sub", },
466: {"subl", "sub", "sub", },
467: {"subw", "sub", "sub", },
468: {"testb", "test", "test", },
469: {"testl", "test", "test", },
470: {"testw", "test", "test", },
471: {"verr", "verr", "verr", },
472: {"verw", "verw", "verw", },
473: {"wait", "wait", "wait", },
474: {"xchg", "xchg", "xchg", },
475: {"xchgb", "xchg", "xchg", },
476: {"xchgw", "xchg", "xchg", },
477: {"xchgl", "xchg", "xchg", },
478: {"xlat", "xlat", "xlat", },
479: {"xlatb", "xlatb", "xlatb", },
480: {"xorb", "xor", "xor", },
481: {"xorl", "xor", "xor", },
482: {"xorw", "xor", "xor", },
483: };
484:
485: #define SF 0x80
486: #define ZF 0x40
487: #define YF 0x20
488: #define HF 0x10
489: #define XF 0x08
490: #define PF 0x04
491: #define VF PF
492: #define NF 0x02
493: #define CF 0x01
494:
495: #define INT_IRQ 0x01
496: #define INT_NMI 0x80
497:
498: #define zF M(1,"z80_AF",0,0,0,0)
499: #define zA M(1,"z80_AF",0,1,0,0)
500: #define zAF M(2,"z80_AF",0,0,0,0)
501: #define zAF32 M(4,"z80_AF",0,0,0,0)
502:
503: #define zC M(1,"z80_BC",0,0,0,0)
504: #define zB M(1,"z80_BC",0,1,0,0)
505: #define zBC M(2,"z80_BC",0,0,0,0)
506: #define zBC32 M(4,"z80_BC",0,0,0,0)
507:
508: #define zE M(1,"z80_DE",0,0,0,0)
509: #define zD M(1,"z80_DE",0,1,0,0)
510: #define zDE M(2,"z80_DE",0,0,0,0)
511: #define zDE32 M(4,"z80_DE",0,0,0,0)
512:
513: #define zL M(1,"z80_HL",0,0,0,0)
514: #define zH M(1,"z80_HL",0,1,0,0)
515: #define zHL M(2,"z80_HL",0,0,0,0)
516: #define zHL32 M(4,"z80_HL",0,0,0,0)
517:
518: #define zLX M(1,"z80_IX",0,0,0,0)
519: #define zHX M(1,"z80_IX",0,1,0,0)
520: #define zIX M(2,"z80_IX",0,0,0,0)
521: #define zIX32 M(4,"z80_IX",0,0,0,0)
522:
523: #define zLY M(1,"z80_IY",0,0,0,0)
524: #define zHY M(1,"z80_IY",0,1,0,0)
525: #define zIY M(2,"z80_IY",0,0,0,0)
526: #define zIY32 M(4,"z80_IY",0,0,0,0)
527:
528: #define zPCL M(1,"z80_PC",0,0,0,0)
529: #define zPCH M(1,"z80_PC",0,1,0,0)
530: #define zPC M(2,"z80_PC",0,0,0,0)
531: #define zPC32 M(4,"z80_PC",0,0,0,0)
532:
533: #define zSPL M(1,"z80_SP",0,0,0,0)
534: #define zSPH M(1,"z80_SP",0,1,0,0)
535: #define zSP M(2,"z80_SP",0,0,0,0)
536: #define zSP32 M(4,"z80_SP",0,0,0,0)
537:
538: #define zF2 M(1,"z80_AF2",0,0,0,0)
539: #define zA2 M(1,"z80_AF2",0,1,0,0)
540: #define zAF2 M(2,"z80_AF2",0,0,0,0)
541: #define zBC2 M(2,"z80_BC2",0,0,0,0)
542: #define zDE2 M(2,"z80_DE2",0,0,0,0)
543: #define zHL2 M(2,"z80_HL2",0,0,0,0)
544:
545: #define zR M(1,"z80_R",0,0,0,0)
546: #define zR2 M(1,"z80_R2",0,0,0,0)
547: #define zIFF1 M(1,"z80_IFF1",0,0,0,0)
548: #define zIFF2 M(1,"z80_IFF2",0,0,0,0)
549: #define zHALT M(1,"z80_HALT",0,0,0,0)
550: #define zIM M(1,"z80_IM",0,0,0,0)
551: #define zI M(1,"z80_I",0,0,0,0)
552: #define pending M(1,"z80_pending_irq",0,0,0,0)
553: #define vector_d M(4,"z80_vector",0,0,0,0)
554: #define vector_w M(2,"z80_vector",0,0,0,0)
555: #define vector_h M(1,"z80_vector",0,2,0,0)
556: #define irq_max M(4,"z80_irq_max",0,0,0,0)
557: #define request_irq M(4,"z80_request_irq",0,0,0,0)
558: #define service_irq M(4,"z80_service_irq",0,0,0,0)
559: #define int_state(n) M(4,"z80_int_state",0,0,n,4)
560: #define irq(n,o) M(4,"z80_irq",n,o,0,0)
561: #define nmi_state M(4,"z80_nmi_state",0,0,0,0)
562: #define irq_state M(4,"z80_irq_state",0,0,0,0)
563: #define irq_callback M(4,"z80_irq_callback",0,0,0,0)
564: #define zEA M(4,"z80_EA",0,0,0,0)
565: #define zMB M(1,"z80_MB",0,0,0,0)
566: #define zDAA(n) M(2,"z80_daa",0,0,n,2)
567:
568: #define zICOUNT M(4,"_Z80_ICount",0,0,0,0)
569: #define zITOTAL M(4,"z80_itotal",0,0,0,0)
570: #define zIEXTRN M(4,"z80_iextrn",0,0,0,0)
571:
572: #define PREVPC M(4,"_previouspc",0,0,0,0)
573: #define DEBUG M(1,"_mame_debug",0,0,0,0)
574: #define BANKBASE(n) M(4,"_cpu_bankbase",0,0,n,4)
575: #define MRHARD M(4,"_cur_mrhard",0,0,0,0)
576: #define READHW(n,a) M(1,"_readhardware",n,-0x4000,a,1)
577: #define READOFFSET(n) M(4,"_memoryreadoffset",0,0,n,4)
578: #define READHANDLER(n) M(4,"_memoryreadhandler",0,0,n,4)
579:
580: #define MWHARD M(4,"_cur_mwhard",0,0,0,0)
581: #define WRITEHW(n,a) M(1,"_writehardware",n,-0x4000,a,1)
582: #define WRITEOFFSET(n) M(4,"_memorywriteoffset",0,0,n,4)
583: #define WRITEHANDLER(n) M(4,"_memorywritehandler",0,0,n,4)
584:
585: #define ROM M(4,"_ROM",0,0,0,0)
586: #define RAM M(4,"_RAM",0,0,0,0)
587: #define OP_ROM M(4,"_OP_ROM",0,0,0,0)
588: #define OP_RAM M(4,"_OP_RAM",0,0,0,0)
589:
590: /* Z80 accu and flags mapped to x86 (E)AX register */
591: #define F AH
592: #define A AL
593: #define AF AX
594: #define AF32 EAX
595:
596: /* Z80 HL mapped to x86 (E)BX register */
597: #define L BL
598: #define H BH
599: #define HL BX
600: #define HL32 EBX
601:
602: /* Z80 program counter mapped to x86 (E)SI register */
603: #define pc32 esi
604: #define PC SI
605: #define PC32 ESI
606:
607: #include "z80daa.h"
608:
609: void emit(const char *fmt, ...)
610: {
611: va_list arg;
612: va_start(arg,fmt);
613: vfprintf(output, fmt, arg);
614: va_end(arg);
615: fprintf(output, "\n");
616: }
617:
618: void com(const char *fmt, ...)
619: {
620: va_list arg;
621: int len = 0;
622: if (fmt) {
623: if (as == GAS)
624: len += fprintf(output, "/* ");
625: else
626: len += fprintf(output, "; ");
627: va_start(arg, fmt);
628: len += vfprintf(output, fmt, arg);
629: va_end(arg);
630: if (as == GAS)
631: {
632: while (len < 72)
633: {
634: fprintf(output, "\t");
635: len += 8 - (len & 7);
636: }
637: fprintf(output, " */");
638: }
639: }
640: fprintf(output, "\n");
641: }
642:
643: /* return an immediate decimal byte size value */
644: const char *B(int value)
645: {
646: static char B_str[32][16];
647: static int which = 0;
648: char *dst;
649:
650: which = ++which % 32;
651: dst = B_str[which];
652: if (as == GAS)
653: sprintf(dst, "$%d", value);
654: else
655: sprintf(dst, "byte %d", value);
656: return B_str[which];
657: }
658:
659: /* return an immediate decimal value */
660: const char *D(int value)
661: {
662: static char D_str[32][16];
663: static int which = 0;
664: char *dst;
665:
666: which = ++which % 32;
667: dst = D_str[which];
668: if (as == GAS)
669: sprintf(dst, "$%d", value);
670: else
671: sprintf(dst, "%d", value);
672: return D_str[which];
673: }
674:
675: /* return an immediate hexadecimal value */
676: const char *X(int value)
677: {
678: static char X_str[32][16];
679: static int which = 0;
680: char *dst;
681:
682: which = ++which % 32;
683: dst = X_str[which];
684: if (as == GAS)
685: sprintf(dst, "$0x%x", value);
686: else
687: sprintf(dst, "0%xh", value);
688: return X_str[which];
689: }
690:
691: /* return a symbol with 'short' distance modifier (for NASM) */
692: char *LS(const char *symbol)
693: {
694: static char buffer[128];
695: if (as == NASM)
696: sprintf(buffer, "short %s", symbol);
697: else
698: sprintf(buffer, "%s", symbol);
699: return buffer;
700: }
701:
702: /* return a symbol with 'near' distance modifier (for NASM) */
703: char *LN(const char *symbol)
704: {
705: static char buffer[128];
706: if (as == NASM)
707: sprintf(buffer, "near %s", symbol);
708: else
709: sprintf(buffer, "%s", symbol);
710: return buffer;
711: }
712:
713: /* emit a symbol and optional comment */
714: void S(const char *symbol, const char *comment, ...)
715: {
716: va_list arg;
717: char buffer[256];
718: char fmt[128];
719: int len = 0;
720:
721: fmt[0] = '\0';
722: if (symbol)
723: len += sprintf(fmt, "%s:", symbol);
724: if (comment) {
725: while (len < 32) {
726: strcat(fmt,"\t");
727: len += 8 - (len & 7);
728: }
729: if (as == GAS) {
730: strcat(fmt,"/* ");
731: len += 3;
732: } else {
733: strcat(fmt,"; ");
734: len += 2;
735: }
736: len += strlen(comment);
737: strcat(fmt, comment);
738: }
739: va_start(arg, comment);
740: len = len - strlen(fmt) + vsprintf(buffer, fmt, arg);
741: va_end(arg);
742:
743: if (comment && as == GAS) {
744: while (len < 72) {
745: strcat(buffer,"\t");
746: len += 8 - (len & 7);
747: }
748: strcat(buffer, "*/");
749: }
750: fprintf(output, "%s\n", buffer);
751: }
752:
753: /* emit an symbol, x86 instruction, dst and src operands and comment */
754: void I(const char *sym, x86_token t, const char *dst, const char *src, const char *comment)
755: {
756: char buffer[32], *p;
757: int len = 0, first_tab;
758:
759: first_tab = (t < align) ? 24 : 8;
760: if (sym)
761: len += fprintf(output, "%s:", sym);
762:
763: strcpy(buffer, x86_token_str[t][as]);
764: if (as == NASM) {
765: p = strstr(buffer,"\tdword"); /* remove 'dword' once if it occurs twice */
766: if (p && ((src && !strncmp(src,"dword",5)) || (dst && !strncmp(dst,"dword",5))))
767: *p = '\0';
768: p = strstr(buffer,"\tword"); /* remove 'word' once if it occurs twice */
769: if (p && ((src && !strncmp(src,"word",4)) || (dst && !strncmp(dst,"word",4))))
770: *p = '\0';
771: }
772:
773: do {
774: len = (len | 7) + 1;
775: fprintf(output, "\t");
776: } while (len < first_tab);
777:
778: len += fprintf(output, "%s", buffer);
779: if (dst) {
780: do {
781: len = (len | 7) + 1;
782: fprintf(output, "\t");
783: } while (len < first_tab + 8);
784: if (src) {
785: if (as == GAS)
786: len += fprintf(output, "%s, %s", src, dst);
787: else
788: len += fprintf(output, "%s, %s", dst, src);
789: } else {
790: len += fprintf(output, "%s", dst);
791: }
792: } else {
793: if (src) {
794: do {
795: len = (len | 7) + 1;
796: fprintf(output, "\t");
797: } while (len < first_tab + 8);
798: len += fprintf(output, "%s", src);
799: }
800: }
801: if (comment) {
802: do {
803: fprintf(output, "\t");
804: len = (len | 7) + 1;
805: } while (len < 48);
806: if (as == GAS) {
807: len += fprintf(output, "/* %s", comment);
808: while (len < 72) {
809: fprintf(output, "\t");
810: len = (len | 7) + 1;
811: }
812: len += fprintf(output, " */");
813: } else {
814: len += fprintf(output, "; %s", comment);
815: }
816: }
817: fprintf(output, "\n");
818: }
819:
820: /* return a memory reference */
821: const char *M(int size, const char *base, x86_regs r1, int offs, x86_regs r2, int mult)
822: {
823: static char mem_str[32][64];
824: static int which = 0;
825: char *dst;
826:
827: which = ++which % 32;
828: dst = mem_str[which];
829: switch (as) {
830: case GAS:
831: if (base) {
832: dst += sprintf(dst, "%s", base);
833: if (offs)
834: dst += sprintf(dst, "%+d", offs);
835: } else {
836: if (offs)
837: dst += sprintf(dst, "%d", offs);
838: }
839: if (r1) {
840: dst += sprintf(dst, "(%s", x86_rstr[r1][as]);
841: if (r2)
842: dst += sprintf(dst, ",%s", x86_rstr[r2][as]);
843: if (mult)
844: dst += sprintf(dst, ",%d", mult);
845: dst += sprintf(dst, ")");
846: } else if (r2) {
847: dst += sprintf(dst, "(,%s", x86_rstr[r2][as]);
848: if (mult)
849: dst += sprintf(dst, ",%d", mult);
850: dst += sprintf(dst, ")");
851: }
852: break;
853:
854: case NASM:
855: switch (size) {
856: case 1:
857: dst += sprintf(dst, "byte[");
858: break;
859: case 2:
860: dst += sprintf(dst, "word[");
861: break;
862: case 4:
863: dst += sprintf(dst, "dword[");
864: break;
865: default: /* no size prefix */
866: dst += sprintf(dst, "[");
867: }
868: if (base)
869: dst += sprintf(dst, "%s", base);
870: if (r1) {
871: if (base)
872: dst += sprintf(dst, "+");
873: dst += sprintf(dst, "%s", x86_rstr[r1][as]);
874: if (offs)
875: dst += sprintf(dst, "%+d", offs);
876: if (r2) {
877: dst += sprintf(dst, "+%s", x86_rstr[r2][as]);
878: if (mult && mult > 1)
879: dst += sprintf(dst, "*%d", mult);
880: }
881: } else if (r2) {
882: if (base)
883: dst += sprintf(dst, "+");
884: dst += sprintf(dst, "%s", x86_rstr[r2][as]);
885: if (mult && mult > 1)
886: dst += sprintf(dst, "*%d", mult);
887: } else {
888: if (offs) {
889: if (base)
890: dst += sprintf(dst, "%+d", offs);
891: else
892: dst += sprintf(dst, "%s", X(offs));
893: }
894: }
895: dst += sprintf(dst, "]");
896: break;
897:
898: case TASM:
899: switch (size) {
900: case 1:
901: dst += sprintf(dst, "byte ptr [");
902: break;
903: case 2:
904: dst += sprintf(dst, "word ptr [");
905: break;
906: case 4:
907: dst += sprintf(dst, "dword ptr [");
908: break;
909: default: /* no size prefix */
910: dst += sprintf(dst, "[");
911: }
912: if (base)
913: dst += sprintf(dst, "%s", base);
914: if (r1) {
915: if (base)
916: dst += sprintf(dst, "+");
917: dst += sprintf(dst, "%s", x86_rstr[r1][as]);
918: if (offs)
919: dst += sprintf(dst, "%+d", offs);
920: if (r2) {
921: dst += sprintf(dst, "+%s", x86_rstr[r2][as]);
922: if (mult)
923: dst += sprintf(dst, "*%d", mult);
924: }
925: } else if (r2) {
926: if (base)
927: dst += sprintf(dst, "+");
928: dst += sprintf(dst, "%s", x86_rstr[r2][as]);
929: if (mult)
930: dst += sprintf(dst, "*%d", mult);
931: } else {
932: if (offs) {
933: if (base)
934: dst += sprintf(dst, "%+d", offs);
935: else
936: dst += sprintf(dst, "%s", X(offs));
937: }
938: }
939: dst += sprintf(dst, "]");
940: break;
941: }
942: return mem_str[which];
943: }
944:
945: /* return a x86 register name */
946: const char *R(x86_regs rg)
947: {
948: if (as == GAS) {
949: switch (rg) {
950: case none: return "none";
951: case al: return "%al";
952: case ah: return "%ah";
953: case cl: return "%cl";
954: case ch: return "%ch";
955: case dl: return "%dl";
956: case dh: return "%dh";
957: case bl: return "%bl";
958: case bh: return "%bh";
959: case ax: return "%ax";
960: case cx: return "%cx";
961: case dx: return "%dx";
962: case bx: return "%bx";
963: case si: return "%si";
964: case di: return "%di";
965: case bp: return "%bp";
966: case sp: return "%sp";
967: case eax: return "%eax";
968: case ecx: return "%ecx";
969: case edx: return "%edx";
970: case ebx: return "%ebx";
971: case esi: return "%esi";
972: case edi: return "%edi";
973: case ebp: return "%ebp";
974: case esp: return "%esp";
975: }
976: } else {
977: switch (rg) {
978: case none: return "none";
979: case al: return "al";
980: case ah: return "ah";
981: case cl: return "cl";
982: case ch: return "ch";
983: case dl: return "dl";
984: case dh: return "dh";
985: case bl: return "bl";
986: case bh: return "bh";
987: case ax: return "ax";
988: case cx: return "cx";
989: case dx: return "dx";
990: case bx: return "bx";
991: case si: return "si";
992: case di: return "di";
993: case bp: return "bp";
994: case sp: return "sp";
995: case eax: return "eax";
996: case ecx: return "ecx";
997: case edx: return "edx";
998: case ebx: return "ebx";
999: case esi: return "esi";
1000: case edi: return "edi";
1001: case ebp: return "ebp";
1002: case esp: return "esp";
1003: }
1004: }
1005: return "xx";
1006: }
1007:
1008: const char *O(const char *symbol)
1009: {
1010: static char ofs_str[32][32];
1011: static int which = 0;
1012: char *dst;
1013:
1014: which = ++which % 32;
1015: dst = ofs_str[which];
1016: switch (as) {
1017: case GAS: /* GAS: $ indicates immediate (address of) */
1018: sprintf(dst, "$%s", symbol);
1019: break;
1020: case NASM: /* NASM: only the name w/o square brackets */
1021: sprintf(dst, "%s", symbol);
1022: break;
1023: case TASM: /* TASM: offset name */
1024: sprintf(dst, "offset %s", symbol);
1025: break;
1026: }
1027: return ofs_str[which];
1028: }
1029:
1030: int str(char *dst, const char *src)
1031: {
1032: int argc = 0;
1033: char strdelim = '"';
1034:
1035: if (as == GAS) {
1036: *dst++ = strdelim;
1037: while (*src) {
1038: switch (*src) {
1039: case '\b': /* backspace */
1040: dst += sprintf(dst, "\\010");
1041: break;
1042: case '\t': /* tab */
1043: dst += sprintf(dst, "\\011");
1044: break;
1045: case '\n': /* newline */
1046: dst += sprintf(dst, "\\012");
1047: break;
1048: case '\r': /* carriage return */
1049: dst += sprintf(dst, "\\015");
1050: break;
1051: default:
1052: if (src[0] == '%' && src[1] != '%')
1053: argc++;
1054: *dst++ = *src;
1055: }
1056: src++;
1057: }
1058: strcpy(dst, "\\000\"");
1059: } else {
1060: char len = 0;
1061: int instr = 0;
1062:
1063: while (*src) {
1064: switch (*src) {
1065: case '\b': /* backspace */
1066: case '\t': /* tab */
1067: case '\n': /* line feed */
1068: case '\r': /* new line */
1069: if (instr) {
1070: *dst++ = strdelim;
1071: len++;
1072: instr = 0;
1073: }
1074: if (len) {
1075: *dst++ = ',';
1076: len++;
1077: }
1078: dst += sprintf(dst, "%d", *src);
1079: break;
1080: default:
1081: if (src[0] == '%' && src[1] != '%')
1082: argc++;
1083: if (!instr) {
1084: if (len) {
1085: *dst++ = ',';
1086: len++;
1087: }
1088: *dst++ = strdelim;
1089: len++;
1090: instr = 1;
1091: }
1092: *dst++ = *src;
1093: len++;
1094: }
1095: src++;
1096: }
1097: if (instr) {
1098: *dst++ = strdelim;
1099: len++;
1100: }
1101: if (len)
1102: *dst++ = ',';
1103: strcpy(dst, "0");
1104: }
1105: return argc;
1106: }
1107:
1108: void debug(int level, char *fmt, ...)
1109: {
1110: static int dbg_cnt = 0;
1111: va_list args;
1112:
1113: if (verbose >= level) {
1114: int i, argc;
1115: char dbgtxt[16], dbgend[16], format[128];
1116: char *arg, pusharg[32][64];
1117:
1118: argc = str(format, fmt);
1119: dbg_cnt++;
1120: sprintf(dbgtxt, "L%04x", dbg_cnt);
1121: sprintf(dbgend, "L%04xx", dbg_cnt);
1122: I(0, data, 0, 0, 0);
1123: I(dbgtxt, dm, format, 0, 0);
1124: I(0, text, 0, 0, 0);
1125: va_start(args, fmt);
1126: for (i = 0; i < argc; i++) {
1127: arg = va_arg(args, char *);
1128: sprintf(pusharg[i],"\t%s\t%s\n",x86_token_str[pushl][as],arg);
1129: }
1130: va_end(args);
1131: I(0,testl, M(4,"_errorlog",0,0,0,0), D(-1), 0);
1132: I(0,je, LS(dbgend), 0, 0);
1133: I(0,pushad,0,0,0);
1134: for (i = argc - 1; i >= 0; i--)
1135: fputs(pusharg[i], output);
1136: I(0,pushl, O(dbgtxt), 0, 0);
1137: I(0,pushl, M(4,"_errorlog",0,0,0,0), 0, 0);
1138: I(0,call, "_fprintf", 0, 0);
1139: I(0,addl, ESP, D((argc + 2) * 4),0);
1140: I(0,popad, 0, 0, 0);
1141: S(dbgend,0);
1142: }
1143: }
1144:
1145: static void dumpregs(void)
1146: {
1147: debug(8,"AF:%04x BC:%04x DE:%04x HL:%04x IX:%04x IY:%04x SP:%04x PC:%04x PC:%04x\n",
1148: zAF,zBC,zDE,zHL,zIX,zIY,zSP,zPC);
1149: }
1150:
1151:
1152: static void pad(int alignment)
1153: {
1154: char buffer[4+1];
1155: com(0);
1156: if (alignment) {
1157: if (as == GAS) {
1158: sprintf(buffer, "%d", alignment);
1159: I(0,align,buffer,0,0);
1160: } else {
1161: sprintf(buffer, "%d", 2<<alignment);
1162: I(0,align,buffer,0,0);
1163: }
1164: }
1165: }
1166:
1167: static void save_af(void)
1168: {
1169: I(0,movb, zF, F, "save F");
1170: I(0,movb, zA, A, "save A");
1171: }
1172:
1173: static void restore_af(void)
1174: {
1175: I(0,movzbl, AF32, zA, "get A");
1176: I(0,movb, F, zF, "get F");
1177: }
1178:
1179: static void save_z80(int opsize)
1180: {
1181: I(0,movw, zPC, PC, "save PC");
1182: I(0,movw, zHL, HL, "save HL");
1183: #if CALC_PREVPC
1184: if (opsize) {
1185: if ( opsize == +1 )
1186: I(0,decl, PC32, 0, "subtract opcode size from PC");
1187: else
1188: I(0,subl, PC32, B(opsize), "subtract opcode size from PC");
1189: I(0,movl, PREVPC, PC32, "store previous PC");
1190: }
1191: #endif
1192: }
1193:
1194: static void restore_z80(void)
1195: {
1196: I(0,movzwl, PC32, zPC, "get PC");
1197: I(0,movzwl, HL32, zHL, "get HL");
1198: }
1199:
1200: /*************************************************************************
1201: * MOVB
1202: * Move register/memory from src to dst
1203: *************************************************************************/
1204: static void MOVB( const char *dst, const char *src, const char *comment, ... )
1205: {
1206: char buffer[128+1];
1207: va_list arg;
1208: va_start(arg, comment);
1209: vsprintf(buffer, comment, arg);
1210: va_end(arg);
1211:
1212: if (!strcmp(dst, src))
1213: return;
1214: if (!strcmp(dst, AL) || !strcmp(src, AL) ||
1215: !strcmp(dst, AH) || !strcmp(src, AH) ||
1216: !strcmp(dst, CL) || !strcmp(src, CL) ||
1217: !strcmp(dst, CH) || !strcmp(src, CH) ||
1218: !strcmp(dst, DL) || !strcmp(src, DL) ||
1219: !strcmp(dst, DH) || !strcmp(src, DH) ||
1220: !strcmp(dst, BL) || !strcmp(src, BL) ||
1221: !strcmp(dst, BH) || !strcmp(src, BH)) {
1222: if (!strcmp(dst,EAX) || !strcmp(dst,ECX) ||
1223: !strcmp(dst,EDX) || !strcmp(dst,EBX) ||
1224: !strcmp(dst,EBP) || !strcmp(dst,ESI) ||
1225: !strcmp(dst,EDI) || !strcmp(dst,ESP)) {
1226: /* zero extend byte register */
1227: I(0,movzbl, dst, src, buffer);
1228: } else {
1229: /* dst and src are byte register */
1230: I(0,movb, dst, src, buffer);
1231: }
1232: } else {
1233: if (!strcmp(dst,EAX) || !strcmp(dst,ECX) ||
1234: !strcmp(dst,EDX) || !strcmp(dst,EBX) ||
1235: !strcmp(dst,EBP) || !strcmp(dst,ESI) ||
1236: !strcmp(dst,EDI) || !strcmp(dst,ESP)) {
1237: /* zero extend memory byte */
1238: I(0,movzbl, dst, src, buffer);
1239: } else {
1240: /* memory to memory byte transfer */
1241: I(0,movb, CL, src, buffer);
1242: I(0,movb, dst, CL, 0);
1243: }
1244: }
1245: }
1246:
1247: /*************************************************************************
1248: * ADJUST_PC
1249: * increment/decrement or adjust program counter (PC)
1250: *************************************************************************/
1251: void ADJUST_PC( int offset )
1252: {
1253: if (offset == +1)
1254: I(0,incl, PC32, 0, "increment PC");
1255: else
1256: if (offset == -1)
1257: I(0,decl, PC32, 0, "decrement PC");
1258: else
1259: I(0,addl, PC32, B(offset), "adjust PC");
1260: }
1261:
1262: /*************************************************************************
1263: * ROP
1264: * Read opcode from OP_ROM at PC
1265: *************************************************************************/
1266: static void ROP( void )
1267: {
1268: I(0,movl, EDI, OP_ROM, "get OP_ROM base");
1269: I(0,movzbl, ECX, M(1,0,edi,0,pc32,1),"read opcode byte");
1270: ADJUST_PC(+1);
1271: }
1272:
1273: /*************************************************************************
1274: * ARG
1275: * dst where to store the result
1276: * Get an 8 bit argument from OP_RAM at PC
1277: *************************************************************************/
1278: static void ARG( const char *dst )
1279: {
1280: I(0,movl, EDI, OP_RAM, "get OP_RAM base");
1281: MOVB( dst, M(1,0,edi,0,pc32,1), "read opcode argument byte");
1282: ADJUST_PC(+1);
1283: }
1284:
1285: /*************************************************************************
1286: * ARG16
1287: * dst where to store the result
1288: * Get an 16 bit argument from OP_RAM at PC
1289: *************************************************************************/
1290: static void ARG16(const char *dst)
1291: {
1292: I(0,movl, EDI, OP_RAM, "get OP_RAM base");
1293: if (!strcmp(dst, EAX) || !strcmp(dst, ECX) ||
1294: !strcmp(dst, EDX) || !strcmp(dst, EBX) ||
1295: !strcmp(dst, ESI) || !strcmp(dst, EDI) ||
1296: !strcmp(dst, EBP) || !strcmp(dst, ESP)) {
1297: I(0,movzwl, dst, M(2,0,edi,0,pc32,1), "read opcode argument word (zero extend)");
1298: } else {
1299: I(0,movzwl, ECX, M(2,0,edi,0,pc32,1), "read opcode argument word (zero extend)");
1300: I(0,movl, dst, ECX, "store result");
1301: }
1302: if (strcmp(dst, PC32)) /* not loaded PC itself? */
1303: ADJUST_PC(+2);
1304: }
1305:
1306: /*************************************************************************
1307: * REL
1308: * Get an sign extended byte argument from OP_RAM at PC into ECX
1309: *************************************************************************/
1310: static void REL( void )
1311: {
1312: I(0,movl, EDI, OP_RAM, "get OP_RAM base");
1313: I(0,movsbl, ECX, M(1,0,edi,0,pc32,1),"read 2's complement offset");
1314: ADJUST_PC(+1);
1315: }
1316:
1317: /*************************************************************************
1318: * OFS
1319: * base IX or IY register (dword[z80_IX] or dword[z80_IY])
1320: * Build index register plus ofs8 (2's complement offset)
1321: *************************************************************************/
1322: static void OFS(const char *base)
1323: {
1324: I(0,movl, EDI, OP_RAM, "get OP_RAM base");
1325: I(0,movsbl, ECX, M(1,0,edi,0,pc32,1),"read opcode argument byte");
1326: I(0,addl, ECX, base, "add index register");
1327: I(0,movzwl, EBP, CX, "16 address bits");
1328: ADJUST_PC(+1);
1329: }
1330:
1331: /*************************************************************************
1332: * CHANGE_PC
1333: * Check if cur_mrhard for the new PC has changed and call
1334: * cpu_setOPbase16 if necessary
1335: *************************************************************************/
1336: static void CHANGE_PC( void )
1337: {
1338: static int chgpc = 0;
1339: char symbol[32+1];
1340: chgpc++;
1341: sprintf(symbol,"chgpc_%02x", chgpc);
1342: I(0,movzwl, ECX, PC, "get PC to ECX");
1343: I(0,movl, PC32, ECX, "make PC 16 bit again");
1344: I(0,movl, EDI, MRHARD, 0);
1345: I(0,shrl, ECX, D(ABITS), ">> (ABITS2_16 + ABITS_MIN_16)");
1346: I(0,movb, CL, M(1,0,edi,0,ecx,1), "get cur_mrhard[index]");
1347: I(0,cmpb, CL, M(1,"_ophw",0,0,0,0), "changed?");
1348: I(0,je, LS(symbol),0, "no, skip");
1349: save_af();
1350: save_z80( 0 );
1351: I(0,pushl, PC32, 0, 0);
1352: I(0,call, "_cpu_setOPbase16",0, 0);
1353: I(0,addl, ESP, B(4), 0);
1354: restore_z80();
1355: restore_af();
1356: S(symbol,0);
1357: }
1358:
1359: /*************************************************************************
1360: * RBYTE
1361: * dst where to store the result
1362: * src memory address
1363: * Read a byte from memory
1364: *************************************************************************/
1365: static void RBYTE( int opsize, const char *val, const char *src )
1366: {
1367: char symbol[15+1];
1368: rbyte++;
1369: sprintf(symbol,"rbyte%d", opsize*CALC_PREVPC);
1370: if (strcmp(src, EBP))
1371: I(0,movl, EBP, src, "memory address to EBP");
1372: I(0,call, symbol, 0, "read byte");
1373: if( strcmp(val, EDX) && strcmp(val, DX) && strcmp(val, DL) )
1374: I(0,movl, val, EDX, "store result");
1375: }
1376:
1377: /*************************************************************************
1378: * RWORD
1379: * val where to store the result
1380: * src memory address
1381: * Read a word from memory
1382: *************************************************************************/
1383: static void RWORD( int opsize, const char *val, const char *src )
1384: {
1385: char symbol[15+1];
1386: rword++;
1387: sprintf(symbol,"rword%d", opsize*CALC_PREVPC);
1388: if (strcmp(src, EBP))
1389: I(0,movl, EBP, src, "memory address to EBP");
1390: I(0,call, symbol, 0, "read word");
1391: if( strcmp(val, EDX) && strcmp(val, DX) && strcmp(val, DL) )
1392: I(0,movl, val, EDX, "store result");
1393: }
1394:
1395: /*************************************************************************
1396: * WBYTE
1397: * dst memory address
1398: * val value to store
1399: * Write a byte to memory
1400: *************************************************************************/
1401: static void WBYTE( int opsize, const char *dst, const char *val )
1402: {
1403: char symbol[15+1];
1404: wbyte++;
1405: sprintf(symbol,"wbyte%d", opsize*CALC_PREVPC);
1406: if (strcmp(dst, EBP))
1407: I(0,movl, EBP, dst, "memory address to EBP");
1408: if (strcmp(val, EDX))
1409: I(0,movl, EDX, val, "get value to EDX");
1410: I(0,call, symbol, 0, "write byte");
1411: }
1412:
1413: /*************************************************************************
1414: * WWORD
1415: * dst memory address
1416: * val value to store
1417: * Write a word to memory
1418: *************************************************************************/
1419: static void WWORD( int opsize, const char *dst, const char *val )
1420: {
1421: char symbol[15+1];
1422: wword++;
1423: sprintf(symbol,"wword%d", opsize*CALC_PREVPC);
1424: if (strcmp(dst, EBP))
1425: I(0,movl, EBP, dst, "memory address to EBP");
1426: if (strcmp(val, EDX))
1427: I(0,movl, EDX, val, "get value to EDX");
1428: I(0,call, symbol, 0, "write word");
1429: }
1430:
1431: static void PUSH( int opsize, const char *src )
1432: {
1433: char reg[32+1];
1434: strcpy(reg, src);
1435: I(0,subw, zSP, B(2), 0);
1436: WWORD( opsize, zSP32, reg );
1437: }
1438:
1439: static void POP( int opsize, const char *dst )
1440: {
1441: char reg[32+1];
1442: strcpy(reg, dst);
1443: RWORD( opsize, reg, zSP32 );
1444: I(0,addw, zSP, B(2), 0);
1445: }
1446:
1447: static char *beg_opcode(int cycles, const char *symbol, const char *comment, ...)
1448: {
1449: static char endfunc[32];
1450: char begfunc[32], *dst = begfunc;
1451: char buffer[256];
1452: va_list args;
1453:
1454: #if GLOBL
1455: /* put an underscore in front of the symbol */
1456: sprintf(dst, "_%s", symbol);
1457: I(0,globl,begfunc,0,0);
1458: #else
1459: /* extract the symbol */
1460: strcpy(dst, symbol);
1461: #endif
1462:
1463: /* symbol to put at the end of the function */
1464: sprintf(endfunc, "L%s", begfunc);
1465:
1466: if (comment) {
1467: va_start(args, comment);
1468: vsprintf(buffer, comment, args);
1469: va_end(args);
1470: com("***** %s", buffer);
1471: }
1472: pad(align_funcs);
1473: S(begfunc,0);
1474: if (cycles)
1475: I(0,subl, zICOUNT, B(cycles), "subtract from ICount");
1476: if (strncmp(symbol,"xx",2)) /* M1 type opcode fetch? */
1477: I(0,incb, zR, 0, "increment R register once");
1478:
1479: opcodes++;
1480:
1481: return endfunc;
1482: }
1483:
1484: static void end_opcode(const char *op_base)
1485: {
1486: if (!strcmp(op_base, "z_op")) {
1487: I(0,orl, zICOUNT, B(0), "all cycles used up?");
1488: I(0,jle, LN("z80_execute_done"),0, 0);
1489: #if (!CALC_PREVPC)
1490: I(0,movl, PREVPC, PC32, "store previous PC");
1491: #endif
1492: if (mame_debug) {
1493: I(0,testb, DEBUG, D(1), 0);
1494: I(0,jne, LN("z80_mame_debug"),0, 0);
1495: }
1496: }
1497: if (strcmp(op_base, "z_xx")) {
1498: ROP();
1499: } else {
1500: ARG( ECX ); /* byte #4 of [DD/FD CB <ofs8> xx] is read as op_arg! */
1501: }
1502: I(0,jmp, M(4,op_base,0,0,ecx,4),0, "jump to opcode handler");
1503: com(0);
1504: }
1505:
1506: static void mk_debug( void )
1507: {
1508: save_af();
1509: save_z80(0);
1510: #if 0
1511: I(0,movb, AL, zR, "get R");
1512: I(0,andb, AL, X(0x7f), "mask lower seven bits");
1513: I(0,orb, AL, zR2, "get original bit 7");
1514: I(0,movb, zR, AL, "save it for the debugger");
1515: #endif
1516: I(0,call, "_MAME_Debug", 0, 0);
1517: restore_z80();
1518: restore_af();
1519: }
1520:
1521: static void mk_take_irq( int opcode )
1522: {
1523: char symbol[14][32+1];
1524: sprintf(symbol[ 0],"z80_%02x_check_daisy_1", opcode);
1525: sprintf(symbol[ 1],"z80_%02x_check_daisy_2", opcode);
1526: sprintf(symbol[ 2],"z80_%02x_check_daisy_3", opcode);
1527: sprintf(symbol[ 3],"z80_%02x_check_daisy_4", opcode);
1528: sprintf(symbol[ 4],"z80_%02x_check_daisy_5", opcode);
1529: sprintf(symbol[ 5],"z80_%02x_take_irq_1", opcode);
1530: sprintf(symbol[ 6],"z80_%02x_take_irq_2", opcode);
1531: sprintf(symbol[ 7],"z80_%02x_take_irq_3", opcode);
1532: sprintf(symbol[ 8],"z80_%02x_take_irq_4", opcode);
1533: sprintf(symbol[ 9],"z80_%02x_take_irq_5", opcode);
1534: sprintf(symbol[10],"z80_%02x_take_irq_6", opcode);
1535: sprintf(symbol[11],"z80_%02x_take_irq_7", opcode);
1536: sprintf(symbol[12],"z80_%02x_take_irq_8", opcode);
1537: sprintf(symbol[13],"z80_%02x_take_irq_done", opcode);
1538:
1539: I(0,cmpl, irq_max, B(0), "daisy chain mode?");
1540: I(0,je, LN(symbol[ 5]),0, "no, single int");
1541:
1542: #if (!EARLY_CTC)
1543: com("===================================================================");
1544: com(" Z80CTC code ");
1545: com("===================================================================");
1546: save_af();
1547: I(0,movb, zIFF1, D(0), "clear IFF1");
1548: I(0,pushl, D(0), 0, "irqline always 0");
1549: I(0,call, irq_callback, 0, "get the vector");
1550: I(0,addl, ESP, B(4), "clean up stack");
1551: I(0,movzbl, EDX, AL, "EDX = state");
1552: I(0,movl, ECX, EAX, 0);
1553: restore_af();
1554: I(0,shrl, ECX, D(8), "ECX = device");
1555: I(0,cmpl, EDX, int_state(ecx), "state change?");
1556: I(0,je, LN(symbol[ 4]),0, "no change, skip");
1557: I(0,movl, int_state(ecx), EDX, "store new state");
1558: I(0,movl, EDX, D(-1), 0);
1559: I(0,movl, ECX, D(0), 0);
1560: I(0,movl, request_irq, EDX, "reset request IRQ");
1561: I(0,movl, service_irq, EDX, "reset service IRQ");
1562: pad(align_loops);
1563: S(symbol[1],0);
1564: I(0,testl, int_state(ecx), X(Z80_INT_IEO), "Z80_INT_IEO set?");
1565: I(0,je, LS(symbol[2]),0, "no, skip");
1566: I(0,movl, request_irq, EDX, "mask lower IRQ");
1567: I(0,movl, service_irq, ECX, "set service device number");
1568: com(0);
1569: S(symbol[2],0);
1570: I(0,testl, int_state(ecx), X(Z80_INT_REQ), "Z80_INT_REQ set?");
1571: I(0,je, LS(symbol[3]),0, "no, skip");
1572: I(0,movl, request_irq, ECX, "set request device number");
1573: com(0);
1574: S(symbol[3],0);
1575: I(0,incl, ECX, 0, "next device");
1576: I(0,cmpl, ECX, irq_max, "more entries to check?");
1577: I(0,jb, LS(symbol[1]),0, "yes, check them");
1578: #endif
1579: com("===================================================================");
1580: com(" check Z80CTC request irq ");
1581: com("===================================================================");
1582: S(symbol[ 4],0);
1583: I(0,movl, ECX, request_irq, "get device");
1584: I(0,cmpl, ECX, B(0), "request?");
1585: I(0,jl, LN(symbol[13]),0, "should not happen, but...");
1586: save_af();
1587: I(0,lea, ECX, M(0,0,0,0,ecx,4), "* sizeof(Z80_DaisyChain)");
1588: I(0,pushl, irq(ecx,12), 0, "Z80.irq[device].irq_param");
1589: I(0,call, irq(ecx, 4), 0, "call Z80.irq[device].interrupt_entry");
1590: I(0,addl, ESP, B(4), "one DWORD was pushed");
1591: I(0,movl, vector_d, EAX, "store vector");
1592: restore_af();
1593: I(0,movl, request_irq, D(-1), "reset request IRQ");
1594: I(0,jmp, LS(symbol[ 6]), 0, 0);
1595:
1596: com("===================================================================");
1597: com(" single interrupt code ");
1598: com("===================================================================");
1599: S(symbol[ 5],0);
1600: save_af();
1601: I(0,movb, zIFF1, D(0), "clear IFF1");
1602: I(0,pushl, D(0), 0, "irqline always 0");
1603: I(0,call, irq_callback, 0, "do a irq_callback");
1604: I(0,movl, vector_d, EAX, "store vector");
1605: I(0,addl, ESP, B(4), "one DWORD was pushed");
1606: restore_af();
1607:
1608: com("===================================================================");
1609: com(" here when a valid vector is set ");
1610: com("===================================================================");
1611: S(symbol[ 6],0);
1612: com(0);
1613: I(0,cmpb, zHALT, D(1), "CPU was halted?");
1614: I(0,jne, LS(symbol[ 7]), 0, "no, skip");
1615: I(0,movb, zHALT, D(0), "clear halt flag");
1616: I(0,incw, PC, 0, 0);
1617: com(0);
1618: S(symbol[ 7],0);
1619: I(0,movl, PREVPC, D(-1), "no valid previous PC");
1620: I(0,cmpb, zIM, B(2), "interrupt mode 2?");
1621: I(0,jne, LN(symbol[ 8]), 0, "no, test IM 1");
1622: I(0,call, "z80_push_pc", 0, 0);
1623: I(0,movzwl, ECX, vector_w, "get vector");
1624: I(0,movb, CH, zI, "get MSB from I register");
1625: RWORD( 0, PC32, ECX );
1626: I(0,jmp, symbol[12], 0, "change PC and exit");
1627:
1628: com(0);
1629: S(symbol[ 8],0);
1630: I(0,cmpb, zIM, B(1), "interrupt mode 1?");
1631: I(0,jne, LN(symbol[ 9]),0, "no, it's IM 0");
1632: I(0,call, "z80_push_pc", 0, 0);
1633: I(0,addl, zIEXTRN, B(11), "subtract <RST xx> cycles");
1634: I(0,movl, PC32, X(0x38), "<RST 38> vector");
1635: I(0,jmp, symbol[12], 0, "change PC and exit");
1636:
1637: com("===================================================================");
1638: com(" here when interrupt mode is 0 ");
1639: com("===================================================================");
1640: S(symbol[ 9],0);
1641: I(0,cmpb, vector_h, X(0xcd), "opcode <CALL imm16>?");
1642: I(0,jne, LN(symbol[10]),0, "no, skip");
1643: I(0,call, "z80_push_pc", 0, 0);
1644: // The C core doesn't count cycles for <CALL imm16> vector
1645: // I(0,addl, zIEXTRN, B(17), "subtract cycles for CALL opcode");
1646: I(0,movzwl, PC32, vector_w, "get vector bits 0..15");
1647: I(0,jmp, LS(symbol[12]), 0, "change PC and exit");
1648:
1649: com(0);
1650: S(symbol[10],0);
1651: I(0,cmpb, vector_h, X(0xc3), "opcode <JP imm16>?");
1652: I(0,jne, LS(symbol[11]), 0, "no, skip");
1653: // The C core doesn't count cycles for <JP imm16> vector
1654: // I(0,addl, zIEXTRN, B(10), "subtract cycles for JP opcode");
1655: I(0,movzwl, PC32, vector_w, "get vector bits 0..15");
1656: I(0,jmp, LS(symbol[12]), 0, "change PC and exit");
1657:
1658: com(0);
1659: S(symbol[11],0);
1660: com("===================================================================");
1661: com(" here when vector is single byte opcode ");
1662: com("===================================================================");
1663: I(0,call, "z80_push_pc", 0, 0);
1664: I(0,addl, zIEXTRN, B(11), "assume <RST xx> cycles");
1665: I(0,movl, PC32, vector_d, "get vector");
1666: I(0,andl, PC32, B(0x38), "mask RST vector");
1667:
1668: com("===================================================================");
1669: com(" here with new PC ");
1670: com("===================================================================");
1671: S(symbol[12],0);
1672: CHANGE_PC();
1673:
1674: com(0);
1675: pad(align_jumps);
1676: S(symbol[13],0);
1677: save_af();
1678: save_z80(0);
1679: }
1680:
1681: static void mk_header(void)
1682: {
1683: int i;
1684:
1685: com("===========================================================================");
1686: com(" ");
1687: com(" Z80 x86 cpu emulation ");
1688: com(" Copyright (c) 1998 by Juergen Buchmueller ");
1689: com(" ([email protected]) ");
1690: com(" ");
1691: if (as == GAS)
1692: com(" For assembly by GNU assembler only ");
1693: else
1694: if (as == NASM)
1695: com(" For assembly by NASM only ");
1696: else
1697: com(" For assembly by TASM 3.2 and later only ");
1698: com(" ");
1699: com(" Theory of operation ");
1700: com(" eax holds the current accumulator and flags (al = A, ah = F) ");
1701: com(" ecx is used as temporary register (address) ");
1702: com(" edx is used as temporary register (data) ");
1703: com(" esi holds the current program counter (PC) ");
1704: com(" ebp is used as memory handler return address ");
1705: com(" ");
1706: com("===========================================================================");
1707: com(0);
1708: if (as == NASM)
1709: emit("bits\t32");
1710: if (as == TASM)
1711: {
1712: emit(".486");
1713: emit(".model\tflat");
1714: }
1715: com(0);
1716: I(0,data,0,0,0);
1717: S("z_op",0);
1718: I(0,dd,"op_00,op_01,op_02,op_03,op_04,op_05,op_06,op_07,op_08,op_09,op_0a,op_0b,op_0c,op_0d,op_0e,op_0f",0,0);
1719: I(0,dd,"op_10,op_11,op_12,op_13,op_14,op_15,op_16,op_17,op_18,op_19,op_1a,op_1b,op_1c,op_1d,op_1e,op_1f",0,0);
1720: I(0,dd,"op_20,op_21,op_22,op_23,op_24,op_25,op_26,op_27,op_28,op_29,op_2a,op_2b,op_2c,op_2d,op_2e,op_2f",0,0);
1721: I(0,dd,"op_30,op_31,op_32,op_33,op_34,op_35,op_36,op_37,op_38,op_39,op_3a,op_3b,op_3c,op_3d,op_3e,op_3f",0,0);
1722: I(0,dd,"op_40,op_41,op_42,op_43,op_44,op_45,op_46,op_47,op_48,op_49,op_4a,op_4b,op_4c,op_4d,op_4e,op_4f",0,0);
1723: I(0,dd,"op_50,op_51,op_52,op_53,op_54,op_55,op_56,op_57,op_58,op_59,op_5a,op_5b,op_5c,op_5d,op_5e,op_5f",0,0);
1724: I(0,dd,"op_60,op_61,op_62,op_63,op_64,op_65,op_66,op_67,op_68,op_69,op_6a,op_6b,op_6c,op_6d,op_6e,op_6f",0,0);
1725: I(0,dd,"op_70,op_71,op_72,op_73,op_74,op_75,op_76,op_77,op_78,op_79,op_7a,op_7b,op_7c,op_7d,op_7e,op_7f",0,0);
1726: I(0,dd,"op_80,op_81,op_82,op_83,op_84,op_85,op_86,op_87,op_88,op_89,op_8a,op_8b,op_8c,op_8d,op_8e,op_8f",0,0);
1727: I(0,dd,"op_90,op_91,op_92,op_93,op_94,op_95,op_96,op_97,op_98,op_99,op_9a,op_9b,op_9c,op_9d,op_9e,op_9f",0,0);
1728: I(0,dd,"op_a0,op_a1,op_a2,op_a3,op_a4,op_a5,op_a6,op_a7,op_a8,op_a9,op_aa,op_ab,op_ac,op_ad,op_ae,op_af",0,0);
1729: I(0,dd,"op_b0,op_b1,op_b2,op_b3,op_b4,op_b5,op_b6,op_b7,op_b8,op_b9,op_ba,op_bb,op_bc,op_bd,op_be,op_bf",0,0);
1730: I(0,dd,"op_c0,op_c1,op_c2,op_c3,op_c4,op_c5,op_c6,op_c7,op_c8,op_c9,op_ca,op_cb,op_cc,op_cd,op_ce,op_cf",0,0);
1731: I(0,dd,"op_d0,op_d1,op_d2,op_d3,op_d4,op_d5,op_d6,op_d7,op_d8,op_d9,op_da,op_db,op_dc,op_dd,op_de,op_df",0,0);
1732: I(0,dd,"op_e0,op_e1,op_e2,op_e3,op_e4,op_e5,op_e6,op_e7,op_e8,op_e9,op_ea,op_eb,op_ec,op_ed,op_ee,op_ef",0,0);
1733: I(0,dd,"op_f0,op_f1,op_f2,op_f3,op_f4,op_f5,op_f6,op_f7,op_f8,op_f9,op_fa,op_fb,op_fc,op_fd,op_fe,op_ff",0,0);
1734: com(0);
1735: S("z_cb",0);
1736: I(0,dd,"cb_00,cb_01,cb_02,cb_03,cb_04,cb_05,cb_06,cb_07,cb_08,cb_09,cb_0a,cb_0b,cb_0c,cb_0d,cb_0e,cb_0f",0,0);
1737: I(0,dd,"cb_10,cb_11,cb_12,cb_13,cb_14,cb_15,cb_16,cb_17,cb_18,cb_19,cb_1a,cb_1b,cb_1c,cb_1d,cb_1e,cb_1f",0,0);
1738: I(0,dd,"cb_20,cb_21,cb_22,cb_23,cb_24,cb_25,cb_26,cb_27,cb_28,cb_29,cb_2a,cb_2b,cb_2c,cb_2d,cb_2e,cb_2f",0,0);
1739: I(0,dd,"cb_30,cb_31,cb_32,cb_33,cb_34,cb_35,cb_36,cb_37,cb_38,cb_39,cb_3a,cb_3b,cb_3c,cb_3d,cb_3e,cb_3f",0,0);
1740: I(0,dd,"cb_40,cb_41,cb_42,cb_43,cb_44,cb_45,cb_46,cb_47,cb_48,cb_49,cb_4a,cb_4b,cb_4c,cb_4d,cb_4e,cb_4f",0,0);
1741: I(0,dd,"cb_50,cb_51,cb_52,cb_53,cb_54,cb_55,cb_56,cb_57,cb_58,cb_59,cb_5a,cb_5b,cb_5c,cb_5d,cb_5e,cb_5f",0,0);
1742: I(0,dd,"cb_60,cb_61,cb_62,cb_63,cb_64,cb_65,cb_66,cb_67,cb_68,cb_69,cb_6a,cb_6b,cb_6c,cb_6d,cb_6e,cb_6f",0,0);
1743: I(0,dd,"cb_70,cb_71,cb_72,cb_73,cb_74,cb_75,cb_76,cb_77,cb_78,cb_79,cb_7a,cb_7b,cb_7c,cb_7d,cb_7e,cb_7f",0,0);
1744: I(0,dd,"cb_80,cb_81,cb_82,cb_83,cb_84,cb_85,cb_86,cb_87,cb_88,cb_89,cb_8a,cb_8b,cb_8c,cb_8d,cb_8e,cb_8f",0,0);
1745: I(0,dd,"cb_90,cb_91,cb_92,cb_93,cb_94,cb_95,cb_96,cb_97,cb_98,cb_99,cb_9a,cb_9b,cb_9c,cb_9d,cb_9e,cb_9f",0,0);
1746: I(0,dd,"cb_a0,cb_a1,cb_a2,cb_a3,cb_a4,cb_a5,cb_a6,cb_a7,cb_a8,cb_a9,cb_aa,cb_ab,cb_ac,cb_ad,cb_ae,cb_af",0,0);
1747: I(0,dd,"cb_b0,cb_b1,cb_b2,cb_b3,cb_b4,cb_b5,cb_b6,cb_b7,cb_b8,cb_b9,cb_ba,cb_bb,cb_bc,cb_bd,cb_be,cb_bf",0,0);
1748: I(0,dd,"cb_c0,cb_c1,cb_c2,cb_c3,cb_c4,cb_c5,cb_c6,cb_c7,cb_c8,cb_c9,cb_ca,cb_cb,cb_cc,cb_cd,cb_ce,cb_cf",0,0);
1749: I(0,dd,"cb_d0,cb_d1,cb_d2,cb_d3,cb_d4,cb_d5,cb_d6,cb_d7,cb_d8,cb_d9,cb_da,cb_db,cb_dc,cb_dd,cb_de,cb_df",0,0);
1750: I(0,dd,"cb_e0,cb_e1,cb_e2,cb_e3,cb_e4,cb_e5,cb_e6,cb_e7,cb_e8,cb_e9,cb_ea,cb_eb,cb_ec,cb_ed,cb_ee,cb_ef",0,0);
1751: I(0,dd,"cb_f0,cb_f1,cb_f2,cb_f3,cb_f4,cb_f5,cb_f6,cb_f7,cb_f8,cb_f9,cb_fa,cb_fb,cb_fc,cb_fd,cb_fe,cb_ff",0,0);
1752: com(0);
1753: S("z_dd",0);
1754: I(0,dd,"dd_00,dd_01,dd_02,dd_03,dd_04,dd_05,dd_06,dd_07,dd_08,dd_09,dd_0a,dd_0b,dd_0c,dd_0d,dd_0e,dd_0f",0,0);
1755: I(0,dd,"dd_10,dd_11,dd_12,dd_13,dd_14,dd_15,dd_16,dd_17,dd_18,dd_19,dd_1a,dd_1b,dd_1c,dd_1d,dd_1e,dd_1f",0,0);
1756: I(0,dd,"dd_20,dd_21,dd_22,dd_23,dd_24,dd_25,dd_26,dd_27,dd_28,dd_29,dd_2a,dd_2b,dd_2c,dd_2d,dd_2e,dd_2f",0,0);
1757: I(0,dd,"dd_30,dd_31,dd_32,dd_33,dd_34,dd_35,dd_36,dd_37,dd_38,dd_39,dd_3a,dd_3b,dd_3c,dd_3d,dd_3e,dd_3f",0,0);
1758: I(0,dd,"dd_40,dd_41,dd_42,dd_43,dd_44,dd_45,dd_46,dd_47,dd_48,dd_49,dd_4a,dd_4b,dd_4c,dd_4d,dd_4e,dd_4f",0,0);
1759: I(0,dd,"dd_50,dd_51,dd_52,dd_53,dd_54,dd_55,dd_56,dd_57,dd_58,dd_59,dd_5a,dd_5b,dd_5c,dd_5d,dd_5e,dd_5f",0,0);
1760: I(0,dd,"dd_60,dd_61,dd_62,dd_63,dd_64,dd_65,dd_66,dd_67,dd_68,dd_69,dd_6a,dd_6b,dd_6c,dd_6d,dd_6e,dd_6f",0,0);
1761: I(0,dd,"dd_70,dd_71,dd_72,dd_73,dd_74,dd_75,dd_76,dd_77,dd_78,dd_79,dd_7a,dd_7b,dd_7c,dd_7d,dd_7e,dd_7f",0,0);
1762: I(0,dd,"dd_80,dd_81,dd_82,dd_83,dd_84,dd_85,dd_86,dd_87,dd_88,dd_89,dd_8a,dd_8b,dd_8c,dd_8d,dd_8e,dd_8f",0,0);
1763: I(0,dd,"dd_90,dd_91,dd_92,dd_93,dd_94,dd_95,dd_96,dd_97,dd_98,dd_99,dd_9a,dd_9b,dd_9c,dd_9d,dd_9e,dd_9f",0,0);
1764: I(0,dd,"dd_a0,dd_a1,dd_a2,dd_a3,dd_a4,dd_a5,dd_a6,dd_a7,dd_a8,dd_a9,dd_aa,dd_ab,dd_ac,dd_ad,dd_ae,dd_af",0,0);
1765: I(0,dd,"dd_b0,dd_b1,dd_b2,dd_b3,dd_b4,dd_b5,dd_b6,dd_b7,dd_b8,dd_b9,dd_ba,dd_bb,dd_bc,dd_bd,dd_be,dd_bf",0,0);
1766: I(0,dd,"dd_c0,dd_c1,dd_c2,dd_c3,dd_c4,dd_c5,dd_c6,dd_c7,dd_c8,dd_c9,dd_ca,dd_cb,dd_cc,dd_cd,dd_ce,dd_cf",0,0);
1767: I(0,dd,"dd_d0,dd_d1,dd_d2,dd_d3,dd_d4,dd_d5,dd_d6,dd_d7,dd_d8,dd_d9,dd_da,dd_db,dd_dc,dd_dd,dd_de,dd_df",0,0);
1768: I(0,dd,"dd_e0,dd_e1,dd_e2,dd_e3,dd_e4,dd_e5,dd_e6,dd_e7,dd_e8,dd_e9,dd_ea,dd_eb,dd_ec,dd_ed,dd_ee,dd_ef",0,0);
1769: I(0,dd,"dd_f0,dd_f1,dd_f2,dd_f3,dd_f4,dd_f5,dd_f6,dd_f7,dd_f8,dd_f9,dd_fa,dd_fb,dd_fc,dd_fd,dd_fe,dd_ff",0,0);
1770: com(0);
1771: S("z_ed",0);
1772: I(0,dd,"illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop",0,0);
1773: I(0,dd,"illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop",0,0);
1774: I(0,dd,"illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop",0,0);
1775: I(0,dd,"illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop",0,0);
1776: I(0,dd,"ed_40,ed_41,ed_42,ed_43,ed_44,ed_45,ed_46,ed_47,ed_48,ed_49,ed_4a,ed_4b,ed_4c,ed_4d,ed_4e,ed_4f",0,0);
1777: I(0,dd,"ed_50,ed_51,ed_52,ed_53,ed_54,ed_55,ed_56,ed_57,ed_58,ed_59,ed_5a,ed_5b,ed_5c,ed_5d,ed_5e,ed_5f",0,0);
1778: I(0,dd,"ed_60,ed_61,ed_62,ed_63,ed_64,ed_65,ed_66,ed_67,ed_68,ed_69,ed_6a,ed_6b,ed_6c,ed_6d,ed_6e,ed_6f",0,0);
1779: I(0,dd,"ed_70,ed_71,ed_72,ed_73,ed_74,ed_75,ed_76,illop,ed_78,ed_79,ed_7a,ed_7b,ed_7c,ed_7d,ed_7e,illop",0,0);
1780: I(0,dd,"illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop",0,0);
1781: I(0,dd,"illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop",0,0);
1782: I(0,dd,"ed_a0,ed_a1,ed_a2,ed_a3,illop,illop,illop,illop,ed_a8,ed_a9,ed_aa,ed_ab,illop,illop,illop,illop",0,0);
1783: I(0,dd,"ed_b0,ed_b1,ed_b2,ed_b3,illop,illop,illop,illop,ed_b8,ed_b9,ed_ba,ed_bb,illop,illop,illop,illop",0,0);
1784: I(0,dd,"illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop",0,0);
1785: I(0,dd,"illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop",0,0);
1786: I(0,dd,"illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop",0,0);
1787: I(0,dd,"illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop,illop",0,0);
1788: com(0);
1789: S("z_fd",0);
1790: I(0,dd,"fd_00,fd_01,fd_02,fd_03,fd_04,fd_05,fd_06,fd_07,fd_08,fd_09,fd_0a,fd_0b,fd_0c,fd_0d,fd_0e,fd_0f",0,0);
1791: I(0,dd,"fd_10,fd_11,fd_12,fd_13,fd_14,fd_15,fd_16,fd_17,fd_18,fd_19,fd_1a,fd_1b,fd_1c,fd_1d,fd_1e,fd_1f",0,0);
1792: I(0,dd,"fd_20,fd_21,fd_22,fd_23,fd_24,fd_25,fd_26,fd_27,fd_28,fd_29,fd_2a,fd_2b,fd_2c,fd_2d,fd_2e,fd_2f",0,0);
1793: I(0,dd,"fd_30,fd_31,fd_32,fd_33,fd_34,fd_35,fd_36,fd_37,fd_38,fd_39,fd_3a,fd_3b,fd_3c,fd_3d,fd_3e,fd_3f",0,0);
1794: I(0,dd,"fd_40,fd_41,fd_42,fd_43,fd_44,fd_45,fd_46,fd_47,fd_48,fd_49,fd_4a,fd_4b,fd_4c,fd_4d,fd_4e,fd_4f",0,0);
1795: I(0,dd,"fd_50,fd_51,fd_52,fd_53,fd_54,fd_55,fd_56,fd_57,fd_58,fd_59,fd_5a,fd_5b,fd_5c,fd_5d,fd_5e,fd_5f",0,0);
1796: I(0,dd,"fd_60,fd_61,fd_62,fd_63,fd_64,fd_65,fd_66,fd_67,fd_68,fd_69,fd_6a,fd_6b,fd_6c,fd_6d,fd_6e,fd_6f",0,0);
1797: I(0,dd,"fd_70,fd_71,fd_72,fd_73,fd_74,fd_75,fd_76,fd_77,fd_78,fd_79,fd_7a,fd_7b,fd_7c,fd_7d,fd_7e,fd_7f",0,0);
1798: I(0,dd,"fd_80,fd_81,fd_82,fd_83,fd_84,fd_85,fd_86,fd_87,fd_88,fd_89,fd_8a,fd_8b,fd_8c,fd_8d,fd_8e,fd_8f",0,0);
1799: I(0,dd,"fd_90,fd_91,fd_92,fd_93,fd_94,fd_95,fd_96,fd_97,fd_98,fd_99,fd_9a,fd_9b,fd_9c,fd_9d,fd_9e,fd_9f",0,0);
1800: I(0,dd,"fd_a0,fd_a1,fd_a2,fd_a3,fd_a4,fd_a5,fd_a6,fd_a7,fd_a8,fd_a9,fd_aa,fd_ab,fd_ac,fd_ad,fd_ae,fd_af",0,0);
1801: I(0,dd,"fd_b0,fd_b1,fd_b2,fd_b3,fd_b4,fd_b5,fd_b6,fd_b7,fd_b8,fd_b9,fd_ba,fd_bb,fd_bc,fd_bd,fd_be,fd_bf",0,0);
1802: I(0,dd,"fd_c0,fd_c1,fd_c2,fd_c3,fd_c4,fd_c5,fd_c6,fd_c7,fd_c8,fd_c9,fd_ca,fd_cb,fd_cc,fd_cd,fd_ce,fd_cf",0,0);
1803: I(0,dd,"fd_d0,fd_d1,fd_d2,fd_d3,fd_d4,fd_d5,fd_d6,fd_d7,fd_d8,fd_d9,fd_da,fd_db,fd_dc,fd_dd,fd_de,fd_df",0,0);
1804: I(0,dd,"fd_e0,fd_e1,fd_e2,fd_e3,fd_e4,fd_e5,fd_e6,fd_e7,fd_e8,fd_e9,fd_ea,fd_eb,fd_ec,fd_ed,fd_ee,fd_ef",0,0);
1805: I(0,dd,"fd_f0,fd_f1,fd_f2,fd_f3,fd_f4,fd_f5,fd_f6,fd_f7,fd_f8,fd_f9,fd_fa,fd_fb,fd_fc,fd_fd,fd_fe,fd_ff",0,0);
1806: com(0);
1807: S("z_xx",0);
1808: I(0,dd,"xx_00,xx_01,xx_02,xx_03,xx_04,xx_05,xx_06,xx_07,xx_08,xx_09,xx_0a,xx_0b,xx_0c,xx_0d,xx_0e,xx_0f",0,0);
1809: I(0,dd,"xx_10,xx_11,xx_12,xx_13,xx_14,xx_15,xx_16,xx_17,xx_18,xx_19,xx_1a,xx_1b,xx_1c,xx_1d,xx_1e,xx_1f",0,0);
1810: I(0,dd,"xx_20,xx_21,xx_22,xx_23,xx_24,xx_25,xx_26,xx_27,xx_28,xx_29,xx_2a,xx_2b,xx_2c,xx_2d,xx_2e,xx_2f",0,0);
1811: I(0,dd,"xx_30,xx_31,xx_32,xx_33,xx_34,xx_35,xx_36,xx_37,xx_38,xx_39,xx_3a,xx_3b,xx_3c,xx_3d,xx_3e,xx_3f",0,0);
1812: I(0,dd,"xx_40,xx_41,xx_42,xx_43,xx_44,xx_45,xx_46,xx_47,xx_48,xx_49,xx_4a,xx_4b,xx_4c,xx_4d,xx_4e,xx_4f",0,0);
1813: I(0,dd,"xx_50,xx_51,xx_52,xx_53,xx_54,xx_55,xx_56,xx_57,xx_58,xx_59,xx_5a,xx_5b,xx_5c,xx_5d,xx_5e,xx_5f",0,0);
1814: I(0,dd,"xx_60,xx_61,xx_62,xx_63,xx_64,xx_65,xx_66,xx_67,xx_68,xx_69,xx_6a,xx_6b,xx_6c,xx_6d,xx_6e,xx_6f",0,0);
1815: I(0,dd,"xx_70,xx_71,xx_72,xx_73,xx_74,xx_75,xx_76,xx_77,xx_78,xx_79,xx_7a,xx_7b,xx_7c,xx_7d,xx_7e,xx_7f",0,0);
1816: I(0,dd,"xx_80,xx_81,xx_82,xx_83,xx_84,xx_85,xx_86,xx_87,xx_88,xx_89,xx_8a,xx_8b,xx_8c,xx_8d,xx_8e,xx_8f",0,0);
1817: I(0,dd,"xx_90,xx_91,xx_92,xx_93,xx_94,xx_95,xx_96,xx_97,xx_98,xx_99,xx_9a,xx_9b,xx_9c,xx_9d,xx_9e,xx_9f",0,0);
1818: I(0,dd,"xx_a0,xx_a1,xx_a2,xx_a3,xx_a4,xx_a5,xx_a6,xx_a7,xx_a8,xx_a9,xx_aa,xx_ab,xx_ac,xx_ad,xx_ae,xx_af",0,0);
1819: I(0,dd,"xx_b0,xx_b1,xx_b2,xx_b3,xx_b4,xx_b5,xx_b6,xx_b7,xx_b8,xx_b9,xx_ba,xx_bb,xx_bc,xx_bd,xx_be,xx_bf",0,0);
1820: I(0,dd,"xx_c0,xx_c1,xx_c2,xx_c3,xx_c4,xx_c5,xx_c6,xx_c7,xx_c8,xx_c9,xx_ca,xx_cb,xx_cc,xx_cd,xx_ce,xx_cf",0,0);
1821: I(0,dd,"xx_d0,xx_d1,xx_d2,xx_d3,xx_d4,xx_d5,xx_d6,xx_d7,xx_d8,xx_d9,xx_da,xx_db,xx_dc,xx_dd,xx_de,xx_df",0,0);
1822: I(0,dd,"xx_e0,xx_e1,xx_e2,xx_e3,xx_e4,xx_e5,xx_e6,xx_e7,xx_e8,xx_e9,xx_ea,xx_eb,xx_ec,xx_ed,xx_ee,xx_ef",0,0);
1823: I(0,dd,"xx_f0,xx_f1,xx_f2,xx_f3,xx_f4,xx_f5,xx_f6,xx_f7,xx_f8,xx_f9,xx_fa,xx_fb,xx_fc,xx_fd,xx_fe,xx_ff",0,0);
1824: com(0);
1825: com(0);
1826: S("z80_daa",0);
1827: for (i = 0; i < sizeof(DAATable)/sizeof(DAATable[0]); i += 4) {
1828: char buffer[32+1];
1829: sprintf(buffer,"%5d,%5d,%5d,%5d",
1830: (word)((DAATable[i+0]<<8)|(DAATable[i+0]>>8)),
1831: (word)((DAATable[i+1]<<8)|(DAATable[i+1]>>8)),
1832: (word)((DAATable[i+2]<<8)|(DAATable[i+2]>>8)),
1833: (word)((DAATable[i+3]<<8)|(DAATable[i+3]>>8)));
1834: I(0,dw,buffer,0,0);
1835: }
1836: I(0,globl,"_Z80_ICount",0,0);
1837: I("_Z80_ICount",dd,"0",0,"cycle count during run");
1838: I("z80_itotal",dd,"0",0,"total cycles to run");
1839: I("z80_iextrn",dd,"0",0,"external cycles to subtract (interrupt)");
1840: com(0);
1841: I(0,globl,"_Z80",0,0);
1842: S("_Z80",0);
1843: I("z80_AF", dd,"0",0,"offset _Z80 + 0x00");
1844: I("z80_BC", dd,"0",0,"offset _Z80 + 0x04");
1845: I("z80_DE", dd,"0",0,"offset _Z80 + 0x08");
1846: I("z80_HL", dd,"0",0,"offset _Z80 + 0x0c");
1847: I("z80_IX", dd,"0",0,"offset _Z80 + 0x10");
1848: I("z80_IY", dd,"0",0,"offset _Z80 + 0x14");
1849: I("z80_PC", dd,"0",0,"offset _Z80 + 0x18");
1850: I("z80_SP", dd,"0",0,"offset _Z80 + 0x1c");
1851: I("z80_AF2", dd,"0",0,"offset _Z80 + 0x20");
1852: I("z80_BC2", dd,"0",0,"offset _Z80 + 0x24");
1853: I("z80_DE2", dd,"0",0,"offset _Z80 + 0x28");
1854: I("z80_HL2", dd,"0",0,"offset _Z80 + 0x2c");
1855: I("z80_R", db,"0",0,"offset _Z80 + 0x30");
1856: I("z80_R2", db,"0",0,"offset _Z80 + 0x31");
1857: I("z80_IFF1", db,"0",0,"offset _Z80 + 0x32");
1858: I("z80_IFF2", db,"0",0,"offset _Z80 + 0x33");
1859: I("z80_HALT", db,"0",0,"offset _Z80 + 0x34");
1860: I("z80_IM", db,"0",0,"offset _Z80 + 0x35");
1861: I("z80_I", db,"0",0,"offset _Z80 + 0x36");
1862: I("z80_pending_irq",db,"0",0,"offset _Z80 + 0x37");
1863: I("z80_vector", dd,"0",0,"offset _Z80 + 0x38");
1864: I("z80_irq_max", dd,"0",0,"offset _Z80 + 0x3c");
1865: I("z80_request_irq",dd,"0",0,"offset _Z80 + 0x40");
1866: I("z80_service_irq",dd,"0",0,"offset _Z80 + 0x44");
1867: I("z80_int_state", dd,"0,0,0,0",0,"offset _Z80 + 0x48");
1868: I("z80_irq", dd,"0,0,0,0",0,"offset _Z80 + 0x58");
1869: I(0, dd,"0,0,0,0",0,"offset _Z80 + 0x68");
1870: I(0, dd,"0,0,0,0",0,"offset _Z80 + 0x78");
1871: I(0, dd,"0,0,0,0",0,"offset _Z80 + 0x88");
1872: I("z80_nmi_state", dd,"0",0,"offset _Z80 + 0x98");
1873: I("z80_irq_state", dd,"0",0,"offset _Z80 + 0x9c");
1874: I("z80_irq_callback",dd,"0",0,"offset _Z80 + 0xa0");
1875: #define Z80_SIZE 0x00a4
1876:
1877: I("z80_EA", dd,"0",0,"temporary storage for effective address");
1878: I("z80_MB", dd,"0",0,"temporary storage for memory byte (LSB or MSB)");
1879: com(0);
1880: if (mame_debug)
1881: I(0,extrn,"_mame_debug",0,0);
1882: if (verbose)
1883: I(0,extrn,"_errorlog",0,0);
1884: I(0,extrn,"_previouspc",0,0);
1885: I(0,extrn,"_ROM",0,0);
1886: I(0,extrn,"_RAM",0,0);
1887: I(0,extrn,"_OP_ROM",0,0);
1888: I(0,extrn,"_OP_RAM",0,0);
1889: com(0);
1890: I(0,text,0,0,0);
1891: I(0,extrn,"_malloc",0,0);
1892: I(0,extrn,"_raise",0,0);
1893: if (mame_debug)
1894: I(0,extrn,"_MAME_Debug",0,0);
1895: if (verbose)
1896: I(0,extrn,"_fprintf",0,0);
1897: com(0);
1898: I(0,extrn,"_ophw",0,0);
1899: I(0,extrn,"_cpu_bankbase",0,0);
1900: com(0);
1901: I(0,extrn,"_mrh_error",0,0);
1902: I(0,extrn,"_cur_mrhard",0,0);
1903: I(0,extrn,"_readhardware",0,0);
1904: I(0,extrn,"_memoryreadoffset",0,0);
1905: I(0,extrn,"_memoryreadhandler",0,0);
1906: I(0,extrn,"_cur_mwhard",0,0);
1907: com(0);
1908: I(0,extrn,"_mwh_error",0,0);
1909: I(0,extrn,"_writehardware",0,0);
1910: I(0,extrn,"_memorywriteoffset",0,0);
1911: I(0,extrn,"_memorywritehandler",0,0);
1912: I(0,extrn,"_cpu_setOPbase16",0,0);
1913: I(0,extrn,"_cpu_getactivecpu",0,0);
1914: com(0);
1915: I(0,extrn,"_cpu_readmem16",0,0);
1916: I(0,extrn,"_cpu_writemem16",0,0);
1917: #if INLINE_IOPORTS
1918: I(0,extrn,"_cur_portmask",0,0);
1919: I(0,extrn,"_cur_readport",0,0);
1920: I(0,extrn,"_cur_writeport",0,0);
1921: #else
1922: I(0,extrn,"_cpu_readport",0,0);
1923: I(0,extrn,"_cpu_writeport",0,0);
1924: #endif
1925: com(0);
1926: }
1927:
1928: static void mk_interface(void)
1929: {
1930: I(0,text,0,0,0);
1931: pad(align_funcs);
1932: com("===================================================================");
1933: com(" void Z80_SetRegs(void *regs); ");
1934: com("===================================================================");
1935: I(0,globl,"_Z80_SetRegs",0,0);
1936: S("_Z80_SetRegs",0);
1937: I(0,pushl, ESI, 0, 0);
1938: I(0,pushl, EDI, 0, 0);
1939: I(0,movl, ESI, M(4,0,esp,12,0,0), "get source");
1940: debug(7,"Z80_SetRegs(0x%08x)\n",ESI);
1941: I(0,movl, EDI, O("_Z80"), "set destination");
1942: I(0,movl, ECX, X(Z80_SIZE/4), 0);
1943: I(0,cld, 0, 0, 0);
1944: I(0,rep, 0, 0, 0);
1945: I(0,movsd, 0, 0, 0);
1946: I(0,movl, ECX, zPC32, 0);
1947: I(0,movl, EDI, MRHARD, 0);
1948: I(0,shrl, ECX, D(ABITS), 0);
1949: I(0,movb, CL, M(1,0,edi,0,ecx,1), 0);
1950: I(0,cmpb, CL, M(1,"_ophw",0,0,0,0),0);
1951: I(0,je, "z80_set_context_1",0, 0);
1952: I(0,pushl, zPC32, 0, 0);
1953: I(0,call, "_cpu_setOPbase16",0, 0);
1954: I(0,addl, ESP, B(4), 0);
1955: S("z80_set_context_1",0);
1956: dumpregs();
1957: I(0,popl, EDI, 0, 0);
1958: I(0,popl, ESI, 0, 0);
1959: I(0,ret, 0, 0, 0);
1960:
1961: pad(align_funcs);
1962: com("===================================================================");
1963: com(" void Z80_GetRegs(void *regs); ");
1964: com("===================================================================");
1965: I(0,globl,"_Z80_GetRegs",0,0);
1966: S("_Z80_GetRegs",0);
1967: I(0,pushl, ESI, 0, 0);
1968: I(0,pushl, EDI, 0, 0);
1969: I(0,movl, EDI, M(4,0,esp,12,0,0), "get destination");
1970: debug(7,"Z80_GetRegs(0x%08x)\n",EDI);
1971: I(0,movl, ESI, O("_Z80"), "set source");
1972: I(0,movl, ECX, X(Z80_SIZE/4), 0);
1973: I(0,cld, 0, 0, 0);
1974: I(0,rep, 0, 0, 0);
1975: I(0,movsd, 0, 0, 0);
1976: dumpregs();
1977: I(0,popl, EDI, 0, 0);
1978: I(0,popl, ESI, 0, 0);
1979: I(0,ret, 0, 0, 0);
1980:
1981: pad(align_funcs);
1982: com("===================================================================");
1983: com(" unsigned Z80_GetPC(void); ");
1984: com("===================================================================");
1985: I(0,globl,"_Z80_GetPC",0,0);
1986: S("_Z80_GetPC",0);
1987: I(0,movl, EAX, zPC32, 0);
1988: debug(7,"Z80_GetPC() %04x\n",EAX);
1989: I(0,ret, 0, 0, 0);
1990:
1991: pad(align_funcs);
1992: com("===================================================================");
1993: com(" void Z80_set_nmi_line(int state); ");
1994: com("===================================================================");
1995: I(0,globl,"_Z80_set_nmi_line",0,0);
1996: S("_Z80_set_nmi_line",0);
1997: I(0,pushl, EBP, 0, 0);
1998: I(0,pushl, EBX, 0, 0);
1999: I(0,pushl, ESI, 0, 0);
2000: I(0,pushl, EDI, 0, 0);
2001: I(0,movl, ECX, M(4,0,esp,20,0,0), "get state");
2002: debug(3,"Z80_set_nmi_line(%d)\n",ECX);
2003: I(0,cmpl, ECX, nmi_state, "changed?");
2004: I(0,je, LN("z80_set_nmi_line_done"),0, "no, leave");
2005: I(0,movl, nmi_state, ECX, "store new state");
2006: I(0,cmpl, ECX, B(CLEAR_LINE), "clear line now?");
2007: I(0,je, LN("z80_set_nmi_line_done"),0, "yes, skip");
2008: com(0);
2009: restore_z80();
2010: restore_af();
2011: I(0,movl, PREVPC, D(-1), "no valid previous PC");
2012: I(0,testb, zHALT, D(1), "halted?");
2013: I(0,je, LS("z80_set_nmi_line_1"),0, "no, skip");
2014: I(0,movb, zHALT, D(0), "clear halt flag");
2015: I(0,incw, PC, 0, 0);
2016: com(0);
2017: S("z80_set_nmi_line_1",0);
2018: I(0,call, "z80_push_pc", 0, 0);
2019: I(0,movb, CL, X(0x00), 0);
2020: I(0,xchgb, CL, zIFF1, "clear IFF1 and copy");
2021: I(0,movb, zIFF2, CL, "previous state to IFF2");
2022: I(0,movl, PC32, X(0x66), "PC = NMI vector");
2023: I(0,movl, ECX, PC32, 0);
2024: I(0,movl, EDI, MRHARD, 0);
2025: I(0,shrl, ECX, D(ABITS), 0);
2026: I(0,movb, CL, M(1,0,edi,0,ecx,1), 0);
2027: I(0,cmpb, CL, M(1,"_ophw",0,0,0,0), 0);
2028: I(0,je, LS("z80_set_nmi_line_2"),0, 0);
2029: I(0,pushl, zPC32, 0, 0);
2030: I(0,call, "_cpu_setOPbase16",0, 0);
2031: I(0,addl, ESP, B(4), 0);
2032: S("z80_set_nmi_line_2",0);
2033: save_af();
2034: save_z80(0);
2035: com(0);
2036: S("z80_set_nmi_line_done",0);
2037: I(0,popl, EDI, 0, 0);
2038: I(0,popl, ESI, 0, 0);
2039: I(0,popl, EBX, 0, 0);
2040: I(0,popl, EBP, 0, 0);
2041: I(0,ret, 0, 0, 0);
2042:
2043: pad(align_funcs);
2044: com("===================================================================");
2045: com(" void Z80_set_irq_line(int irqline, int state); ");
2046: com("===================================================================");
2047: I(0,globl,"_Z80_set_irq_line",0,0);
2048: S("_Z80_set_irq_line",0);
2049: I(0,pushl, EBP, 0, 0);
2050: I(0,pushl, EBX, 0, 0);
2051: I(0,pushl, ESI, 0, 0);
2052: I(0,pushl, EDI, 0, 0);
2053: restore_af();
2054: restore_z80();
2055: I(0,movl, EDX, M(4,0,esp,24,0,0), 0);
2056: I(0,movl, ECX, M(4,0,esp,20,0,0), 0);
2057: I(0,movl, irq_state, EDX, 0);
2058: debug(3,"Z80_set_irq_line(%d,%d)\n",ECX,EDX);
2059: I(0,cmpl, EDX, B(CLEAR_LINE), "line cleared?");
2060: I(0,je, LN("z80_set_irq_line_done"),0, "yes, leave");
2061: #if EARLY_CTC
2062: I(0,cmpl, irq_max, B(0), "daisy chain mode?");
2063: I(0,je, LN("z80_set_irq_line_assert"),0, "no, it's single int");
2064: save_af();
2065: I(0,pushl, D(0), 0, "irqline always 0");
2066: I(0,call, irq_callback, 0, "get the vector");
2067: I(0,addl, ESP, B(4), "clean up stack");
2068: I(0,movl, ECX, EAX, "ECX = (device<<8)");
2069: I(0,movzbl, EDX, AL, "EDX = state");
2070: restore_af();
2071: I(0,shrl, ECX, D(8), "ECX = device");
2072: I(0,cmpl, EDX, int_state(ecx), "state change?");
2073: I(0,je, LN("z80_set_irq_line_assert"),0, "no change, skip");
2074: I(0,movl, int_state(ecx), EDX, "store new state");
2075: I(0,movl, EDX, D(-1), 0);
2076: I(0,movl, ECX, D(0), 0);
2077: I(0,movl, request_irq, EDX, "reset request IRQ");
2078: I(0,movl, service_irq, EDX, "reset service IRQ");
2079: S("z80_set_irq_line_dc_1",0);
2080: I(0,testl, int_state(ecx), X(Z80_INT_IEO), "Z80_INT_IEO set?");
2081: I(0,je, LS("z80_set_irq_line_dc_2"),0, "no, skip");
2082: I(0,movl, request_irq, EDX, "mask lower IRQ");
2083: I(0,movl, service_irq, ECX, "set service device number");
2084: com(0);
2085: S("z80_set_irq_line_dc_2",0);
2086: I(0,testb, int_state(ecx), X(Z80_INT_REQ), "Z80_INT_REQ set?");
2087: I(0,je, LS("z80_set_irq_line_dc_3"),0, "no, skip");
2088: I(0,movl, request_irq, ECX, "set request device number");
2089: com(0);
2090: S("z80_set_irq_line_dc_3",0);
2091: I(0,incl, ECX, 0, "next device");
2092: I(0,cmpl, ECX, irq_max, "more entries to check?");
2093: I(0,jb, LS("z80_set_irq_line_dc_1"),0, "yes, check them");
2094: S("z80_set_irq_line_assert",0);
2095: #endif
2096: I(0,testb, zIFF1, X(INT_IRQ), "interrupts enabled?");
2097: I(0,je, LN("z80_set_irq_line_done"),0, "no, leave");
2098: mk_take_irq( 0x00 );
2099: S("z80_set_irq_line_done",0);
2100: save_af();
2101: save_z80(0);
2102: I(0,popl, EDI, 0, 0);
2103: I(0,popl, ESI, 0, 0);
2104: I(0,popl, EBX, 0, 0);
2105: I(0,popl, EBP, 0, 0);
2106: I(0,ret, 0, 0, 0);
2107: com(0);
2108:
2109: pad(align_funcs);
2110: com("===================================================================");
2111: com(" void Z80_set_irq_callback(int (*callback)(int irqline)); ");
2112: com("===================================================================");
2113: I(0,globl,"_Z80_set_irq_callback",0,0);
2114: S("_Z80_set_irq_callback",0);
2115: I(0,movl, EAX, M(4,0,esp,4,0,0), 0);
2116: debug(3,"Z80_set_irq_callback(%x)\n",EAX);
2117: I(0,movl, irq_callback, EAX, 0);
2118: I(0,ret,0,0,0);
2119: com(0);
2120:
2121: pad(align_funcs);
2122: com("===================================================================");
2123: com(" void Z80_Reset(Z80_DaisyChain *daisy_chain); ");
2124: com("===================================================================");
2125: I(0,globl,"_Z80_Reset",0,0);
2126: S("_Z80_Reset",0);
2127: I(0,pushl, EBP, 0, 0);
2128: I(0,pushl, EBX, 0, 0);
2129: I(0,pushl, ESI, 0, 0);
2130: I(0,pushl, EDI, 0, 0);
2131: debug(1,"Z80_reset()\n");
2132: I(0,movl, EAX, D(0), 0);
2133: I(0,movl, EDI, O("_Z80"), "wipe out Z80 registers");
2134: I(0,movl, ECX, D(Z80_SIZE/4), 0);
2135: I(0,cld, 0, 0, 0);
2136: I(0,rep, 0, 0, 0);
2137: I(0,stosd, 0, 0, 0);
2138: I(0,movl, request_irq, D(-1), 0);
2139: I(0,movl, service_irq, D(-1), 0);
2140: I(0,movl, zSP32, X(0xf000), 0);
2141: I(0,movl, ESI, M(4,0,esp,20,0,0), "get daisy_chain");
2142: I(0,orl, ESI, ESI, "NULL ?");
2143: I(0,je, LS("z80_reset_3"),0, "yes, skip");
2144: I(0,movl, EBX, D(Z80_MAXDAISY), 0);
2145: I(0,movl, EDI, O("z80_irq"), "copy to z80_irq++");
2146:
2147: pad(align_loops);
2148: S("z80_reset_1",0);
2149: I(0,cmpl, M(4,0,esi,12,0,0),D(-1), "more entries?");
2150: I(0,je, LS("z80_reset_3"),0, 0);
2151: I(0,movl, EAX, M(4,0,esi,0,0,0), "get Z80.irq[device].reset");
2152: I(0,cmp, EAX, D(0), "handler?");
2153: I(0,je, LS("z80_reset_2"),0, "no, skip");
2154: I(0,pushl, M(4,0,esi,12,0,0),0, "Z80.irq[device].irq_param");
2155: I(0,call, EAX, 0, 0);
2156: I(0,addl, ESP, B(4), 0);
2157: S("z80_reset_2",0);
2158: I(0,cld, 0, 0, 0);
2159: I(0,movsd, 0, 0, 0);
2160: I(0,movsd, 0, 0, 0);
2161: I(0,movsd, 0, 0, 0);
2162: I(0,movsd, 0, 0, 0);
2163: I(0,incl, irq_max, 0, "count entries");
2164: I(0,decl, EBX, 0, "more to check?");
2165: I(0,jne, LS("z80_reset_1"),0, 0);
2166: S("z80_reset_3",0);
2167: I(0,movl, ECX, zPC32, 0);
2168: I(0,movl, EDI, MRHARD, 0);
2169: I(0,shrl, ECX, D(ABITS), 0);
2170: I(0,movb, CL, M(1,0,edi,0,ecx,1), 0);
2171: I(0,cmpb, CL, M(1,"_ophw",0,0,0,0),0);
2172: I(0,je, "z80_reset_4",0, 0);
2173: I(0,pushl, zPC32, 0, 0);
2174: I(0,call, "_cpu_setOPbase16",0, 0);
2175: I(0,addl, ESP, B(4), 0);
2176: S("z80_reset_4",0);
2177: dumpregs();
2178: I(0,popl, EDI, 0, 0);
2179: I(0,popl, ESI, 0, 0);
2180: I(0,popl, EBX, 0, 0);
2181: I(0,popl, EBP, 0, 0);
2182: I(0,ret, 0, 0, 0);
2183: com(0);
2184:
2185: pad(align_funcs);
2186: com("===================================================================");
2187: com(" int Z80_Execute(int cycles); ");
2188: com("===================================================================");
2189: I(0,globl,"_Z80_Execute",0,0);
2190: S("_Z80_Execute",0);
2191: I(0,pushl, EBP, 0, 0);
2192: I(0,pushl, EBX, 0, 0);
2193: I(0,pushl, ESI, 0, 0);
2194: I(0,pushl, EDI, 0, 0);
2195: I(0,movl, EAX, M(4,0,esp,20,0,0), "get the ICount");
2196: I(0,movl, ECX, D(0), 0);
2197: I(0,xchgl, ECX, zIEXTRN, "external cycles (interrupt)");
2198: I(0,movl, zITOTAL, EAX, "store total cycles");
2199: I(0,subl, EAX, ECX, "subtract from cycle count");
2200: I(0,movl, zICOUNT, EAX, "store cycles to run");
2201: debug(6,"Z80_execute(%d)\n",EAX);
2202: restore_af();
2203: restore_z80();
2204: I(0,jmp, "z80_next_opcode",0, 0);
2205:
2206: pad(align_funcs);
2207: com("===================================================================");
2208: com(" illegal opcode ");
2209: com("===================================================================");
2210: S("illop",0);
2211: debug(5,"illegal opcode $%04x: %02x\n", PC32, EAX);
2212:
2213: pad(align_funcs);
2214: com("===================================================================");
2215: com(" fetch next opcode ");
2216: com("===================================================================");
2217: S("z80_next_opcode",0);
2218: if (mame_debug) {
2219: com("===================================================================");
2220: com(" call MAME debugger ");
2221: com("===================================================================");
2222: I(0,testb, DEBUG, D(1), 0);
2223: I(0,je, LS("z80_no_debug"),0, 0);
2224: S("z80_mame_debug",0);
2225: mk_debug();
2226: S("z80_no_debug",0);
2227: }
2228: S("z80_next_opcode_1",0);
2229: ROP();
2230: I(0,jmp, M(4,"z_op",0,0,ecx,4),0, "jump to opcode handler");
2231:
2232: pad(align_funcs);
2233: S("z80_execute_done",0);
2234: save_z80(0);
2235: save_af();
2236: I(0,popl, EDI, 0, 0);
2237: I(0,popl, ESI, 0, 0);
2238: I(0,popl, EBX, 0, 0);
2239: I(0,popl, EBP, 0, 0);
2240: I(0,movl, EAX, zITOTAL, 0);
2241: I(0,subl, EAX, zICOUNT, 0);
2242: debug(6,"Z80_execute() : %d\n", EAX);
2243: I(0,ret, 0, 0, 0);
2244: com(0);
2245: }
2246:
2247: static void mk_rbyte_handler( int i )
2248: {
2249: #if FAST_MEMORY
2250: #define rTBL 1 /* jump table */
2251: #define rRAM 2 /* read RAM */
2252: #define rNOP 3 /* read NOP */
2253: #define rBNK 4 /* read bank memory */
2254: #define rRHW 5 /* readhardware */
2255: #define rUSR 6 /* read user (handler) */
2256: #define rNON 7 /* read unassigned memory */
2257:
2258: int j;
2259: char buffer[128+1], symbol[8][31+1];
2260: static UINT8 mr[256] = { /* MHELE (HT_XXX) to symbol mapping */
2261: rRAM,rBNK,rBNK,rBNK,rBNK,rBNK,rBNK,rBNK,rBNK,rNON,rNOP,rRAM,rRAM,rUSR,rUSR,rUSR,
2262: rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,
2263: rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,
2264: rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,rUSR,
2265: rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,
2266: rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,
2267: rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,
2268: rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,
2269: rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,
2270: rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,
2271: rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,
2272: rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,
2273: rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,
2274: rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,
2275: rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,
2276: rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW,rRHW
2277: };
2278:
2279: sprintf(symbol[0], "rbyte%d", i);
2280: sprintf(symbol[rTBL], "rbyte%d_tbl", i);
2281: sprintf(symbol[rRAM], "rbyte0_ram"); /* not different due to opsize */
2282: sprintf(symbol[rNOP], "rbyte0_nop"); /* not different due to opsize */
2283: sprintf(symbol[rBNK], "rbyte0_bnk"); /* not different due to opsize */
2284: sprintf(symbol[rRHW], "rbyte%d_rhw", i);
2285: sprintf(symbol[rUSR], "rbyte%d_usr", i);
2286: sprintf(symbol[rNON], "rbyte%d_non", i);
2287:
2288: com("===================================================================");
2289: com(" read a byte from memory at EBP to EDX for opcodes of size %d ",i);
2290: com("===================================================================");
2291: pad(align_funcs);
2292: S(symbol[0],0);
2293: I(0,movl, ECX, EBP, "memory address to ECX");
2294: I(0,movl, EDI, MRHARD, "read flags");
2295: I(0,shrl, ECX, D(ABITS), ">> (ABITS2_16 + ABITS_MIN_16)");
2296: I(0,movzbl, EDX, M(1,0,edi,0,ecx,1), "get MHELE value");
2297: I(0,jmp, M(4,symbol[rTBL],0,0,edx,4),0, "jump to memory read function");
2298:
2299: I(0,data,0,0,0);
2300: pad(align_funcs);
2301: S(symbol[rTBL],0);
2302: for (j = 0; j < 256; j += 4) {
2303: sprintf(buffer,"%s,%s,%s,%s",symbol[mr[j+0]], symbol[mr[j+1]],symbol[mr[j+2]], symbol[mr[j+3]]);
2304: I(0,dd,buffer,0,0);
2305: }
2306: I(0,text,0,0,0);
2307:
2308: if (i == 0) { /* functions that are needed only once */
2309: pad(align_funcs);
2310: S(symbol[rRAM],"read HT_RAM, HT_RAMROM, HT_ROM");
2311: I(0,movl, EDI, RAM, "get RAM/ROM base");
2312: I(0,movb, DL, M(1,0,edi,0,ebp,1), "get byte from RAM/ROM");
2313: I(0,ret, 0, 0, 0);
2314:
2315: pad(align_funcs);
2316: S(symbol[rNOP],"read HT_NOP");
2317: I(0,movb, DL, D(0), "return zero");
2318: I(0,ret, 0, 0, 0);
2319:
2320: pad(align_funcs);
2321: S(symbol[rBNK],"read HT_BANK1 .. HT_BANK8");
2322: I(0,movl, ECX, EBP, "get address to ECX");
2323: I(0,movl, EDI, BANKBASE(edx), "get BANKn base");
2324: I(0,subl, ECX, READOFFSET(edx), "subtract read offset");
2325: I(0,movb, DL, M(1,0,edi,0,ecx,1), "get byte from BANKn");
2326: I(0,ret, 0, 0, 0);
2327: }
2328:
2329: pad(align_funcs);
2330: S(symbol[rRHW],"read MH_HARDMAX .. 255");
2331: I(0,movl, EDI, EDX, "get hw to EDI");
2332: I(0,movl, ECX, EBP, "address to ECX");
2333: I(0,shll, EDI, D(8), "hw << MH_SBITS");
2334: I(0,andl, ECX, B(15), "mask bits 0..3");
2335: I(0,movb, DL, READHW(edi,ecx), "get MHELE");
2336: I(0,jmp, M(4,symbol[rTBL],0,0,edx,4),0, "jump to read handler");
2337:
2338: pad(align_funcs);
2339: S(symbol[rUSR],"read HT_USER .. MH_HARDMAX-1");
2340: save_af();
2341: save_z80( i );
2342: I(0,movl, ECX, EBP, "get address to ECX");
2343: I(0,subl, ECX, READOFFSET(edx), "subtract read offset");
2344: I(0,movl, EDI, READHANDLER(edx), "get memoryreadhandler");
2345: I(0,pushl, ECX, 0, "offset");
2346: I(0,call, EDI, 0, "call handler");
2347: I(0,movl, EDX, EAX, "return value");
2348: I(0,addl, ESP, B(1*4), "one DWORD was pushed");
2349: restore_z80();
2350: restore_af();
2351: I(0,ret, 0, 0, 0);
2352:
2353: pad(align_funcs);
2354: S(symbol[rNON],"read HT_NON");
2355: save_af();
2356: save_z80( i );
2357: I(0,pushl, EBP, 0, "memory address");
2358: I(0,call, "_mrh_error",0, 0);
2359: I(0,movl, EDX, EAX, "return value");
2360: I(0,addl, ESP, B(1*4), "one DWORD was pushed");
2361: restore_z80();
2362: restore_af();
2363: I(0,ret, 0, 0, 0);
2364:
2365: #else
2366: char symbol[2][31+1];
2367: sprintf(symbol[0], "rbyte%d", i);
2368: sprintf(symbol[1], "rbyte%d_user", i);
2369:
2370: pad(align_funcs);
2371: com("===================================================================");
2372: com(" read a byte from memory at EBP to EDX for opcodes of size %d ",i);
2373: com("===================================================================");
2374: S(symbol[0],0);
2375: I(0,movl, ECX, EBP, "memory address to ECX");
2376: I(0,movl, EDI, MRHARD, "read flags");
2377: I(0,shrl, ECX, D(ABITS), ">> (ABITS2_16 + ABITS_MIN_16)");
2378: I(0,testb, M(1,0,edi,0,ecx,1),D(-1), "ROM/RAM?");
2379: I(0,jne, LS(symbol[1]),0, "nope, need to call handler");
2380: I(0,movl, EDI, RAM, "get RAM base");
2381: I(0,movzbl, EDX, M(1,0,edi,0,ebp,1), "get byte from RAM");
2382: I(0,ret, 0, 0, 0);
2383:
2384: pad(align_jumps);
2385: S(symbol[1],0);
2386: save_af();
2387: save_z80( i );
2388: I(0,pushl, EBP, 0, "memory address");
2389: I(0,call, "_cpu_readmem16",0, 0);
2390: I(0,movl, EDX, EAX, "return value");
2391: I(0,addl, ESP, B(1*4), "one DWORD was pushed");
2392: restore_z80();
2393: restore_af();
2394: I(0,ret, 0, 0, 0);
2395: #endif
2396: }
2397:
2398: static void mk_rword_handler( int i )
2399: {
2400: char symbol[3][15+1];
2401: sprintf(symbol[0], "rword%d", i);
2402: sprintf(symbol[1], "rword%d_usr", i);
2403: sprintf(symbol[2], "rbyte%d", i);
2404:
2405: pad(align_funcs);
2406: com("===================================================================");
2407: com(" read a word from memory at EBP to EDX for opcodes of size %d ",i);
2408: com("===================================================================");
2409: S(symbol[0],0);
2410: I(0,movl, ECX, EBP, "memory address to ECX");
2411: I(0,orl, ECX, B(15), "check if address...");
2412: I(0,cmpl, ECX, EBP, "...is 0xxxFh");
2413: I(0,je, LS(symbol[1]),0, "yes, need to read LSB then MSB");
2414: I(0,shrl, ECX, D(4), ">> (ABITS2_16 + ABITS_MIN_16)");
2415: I(0,movl, EDI, MRHARD, "read flags");
2416: I(0,testb, M(1,0,edi,0,ecx,1),D(-1), "MHELE == ROM/RAM?");
2417: I(0,jne, LS(symbol[1]),0, "nope, need to call handler");
2418: pad(align_funcs);
2419: I(0,movl, EDI, RAM, "get RAM base");
2420: I(0,movzwl, EDX, M(2,0,edi,0,ebp,1), "get word from ROM/RAM");
2421: I(0,ret, 0, 0, 0);
2422:
2423: pad(align_funcs);
2424: S(symbol[1],0);
2425: I(0,call, symbol[2], 0, "read LSB");
2426: I(0,incw, BP, 0, "address + 1");
2427: I(0,movb, zMB, DL, "save LSB value");
2428: I(0,call, symbol[2], 0, "read MSB");
2429: I(0,shll, EDX, D(8), "value to MSB");
2430: I(0,movb, DL, zMB, "get LSB");
2431: I(0,ret, 0, 0, 0);
2432: }
2433:
2434: static void mk_wbyte_handler( int i )
2435: {
2436: #if FAST_MEMORY
2437: #define wTBL 1 /* jump table */
2438: #define wRAM 2 /* write RAM */
2439: #define wNOP 3 /* don't write (NOP or ROM) */
2440: #define wRAR 4 /* write RAM and ROM */
2441: #define wBNK 5 /* write bank memory */
2442: #define wWHW 6 /* writehardware */
2443: #define wUSR 7 /* write user (handler) */
2444: #define wNON 8 /* write unassigned memory */
2445: int j;
2446: char buffer[128+1], symbol[9][31+1];
2447: static UINT8 mw[256] = { /* MHELE (HT_XXX) to symbol mapping */
2448: wRAM,wBNK,wBNK,wBNK,wBNK,wBNK,wBNK,wBNK,wBNK,wNON,wNOP,wRAR,wNOP,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,
2449: wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,wUSR,
2450: wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,
2451: wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,
2452: wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,
2453: wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,
2454: wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,
2455: wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW,wWHW
2456: };
2457:
2458: sprintf(symbol[0], "wbyte%d", i);
2459: sprintf(symbol[wTBL], "wbyte%d_tbl", i);
2460: sprintf(symbol[wRAM], "wbyte0_ram"); /* not different due to opsize */
2461: sprintf(symbol[wNOP], "wbyte0_nop"); /* not different due to opsize */
2462: sprintf(symbol[wRAR], "wbyte0_rar"); /* not different due to opsize */
2463: sprintf(symbol[wBNK], "wbyte0_bnk"); /* not different due to opsize */
2464: sprintf(symbol[wWHW], "wbyte%d_whw", i);
2465: sprintf(symbol[wUSR], "wbyte%d_usr", i);
2466: sprintf(symbol[wNON], "wbyte%d_non", i);
2467:
2468: com("===================================================================");
2469: com(" write a byte from EDX to memory at EBP for opcodes of size %d ",i);
2470: com("===================================================================");
2471: pad(align_funcs);
2472: S(symbol[0],0);
2473: I(0,movl, ECX, EBP, "memory address to ECX");
2474: I(0,movl, EDI, MWHARD, "write flags");
2475: I(0,shrl, ECX, D(ABITS), ">> (ABITS2_16 + ABITS_MIN_16)");
2476: I(0,movzbl, EDI, M(1,0,edi,0,ecx,1), "get MHELE value");
2477: I(0,jmp, M(4,symbol[wTBL],0,0,edi,4),0, "jump to memory write function");
2478:
2479: I(0,data,0,0,0);
2480: pad(align_funcs);
2481: S(symbol[wTBL],0);
2482: for (j = 0; j < 256; j += 4) {
2483: sprintf(buffer,"%s,%s,%s,%s",symbol[mw[j+0]], symbol[mw[j+1]],symbol[mw[j+2]], symbol[mw[j+3]]);
2484: I(0,dd,buffer,0,0);
2485: }
2486: I(0,text,0,0,0);
2487:
2488: if (i == 0) { /* functions that are needed only once */
2489: pad(align_funcs);
2490: S(symbol[wRAM],"HT_RAM");
2491: I(0,movl, EDI, RAM, "get RAM base");
2492: I(0,movb, M(1,0,edi,0,ebp,1), DL, "put byte into RAM");
2493: I(0,ret, 0, 0, 0);
2494:
2495: pad(align_funcs);
2496: S(symbol[wNOP],"HT_NOP");
2497: I(0,ret, 0, 0, "do nothing");
2498:
2499: pad(align_funcs);
2500: S(symbol[wRAR],"HT_RAMROM");
2501: I(0,movl, EDI, RAM, "get RAM base");
2502: I(0,movl, ECX, ROM, "get ROM base");
2503: I(0,movb, M(1,0,edi,0,ebp,1), DL, "put byte into RAM");
2504: I(0,movb, M(1,0,ecx,0,ebp,1), DL, "put byte into ROM");
2505: I(0,ret, 0, 0, 0);
2506:
2507: pad(align_funcs);
2508: S(symbol[wBNK],"HT_BANK1 - HT_BANK8");
2509: I(0,movl, ECX, EBP, "get address int0 ECX");
2510: I(0,subl, ECX, WRITEOFFSET(edi), "subtract write offset");
2511: I(0,movl, EDI, BANKBASE(edi), "get BANKn base");
2512: I(0,movb, M(1,0,edi,0,ecx,1), DL, "put byte to BANKn + offset");
2513: I(0,ret, 0, 0, 0);
2514: }
2515:
2516: pad(align_funcs);
2517: S(symbol[wWHW],"MH_HARDMAX..255");
2518: I(0,movl, ECX, EBP, "get address to ECX");
2519: I(0,shll, EDI, D(8), "hw << MH_SBITS");
2520: I(0,andl, ECX, B(15), "mask bits 0..3");
2521: I(0,movzbl, EDI, WRITEHW(edi,ecx), "get MHELE");
2522: I(0,jmp, M(4,symbol[wTBL],0,0,edi,4),0, "jump to write handler");
2523:
2524: pad(align_funcs);
2525: S(symbol[wUSR],"HT_USER .. MH_HARDMAX-1");
2526: save_af();
2527: save_z80( i );
2528: I(0,movl, ECX, EBP, "get address to ECX");
2529: I(0,pushl, EDX, 0, "data byte");
2530: I(0,subl, ECX, WRITEOFFSET(edi), "subtract write offset");
2531: I(0,movl, EDI, WRITEHANDLER(edi), "get memorywritehandler");
2532: I(0,pushl, ECX, 0, "offset");
2533: I(0,call, EDI, 0, "call handler");
2534: I(0,addl, ESP, B(2*4), "two DWORDs were pushed");
2535: restore_z80();
2536: restore_af();
2537: I(0,ret, 0, 0, 0);
2538:
2539: pad(align_funcs);
2540: S(symbol[wNON],"HT_NON");
2541: save_af();
2542: save_z80( i );
2543: I(0,pushl, EDX, 0, "data byte");
2544: I(0,pushl, EBP, 0, "memory address");
2545: I(0,call, "_mwh_error",0, 0);
2546: I(0,addl, ESP, B(2*4), "two DWORDs were pushed");
2547: restore_z80();
2548: restore_af();
2549: I(0,ret, 0, 0, 0);
2550:
2551: #else
2552: char symbol[2][31+1];
2553: sprintf(symbol[0], "wbyte%d", i);
2554: sprintf(symbol[1], "wbyte%d_user", i);
2555: pad(align_funcs);
2556: com("===================================================================");
2557: com(" write a byte from EDX to memory at EBP for opcodes of size %d ",i);
2558: com("===================================================================");
2559: S(symbol[0],0);
2560: I(0,movl, ECX, EBP, "get memory address to ECX");
2561: I(0,movl, EDI, MWHARD, "write flags");
2562: I(0,shrl, ECX, D(ABITS), ">> (ABITS2_16 + ABITS_MIN_16)");
2563: I(0,movzbl, ECX, M(1,0,edi,0,ecx,1), "get MHELE");
2564: I(0,orb, CL, CL, "write to RAM?");
2565: I(0,jne, LS(symbol[1]),0, "nope, need to call writemem16");
2566: I(0,movl, EDI, RAM, "get RAM base");
2567: I(0,movb, M(1,0,edi,0,ebp,1),DL, "store byte to RAM");
2568: I(0,ret, 0, 0, "return to caller");
2569:
2570: pad(align_jumps);
2571: S(symbol[1],0);
2572: save_af();
2573: save_z80( i );
2574: I(0,pushl, EDX, 0, "value");
2575: I(0,pushl, EBP, 0, "memory address");
2576: I(0,call, "_cpu_writemem16",0, 0);
2577: I(0,addl, ESP, B(2*4), "two DWORDs were pushed");
2578: restore_z80();
2579: restore_af();
2580: I(0,ret, 0, 0, "return to caller");
2581: #endif
2582: }
2583:
2584: static void mk_wword_handler( int i )
2585: {
2586: char symbol[3][15+1];
2587:
2588: sprintf(symbol[0], "wword%d", i);
2589: sprintf(symbol[1], "wword%d_usr", i);
2590: sprintf(symbol[2], "wbyte%d", i);
2591: pad(align_funcs);
2592: com("===================================================================");
2593: com(" write a word from EDX to memory at ECX for opcodes of size %d ",i);
2594: com("===================================================================");
2595: S(symbol[0],0);
2596: I(0,movl, ECX, EBP, "memory address to ECX");
2597: I(0,orb, CL, X(0x0f), "check if address...");
2598: I(0,cmpl, ECX, EBP, "...is 0xxxFh");
2599: I(0,je, LS(symbol[1]),0, "yes, need to write LSB then MSB");
2600: I(0,movl, EDI, MWHARD, "write flags");
2601: I(0,shrl, ECX, D(ABITS), ">> (ABITS2_16 + ABITS_MIN_16)");
2602: I(0,testb, M(1,0,edi,0,ecx,1),D(-1), "MHELE == RAM?");
2603: I(0,jne, LS(symbol[1]),0, "nope, need to call handler");
2604: pad(align_funcs);
2605: I(0,movl, EDI, RAM, "get RAM base");
2606: I(0,movw, M(2,0,edi,0,ebp,1),DX, "store word to RAM");
2607: I(0,ret, 0, 0, 0);
2608:
2609: pad(align_funcs);
2610: S(symbol[1],0);
2611: I(0,movb, zMB, DH, "save MSB of data");
2612: I(0,movzbl, EDX, DL, "EDX = LSB only");
2613: I(0,call, symbol[2], 0, "write LSB");
2614: I(0,incw, BP, 0, "address + 1");
2615: I(0,movzbl, EDX, zMB, "EDX = MSB only");
2616: I(0,call, symbol[2], 0, "write MSB");
2617: I(0,ret, 0, 0, 0);
2618: }
2619:
2620: static void mk_memory_handlers( void )
2621: {
2622: int i;
2623:
2624: for (i = 0; i <= 4*CALC_PREVPC; i++) {
2625: mk_rbyte_handler(i);
2626: mk_rword_handler(i);
2627: mk_wbyte_handler(i);
2628: mk_wword_handler(i);
2629: }
2630:
2631: com(0);
2632: com("===================================================================");
2633: com(" push PC to stack (called from interrupt handlers) ");
2634: com("===================================================================");
2635: pad(align_funcs);
2636: S("z80_push_pc",0);
2637: I(0,subw, zSP, B(2), 0);
2638: I(0,movzwl, EDX, PC, "get PC to EDX");
2639: I(0,movzwl, EBP, zSP, "get SP to EBP");
2640: I(0,jmp, "wword0", 0, "write word");
2641:
2642: com(0);
2643: com("===================================================================");
2644: com(" write back EDX to address EBP (DD/FD CB <ofs> xx opcodes) ");
2645: com("===================================================================");
2646: pad(align_funcs);
2647: S("wb_ea4_edx",0);
2648: #if CALC_PREVPC
2649: I(0,call, "wbyte4",0, "write the value in EDX");
2650: #else
2651: I(0,call, "wbyte0",0, "write the value in EDX");
2652: #endif
2653: end_opcode("z_op");
2654: }
2655:
2656: void M_INC( const char *dst )
2657: {
2658: I(0,shrb, F, D(1), "save carry");
2659: I(0,incb, dst, 0, 0);
2660: I(0,lahf, 0, 0, 0);
2661: I(0,seto, CL, 0, 0);
2662: I(0,shlb, CL, D(2), "get overflow to P/V bit position");
2663: I(0,andb, F, X(SF|ZF|HF|CF), "mask S,Z,H and C");
2664: I(0,orb, F, CL, "combine the flags");
2665: }
2666:
2667: void M_DEC( const char *dst )
2668: {
2669: I(0,shrb, F, D(1), "save carry");
2670: I(0,decb, dst, 0, 0);
2671: I(0,lahf, 0, 0, 0);
2672: I(0,seto, CL, 0, 0);
2673: I(0,shlb, CL, D(2), "get overflow to P/V bit position");
2674: I(0,andb, F, X(SF|ZF|HF|CF), "mask S,Z,H and C");
2675: I(0,orb, F, X(NF), "set N");
2676: I(0,orb, F, CL, "combine the flags");
2677: }
2678:
2679: void M_ADD16( const char *dst, const char *src )
2680: {
2681: I(0,movw, DX, dst, "get destination");
2682: I(0,movw, CX, src, "get source");
2683: I(0,addb, DL, CL, 0);
2684: I(0,adcb, DH, CH, 0);
2685: I(0,movb, CL, F, "get old flags");
2686: I(0,lahf, 0, 0, 0);
2687: I(0,andb, CL, X(SF|ZF|PF), "mask S,Z and P/V");
2688: I(0,movw, dst, DX, "store result");
2689: I(0,andb, F, X(HF|CF), "mask H and C");
2690: I(0,orb, F, CL, "set old flag bits");
2691: }
2692:
2693: void M_ADD( const char *src )
2694: {
2695: I(0,addb, A, src, "add source");
2696: I(0,lahf, 0, 0, 0);
2697: I(0,seto, CL, 0, 0);
2698: I(0,shlb, CL, D(2), "get overflow to P/V bit position");
2699: I(0,andb, F, X(SF|ZF|HF|CF), "mask S,Z,H and C");
2700: I(0,orb, F, CL, "combine the flags");
2701: }
2702:
2703: void M_ADC( const char *src )
2704: {
2705: I(0,sahf, 0, 0, "set flags");
2706: I(0,adcb, A, src, "add source with carry");
2707: I(0,lahf, 0, 0, 0);
2708: I(0,seto, CL, 0, 0);
2709: I(0,shlb, CL, D(2), "get overflow to P/V bit position");
2710: I(0,andb, F, X(SF|ZF|HF|CF), "mask S,Z,H and C");
2711: I(0,orb, F, CL, "combine the flags");
2712: }
2713:
2714: void M_SUB( const char *src )
2715: {
2716: I(0,subb, A, src, "subtract source");
2717: I(0,lahf, 0, 0, 0);
2718: I(0,seto, CL, 0, 0);
2719: I(0,shlb, CL, D(2), "get overflow to P/V bit position");
2720: I(0,andb, F, X(SF|ZF|HF|CF), "mask S,Z,H and C");
2721: I(0,orb, F, X(NF), "set N");
2722: I(0,orb, F, CL, "combine the flags");
2723: }
2724:
2725: void M_SBC( const char *src )
2726: {
2727: I(0,sahf, 0, 0, "set the flags");
2728: I(0,sbbb, A, src, "subtract source with carry");
2729: I(0,lahf, 0, 0, 0);
2730: I(0,seto, CL, 0, 0);
2731: I(0,shlb, CL, D(2), "get overflow to P/V bit position");
2732: I(0,andb, F, X(SF|ZF|HF|CF), "mask S,Z and C");
2733: I(0,orb, F, X(NF), "set N");
2734: I(0,orb, F, CL, "combine the flags");
2735: }
2736:
2737: void M_AND( const char *src )
2738: {
2739: I(0,andb, A, src, "logical and with source");
2740: I(0,lahf, 0, 0, 0);
2741: I(0,andb, F, X(SF|ZF|PF), "mask S,Z and P/V");
2742: I(0,orb, F, X(HF), "set H");
2743: }
2744:
2745: void M_XOR( const char *src )
2746: {
2747: I(0,xorb, A, src, "logical exclusive or with source");
2748: I(0,lahf, 0, 0, 0);
2749: I(0,andb, F, X(SF|ZF|PF), "mask S,Z and P/V");
2750: }
2751:
2752: void M_OR( const char *src )
2753: {
2754: I(0,orb, A, src, "logical or with source");
2755: I(0,lahf, 0, 0, 0);
2756: I(0,andb, F, X(SF|ZF|PF), "mask S,Z and P/V flags");
2757: }
2758:
2759: void M_CP( const char *src )
2760: {
2761: I(0,cmpb, A, src, "compare with source");
2762: I(0,lahf, 0, 0, 0);
2763: I(0,seto, CL, 0, 0);
2764: I(0,shlb, CL, D(2), "get overflow to P/V bit position");
2765: I(0,andb, F, X(SF|ZF|HF|CF), "mask S,Z,H and C flags");
2766: I(0,orb, F, X(NF), "set N");
2767: I(0,orb, F, CL, "combine the flags");
2768: }
2769:
2770: #if BUSY_LOOP_HACKS
2771: void M_JR( int opcode )
2772: {
2773: char symbol[4][32+1];
2774: int i;
2775: for (i = 0; i < 4; i++)
2776: sprintf(symbol[i],"op_%02x_%d", opcode, i);
2777: I(0,movl, EDX, PC32, "ECX = old PC");
2778: I(0,decl, EDX, 0, "- 1");
2779: REL();
2780: I(0,addl, PC32, ECX, "change PC");
2781: I(0,cmpl, EDX, PC32, "busy loop (tight) ?");
2782: I(0,jne, LS(symbol[0]),0, "no, skip");
2783: I(0,orl, zICOUNT, B(0), "more cycles left?");
2784: I(0,jle, LN(symbol[3]),0, "no, skip");
2785: I(0,movl, zICOUNT, D(0), "bail out");
2786: I(0,jmp, symbol[3], 0, 0);
2787:
2788: pad(align_jumps);
2789: S(symbol[0],0);
2790: I(0,decl, EDX, 0, "EDX = oldpc - 1");
2791: I(0,movl, EDI, OP_ROM, "get OP_ROM base");
2792: I(0,movb, CL, M(1,0,edi,0,pc32,1), "read opcode byte");
2793: I(0,cmpl, EDX, PC32, "busy loop (1 byte opcode) ?");
2794: I(0,jne, LS(symbol[2]),0, "no, skip");
2795: I(0,cmpb, CL, X(0x00), "NOP - JR xxxx ?");
2796: I(0,jne, LS(symbol[1]),0, "no, skip");
2797: I(0,orl, zICOUNT, B(0), "more cycles left?");
2798: I(0,jle, LS(symbol[3]),0, "nope, leave");
2799: I(0,movl, zICOUNT, D(0), "bail out");
2800: I(0,jmp, symbol[3], 0, 0);
2801:
2802: pad(align_jumps);
2803: S(symbol[1],0);
2804: I(0,cmpb, CL, X(0xfb), "EI - JR xxxx ?");
2805: I(0,jne, LS(symbol[2]),0, "no, skip");
2806: I(0,cmpl, zICOUNT, B(4), "more than four cycles left?");
2807: I(0,jle, LS(symbol[3]),0, "nope, leave");
2808: I(0,movl, zICOUNT, D(4), "bail out after EI");
2809: I(0,jmp, symbol[3], 0, 0);
2810:
2811: pad(align_jumps);
2812: S(symbol[2],0);
2813: I(0,cmpb, CL, X(0x31), "LD SP,xxxx - JR xxxx ?");
2814: I(0,jne, LS(symbol[3]),0, "no, skip");
2815: I(0,subl, EDX, B(2), "EDX = oldpc - 3");
2816: I(0,cmpl, EDX, PC32, "busy loop (3 byte opcode) ?");
2817: I(0,jne, LS(symbol[3]),0, "no, skip");
2818: I(0,cmpl, zICOUNT, B(10), "more than ten cycles left?");
2819: I(0,jle, LS(symbol[3]),0, "nope, leave");
2820: I(0,movl, zICOUNT, D(10), "bail out after LD SP,xxxx");
2821: I(0,jmp, LS(symbol[3]),0, 0);
2822:
2823: pad(align_jumps);
2824: S(symbol[3],0);
2825: CHANGE_PC();
2826: }
2827: #else
2828: void M_JR( int opcode )
2829: {
2830: REL();
2831: I(0,addl, PC32, ECX, "change PC");
2832: CHANGE_PC();
2833: }
2834: #endif
2835:
2836: void M_JR_CC( int opcode, int flag )
2837: {
2838: char symbol[32+1];
2839: sprintf(symbol,"op_%02x_take", opcode);
2840: if (flag) {
2841: I(0,sahf, 0, 0, "set flags");
2842: switch (opcode & 0x38) {
2843: case 0x20: I(0,jnz, LS(symbol),0,"Z == 0: take jump"); break;
2844: case 0x28: I(0,jz, LS(symbol),0,"Z == 1: take jump"); break;
2845: case 0x30: I(0,jnc, LS(symbol),0,"C == 0: take jump"); break;
2846: case 0x38: I(0,jc, LS(symbol),0,"C == 1: take jump"); break;
2847: }
2848: ADJUST_PC(+1);
2849: end_opcode("z_op");
2850: }
2851:
2852: pad(align_jumps);
2853: S(symbol,"take the relative jump");
2854: REL();
2855: I(0,addl, PC32, ECX, "change PC");
2856: I(0,subl, zICOUNT,B(5), "five additional cycles");
2857: CHANGE_PC();
2858: }
2859:
2860: void M_DJNZ( int opcode )
2861: {
2862: char symbol[32+1];
2863: sprintf(symbol,"op_%02x_take ", opcode);
2864: I(0,decb, zB, 0, "decrement B");
2865: I(0,jne, LS(symbol),0, "not zero, take the jump");
2866: ADJUST_PC(+1);
2867: end_opcode("z_op");
2868:
2869: pad(align_jumps);
2870: S(symbol,"take the relative jump");
2871: REL();
2872: I(0,addl, PC32, ECX, "change PC");
2873: I(0,subl, zICOUNT,B(5), "five additional cycles");
2874: CHANGE_PC();
2875: }
2876:
2877: void M_HALT( int opcode )
2878: {
2879: char symbol[32+1];
2880: sprintf(symbol,"op_%02x_done", opcode);
2881: I(0,movb, zHALT, B(1), "set HALT flag");
2882: ADJUST_PC(-1);
2883: I(0,orl, zICOUNT, B(0), "cycle count <= zero already?");
2884: I(0,jle, LS(symbol), 0, 0);
2885: I(0,movl, zICOUNT, D(0), 0);
2886: S(symbol,0);
2887: }
2888:
2889: void M_RET( int opcode )
2890: {
2891: POP( 1, PC32 );
2892: CHANGE_PC();
2893: }
2894:
2895: void M_RET_CC( int opcode )
2896: {
2897: char symbol[32+1];
2898: sprintf(symbol,"op_%02x_done", opcode);
2899: I(0,sahf, 0, 0, "set flags");
2900: switch (opcode & 0x38) {
2901: case 0x00: I(0,jne, LS(symbol),0,"Z == 0: return"); break;
2902: case 0x08: I(0,je, LS(symbol),0,"Z == 1: return"); break;
2903: case 0x10: I(0,jnc, LS(symbol),0,"C == 0: return"); break;
2904: case 0x18: I(0,jc, LS(symbol),0,"C == 1: return"); break;
2905: case 0x20: I(0,jpo, LS(symbol),0,"P == 0: return"); break;
2906: case 0x28: I(0,jpe, LS(symbol),0,"P == 1: return"); break;
2907: case 0x30: I(0,jns, LS(symbol),0,"S == 0: return"); break;
2908: case 0x38: I(0,js, LS(symbol),0,"S == 1: return"); break;
2909: }
2910: end_opcode("z_op");
2911:
2912: pad(align_jumps);
2913: S(symbol,"execute the return");
2914: I(0,subl, zICOUNT,B(6), "six additional cycles");
2915: M_RET( opcode );
2916: }
2917:
2918: #if BUSY_LOOP_HACKS
2919: void M_JP( int opcode )
2920: {
2921: char symbol[4][32+1];
2922: int i;
2923: for (i = 0; i < 4; i++)
2924: sprintf(symbol[i],"op_%02x_%d", opcode, i);
2925: I(0,movl, ECX, PC32, "ECX = PC");
2926: I(0,decl, ECX, 0, "- 1");
2927: ARG16( PC32 );
2928: I(0,cmpl, ECX, PC32, "busy loop (tight) ?");
2929: I(0,jne, LS(symbol[0]),0, "no, skip");
2930: I(0,orl, zICOUNT, B(0), "more cycles left?");
2931: I(0,jle, LN(symbol[3]),0, "no, skip");
2932: I(0,movl, zICOUNT, D(0), "bail out");
2933: I(0,jmp, symbol[3], 0, 0);
2934: pad(align_jumps);
2935: S(symbol[0],0);
2936: I(0,decl, ECX, 0, "ECX = oldpc - 1");
2937: I(0,movl, EDI, OP_ROM, "get OP_ROM base");
2938: I(0,movb, DL, M(1,0,edi,0,pc32,1), "read opcode byte");
2939: I(0,cmpl, ECX, PC32, "busy loop (1 byte opcode) ?");
2940: I(0,jne, LS(symbol[2]),0, "no, skip");
2941: I(0,cmpb, DL, X(0x00), "NOP - JP xxxx ?");
2942: I(0,jne, LS(symbol[1]),0, "no, skip");
2943: I(0,orl, zICOUNT, B(0), "more cycles left?");
2944: I(0,jle, LS(symbol[3]),0, "nope, leave");
2945: I(0,movl, zICOUNT, D(0), "bail out");
2946: I(0,jmp, symbol[3], 0, 0);
2947: pad(align_jumps);
2948: S(symbol[1],0);
2949: I(0,cmpb, DL, X(0xfb), "EI - JP xxxx ?");
2950: I(0,jne, LS(symbol[2]),0, "no, skip");
2951: I(0,cmpl, zICOUNT, B(4), "more than four cycles left?");
2952: I(0,jle, LS(symbol[3]),0, "nope, leave");
2953: I(0,movl, zICOUNT, D(4), "bail out after EI");
2954: I(0,jmp, symbol[3], 0, 0);
2955: pad(align_jumps);
2956: S(symbol[2],0);
2957: I(0,cmpb, DL, X(0x31), "LD SP,xxxx - JP xxxx ?");
2958: I(0,jne, LS(symbol[3]),0, "no, skip");
2959: I(0,subl, ECX, B(2), "ECX = oldpc - 3");
2960: I(0,cmpl, ECX, PC32, "busy loop (3 byte opcode) ?");
2961: I(0,jne, LS(symbol[3]),0, "no, skip");
2962: I(0,cmpl, zICOUNT, B(10), "more than ten cycles left?");
2963: I(0,jle, LS(symbol[3]),0, "nope, leave");
2964: I(0,movl, zICOUNT, D(10), "bail out after LD SP,xxxx");
2965: I(0,jmp, LS(symbol[3]),0, 0);
2966: pad(align_jumps);
2967: S(symbol[3],0);
2968: CHANGE_PC();
2969: }
2970: #else
2971: void M_JP( int opcode )
2972: {
2973: ARG16( PC32 );
2974: CHANGE_PC();
2975: }
2976: #endif
2977:
2978: void M_JP_CC( int opcode )
2979: {
2980: char symbol[32+1];
2981: sprintf(symbol,"op_%02x_take", opcode);
2982: I(0,sahf, 0, 0, "set flags");
2983: switch (opcode & 0x38) {
2984: case 0x00: I(0,jne, LS(symbol),0,"Z == 0: jump"); break;
2985: case 0x08: I(0,je, LS(symbol),0,"Z == 1: jump"); break;
2986: case 0x10: I(0,jnc, LS(symbol),0,"C == 0: jump"); break;
2987: case 0x18: I(0,jc, LS(symbol),0,"C == 1: jump"); break;
2988: case 0x20: I(0,jpo, LS(symbol),0,"P == 0: jump"); break;
2989: case 0x28: I(0,jpe, LS(symbol),0,"P == 1: jump"); break;
2990: case 0x30: I(0,jns, LS(symbol),0,"S == 0: jump"); break;
2991: case 0x38: I(0,js, LS(symbol),0,"S == 1: jump"); break;
2992: }
2993: ADJUST_PC(+2);
2994: end_opcode("z_op");
2995:
2996: pad(align_jumps);
2997: S(symbol,"take the jump");
2998: ARG16( PC32 );
2999: CHANGE_PC();
3000: }
3001:
3002: void M_JP_REG( int opcode, const char *reg )
3003: {
3004: I(0,movl, PC32, reg, 0);
3005: CHANGE_PC();
3006: }
3007:
3008: void M_CALL( int opcode )
3009: {
3010: ARG16( zEA );
3011: PUSH( 3, PC32 );
3012: I(0,movl, PC32, zEA, "get the new PC");
3013: CHANGE_PC();
3014: }
3015:
3016: void M_CALL_CC( int opcode )
3017: {
3018: char symbol[32+1];
3019: sprintf(symbol,"op_%02x_take", opcode);
3020: I(0,sahf, 0, 0, "set flags");
3021: switch (opcode & 0x38) {
3022: case 0x00: I(0,jne, LS(symbol),0,"Z == 0: call"); break;
3023: case 0x08: I(0,je, LS(symbol),0,"Z == 1: call"); break;
3024: case 0x10: I(0,jnc, LS(symbol),0,"C == 0: call"); break;
3025: case 0x18: I(0,jc, LS(symbol),0,"C == 1: call"); break;
3026: case 0x20: I(0,jpo, LS(symbol),0,"P == 0: call"); break;
3027: case 0x28: I(0,jpe, LS(symbol),0,"P == 1: call"); break;
3028: case 0x30: I(0,jns, LS(symbol),0,"S == 0: call"); break;
3029: case 0x38: I(0,js, LS(symbol),0,"S == 1: call"); break;
3030: }
3031: ADJUST_PC(+2);
3032: end_opcode("z_op");
3033:
3034: pad(align_jumps);
3035: S(symbol,"make the call");
3036: ARG16( zEA );
3037: PUSH( 3, PC32 );
3038: I(0,movl, PC32, zEA, "get new PC");
3039: I(0,subl, zICOUNT,B(7), "seven additional cycles");
3040: CHANGE_PC();
3041: }
3042:
3043: void M_RST( int opcode )
3044: {
3045: PUSH( 1, PC32 );
3046: I(0,movl, PC32, X(opcode & 0x38), 0);
3047: CHANGE_PC();
3048: }
3049:
3050: void M_EX_AF_AF2( void )
3051: {
3052: I(0,xchgb, F, zF2, 0);
3053: I(0,xchgb, A, zA2, 0);
3054: }
3055:
3056: void M_EXX( void )
3057: {
3058: I(0,movzwl, ECX, zBC, 0);
3059: I(0,xchgw, CX, zBC2, 0);
3060: I(0,movw, zBC, CX, 0);
3061: I(0,movzwl, ECX, zDE, 0);
3062: I(0,xchgw, CX, zDE2, 0);
3063: I(0,movw, zDE, CX, 0);
3064: I(0,xchgw, HL, zHL2, 0);
3065: }
3066:
3067: void M_EX_DE_HL( void )
3068: {
3069: I(0,xchgw, HL, zDE, 0);
3070: }
3071:
3072: void M_RLCA( void )
3073: {
3074: I(0,shrb, F, D(1), "knock out C");
3075: I(0,rolb, A, D(1), 0);
3076: I(0,adcb, F, F, "get C");
3077: I(0,andb, F, X(~(HF|NF)&255),"remove H and N flags");
3078: }
3079:
3080: void M_RRCA( void )
3081: {
3082: I(0,shrb, F, D(1), "knock out C");
3083: I(0,rorb, A, D(1), 0);
3084: I(0,adcb, F, F, "get C");
3085: I(0,andb, F, X(~(HF|NF)&255),"remove H and N flags");
3086: }
3087:
3088: void M_RLA( void )
3089: {
3090: I(0,shrb, F, D(1), "C into carry");
3091: I(0,rclb, A, D(1), 0);
3092: I(0,adcb, F, F, "get C");
3093: I(0,andb, F, X(~(HF|NF)&255),"remove H and N flags");
3094: }
3095:
3096: void M_RRA( void )
3097: {
3098: I(0,shrb, F, D(1), "C into carry");
3099: I(0,rcrb, A, D(1), 0);
3100: I(0,adcb, F, F, "get C");
3101: I(0,andb, F, X(~(HF|NF)&255),"remove H and N flags");
3102: }
3103:
3104: void M_CPL( void )
3105: {
3106: I(0,xorb, A, X(0xff), "one's complement accumulator");
3107: I(0,orb, F, X(HF|NF), "set H and N");
3108: }
3109:
3110: void M_DAA( int opcode )
3111: {
3112: I(0,movzbl, ECX, A, "get accu");
3113: I(0,rorb, F, D(2), "check N flag");
3114: I(0,adcb, CH, CH, 0);
3115: I(0,rorb, F, D(3), "check H flag");
3116: I(0,adcb, CH, CH, 0);
3117: I(0,rorb, F, D(5), "check C flag");
3118: I(0,adcb, CH, CH, 0);
3119: I(0,movzwl, AF32, zDAA(ecx), "get DAA table entry");
3120: }
3121:
3122: void M_SCF( void )
3123: {
3124: I(0,andb, F, X(~(HF|NF)&255),"clear H and N");
3125: I(0,orb, F, X(CF), "set C");
3126: }
3127:
3128: void M_CCF( void )
3129: {
3130: I(0,movb, CL, F, 0);
3131: I(0,andb, F, X(~(HF|NF)),"clear H and N");
3132: I(0,andb, CL, X(CF), "mask C");
3133: I(0,shlb, CL, D(4), "move C to H");
3134: I(0,orb, CL, X(CF), "set C");
3135: I(0,xorb, F, CL, "toggle C, set/leave H");
3136: }
3137:
3138: void M_DI( void )
3139: {
3140: I(0,movb, zIFF1, D(0), "clear both interrupt flip-flops");
3141: I(0,movb, zIFF2, D(0), 0);
3142: }
3143:
3144: void M_EI( int opcode )
3145: {
3146: char symbol[32+1];
3147: sprintf(symbol, "op_%02x_skip", opcode);
3148: I(0,movb, CL, X(0xff), 0);
3149: I(0,movb, zIFF2, CL, "set interrupt flip-flop 2");
3150: I(0,cmpb, CL, zIFF1, "interrupt flip-flop 1 already set?");
3151: I(0,je, LN(symbol), 0, "yes, skip");
3152: I(0,movb, zIFF1, CL, "set IFF1");
3153: I(0,cmpl, irq_state, B(CLEAR_LINE), "irq line clear?");
3154: I(0,je, LN(symbol), 0, "yes, skip");
3155: save_af();
3156: save_z80(2);
3157: I(0,movl, ESI, zICOUNT, "save remaining cycle count");
3158: I(0,movl, EDI, zITOTAL, "and total cycle count");
3159: I(0,pushl, D(1), 0, "execute one opcode");
3160: I(0,call, "_Z80_Execute", 0, "recursive.. eww!");
3161: I(0,movl, zITOTAL, EDI, "restore total cycle count");
3162: I(0,movl, zICOUNT, ESI, "restore remaining cycle count");
3163: I(0,addl, ESP, B(4), "clean up stack");
3164: I(0,subl, zICOUNT, EAX, "subtract cycles used");
3165: restore_z80();
3166: restore_af();
3167: mk_take_irq( opcode );
3168: I(0,movl, ECX, D(0), 0);
3169: I(0,xchgl, ECX, zIEXTRN, "interrupt used cycles");
3170: I(0,subl, zICOUNT, ECX, "subtract from cycle count");
3171: com(0);
3172: pad(align_jumps);
3173: S(symbol,0);
3174: }
3175:
3176: void M_RLC( const char *reg )
3177: {
3178: I(0,rolb, reg, D(1), "rotate left circular");
3179: I(0,setc, CL, 0, "CL = 1 if carry set");
3180: I(0,orb, reg, D(0), "check sign, zero and parity");
3181: I(0,lahf, 0, 0, 0);
3182: I(0,andb, F, X(SF|ZF|PF), "mask S, Z and P/V flags");
3183: I(0,orb, F, CL, "combine with C");
3184: }
3185:
3186: void M_RRC( const char *reg )
3187: {
3188: I(0,rorb, reg, D(1), "rotate right circular");
3189: I(0,setc, CL, 0, "CL = 1 if carry set");
3190: I(0,orb, reg, D(0), "check sign, zero and parity");
3191: I(0,lahf, 0, 0, 0);
3192: I(0,andb, F, X(SF|ZF|PF), "mask S, Z and P/V flags");
3193: I(0,orb, F, CL, "combine with C");
3194: }
3195:
3196: void M_RL( const char *reg )
3197: {
3198: I(0,shrb, F, D(1), "get C into carry");
3199: I(0,rclb, reg, D(1), "rotate left through carry");
3200: I(0,setc, CL, 0, "CL = 1 if carry set");
3201: I(0,orb, reg, D(0), 0);
3202: I(0,lahf, 0, 0, 0);
3203: I(0,andb, F, X(SF|ZF|PF), "mask S,Z and P/V flags");
3204: I(0,orb, F, CL, "combine with C");
3205: }
3206:
3207: void M_RR( const char *reg )
3208: {
3209: I(0,shrb, F, D(1), "get C into carry");
3210: I(0,rcrb, reg, D(1), "rotate right through carry");
3211: I(0,setc, CL, 0, "CL = 1 if carry set");
3212: I(0,orb, reg, D(0), "check sign, zero and parity");
3213: I(0,lahf, 0, 0, 0);
3214: I(0,andb, F, X(SF|ZF|PF), "mask S,Z and P/V flags");
3215: I(0,orb, F, CL, "combine with C");
3216: }
3217:
3218: void M_SLL( const char *reg )
3219: {
3220: I(0,shlb, reg, D(1), "shift left logical");
3221: I(0,lahf, 0, 0, 0);
3222: I(0,andb, F, X(SF|PF|CF), "mask S, P/V and C flags");
3223: I(0,orb, reg, D(1), "set bit 0 of destination");
3224: }
3225:
3226: void M_SRL( const char *reg )
3227: {
3228: I(0,shrb, reg, D(1), "shift right logical");
3229: I(0,lahf, 0, 0, 0);
3230: I(0,andb, F, X(SF|ZF|PF|CF), "mask S, Z, P/V and C flags");
3231: }
3232:
3233: void M_SLA( const char *reg )
3234: {
3235: I(0,salb, reg, D(1), "shift left arithmetical (well..)");
3236: I(0,lahf, 0, 0, 0);
3237: I(0,andb, F, X(SF|ZF|PF|CF), "mask S, Z, P/V and C flags");
3238: }
3239:
3240: void M_SRA( const char *reg )
3241: {
3242: I(0,sarb, reg, D(1), "shift right arithmetical");
3243: I(0,lahf, 0, 0, 0);
3244: I(0,andb, F, X(SF|ZF|PF|CF), "mask S, Z, P/V and C flags");
3245: }
3246:
3247: void M_BIT( int n, const char *reg )
3248: {
3249: I(0,movb, CL, F, "save flags");
3250: I(0,movb, CH, X(1<<n), "bit mask");
3251: I(0,andb, CL, X(CF), "keep C flag");
3252: I(0,orb, CL, X(HF), "set H flag");
3253: I(0,andb, CH, reg, "check sign and zero");
3254: I(0,lahf, 0, 0, 0);
3255: I(0,andb, F, X(SF|ZF), "mask S and Z flags");
3256: I(0,orb, F, CL, "combine with C");
3257: }
3258:
3259: void M_RES( int n, const char *reg )
3260: {
3261: I(0,andb, reg, X(~(1<<n)&255), "reset bit mask");
3262: }
3263:
3264: void M_SET( int n, const char *reg )
3265: {
3266: I(0,orb, reg, X(1<<n), "set bit mask");
3267: }
3268:
3269: void M_OUT( int opsize, const char *port, const char *reg )
3270: {
3271: #if INLINE_IOPORTS
3272: static int wport = 0;
3273: char symbol[3][7+1];
3274: int i;
3275: wport++;
3276: for (i = 0; i < 3; i++)
3277: sprintf(symbol[i], "WP%03x_%d", wport, i);
3278: if (strcmp(reg, EDX))
3279: I(0,movzbl, EDX, reg, "output register");
3280: if (strcmp(port, ECX))
3281: I(0,movl, ECX, port, "output port");
3282: save_af();
3283: save_z80(opsize);
3284: I(0,movl, EDI, M(4,"_cur_writeport",0,0,0,0),0);
3285: I(0,orl, EDI, EDI, 0);
3286: I(0,je, LS(symbol[2]),0, 0);
3287: I(0,andl, ECX, M(4,"_cur_portmask",0,0,0,0),0);
3288: pad(align_jumps);
3289: S(symbol[0],0);
3290: I(0,cmpl, M(4,0,edi,0,0,0), D(-1), "end of table?");
3291: I(0,je, LS(symbol[2]),0, 0);
3292: I(0,cmpl, ECX, M(4,0,edi,0,0,0), "port < start?");
3293: I(0,jb, LS(symbol[1]),0, 0);
3294: I(0,cmpl, ECX, M(4,0,edi,4,0,0), "port > end?");
3295: I(0,ja, LS(symbol[1]),0, 0);
3296: I(0,movl, EBX, M(4,0,edi,8,0,0), "get handler");
3297: I(0,orl, EBX, EBX, "IOWP_NOP ?");
3298: I(0,je, LS(symbol[2]),0, 0);
3299: I(0,subl, ECX, M(4,0,edi,0,0,0), "subtract start");
3300: I(0,pushl, EDX, 0, "value");
3301: I(0,pushl, ECX, 0, "offset");
3302: I(0,call, EBX, 0, "call handler");
3303: I(0,addl, ESP, B(8), "two DWORDs were pushed");
3304: I(0,jmp, LS(symbol[2]),0, 0);
3305: pad(align_jumps);
3306: S(symbol[1],0);
3307: I(0,addl, EDI, B(12), "skip sizeof(IOWritePort)");
3308: I(0,jmp, LS(symbol[0]),0, "test next entry");
3309: pad(align_jumps);
3310: S(symbol[2],0);
3311: restore_z80();
3312: restore_af();
3313: #else
3314: if (strcmp(reg,EDX))
3315: I(0,movzbl, EDX, reg, "output register");
3316: if (strcmp(port,ECX))
3317: I(0,movl, ECX, port, "port");
3318: save_af();
3319: save_z80(opsize);
3320: I(0,pushl, EDX, 0, "value");
3321: I(0,pushl, ECX, 0, "port");
3322: I(0,call, "_cpu_writeport",0, 0);
3323: I(0,addl, ESP, B(8), "two DWORDs were pushed");
3324: restore_z80();
3325: restore_af();
3326: #endif
3327: }
3328:
3329: void M_IN( int opsize, const char *reg, const char *port )
3330: {
3331: #if INLINE_IOPORTS
3332: static int wport = 0;
3333: char symbol[3][7+1];
3334: int i;
3335: wport++;
3336: for (i = 0; i < 3; i++)
3337: sprintf(symbol[i], "RP%03x_%d", wport, i);
3338: if (strcmp(port,ECX))
3339: I(0,movl, ECX, port, "output port");
3340: save_af();
3341: save_z80(opsize);
3342: I(0,movl, EDI, M(4,"_cur_readport",0,0,0,0),0);
3343: I(0,orl, EDI, EDI, 0);
3344: I(0,je, LS(symbol[2]),0, 0);
3345: I(0,andl, ECX, M(4,"_cur_portmask",0,0,0,0),0);
3346: pad(align_jumps);
3347: S(symbol[0],0);
3348: I(0,cmpl, M(4,0,edi,0,0,0), D(-1), "end of table?");
3349: I(0,je, LS(symbol[2]),0, 0);
3350: I(0,cmpl, ECX, M(4,0,edi,0,0,0), "port < start?");
3351: I(0,jb, LS(symbol[1]),0, 0);
3352: I(0,cmpl, ECX, M(4,0,edi,4,0,0), "port > end?");
3353: I(0,ja, LS(symbol[1]),0, 0);
3354: I(0,movl, EAX, M(4,0,edi,8,0,0), "get handler");
3355: I(0,orl, EAX, EAX, "IORP_NOP ?");
3356: I(0,je, LS(symbol[2]),0, 0);
3357: I(0,subl, ECX, M(4,0,edi,0,0,0), "subtract start");
3358: I(0,pushl, ECX, 0, "offset");
3359: I(0,call, EAX, 0, "call handler");
3360: I(0,addl, ESP, B(4), 0);
3361: I(0,jmp, LS(symbol[2]),0, 0);
3362: pad(align_jumps);
3363: S(symbol[1],0);
3364: I(0,addl, EDI, B(12), "skip sizeof(IOReadPort)");
3365: I(0,jmp, LS(symbol[0]),0, "test next entry");
3366: pad(align_jumps);
3367: S(symbol[2],0);
3368: I(0,movzbl, EDX, AL, 0);
3369: restore_z80();
3370: restor_af();
3371: #else
3372: if (strcmp(port,ECX))
3373: I(0,movl, ECX, port, "output port");
3374: save_af();
3375: save_z80(opsize);
3376: I(0,pushl, ECX, 0, 0);
3377: I(0,call, "_cpu_readport",0, 0);
3378: I(0,addl, ESP, B(4), 0);
3379: I(0,movzbl, EDX, AL, 0);
3380: restore_z80();
3381: restore_af();
3382: #endif
3383: if (strcmp(reg, EDX) && strcmp(reg, DL))
3384: I(0,movb, reg, DL, "input register");
3385: }
3386:
3387: void M_OUT_BC( const char *reg )
3388: {
3389: I(0,movzbl, EDX, reg, "get value to EDX");
3390: M_OUT( 2, zBC32, EDX );
3391: }
3392:
3393: void M_IN_BC( const char *reg )
3394: {
3395: M_IN( 2, EDX, zBC32 );
3396: I(0,movb, CL, F, "save flags");
3397: I(0,andb, CL, X(CF), "mask C flag");
3398: I(0,orb, DL, DL, "check sign, zero and parity");
3399: I(0,lahf, 0, 0, 0);
3400: I(0,andb, F, X(SF|ZF|PF), "mask S, Z and P/V flags");
3401: if (strcmp(reg, DL))
3402: I(0,movb, reg, DL, 0);
3403: I(0,orb, F, CL, "combine with carry");
3404: }
3405:
3406: void M_ADC16( const char *src )
3407: {
3408: I(0,movw, DX, src, "get source");
3409: I(0,sahf, 0, 0, "set flags");
3410: I(0,adcb, L, DL, "add LSB");
3411: I(0,adcb, H, DH, "add with carry MSB");
3412: I(0,seto, CL, 0, "CL = 1 if overflow");
3413: I(0,lahf, 0, 0, 0);
3414: I(0,shlb, CL, D(2), "shift overflow to P/V bit position");
3415: I(0,andb, F, X(SF|HF|CF), "mask S, H and C flags");
3416: I(0,orb, F, CL, "combine with P/V");
3417: I(0,cmpl, HL32, B(0), "HL = zero?");
3418: I(0,setz, CL, 0, "CL = 1 if zero");
3419: I(0,shlb, CL, D(6), "shift zero to Z bit position");
3420: I(0,orb, F, CL, "combine with Z");
3421: }
3422:
3423: void M_SBC16( const char *src )
3424: {
3425: I(0,movw, DX, src, "get source");
3426: I(0,sahf, 0, 0, "set flags");
3427: I(0,sbbb, L, DL, 0);
3428: I(0,sbbb, H, DH, 0);
3429: I(0,seto, CL, 0, "F = 1 if overflow");
3430: I(0,lahf, 0, 0, 0);
3431: I(0,shlb, CL, D(2), "shift overflow to P/V bit position");
3432: I(0,andb, F, X(SF|HF|CF), "mask S, H and C flags");
3433: I(0,orb, F, CL, "combine with P/V");
3434: I(0,cmpl, HL32, B(0), "HL = zero?");
3435: I(0,setz, CL, 0, "CL = 1 if zero");
3436: I(0,orb, F, X(NF), "set N");
3437: I(0,shlb, CL, D(6), "shift zero to Z bit position");
3438: I(0,orb, F, CL, "combine with Z");
3439: }
3440:
3441: void M_NEG( void )
3442: {
3443: I(0,movb, CL, A, "get accumulator");
3444: I(0,movb, A, D(0), "subtract from zero");
3445: I(0,subb, A, CL, 0);
3446: I(0,lahf, 0, 0, 0);
3447: I(0,seto, CL, 0, "F = 1 if overflow");
3448: I(0,shlb, CL, D(2), "get overflow to P/V bit position");
3449: I(0,andb, F, X(SF|ZF|HF|CF), "mask S, Z, H and C flags");
3450: I(0,orb, F, X(NF), "set N");
3451: I(0,orb, F, CL, "combine with P/V");
3452: }
3453:
3454: void M_RETI( int opcode )
3455: {
3456: char symbol[32+1];
3457: sprintf(symbol,"ed_%02x_skip", opcode);
3458:
3459: POP( 2, PC32 );
3460: CHANGE_PC();
3461: I(0,movl, ECX, service_irq, 0);
3462: I(0,cmpl, ECX, B(0), 0);
3463: I(0,jl, LS(symbol),0, 0);
3464: save_af();
3465: save_z80(2);
3466: I(0,lea, ECX, M(0,0,0,0,ecx,4),"* sizeof(Z80_DaisyChain)");
3467: I(0,pushl, irq(ecx,12),0, "Z80.irq[device].irq_param");
3468: I(0,call, irq(ecx, 8),0, "Z80.irq[device].interrupt_reti");
3469: I(0,addl, ESP, B(4), 0);
3470: restore_z80();
3471: restore_af();
3472: pad(align_jumps);
3473: S(symbol,0);
3474: }
3475:
3476: void M_RETN( int opcode )
3477: {
3478: char symbol[32+1];
3479: sprintf(symbol,"ed_%02x_skip", opcode);
3480:
3481: POP( 2, PC32 );
3482: CHANGE_PC();
3483: I(0,movb, CL, zIFF2, "get interrupt flip-flop 2");
3484: I(0,orb, CL, CL, "will RETN enable interrupts?");
3485: I(0,je, LN(symbol),0, "no, skip");
3486: I(0,movb, zIFF1, CL, "copy to interrupt flip-flop 1");
3487: I(0,cmpl, irq_state, B(CLEAR_LINE),"irq line cleared?");
3488: I(0,je, LN(symbol),0, "yes, skip");
3489: mk_take_irq( opcode );
3490: I(0,movl, ECX, D(0), 0);
3491: I(0,xchgl, ECX, zIEXTRN, "interrupt used cycles");
3492: I(0,subl, zICOUNT, ECX, "subtract from cycle count");
3493: pad(align_jumps),
3494: S(symbol,0);
3495: }
3496:
3497: void M_LD_I_A( void )
3498: {
3499: I(0,movb, zI, A, 0);
3500: }
3501:
3502: void M_LD_A_I( void )
3503: {
3504: I(0,movb, CL, F, "save flags");
3505: I(0,movb, A, zI, 0);
3506: I(0,andb, CL, X(CF), "mask C flag");
3507: I(0,orb, A, A, "check sign and zero");
3508: I(0,lahf, 0, 0, 0);
3509: I(0,andb, F, X(SF|ZF), "mask S and Z flags");
3510: I(0,orb, F, CL, "combine with C");
3511: I(0,movb, CL, zIFF2, "get interrupt flip-flop 2");
3512: I(0,andb, CL, X(PF), "shift to P/V bit position");
3513: I(0,orb, F, CL, "get IFF2 into P/V");
3514: }
3515:
3516: void M_LD_R_A( void )
3517: {
3518: I(0,movb, CL, A, 0);
3519: I(0,movb, zR, CL, "store accu into R");
3520: I(0,andb, CL, X(0x80), "mask bit 7");
3521: I(0,movb, zR2, CL, "save in R2");
3522: }
3523:
3524: void M_LD_A_R( void )
3525: {
3526: I(0,movb, CL, F, "save flags");
3527: I(0,movb, A, zR, 0);
3528: I(0,andb, A, X(0x7f), "mask lower 7 bits");
3529: I(0,andb, CL, X(CF), "mask C flag");
3530: I(0,orb, A, zR2, "get bit 7 from original R");
3531: I(0,lahf, 0, 0, 0);
3532: I(0,andb, F, X(SF|ZF), "mask S and Z flags");
3533: I(0,orb, F, CL, "combine with C");
3534: I(0,movb, CL, zIFF2, "get interrupt flip-flop 2");
3535: I(0,andb, CL, X(PF), "shift to P/V bit position");
3536: I(0,orb, F, CL, "get IFF2 into P/V");
3537: }
3538:
3539: void M_RLD( void )
3540: {
3541: RBYTE( 2, EDX, HL32 );
3542: I(0,movb, CH, A, "get accu into CH");
3543: I(0,movb, CL, F, "save flags");
3544: I(0,andl, ECX, X(0x0f00|CF), "mask lower nibble and keep C flag");
3545: I(0,shll, EDX, D(4), "shift memory byte left one nibble");
3546: I(0,xorb, A, CH, "remove lower nibble from accu");
3547: I(0,orb, DL, CH, "put lower nibble of A into lower nibble of result");
3548: I(0,orb, A, DH, "put upper nibble of result into lower nibble of A");
3549: I(0,lahf, 0, 0, 0);
3550: I(0,andb, F, X(SF|ZF|PF), "mask S, Z and P/V flags");
3551: I(0,orb, F, CL, "combine with C");
3552: I(0,movzbl, EDX, DL, "EDX = result");
3553: WBYTE( 2, HL32, EDX );
3554: }
3555:
3556: void M_RRD( void )
3557: {
3558: RBYTE( 2, EDX, HL32 );
3559: I(0,movb, DH, A, "put A into MSB of result");
3560: I(0,rorw, DX, D(4), "DL = result, DH 4..7 = lower nibble of memory");
3561: I(0,movb, CL, F, "save flags");
3562: I(0,shrb, DH, D(4), "DH 0..3 = lower nibble of memory");
3563: I(0,andb, CL, X(CF), "keep C flag");
3564: I(0,andb, A, X(0xf0), "keep upper nibble of A");
3565: I(0,orb, A, DH, "set lower nibble from memory");
3566: I(0,lahf, 0, 0, 0);
3567: I(0,andb, F, X(SF|ZF|PF), "mask S, Z and P/V flags");
3568: I(0,orb, F, CL, "combine flags");
3569: I(0,movzbl, EDX, DL, "EDX = result");
3570: WBYTE( 2, HL32, EDX );
3571: }
3572:
3573: const char *s(char *fmt, ...)
3574: {
3575: va_list arg;
3576: static char buffer[128];
3577: va_start(arg, fmt);
3578: vsprintf(buffer, fmt, arg);
3579: va_end(arg);
3580: return buffer;
3581: }
3582:
3583: void mk_opcodes(int op_base)
3584: {
3585: char op[32];
3586: char hl[2+1], h[2+1], l[2+1], m[8+1];
3587: char zhl[32+1], zh[32+1], zl[32+1], zhl32[32+1];
3588: int mc = 0, mi = 0, mr = 0;
3589:
3590: if (op_base == 0xdd00) {
3591: strcpy(op,"dd_%02x"); /* opcode label mask */
3592: strcpy(hl,"IX"); /* word register name */
3593: strcpy(h,"HX"); /* MSB byte register name */
3594: strcpy(l,"LX"); /* LSB byte register name */
3595: strcpy(m,"(IX+ofs8)"); /* memory register name */
3596: strcpy(zh,zHX); /* MSB byte register */
3597: strcpy(zl,zLX); /* LSB byte register */
3598: strcpy(zhl,zIX); /* word register */
3599: strcpy(zhl32,zIX32); /* dword register */
3600: mc = 8; /* additional cycles for r/w (IX+ofs8) */
3601: mi = 5; /* additional cycles for w (IX+ofs8),imm8 */
3602: mr = 1; /* additional cycles for accessing IXL/IXH */
3603: } else
3604: if (op_base == 0xfd00) {
3605: strcpy(op,"fd_%02x"); /* opcode label mask */
3606: strcpy(hl,"IY"); /* word register name */
3607: strcpy(h,"HY"); /* MSB byte register name */
3608: strcpy(l,"LY"); /* LSB byte register name */
3609: strcpy(m,"(IY+ofs8)"); /* memory register name */
3610: strcpy(zh,zHY); /* MSB byte register */
3611: strcpy(zl,zLY); /* LSB byte register */
3612: strcpy(zhl,zIY); /* word register */
3613: strcpy(zhl32,zIY32); /* dword register */
3614: mc = 8; /* additional cycles for r/w (IY+ofs8) */
3615: mi = 5; /* additional cycles for w (IY+ofs8),imm8 */
3616: mr = 1; /* additional cycles for accessing IXL/IXH */
3617: } else {
3618: strcpy(op,"op_%02x"); /* opcode label mask */
3619: strcpy(hl,"HL"); /* word register name */
3620: strcpy(h,"H"); /* MSB byte register name */
3621: strcpy(l,"L"); /* LSB byte register name */
3622: strcpy(m,"(HL)"); /* memory register name */
3623: strcpy(zh,H); /* MSB byte register */
3624: strcpy(zl,L); /* LSB byte register */
3625: strcpy(zhl,HL); /* word register */
3626: strcpy(zhl32,HL32); /* dword register */
3627: }
3628:
3629: beg_opcode( 4,s(op,0x00),"NOP");
3630: end_opcode("z_op");
3631:
3632: beg_opcode( 4,s(op,0x08),"EX AF,AF'");
3633: M_EX_AF_AF2();
3634: end_opcode("z_op");
3635:
3636: beg_opcode( 8,s(op,0x10),"DJNZ ofs8");
3637: M_DJNZ( op_base|0x10 );
3638: end_opcode("z_op");
3639:
3640: beg_opcode(12,s(op,0x18),"JR ofs8");
3641: M_JR( op_base|0x18 );
3642: end_opcode("z_op");
3643:
3644: beg_opcode( 7,s(op,0x20),"JR NZ,ofs8");
3645: M_JR_CC( op_base|0x20, ZF );
3646: end_opcode("z_op");
3647:
3648: beg_opcode( 7,s(op,0x28),"JR Z,ofs8");
3649: M_JR_CC( op_base|0x28, ZF );
3650: end_opcode("z_op");
3651:
3652: beg_opcode( 7,s(op,0x30),"JR NC,ofs8");
3653: M_JR_CC( op_base|0x30, CF );
3654: end_opcode("z_op");
3655:
3656: beg_opcode( 7,s(op,0x38),"JR C,ofs8");
3657: M_JR_CC( op_base|0x38, CF );
3658: end_opcode("z_op");
3659:
3660: /*********/
3661:
3662: beg_opcode(10,s(op,0x01),"LD BC,imm16");
3663: ARG16( zBC32 );
3664: end_opcode("z_op");
3665:
3666: beg_opcode(10,s(op,0x11),"LD DE,imm16");
3667: ARG16( zDE32 );
3668: end_opcode("z_op");
3669:
3670: beg_opcode(10,s(op,0x21),"LD %s,imm16",hl);
3671: ARG16( zhl32 );
3672: end_opcode("z_op");
3673:
3674: beg_opcode(10,s(op,0x31),"LD SP,imm16");
3675: ARG16( zSP32 );
3676: end_opcode("z_op");
3677:
3678: /*********/
3679:
3680: beg_opcode(11,s(op,0x09),"ADD %s,BC",hl);
3681: M_ADD16( zhl, zBC );
3682: end_opcode("z_op");
3683:
3684: beg_opcode(11,s(op,0x19),"ADD %s,DE",hl);
3685: M_ADD16( zhl, zDE );
3686: end_opcode("z_op");
3687:
3688: beg_opcode(11,s(op,0x29),"ADD %s,%s",hl,hl);
3689: M_ADD16( zhl, zhl );
3690: end_opcode("z_op");
3691:
3692: beg_opcode(11,s(op,0x39),"ADD %s,SP",hl);
3693: M_ADD16( zhl, zSP );
3694: end_opcode("z_op");
3695:
3696: /*********/
3697:
3698: beg_opcode( 7,s(op,0x02),"LD (BC),A");
3699: I(0,movzbl, EDX, A, 0);
3700: WBYTE( 1, zBC32, EDX );
3701: end_opcode("z_op");
3702:
3703: beg_opcode( 7,s(op,0x0a),"LD A,(BC)");
3704: RBYTE( 1, EDX, zBC32 );
3705: I(0,movb, A, DL, 0);
3706: end_opcode("z_op");
3707:
3708: beg_opcode( 7,s(op,0x12),"LD (DE),A");
3709: I(0,movzbl, EDX, A, 0);
3710: WBYTE( 1, zDE32, EDX );
3711: end_opcode("z_op");
3712:
3713: beg_opcode( 7,s(op,0x1a),"LD A,(DE)");
3714: RBYTE( 1, EDX, zDE32 );
3715: I(0,movb, A, DL, 0);
3716: end_opcode("z_op");
3717:
3718: beg_opcode(16,s(op,0x22),"LD (imm16),%s",hl);
3719: ARG16( EBP );
3720: WWORD( (op_base)?4:3, EBP, zhl32 );
3721: end_opcode("z_op");
3722:
3723: beg_opcode(16,s(op,0x2a),"LD %s,(imm16)",hl);
3724: ARG16( EBP );
3725: RWORD( (op_base)?4:3, zhl32, EBP );
3726: end_opcode("z_op");
3727:
3728: beg_opcode(13,s(op,0x32),"LD (imm16),A");
3729: ARG16( EBP );
3730: I(0,movzbl, EDX, A, 0);
3731: WBYTE( 3, EBP, EDX );
3732: end_opcode("z_op");
3733:
3734: beg_opcode(13,s(op,0x3a),"LD A,(imm16)");
3735: ARG16( EBP );
3736: RBYTE( 3, EDX, EBP );
3737: I(0,movb, A, DL, 0);
3738: end_opcode("z_op");
3739:
3740: /*********/
3741:
3742: beg_opcode( 6,s(op,0x03),"INC BC");
3743: I(0,incw, zBC, 0, 0);
3744: end_opcode("z_op");
3745:
3746: beg_opcode( 6,s(op,0x0b),"DEC BC");
3747: I(0,decw, zBC, 0, 0);
3748: end_opcode("z_op");
3749:
3750: beg_opcode( 6,s(op,0x13),"INC DE");
3751: I(0,incw, zDE, 0, 0);
3752: end_opcode("z_op");
3753:
3754: beg_opcode( 6,s(op,0x1b),"DEC DE");
3755: I(0,decw, zDE, 0, 0);
3756: end_opcode("z_op");
3757:
3758: beg_opcode( 6,s(op,0x23),"INC %s",hl);
3759: I(0,incw, zhl, 0, 0);
3760: end_opcode("z_op");
3761:
3762: beg_opcode( 6,s(op,0x2b),"DEC %s",hl);
3763: I(0,decw, zhl, 0, 0);
3764: end_opcode("z_op");
3765:
3766: beg_opcode( 6,s(op,0x33),"INC SP");
3767: I(0,incw, zSP, 0, 0);
3768: end_opcode("z_op");
3769:
3770: beg_opcode( 6, s(op,0x3b),"DEC SP");
3771: I(0,decw, zSP, 0, 0);
3772: end_opcode("z_op");
3773:
3774: /*********/
3775:
3776: beg_opcode( 4,s(op,0x04),"INC B");
3777: M_INC( zB );
3778: end_opcode("z_op");
3779:
3780: beg_opcode( 4,s(op,0x0c),"INC C");
3781: M_INC( zC );
3782: end_opcode("z_op");
3783:
3784: beg_opcode( 4,s(op,0x14),"INC D");
3785: M_INC( zD );
3786: end_opcode("z_op");
3787:
3788: beg_opcode( 4,s(op,0x1c),"INC E");
3789: M_INC( zE );
3790: end_opcode("z_op");
3791:
3792: beg_opcode( 4+mr,s(op,0x24),"INC %s",h);
3793: M_INC( zh );
3794: end_opcode("z_op");
3795:
3796: beg_opcode( 4+mr,s(op,0x2c),"INC %s",l);
3797: M_INC( zl );
3798: end_opcode("z_op");
3799:
3800: beg_opcode(11+mc,s(op,0x34),"INC %s",m);
3801: if (op_base) {
3802: OFS( zhl32 );
3803: RBYTE( 3, EDX, EBP );
3804: M_INC( DL );
3805: WBYTE( 3, EBP, EDX );
3806: } else {
3807: RBYTE( 1, EDX, HL32 );
3808: M_INC( DL );
3809: WBYTE( 1, HL32, EDX );
3810: }
3811: end_opcode("z_op");
3812:
3813: beg_opcode( 4,s(op,0x3c),"INC A");
3814: M_INC( A );
3815: end_opcode("z_op");
3816:
3817: /*********/
3818:
3819: beg_opcode( 4,s(op,0x05),"DEC B");
3820: M_DEC( zB );
3821: end_opcode("z_op");
3822:
3823: beg_opcode( 4,s(op,0x0d),"DEC C");
3824: M_DEC( zC );
3825: end_opcode("z_op");
3826:
3827: beg_opcode( 4,s(op,0x15),"DEC D");
3828: M_DEC( zD );
3829: end_opcode("z_op");
3830:
3831: beg_opcode( 4,s(op,0x1d),"DEC E");
3832: M_DEC( zE );
3833: end_opcode("z_op");
3834:
3835: beg_opcode( 4+mr,s(op,0x25),"DEC %s",h);
3836: M_DEC( zh );
3837: end_opcode("z_op");
3838:
3839: beg_opcode( 4+mr,s(op,0x2d),"DEC %s",l);
3840: M_DEC( zl );
3841: end_opcode("z_op");
3842:
3843: beg_opcode(11+mc,s(op,0x35),"DEC %s",m);
3844: if (op_base) {
3845: OFS( zhl32 );
3846: RBYTE( 3, EDX, EBP );
3847: M_DEC( DL );
3848: WBYTE( 3, EBP, EDX );
3849: } else {
3850: RBYTE( 1, EDX, HL32 );
3851: M_DEC( DL );
3852: WBYTE( 1, HL32, EDX );
3853: }
3854: end_opcode("z_op");
3855:
3856: beg_opcode( 4,s(op,0x3d),"DEC A");
3857: M_DEC( A );
3858: end_opcode("z_op");
3859:
3860: /*********/
3861:
3862: beg_opcode( 7,s(op,0x06),"LD B,imm8");
3863: ARG( CL );
3864: I(0,movb, zB, CL, 0);
3865: end_opcode("z_op");
3866:
3867: beg_opcode( 7,s(op,0x0e),"LD C,imm8");
3868: ARG( CL );
3869: I(0,movb, zC, CL, 0);
3870: end_opcode("z_op");
3871:
3872: beg_opcode( 7,s(op,0x16),"LD D,imm8");
3873: ARG( CL );
3874: I(0,movb, zD, CL, 0);
3875: end_opcode("z_op");
3876:
3877: beg_opcode( 7,s(op,0x1e),"LD E,imm8");
3878: ARG( CL );
3879: I(0,movb, zE, CL, 0);
3880: end_opcode("z_op");
3881:
3882: if ( op_base ) {
3883: beg_opcode( 5,s(op,0x26),"LD %s,imm8",h);
3884: ARG( CL );
3885: I(0,movb, zh, CL, 0);
3886: } else {
3887: beg_opcode( 7,s(op,0x26),"LD %s,imm8",h);
3888: ARG( zh );
3889: }
3890: end_opcode("z_op");
3891:
3892: if ( op_base ) {
3893: beg_opcode( 5,s(op,0x2e),"LD %s,imm8",l);
3894: ARG( CL );
3895: I(0,movb, zl, CL, 0);
3896: } else {
3897: beg_opcode( 7,s(op,0x2e),"LD %s,imm8",l);
3898: ARG( zl );
3899: }
3900: end_opcode("z_op");
3901:
3902: beg_opcode(10+mi,s(op,0x36),"LD %s,imm8",m);
3903: if (op_base) {
3904: OFS( zhl32 );
3905: ARG( EDX );
3906: #if WB_EA4_EDX
3907: I(0,jmp, "wb_ea4_edx",0, 0);
3908: #else
3909: WBYTE( 4, EBP, EDX );
3910: end_opcode("z_op");
3911: #endif
3912: } else {
3913: ARG( EDX );
3914: WBYTE( 2, HL32, EDX );
3915: end_opcode("z_op");
3916: }
3917:
3918: beg_opcode( 7,s(op,0x3e),"LD A,imm8");
3919: ARG( CL );
3920: I(0,movb, A, CL, 0);
3921: end_opcode("z_op");
3922:
3923: /*********/
3924:
3925: beg_opcode( 4,s(op,0x1f),"RRA");
3926: M_RRA();
3927: end_opcode("z_op");
3928:
3929: beg_opcode( 4,s(op,0x07),"RLCA");
3930: M_RLCA();
3931: end_opcode("z_op");
3932:
3933: beg_opcode( 4,s(op,0x0f),"RRCA");
3934: M_RRCA();
3935: end_opcode("z_op");
3936:
3937: beg_opcode( 4,s(op,0x17),"RLA");
3938: M_RLA();
3939: end_opcode("z_op");
3940:
3941: beg_opcode( 4,s(op,0x27),"DAA");
3942: M_DAA( op_base|0x27 );
3943: end_opcode("z_op");
3944:
3945: beg_opcode( 4,s(op,0x2f),"CPL");
3946: M_CPL();
3947: end_opcode("z_op");
3948:
3949: beg_opcode( 4,s(op,0x37),"SCF");
3950: M_SCF();
3951: end_opcode("z_op");
3952:
3953: beg_opcode( 4,s(op,0x3f),"CCF");
3954: M_CCF();
3955: end_opcode("z_op");
3956:
3957: /*********/
3958:
3959: beg_opcode( 4,s(op,0x40),"LD B,B");
3960: MOVB( zB, zB, "B = B" );
3961: end_opcode("z_op");
3962:
3963: beg_opcode( 4,s(op,0x41),"LD B,C");
3964: MOVB( zB, zC, "B = C" );
3965: end_opcode("z_op");
3966:
3967: beg_opcode( 4,s(op,0x42),"LD B,D");
3968: MOVB( zB, zD, "B = D" );
3969: end_opcode("z_op");
3970:
3971: beg_opcode( 4,s(op,0x43),"LD B,E");
3972: MOVB( zB, zE, "B = E" );
3973: end_opcode("z_op");
3974:
3975: beg_opcode( 4+mr,s(op,0x44),"LD B,%s",h);
3976: MOVB( zB, zh, "B = %s", h );
3977: end_opcode("z_op");
3978:
3979: beg_opcode( 4+mr,s(op,0x45),"LD B,%s",l);
3980: MOVB( zB, zl, "B = %s", l );
3981: end_opcode("z_op");
3982:
3983: beg_opcode( 7+mc,s(op,0x46),"LD B,%s",m);
3984: if (op_base) {
3985: OFS( zhl32 );
3986: RBYTE( 3, EDX, EBP );
3987: } else {
3988: RBYTE( 1, EDX, HL32 );
3989: }
3990: MOVB( zB, DL, "B = %s", m );
3991: end_opcode("z_op");
3992:
3993: beg_opcode( 4,s(op,0x47),"LD B,A");
3994: MOVB( zB, A, "B = A" );
3995: end_opcode("z_op");
3996:
3997: /*********/
3998:
3999: beg_opcode( 4,s(op,0x48),"LD C,B");
4000: MOVB( zC, zB, "C = B" );
4001: end_opcode("z_op");
4002:
4003: beg_opcode( 4,s(op,0x49),"LD C,C");
4004: MOVB( zC, zC, "C = C" );
4005: end_opcode("z_op");
4006:
4007: beg_opcode( 4,s(op,0x4a),"LD C,D");
4008: MOVB( zC, zD, "C = D" );
4009: end_opcode("z_op");
4010:
4011: beg_opcode( 4,s(op,0x4b),"LD C,E");
4012: MOVB( zC, zE, "C = E" );
4013: end_opcode("z_op");
4014:
4015: beg_opcode( 4+mr,s(op,0x4c),"LD C,%s",h);
4016: MOVB( zC, zh, "C = %s", h );
4017: end_opcode("z_op");
4018:
4019: beg_opcode( 4+mr,s(op,0x4d),"LD C,%s",l);
4020: MOVB( zC, zl, "C = %s", l );
4021: end_opcode("z_op");
4022:
4023: beg_opcode( 7+mc,s(op,0x4e),"LD C,%s",m);
4024: if (op_base) {
4025: OFS( zhl32 );
4026: RBYTE( 3, EDX, EBP );
4027: } else {
4028: RBYTE( 1, EDX, HL32 );
4029: }
4030: MOVB( zC, DL, "C = %s", m );
4031: end_opcode("z_op");
4032:
4033: beg_opcode( 4,s(op,0x4f),"LD C,A");
4034: MOVB( zC, A, "C = A" );
4035: end_opcode("z_op");
4036:
4037: /*********/
4038:
4039: beg_opcode( 4,s(op,0x50),"LD D,B");
4040: MOVB( zD, zB, "D = B" );
4041: end_opcode("z_op");
4042:
4043: beg_opcode( 4,s(op,0x51),"LD D,C");
4044: MOVB( zD, zC, "D = C" );
4045: end_opcode("z_op");
4046:
4047: beg_opcode( 4,s(op,0x52),"LD D,D");
4048: MOVB( zD, zD, "D = D" );
4049: end_opcode("z_op");
4050:
4051: beg_opcode( 4,s(op,0x53),"LD D,E");
4052: MOVB( zD, zE, "D = E" );
4053: end_opcode("z_op");
4054:
4055: beg_opcode( 4+mr,s(op,0x54),"LD D,%s",h);
4056: MOVB( zD, zh, "D = %s", h );
4057: end_opcode("z_op");
4058:
4059: beg_opcode( 4+mr,s(op,0x55),"LD D,%s",l);
4060: MOVB( zD, zl, "D = %s", l );
4061: end_opcode("z_op");
4062:
4063: beg_opcode( 7+mc,s(op,0x56),"LD D,%s",m);
4064: if (op_base) {
4065: OFS( zhl32 );
4066: RBYTE( 3, EDX, EBP );
4067: } else {
4068: RBYTE( 1, EDX, HL32 );
4069: }
4070: MOVB( zD, DL, "D = %s", m );
4071: end_opcode("z_op");
4072:
4073: beg_opcode( 4,s(op,0x57),"LD D,A");
4074: MOVB( zD, A, "D = A" );
4075: end_opcode("z_op");
4076:
4077: /*********/
4078:
4079: beg_opcode( 4,s(op,0x58),"LD E,B");
4080: MOVB( zE, zB, "E = B" );
4081: end_opcode("z_op");
4082:
4083: beg_opcode( 4,s(op,0x59),"LD E,C");
4084: MOVB( zE, zC, "E = C" );
4085: end_opcode("z_op");
4086:
4087: beg_opcode( 4,s(op,0x5a),"LD E,D");
4088: MOVB( zE, zD, "E = D" );
4089: end_opcode("z_op");
4090:
4091: beg_opcode( 4,s(op,0x5b),"LD E,E");
4092: MOVB( zE, zE, "E = E" );
4093: end_opcode("z_op");
4094:
4095: beg_opcode( 4+mr,s(op,0x5c),"LD E,%s",h);
4096: MOVB( zE, zh, "E = %s", h );
4097: end_opcode("z_op");
4098:
4099: beg_opcode( 4+mr,s(op,0x5d),"LD E,%s",l);
4100: MOVB( zE, zl, "E = %s", l );
4101: end_opcode("z_op");
4102:
4103: beg_opcode( 7+mc,s(op,0x5e),"LD E,%s",m);
4104: if (op_base) {
4105: OFS( zhl32 );
4106: RBYTE( 3, EDX, EBP );
4107: } else {
4108: RBYTE( 1, EDX, HL32 );
4109: }
4110: MOVB( zE, DL, "E = %s", m );
4111: end_opcode("z_op");
4112:
4113: beg_opcode( 4,s(op,0x5f),"LD E,A");
4114: MOVB( zE, A, "E = A" );
4115: end_opcode("z_op");
4116:
4117: /*********/
4118:
4119: beg_opcode( 4+mr,s(op,0x60),"LD %s,B",h);
4120: MOVB( zh, zB, "%s = B", h );
4121: end_opcode("z_op");
4122:
4123: beg_opcode( 4+mr,s(op,0x61),"LD %s,C",h);
4124: MOVB( zh, zC, "%s = C", h );
4125: end_opcode("z_op");
4126:
4127: beg_opcode( 4+mr,s(op,0x62),"LD %s,D",h);
4128: MOVB( zh, zD, "%s = D", h );
4129: end_opcode("z_op");
4130:
4131: beg_opcode( 4+mr,s(op,0x63),"LD %s,E",h);
4132: MOVB( zh, zE, "%s = E", h );
4133: end_opcode("z_op");
4134:
4135: beg_opcode( 4+mr,s(op,0x64),"LD %s,%s",h,h);
4136: MOVB( zh, zh, "%s = %s", h, h );
4137: end_opcode("z_op");
4138:
4139: beg_opcode( 4+mr,s(op,0x65),"LD %s,%s",h,l);
4140: MOVB( zh, zl, "%s = %s", h, l );
4141: end_opcode("z_op");
4142:
4143: beg_opcode( 7+mc,s(op,0x66),"LD H,%s",m);
4144: if (op_base) {
4145: OFS( zhl32 );
4146: RBYTE( 3, EDX, EBP );
4147: } else {
4148: RBYTE( 1, EDX, HL32 );
4149: }
4150: MOVB( H, DL, "H = %s", m );
4151: end_opcode("z_op");
4152:
4153: beg_opcode( 4+mr,s(op,0x67),"LD %s,A",h);
4154: MOVB( zh, A, "%s = A", h );
4155: end_opcode("z_op");
4156:
4157: /*********/
4158:
4159: beg_opcode( 4+mr,s(op,0x68),"LD %s,B",l);
4160: MOVB( zl, zB, "%s = B", l );
4161: end_opcode("z_op");
4162:
4163: beg_opcode( 4+mr,s(op,0x69),"LD %s,C",l);
4164: MOVB( zl, zC, "%s = C", l );
4165: end_opcode("z_op");
4166:
4167: beg_opcode( 4+mr,s(op,0x6a),"LD %s,D",l);
4168: MOVB( zl, zD, "%s = D", l );
4169: end_opcode("z_op");
4170:
4171: beg_opcode( 4+mr,s(op,0x6b),"LD %s,E",l);
4172: MOVB( zl, zE, "%s = E", l );
4173: end_opcode("z_op");
4174:
4175: beg_opcode( 4+mr,s(op,0x6c),"LD %s,%s",l,h);
4176: MOVB( zl, zh, "%s = %s", l, h );
4177: end_opcode("z_op");
4178:
4179: beg_opcode( 4+mr,s(op,0x6d),"LD %s,%s",l,l);
4180: MOVB( zl, zl, "%s = %s", l, l );
4181: end_opcode("z_op");
4182:
4183: beg_opcode( 7+mc,s(op,0x6e),"LD L,%s",m);
4184: if (op_base) {
4185: OFS( zhl32 );
4186: RBYTE( 3, EDX, EBP );
4187: } else {
4188: RBYTE( 1, EDX, HL32 );
4189: }
4190: MOVB( L, DL, "L = %s", m );
4191: end_opcode("z_op");
4192:
4193: beg_opcode( 4+mr,s(op,0x6f),"LD %s,A",l);
4194: MOVB( zl, A, "%s = A", l );
4195: end_opcode("z_op");
4196:
4197: /*********/
4198:
4199: beg_opcode( 7+mc,s(op,0x70),"LD %s,B",m);
4200: MOVB( EDX, zB, "%s = B", m );
4201: if (op_base) {
4202: OFS( zhl32 );
4203: WBYTE( 3, EBP, EDX );
4204: } else {
4205: WBYTE( 1, HL32, EDX );
4206: }
4207: end_opcode("z_op");
4208:
4209: beg_opcode( 7+mc,s(op,0x71),"LD %s,C",m);
4210: MOVB( EDX, zC, "%s = C", m );
4211: if (op_base) {
4212: OFS( zhl32 );
4213: WBYTE( 3, EBP, EDX );
4214: } else {
4215: WBYTE( 1, HL32, EDX );
4216: }
4217: end_opcode("z_op");
4218:
4219: beg_opcode( 7+mc,s(op,0x72),"LD %s,D",m);
4220: MOVB( EDX, zD, "%s = D", m );
4221: if (op_base) {
4222: OFS( zhl32 );
4223: WBYTE( 3, EBP, EDX );
4224: } else {
4225: WBYTE( 1, HL32, EDX );
4226: }
4227: end_opcode("z_op");
4228:
4229: beg_opcode( 7+mc,s(op,0x73),"LD %s,E",m);
4230: MOVB( EDX, zE, "%s = E", m );
4231: if (op_base) {
4232: OFS( zhl32 );
4233: WBYTE( 3, EBP, EDX );
4234: } else {
4235: WBYTE( 1, HL32, EDX );
4236: }
4237: end_opcode("z_op");
4238:
4239: beg_opcode( 7+mc,s(op,0x74),"LD %s,H",m);
4240: MOVB( EDX, H, "%s = H", m );
4241: if (op_base) {
4242: OFS( zhl32 );
4243: WBYTE( 3, EBP, EDX );
4244: } else {
4245: WBYTE( 1, HL32, EDX );
4246: }
4247: end_opcode("z_op");
4248:
4249: beg_opcode( 7+mc,s(op,0x75),"LD %s,L",m);
4250: MOVB( EDX, L, "%s = L", m );
4251: if (op_base) {
4252: OFS( zhl32 );
4253: WBYTE( 3, EBP, EDX );
4254: } else {
4255: WBYTE( 1, HL32, EDX );
4256: }
4257: end_opcode("z_op");
4258:
4259: beg_opcode( 4,s(op,0x76),"HALT");
4260: M_HALT( op_base|0x76 );
4261: end_opcode("z_op");
4262:
4263: beg_opcode( 7+mc,s(op,0x77),"LD %s,A",m);
4264: MOVB( EDX, A, "%s = A", m );
4265: if (op_base) {
4266: OFS( zhl32 );
4267: WBYTE( 3, EBP, EDX );
4268: } else {
4269: WBYTE( 1, HL32, EDX );
4270: }
4271: end_opcode("z_op");
4272:
4273: /*********/
4274:
4275: beg_opcode( 4,s(op,0x78),"LD A,B");
4276: MOVB( A, zB, "A = B" );
4277: end_opcode("z_op");
4278:
4279: beg_opcode( 4,s(op,0x79),"LD A,C");
4280: MOVB( A, zC, "A = C" );
4281: end_opcode("z_op");
4282:
4283: beg_opcode( 4,s(op,0x7a),"LD A,D");
4284: MOVB( A, zD, "A = D" );
4285: end_opcode("z_op");
4286:
4287: beg_opcode( 4,s(op,0x7b),"LD A,E");
4288: MOVB( A, zE, "A = E" );
4289: end_opcode("z_op");
4290:
4291: beg_opcode( 4+mr,s(op,0x7c),"LD A,%s",h);
4292: MOVB( A, zh, "A = %s", h );
4293: end_opcode("z_op");
4294:
4295: beg_opcode( 4+mr,s(op,0x7d),"LD A,%s",l);
4296: MOVB( A, zl, "A = %s", l );
4297: end_opcode("z_op");
4298:
4299: beg_opcode( 7+mc,s(op,0x7e),"LD A,%s",m);
4300: if (op_base) {
4301: OFS( zhl32 );
4302: RBYTE( 3, EDX, EBP );
4303: } else {
4304: RBYTE( 1, EDX, HL32 );
4305: }
4306: MOVB( A, DL, "A = %s", m );
4307: end_opcode("z_op");
4308:
4309: beg_opcode( 4,s(op,0x7f),"LD A,A");
4310: MOVB( A, A, "A = A" );
4311: end_opcode("z_op");
4312:
4313: /*********/
4314:
4315: beg_opcode( 4,s(op,0x80),"ADD A,B");
4316: M_ADD( zB );
4317: end_opcode("z_op");
4318:
4319: beg_opcode( 4,s(op,0x81),"ADD A,C");
4320: M_ADD( zC );
4321: end_opcode("z_op");
4322:
4323: beg_opcode( 4,s(op,0x82),"ADD A,D");
4324: M_ADD( zD );
4325: end_opcode("z_op");
4326:
4327: beg_opcode( 4,s(op,0x83),"ADD A,E");
4328: M_ADD( zE );
4329: end_opcode("z_op");
4330:
4331: beg_opcode( 4+mr,s(op,0x84),"ADD A,%s",h);
4332: M_ADD( zh );
4333: end_opcode("z_op");
4334:
4335: beg_opcode( 4+mr,s(op,0x85),"ADD A,%s",l);
4336: M_ADD( zl );
4337: end_opcode("z_op");
4338:
4339: beg_opcode( 7+mc,s(op,0x86),"ADD A,%s",m);
4340: if (op_base) {
4341: OFS( zhl32 );
4342: RBYTE( 3, EDX, EBP );
4343: } else {
4344: RBYTE( 1, EDX, HL32 );
4345: }
4346: M_ADD( DL );
4347: end_opcode("z_op");
4348:
4349: beg_opcode( 4,s(op,0x87),"ADD A,A");
4350: M_ADD( A );
4351: end_opcode("z_op");
4352:
4353: /*********/
4354:
4355: beg_opcode( 4,s(op,0x88),"ADC A,B");
4356: M_ADC( zB );
4357: end_opcode("z_op");
4358:
4359: beg_opcode( 4,s(op,0x89),"ADC A,C");
4360: M_ADC( zC );
4361: end_opcode("z_op");
4362:
4363: beg_opcode( 4,s(op,0x8a),"ADC A,D");
4364: M_ADC( zD );
4365: end_opcode("z_op");
4366:
4367: beg_opcode( 4,s(op,0x8b),"ADC A,E");
4368: M_ADC( zE );
4369: end_opcode("z_op");
4370:
4371: beg_opcode( 4+mr,s(op,0x8c),"ADC A,%s",h);
4372: M_ADC( zh );
4373: end_opcode("z_op");
4374:
4375: beg_opcode( 4+mr,s(op,0x8d),"ADC A,%s",l);
4376: M_ADC( zl );
4377: end_opcode("z_op");
4378:
4379: beg_opcode( 7+mc,s(op,0x8e),"ADC A,%s",m);
4380: if (op_base) {
4381: OFS( zhl32 );
4382: RBYTE( 3, EDX, EBP );
4383: } else {
4384: RBYTE( 1, EDX, HL32 );
4385: }
4386: M_ADC( DL );
4387: end_opcode("z_op");
4388:
4389: beg_opcode( 4,s(op,0x8f),"ADC A,A");
4390: M_ADC( A );
4391: end_opcode("z_op");
4392:
4393: /*********/
4394:
4395: beg_opcode( 4,s(op,0x90),"SUB B");
4396: M_SUB( zB );
4397: end_opcode("z_op");
4398:
4399: beg_opcode( 4,s(op,0x91),"SUB C");
4400: M_SUB( zC );
4401: end_opcode("z_op");
4402:
4403: beg_opcode( 4,s(op,0x92),"SUB D");
4404: M_SUB( zD );
4405: end_opcode("z_op");
4406:
4407: beg_opcode( 4,s(op,0x93),"SUB E");
4408: M_SUB( zE );
4409: end_opcode("z_op");
4410:
4411: beg_opcode( 4+mr,s(op,0x94),"SUB %s",h);
4412: M_SUB( zh );
4413: end_opcode("z_op");
4414:
4415: beg_opcode( 4+mr,s(op,0x95),"SUB %s",l);
4416: M_SUB( zl );
4417: end_opcode("z_op");
4418:
4419: beg_opcode( 7+mc,s(op,0x96),"SUB %s",m);
4420: if (op_base) {
4421: OFS( zhl32 );
4422: RBYTE( 3, EDX, EBP );
4423: } else {
4424: RBYTE( 1, EDX, HL32 );
4425: }
4426: M_SUB( DL );
4427: end_opcode("z_op");
4428:
4429: beg_opcode( 4,s(op,0x97),"SUB A");
4430: M_SUB( A );
4431: end_opcode("z_op");
4432:
4433: /*********/
4434:
4435: beg_opcode( 4,s(op,0x98),"SBC A,B");
4436: M_SBC( zB );
4437: end_opcode("z_op");
4438:
4439: beg_opcode( 4,s(op,0x99),"SBC A,C");
4440: M_SBC( zC );
4441: end_opcode("z_op");
4442:
4443: beg_opcode( 4,s(op,0x9a),"SBC A,D");
4444: M_SBC( zD );
4445: end_opcode("z_op");
4446:
4447: beg_opcode( 4,s(op,0x9b),"SBC A,E");
4448: M_SBC( zE );
4449: end_opcode("z_op");
4450:
4451: beg_opcode( 4+mr,s(op,0x9c),"SBC A,%s",h);
4452: M_SBC( zh );
4453: end_opcode("z_op");
4454:
4455: beg_opcode( 4+mr,s(op,0x9d),"SBC A,%s",l);
4456: M_SBC( zl );
4457: end_opcode("z_op");
4458:
4459: beg_opcode( 7+mc,s(op,0x9e),"SBC A,%s",m);
4460: if (op_base) {
4461: OFS( zhl32 );
4462: RBYTE( 3, EDX, EBP );
4463: } else {
4464: RBYTE( 1, EDX, HL32 );
4465: }
4466: M_SBC( DL );
4467: end_opcode("z_op");
4468:
4469: beg_opcode( 4,s(op,0x9f),"SBC A,A");
4470: M_SBC( A );
4471: end_opcode("z_op");
4472:
4473: /*********/
4474:
4475: beg_opcode( 4,s(op,0xa0),"AND B");
4476: M_AND( zB );
4477: end_opcode("z_op");
4478:
4479: beg_opcode( 4,s(op,0xa1),"AND C");
4480: M_AND( zC );
4481: end_opcode("z_op");
4482:
4483: beg_opcode( 4,s(op,0xa2),"AND D");
4484: M_AND( zD );
4485: end_opcode("z_op");
4486:
4487: beg_opcode( 4,s(op,0xa3),"AND E");
4488: M_AND( zE );
4489: end_opcode("z_op");
4490:
4491: beg_opcode( 4+mr,s(op,0xa4),"AND %s",h);
4492: M_AND( zh );
4493: end_opcode("z_op");
4494:
4495: beg_opcode( 4+mr,s(op,0xa5),"AND %s",l);
4496: M_AND( zl );
4497: end_opcode("z_op");
4498:
4499: beg_opcode( 7+mc,s(op,0xa6),"AND %s",m);
4500: if (op_base) {
4501: OFS( zhl32 );
4502: RBYTE( 3, EDX, EBP );
4503: } else {
4504: RBYTE( 1, EDX, HL32 );
4505: }
4506: M_AND( DL );
4507: end_opcode("z_op");
4508:
4509: beg_opcode( 4,s(op,0xa7),"AND A");
4510: M_AND( A );
4511: end_opcode("z_op");
4512:
4513: /*********/
4514:
4515: beg_opcode( 4,s(op,0xa8),"XOR B");
4516: M_XOR( zB );
4517: end_opcode("z_op");
4518:
4519: beg_opcode( 4,s(op,0xa9),"XOR C");
4520: M_XOR( zC );
4521: end_opcode("z_op");
4522:
4523: beg_opcode( 4,s(op,0xaa),"XOR D");
4524: M_XOR( zD );
4525: end_opcode("z_op");
4526:
4527: beg_opcode( 4,s(op,0xab),"XOR E");
4528: M_XOR( zE );
4529: end_opcode("z_op");
4530:
4531: beg_opcode( 4+mr,s(op,0xac),"XOR %s",h);
4532: M_XOR( zh );
4533: end_opcode("z_op");
4534:
4535: beg_opcode( 4+mr,s(op,0xad),"XOR %s",l);
4536: M_XOR( zl );
4537: end_opcode("z_op");
4538:
4539: beg_opcode( 7+mc,s(op,0xae),"XOR %s",m);
4540: if (op_base) {
4541: OFS( zhl32 );
4542: RBYTE( 3, EDX, EBP );
4543: } else {
4544: RBYTE( 1, EDX, HL32 );
4545: }
4546: M_XOR( DL );
4547: end_opcode("z_op");
4548:
4549: beg_opcode( 4,s(op,0xaf),"XOR A");
4550: M_XOR( A );
4551: end_opcode("z_op");
4552:
4553: /*********/
4554:
4555: beg_opcode( 4,s(op,0xb0),"OR B");
4556: M_OR( zB );
4557: end_opcode("z_op");
4558:
4559: beg_opcode( 4,s(op,0xb1),"OR C");
4560: M_OR( zC );
4561: end_opcode("z_op");
4562:
4563: beg_opcode( 4,s(op,0xb2),"OR D");
4564: M_OR( zD );
4565: end_opcode("z_op");
4566:
4567: beg_opcode( 4,s(op,0xb3),"OR E");
4568: M_OR( zE );
4569: end_opcode("z_op");
4570:
4571: beg_opcode( 4+mr,s(op,0xb4),"OR %s",h);
4572: M_OR( zh );
4573: end_opcode("z_op");
4574:
4575: beg_opcode( 4+mr,s(op,0xb5),"OR %s",l);
4576: M_OR( zl );
4577: end_opcode("z_op");
4578:
4579: beg_opcode( 7+mc,s(op,0xb6),"OR %s",m);
4580: if (op_base) {
4581: OFS( zhl32 );
4582: RBYTE( 3, EDX, EBP );
4583: } else {
4584: RBYTE( 1, EDX, HL32 );
4585: }
4586: M_OR( DL );
4587: end_opcode("z_op");
4588:
4589: beg_opcode( 4,s(op,0xb7),"OR A");
4590: M_OR( A );
4591: end_opcode("z_op");
4592:
4593: /*********/
4594:
4595: beg_opcode( 4,s(op,0xb8),"CP B");
4596: M_CP( zB );
4597: end_opcode("z_op");
4598:
4599: beg_opcode( 4,s(op,0xb9),"CP C");
4600: M_CP( zC );
4601: end_opcode("z_op");
4602:
4603: beg_opcode( 4,s(op,0xba),"CP D");
4604: M_CP( zD );
4605: end_opcode("z_op");
4606:
4607: beg_opcode( 4,s(op,0xbb),"CP E");
4608: M_CP( zE );
4609: end_opcode("z_op");
4610:
4611: beg_opcode( 4+mr,s(op,0xbc),"CP %s",h);
4612: M_CP( zh );
4613: end_opcode("z_op");
4614:
4615: beg_opcode( 4+mr,s(op,0xbd),"CP %s",l);
4616: M_CP( zl );
4617: end_opcode("z_op");
4618:
4619: beg_opcode( 7+mc,s(op,0xbe),"CP %s",m);
4620: if (op_base) {
4621: OFS( zhl32 );
4622: RBYTE( 3, EDX, EBP );
4623: } else {
4624: RBYTE( 1, EDX, HL32 );
4625: }
4626: M_CP( DL );
4627: end_opcode("z_op");
4628:
4629: beg_opcode( 4,s(op,0xbf),"CP A");
4630: M_CP( A );
4631: end_opcode("z_op");
4632:
4633: /*********/
4634:
4635: beg_opcode( 5,s(op,0xc0),"RET NZ");
4636: M_RET_CC( op_base|0xc0 );
4637: end_opcode("z_op");
4638:
4639: beg_opcode( 5,s(op,0xc8),"RET Z");
4640: M_RET_CC( op_base|0xc8 );
4641: end_opcode("z_op");
4642:
4643: beg_opcode( 5,s(op,0xd0),"RET NC");
4644: M_RET_CC( op_base|0xd0 );
4645: end_opcode("z_op");
4646:
4647: beg_opcode( 5,s(op,0xd8),"RET C");
4648: M_RET_CC( op_base|0xd8 );
4649: end_opcode("z_op");
4650:
4651: beg_opcode( 5,s(op,0xe0),"RET PE");
4652: M_RET_CC( op_base|0xe0 );
4653: end_opcode("z_op");
4654:
4655: beg_opcode( 5,s(op,0xe8),"RET PO");
4656: M_RET_CC( op_base|0xe8 );
4657: end_opcode("z_op");
4658:
4659: beg_opcode( 5,s(op,0xf0),"RET P");
4660: M_RET_CC( op_base|0xf0 );
4661: end_opcode("z_op");
4662:
4663: beg_opcode( 5,s(op,0xf8),"RET M");
4664: M_RET_CC( op_base|0xf8 );
4665: end_opcode("z_op");
4666:
4667: /*********/
4668:
4669: beg_opcode(10,s(op,0xc1),"POP BC");
4670: POP( 1, zBC32 );
4671: end_opcode("z_op");
4672:
4673: beg_opcode(10,s(op,0xd1),"POP DE");
4674: POP( 1, zDE32 );
4675: end_opcode("z_op");
4676:
4677: beg_opcode(10,s(op,0xe1),"POP %s",hl);
4678: POP( (op_base)?2:1, zhl32 );
4679: end_opcode("z_op");
4680:
4681: beg_opcode(10,s(op,0xf1),"POP AF");
4682: POP( 1, zAF32 );
4683: restore_af();
4684: end_opcode("z_op");
4685:
4686: beg_opcode(11,s(op,0xc5),"PUSH BC");
4687: PUSH( 1, zBC32 );
4688: end_opcode("z_op");
4689:
4690: beg_opcode(11,s(op,0xd5),"PUSH DE");
4691: PUSH( 1, zDE32 );
4692: end_opcode("z_op");
4693:
4694: beg_opcode(11,s(op,0xe5),"PUSH %s",hl);
4695: PUSH( (op_base)?2:1, zhl32 );
4696: end_opcode("z_op");
4697:
4698: beg_opcode(11,s(op,0xf5),"PUSH AF");
4699: save_af();
4700: PUSH( 1, zAF32 );
4701: end_opcode("z_op");
4702:
4703: /*********/
4704:
4705: beg_opcode(10,s(op,0xc2),"JP NZ,imm16");
4706: M_JP_CC( op_base|0xc2 );
4707: end_opcode("z_op");
4708:
4709: beg_opcode(10,s(op,0xca),"JP Z,imm16");
4710: M_JP_CC( op_base|0xca );
4711: end_opcode("z_op");
4712:
4713: beg_opcode(10,s(op,0xd2),"JP NC,imm16");
4714: M_JP_CC( op_base|0xd2 );
4715: end_opcode("z_op");
4716:
4717: beg_opcode(10,s(op,0xda),"JP C,imm16");
4718: M_JP_CC( op_base|0xda );
4719: end_opcode("z_op");
4720:
4721: beg_opcode(10,s(op,0xe2),"JP PE,imm16");
4722: M_JP_CC( op_base|0xe2 );
4723: end_opcode("z_op");
4724:
4725: beg_opcode(10,s(op,0xea),"JP PO,imm16");
4726: M_JP_CC( op_base|0xea );
4727: end_opcode("z_op");
4728:
4729: beg_opcode(10,s(op,0xf2),"JP P,imm16");
4730: M_JP_CC( op_base|0xf2 );
4731: end_opcode("z_op");
4732:
4733: beg_opcode(10,s(op,0xfa),"JP M,imm16");
4734: M_JP_CC( op_base|0xfa );
4735: end_opcode("z_op");
4736:
4737: /*********/
4738:
4739: beg_opcode(10,s(op,0xc3),"JP imm16");
4740: M_JP( op_base|0xc3 );
4741: end_opcode("z_op");
4742:
4743: if (op_base) {
4744: beg_opcode( 0,s(op,0xcb),"%02x CB <ofs8> xx", op_base >> 8);
4745: OFS( zhl32 );
4746: RBYTE( 3, EDX, EBP );
4747: end_opcode("z_xx");
4748: } else {
4749: beg_opcode( 0,s(op,0xcb),"CB xx");
4750: end_opcode("z_cb");
4751: }
4752:
4753: beg_opcode(11,s(op,0xd3),"OUT (imm8),A");
4754: ARG( ECX );
4755: I(0,movzbl, EDX, A, "value");
4756: I(0,movb, CH, A, "16 bit port A on upper 8 address lines");
4757: M_OUT( 2, ECX, EDX );
4758: end_opcode("z_op");
4759:
4760: beg_opcode(11,s(op,0xdb),"IN A,(imm8)");
4761: ARG( ECX );
4762: I(0,movb, CH, A, "16 bit port A on upper 8 address lines");
4763: M_IN( 2, EDX, ECX );
4764: I(0,movb, A, DL, "get result");
4765: end_opcode("z_op");
4766:
4767: beg_opcode(19,s(op,0xe3),"EX (SP),%s",hl);
4768: RWORD( (op_base)?2:1, EDX, zSP32 );
4769: I(0,xchgw, DX, zhl, 0);
4770: WWORD( (op_base)?2:1, zSP32, EDX );
4771: end_opcode("z_op");
4772:
4773: beg_opcode( 4,s(op,0xeb),"EX DE,HL");
4774: M_EX_DE_HL();
4775: end_opcode("z_op");
4776:
4777: beg_opcode( 4,s(op,0xf3),"DI");
4778: M_DI();
4779: end_opcode("z_op");
4780:
4781: beg_opcode( 4,s(op,0xfb),"EI");
4782: M_EI( op_base|0xfb );
4783: end_opcode("z_op");
4784:
4785: /*********/
4786:
4787: beg_opcode(10,s(op,0xc4),"CALL NZ,imm16");
4788: M_CALL_CC( op_base|0xc4 );
4789: end_opcode("z_op");
4790:
4791: beg_opcode(10,s(op,0xcc),"CALL Z,imm16");
4792: M_CALL_CC( op_base|0xcc );
4793: end_opcode("z_op");
4794:
4795: beg_opcode(10,s(op,0xd4),"CALL NC,imm16");
4796: M_CALL_CC( op_base|0xd4 );
4797: end_opcode("z_op");
4798:
4799: beg_opcode(10,s(op,0xdc),"CALL C,imm16");
4800: M_CALL_CC( op_base|0xdc );
4801: end_opcode("z_op");
4802:
4803: beg_opcode(10,s(op,0xe4),"CALL PE,imm16");
4804: M_CALL_CC( op_base|0xe4 );
4805: end_opcode("z_op");
4806:
4807: beg_opcode(10,s(op,0xec),"CALL PO,imm16");
4808: M_CALL_CC( op_base|0xec );
4809: end_opcode("z_op");
4810:
4811: beg_opcode(10,s(op,0xf4),"CALL P,imm16");
4812: M_CALL_CC( op_base|0xf4 );
4813: end_opcode("z_op");
4814:
4815: beg_opcode(10,s(op,0xfc),"CALL M,imm16");
4816: M_CALL_CC( op_base|0xfc );
4817: end_opcode("z_op");
4818:
4819: /*********/
4820:
4821: beg_opcode(10,s(op,0xc9),"RET");
4822: M_RET( op_base|0xc9 );
4823: end_opcode("z_op");
4824:
4825: beg_opcode( 4,s(op,0xd9),"EXX");
4826: M_EXX();
4827: end_opcode("z_op");
4828:
4829: beg_opcode( 4,s(op,0xe9),"JP (%s)",hl);
4830: M_JP_REG( op_base|0xe9, zhl32 );
4831: end_opcode("z_op");
4832:
4833: beg_opcode( 6,s(op,0xf9),"LD SP,%s",hl);
4834: I(0,movl, ECX, zhl32, 0);
4835: I(0,movl, zSP32, ECX, 0);
4836: end_opcode("z_op");
4837:
4838: beg_opcode(17,s(op,0xcd),"CALL imm16");
4839: M_CALL( op_base|0xcd );
4840: end_opcode("z_op");
4841:
4842: beg_opcode( 4,s(op,0xdd),"DD xx");
4843: end_opcode("z_dd");
4844:
4845: beg_opcode( 0,s(op,0xed),"ED xx");
4846: end_opcode("z_ed");
4847:
4848: beg_opcode( 4,s(op,0xfd),"FD xx");
4849: end_opcode("z_fd");
4850:
4851: /*********/
4852:
4853: beg_opcode( 7,s(op,0xc6),"ADD A,imm8");
4854: ARG( DL );
4855: M_ADD( DL );
4856: end_opcode("z_op");
4857:
4858: beg_opcode( 7,s(op,0xce),"ADC A,imm8");
4859: ARG( DL );
4860: M_ADC( DL );
4861: end_opcode("z_op");
4862:
4863: beg_opcode( 7,s(op,0xd6),"SUB imm8");
4864: ARG( DL );
4865: M_SUB( DL );
4866: end_opcode("z_op");
4867:
4868: beg_opcode( 7,s(op,0xde),"SBC A,imm8");
4869: ARG( DL );
4870: M_SBC( DL );
4871: end_opcode("z_op");
4872:
4873: beg_opcode( 7,s(op,0xe6),"AND imm8");
4874: ARG( DL );
4875: M_AND( DL );
4876: end_opcode("z_op");
4877:
4878: beg_opcode( 7,s(op,0xee),"XOR imm8");
4879: ARG( DL );
4880: M_XOR( DL );
4881: end_opcode("z_op");
4882:
4883: beg_opcode( 7,s(op,0xf6),"OR imm8");
4884: ARG( DL );
4885: M_OR( DL );
4886: end_opcode("z_op");
4887:
4888: beg_opcode( 7,s(op,0xfe),"CP imm8");
4889: ARG( DL );
4890: M_CP( DL );
4891: end_opcode("z_op");
4892:
4893: /*********/
4894:
4895: beg_opcode(11,s(op,0xc7),"RST $00");
4896: M_RST( op_base|0xc7 );
4897: end_opcode("z_op");
4898:
4899: beg_opcode(11,s(op,0xcf),"RST $08");
4900: M_RST( op_base|0xcf );
4901: end_opcode("z_op");
4902:
4903: beg_opcode(11,s(op,0xd7),"RST $10");
4904: M_RST( op_base|0xd7 );
4905: end_opcode("z_op");
4906:
4907: beg_opcode(11,s(op,0xdf),"RST $18");
4908: M_RST( op_base|0xdf );
4909: end_opcode("z_op");
4910:
4911: beg_opcode(11,s(op,0xe7),"RST $20");
4912: M_RST( op_base|0xe7 );
4913: end_opcode("z_op");
4914:
4915: beg_opcode(11,s(op,0xef),"RST $28");
4916: M_RST( op_base|0xef );
4917: end_opcode("z_op");
4918:
4919: beg_opcode(11,s(op,0xf7),"RST $30");
4920: M_RST( op_base|0xf7 );
4921: end_opcode("z_op");
4922:
4923: beg_opcode(11,s(op,0xff),"RST $38");
4924: M_RST( op_base|0xff );
4925: end_opcode("z_op");
4926: }
4927:
4928: void mk_opcodes_cb(void)
4929: {
4930: int i, j, b;
4931: char r[4+1], zr[32+1];
4932: for (i = 0; i < 0x100; i += 0x08) {
4933: for (j = 0; j < 8; j++) {
4934: switch (j) {
4935: case 0: strcpy(r,"B"); strcpy(zr,zB); break;
4936: case 1: strcpy(r,"C"); strcpy(zr,zC); break;
4937: case 2: strcpy(r,"D"); strcpy(zr,zD); break;
4938: case 3: strcpy(r,"E"); strcpy(zr,zE); break;
4939: case 4: strcpy(r,"H"); strcpy(zr,H); break;
4940: case 5: strcpy(r,"L"); strcpy(zr,L); break;
4941: case 6: strcpy(r,"(HL)"); strcpy(zr,DL); break;
4942: case 7: strcpy(r,"A"); strcpy(zr,A); break;
4943: }
4944: switch (i) {
4945: case 0x00:
4946: if (j == 6) {
4947: beg_opcode(15,s("cb_%02x",i+j),"RLC %s",r);
4948: RBYTE( 2, EDX, HL32 );
4949: } else {
4950: beg_opcode( 8,s("cb_%02x",i+j),"RLC %s",r);
4951: }
4952: M_RLC( zr );
4953: if (j == 6) WBYTE( 2, HL32, EDX );
4954: end_opcode("z_op");
4955: break;
4956: case 0x08:
4957: if (j == 6) {
4958: beg_opcode(15,s("cb_%02x",i+j),"RRC %s",r);
4959: RBYTE( 2, EDX, HL32 );
4960: } else {
4961: beg_opcode( 8,s("cb_%02x",i+j),"RRC %s",r);
4962: }
4963: M_RRC( zr );
4964: if (j == 6) WBYTE( 2, HL32, EDX );
4965: end_opcode("z_op");
4966: break;
4967: case 0x10:
4968: if (j == 6) {
4969: beg_opcode(15,s("cb_%02x",i+j),"RL %s",r);
4970: RBYTE( 2, EDX, HL32 );
4971: } else {
4972: beg_opcode( 8,s("cb_%02x",i+j),"RL %s",r);
4973: }
4974: M_RL ( zr );
4975: if (j == 6) WBYTE( 2, HL32, EDX );
4976: end_opcode("z_op");
4977: break;
4978: case 0x18:
4979: if (j == 6) {
4980: beg_opcode(15,s("cb_%02x",i+j),"RR %s",r);
4981: RBYTE( 2, EDX, HL32 );
4982: } else {
4983: beg_opcode( 8,s("cb_%02x",i+j),"RR %s",r);
4984: }
4985: M_RR ( zr );
4986: if (j == 6) WBYTE( 2, HL32, EDX );
4987: end_opcode("z_op");
4988: break;
4989: case 0x20:
4990: if (j == 6) {
4991: beg_opcode(15,s("cb_%02x",i+j),"SLA %s",r);
4992: RBYTE( 2, EDX, HL32 );
4993: } else {
4994: beg_opcode( 8,s("cb_%02x",i+j),"SLA %s",r);
4995: }
4996: M_SLA( zr );
4997: if (j == 6) WBYTE( 2, HL32, EDX );
4998: end_opcode("z_op");
4999: break;
5000: case 0x28:
5001: if (j == 6) {
5002: beg_opcode(15,s("cb_%02x",i+j),"SRA %s",r);
5003: RBYTE( 2, EDX, HL32 );
5004: } else {
5005: beg_opcode( 8,s("cb_%02x",i+j),"SRA %s",r);
5006: }
5007: M_SRA( zr );
5008: if (j == 6) WBYTE( 2, HL32, EDX );
5009: end_opcode("z_op");
5010: break;
5011: case 0x30:
5012: if (j == 6) {
5013: beg_opcode(15,s("cb_%02x",i+j),"SLL %s",r);
5014: RBYTE( 2, EDX, HL32 );
5015: } else {
5016: beg_opcode( 8,s("cb_%02x",i+j),"SLL %s",r);
5017: }
5018: M_SLL( zr );
5019: if (j == 6) WBYTE( 2, HL32, EDX );
5020: end_opcode("z_op");
5021: break;
5022: case 0x38:
5023: if (j == 6) {
5024: beg_opcode(15,s("cb_%02x",i+j),"SRL %s",r);
5025: RBYTE( 2, EDX, HL32 );
5026: } else {
5027: beg_opcode( 8,s("cb_%02x",i+j),"SRL %s",r);
5028: }
5029: M_SRL( zr );
5030: if (j == 6) WBYTE( 2, HL32, EDX );
5031: end_opcode("z_op");
5032: break;
5033: case 0x40: case 0x48: case 0x50: case 0x58:
5034: case 0x60: case 0x68: case 0x70: case 0x78:
5035: b = (i >> 3) & 7;
5036: if (j == 6) {
5037: beg_opcode(12,s("cb_%02x",i+j),"BIT %d,%s",b,r);
5038: RBYTE( 2, EDX, HL32 );
5039: } else {
5040: beg_opcode( 8,s("cb_%02x",i+j),"BIT %d,%s",b,r);
5041: }
5042: M_BIT( b, zr );
5043: end_opcode("z_op");
5044: break;
5045: case 0x80: case 0x88: case 0x90: case 0x98:
5046: case 0xa0: case 0xa8: case 0xb0: case 0xb8:
5047: b = (i >> 3) & 7;
5048: if (j == 6) {
5049: beg_opcode(15,s("cb_%02x",i+j),"RES %d,%s",b,r);
5050: RBYTE( 2, EDX, HL32 );
5051: } else {
5052: beg_opcode( 8,s("cb_%02x",i+j),"RES %d,%s",b,r);
5053: }
5054: M_RES( b, zr );
5055: if (j == 6) WBYTE( 2, HL32, EDX );
5056: end_opcode("z_op");
5057: break;
5058: case 0xc0: case 0xc8: case 0xd0: case 0xd8:
5059: case 0xe0: case 0xe8: case 0xf0: case 0xf8:
5060: b = (i >> 3) & 7;
5061: if (j == 6) {
5062: beg_opcode(15,s("cb_%02x",i+j),"SET %d,%s",b,r);
5063: RBYTE( 2, EDX, HL32 );
5064: } else {
5065: beg_opcode( 8,s("cb_%02x",i+j),"SET %d,%s",b,r);
5066: }
5067: M_SET( b, zr );
5068: if (j == 6) WBYTE( 2, HL32, EDX );
5069: end_opcode("z_op");
5070: break;
5071: }
5072: }
5073: }
5074: }
5075:
5076: void mk_opcodes_xx(void)
5077: {
5078: int i, j, b;
5079: char r[32+1], zr[32+1];
5080: for (i = 0; i < 0x100; i += 0x08) {
5081: for (j = 0; j < 8; j++) {
5082: switch (j) {
5083: case 0: strcpy(r,"B=(IX/IY+ofs8)"); strcpy(zr,zB); break;
5084: case 1: strcpy(r,"C=(IX/IY+ofs8)"); strcpy(zr,zC); break;
5085: case 2: strcpy(r,"D=(IX/IY+ofs8)"); strcpy(zr,zD); break;
5086: case 3: strcpy(r,"E=(IX/IY+ofs8)"); strcpy(zr,zE); break;
5087: case 4: strcpy(r,"H=(IX/IY+ofs8)"); strcpy(zr,H); break;
5088: case 5: strcpy(r,"L=(IX/IY+ofs8)"); strcpy(zr,L); break;
5089: case 6: strcpy(r,"(IX/IY+ofs8)"); strcpy(zr,DL); break;
5090: case 7: strcpy(r,"A=(IX/IY+ofs8)"); strcpy(zr,A); break;
5091: }
5092: switch (i) {
5093: case 0x00:
5094: beg_opcode(19,s("xx_%02x",i+j),"RLC %s",r);
5095: M_RLC( DL );
5096: if (j != 6) I(0,movb, zr, DL, 0);
5097: #if WB_EA4_EDX
5098: I(0,jmp, "wb_ea4_edx",0, 0);
5099: #else
5100: WBYTE( 4, EBP, EDX );
5101: end_opcode("z_op");
5102: #endif
5103: break;
5104: case 0x08:
5105: beg_opcode(19,s("xx_%02x",i+j),"RRC %s",r);
5106: M_RRC( DL );
5107: if (j != 6) I(0,movb, zr, DL, 0);
5108: #if WB_EA4_EDX
5109: I(0,jmp, "wb_ea4_edx",0, 0);
5110: #else
5111: WBYTE( 4, EBP, EDX );
5112: end_opcode("z_op");
5113: #endif
5114: break;
5115: case 0x10:
5116: beg_opcode(19,s("xx_%02x",i+j),"RL %s",r);
5117: M_RL ( DL );
5118: if (j != 6) I(0,movb, zr, DL, 0);
5119: #if WB_EA4_EDX
5120: I(0,jmp, "wb_ea4_edx",0, 0);
5121: #else
5122: WBYTE( 4, EBP, EDX );
5123: end_opcode("z_op");
5124: #endif
5125: break;
5126: case 0x18:
5127: beg_opcode(19,s("xx_%02x",i+j),"RR %s",r);
5128: M_RR ( DL );
5129: if (j != 6) I(0,movb, zr, DL, 0);
5130: #if WB_EA4_EDX
5131: I(0,jmp, "wb_ea4_edx",0, 0);
5132: #else
5133: WBYTE( 4, EBP, EDX );
5134: end_opcode("z_op");
5135: #endif
5136: break;
5137: case 0x20:
5138: beg_opcode(19,s("xx_%02x",i+j),"SLA %s",r);
5139: M_SLA( DL );
5140: if (j != 6) I(0,movb, zr, DL, 0);
5141: #if WB_EA4_EDX
5142: I(0,jmp, "wb_ea4_edx",0, 0);
5143: #else
5144: WBYTE( 4, EBP, EDX );
5145: end_opcode("z_op");
5146: #endif
5147: break;
5148: case 0x28:
5149: beg_opcode(19,s("xx_%02x",i+j),"SRA %s",r);
5150: M_SRA( DL );
5151: if (j != 6) I(0,movb, zr, DL, 0);
5152: #if WB_EA4_EDX
5153: I(0,jmp, "wb_ea4_edx",0, 0);
5154: #else
5155: WBYTE( 4, EBP, EDX );
5156: end_opcode("z_op");
5157: #endif
5158: break;
5159: case 0x30:
5160: beg_opcode(19,s("xx_%02x",i+j),"SLL %s",r);
5161: M_SLL( DL );
5162: if (j != 6) I(0,movb, zr, DL, 0);
5163: #if WB_EA4_EDX
5164: I(0,jmp, "wb_ea4_edx",0, 0);
5165: #else
5166: WBYTE( 4, EBP, EDX );
5167: end_opcode("z_op");
5168: #endif
5169: break;
5170: case 0x38:
5171: beg_opcode(19,s("xx_%02x",i+j),"SRL %s",r);
5172: M_SRL( DL );
5173: if (j != 6) I(0,movb, zr, DL, 0);
5174: #if WB_EA4_EDX
5175: I(0,jmp, "wb_ea4_edx",0, 0);
5176: #else
5177: WBYTE( 4, EBP, EDX );
5178: end_opcode("z_op");
5179: #endif
5180: break;
5181: case 0x40: case 0x48: case 0x50: case 0x58:
5182: case 0x60: case 0x68: case 0x70: case 0x78:
5183: b = (i >> 3) & 7;
5184: beg_opcode(16,s("xx_%02x",i+j),"BIT %d,%s",b,r);
5185: M_BIT( b, DL );
5186: end_opcode("z_op");
5187: break;
5188: case 0x80: case 0x88: case 0x90: case 0x98:
5189: case 0xa0: case 0xa8: case 0xb0: case 0xb8:
5190: b = (i >> 3) & 7;
5191: beg_opcode(19,s("xx_%02x",i+j),"RES %d,%s",b,r);
5192: M_RES( b, DL );
5193: if (j != 6) I(0,movb, zr, DL, 0);
5194: #if WB_EA4_EDX
5195: I(0,jmp, "wb_ea4_edx",0, 0);
5196: #else
5197: WBYTE( 4, EBP, EDX );
5198: end_opcode("z_op");
5199: #endif
5200: break;
5201: case 0xc0: case 0xc8: case 0xd0: case 0xd8:
5202: case 0xe0: case 0xe8: case 0xf0: case 0xf8:
5203: b = (i >> 3) & 7;
5204: beg_opcode(19,s("xx_%02x",i+j),"SET %d,%s",b,r);
5205: M_SET( b, DL );
5206: if (j != 6) I(0,movb, zr, DL, 0);
5207: #if WB_EA4_EDX
5208: I(0,jmp, "wb_ea4_edx",0, 0);
5209: #else
5210: WBYTE( 4, EBP, EDX );
5211: end_opcode("z_op");
5212: #endif
5213: break;
5214: }
5215: }
5216: }
5217: }
5218:
5219: void mk_opcodes_ed(void)
5220: {
5221: beg_opcode(12,"ed_40","IN B,(C)");
5222: M_IN_BC( zB );
5223: end_opcode("z_op");
5224:
5225: beg_opcode(12,"ed_41","OUT (C),B");
5226: M_OUT_BC( zB );
5227: end_opcode("z_op");
5228:
5229: beg_opcode(15,"ed_42","SBC HL,BC");
5230: M_SBC16( zBC );
5231: end_opcode("z_op");
5232:
5233: beg_opcode(20,"ed_43","LD (imm16),BC");
5234: ARG16( ECX );
5235: WWORD( 4, ECX, zBC32 );
5236: end_opcode("z_op");
5237:
5238: beg_opcode( 8,"ed_44","NEG");
5239: M_NEG();
5240: end_opcode("z_op");
5241:
5242: beg_opcode(14,"ed_45","RETN");
5243: M_RETN( 0x45 );
5244: end_opcode("z_op");
5245:
5246: beg_opcode( 8,"ed_46","IM 0");
5247: I(0,movb, zIM, D(0), "set IM = 0");
5248: end_opcode("z_op");
5249:
5250: beg_opcode( 9,"ed_47","LD I,A");
5251: M_LD_I_A();
5252: end_opcode("z_op");
5253:
5254: beg_opcode(12,"ed_48","IN C,(C)");
5255: M_IN_BC( zC );
5256: end_opcode("z_op");
5257:
5258: beg_opcode(12,"ed_49","OUT (C),C");
5259: M_OUT_BC( zC );
5260: end_opcode("z_op");
5261:
5262: beg_opcode(15,"ed_4a","ADC HL,BC");
5263: M_ADC16( zBC );
5264: end_opcode("z_op");
5265:
5266: beg_opcode(20,"ed_4b","LD BC,(imm16)");
5267: ARG16( ECX );
5268: RWORD( 4, EDX, ECX );
5269: I(0,movw, zBC, DX, 0);
5270: end_opcode("z_op");
5271:
5272: beg_opcode( 8,"ed_4c","NEG");
5273: M_NEG();
5274: end_opcode("z_op");
5275:
5276: beg_opcode(14,"ed_4d","RETI");
5277: M_RETI(0x4d);
5278: end_opcode("z_op");
5279:
5280: beg_opcode( 8,"ed_4e","IM 0");
5281: I(0,movb, zIM, D(0), "set IM = 0");
5282: end_opcode("z_op");
5283:
5284: beg_opcode( 9,"ed_4f","LD R,A");
5285: M_LD_R_A();
5286: end_opcode("z_op");
5287:
5288: beg_opcode(12,"ed_50","IN D,(C)");
5289: M_IN_BC( zD );
5290: end_opcode("z_op");
5291:
5292: beg_opcode(12,"ed_51","OUT (C),D");
5293: M_OUT_BC( zD );
5294: end_opcode("z_op");
5295:
5296: beg_opcode(15,"ed_52","SBC HL,DE");
5297: M_SBC16( zDE );
5298: end_opcode("z_op");
5299:
5300: beg_opcode(20,"ed_53","LD (imm16),DE");
5301: ARG16( ECX );
5302: WWORD( 4, ECX, zDE32 );
5303: end_opcode("z_op");
5304:
5305: beg_opcode( 8,"ed_54","NEG");
5306: M_NEG();
5307: end_opcode("z_op");
5308:
5309: beg_opcode(14,"ed_55","RETN");
5310: M_RETN( 0x55 );
5311: end_opcode("z_op");
5312:
5313: beg_opcode( 8,"ed_56","IM 1");
5314: I(0,movb, zIM, D(1), "set IM = 1");
5315: end_opcode("z_op");
5316:
5317: beg_opcode( 9,"ed_57","LD A,I");
5318: M_LD_A_I();
5319: end_opcode("z_op");
5320:
5321: beg_opcode(12,"ed_58","IN E,(C)");
5322: M_IN_BC( zE );
5323: end_opcode("z_op");
5324:
5325: beg_opcode(12,"ed_59","OUT (C),E");
5326: M_OUT_BC( zE );
5327: end_opcode("z_op");
5328:
5329: beg_opcode(15,"ed_5a","ADC HL,DE");
5330: M_ADC16( zDE );
5331: end_opcode("z_op");
5332:
5333: beg_opcode(20,"ed_5b","LD DE,(imm16)");
5334: ARG16( ECX );
5335: RWORD( 4, EDX, ECX );
5336: I(0,movw, zDE, DX, 0);
5337: end_opcode("z_op");
5338:
5339: beg_opcode( 8,"ed_5c","NEG");
5340: M_NEG();
5341: end_opcode("z_op");
5342:
5343: beg_opcode(14,"ed_5d","RETI");
5344: M_RETI( 0x5d );
5345: end_opcode("z_op");
5346:
5347: beg_opcode( 8,"ed_5e","IM 2");
5348: I(0,movb, zIM, D(2), "set IM = 2");
5349: end_opcode("z_op");
5350:
5351: beg_opcode( 9,"ed_5f","LD A,R");
5352: M_LD_A_R();
5353: end_opcode("z_op");
5354:
5355: beg_opcode(12,"ed_60","IN H,(C)");
5356: M_IN_BC( H );
5357: end_opcode("z_op");
5358:
5359: beg_opcode(12,"ed_61","OUT (C),H");
5360: M_OUT_BC( H );
5361: end_opcode("z_op");
5362:
5363: beg_opcode(15,"ed_62","SBC HL,HL");
5364: M_SBC16( HL );
5365: end_opcode("z_op");
5366:
5367: beg_opcode(20,"ed_63","LD (imm16),HL");
5368: ARG16( ECX );
5369: WWORD( 4, ECX, HL32 );
5370: end_opcode("z_op");
5371:
5372: beg_opcode( 8,"ed_64","NEG");
5373: M_NEG();
5374: end_opcode("z_op");
5375:
5376: beg_opcode(14,"ed_65","RETN");
5377: M_RETN( 0x65 );
5378: end_opcode("z_op");
5379:
5380: beg_opcode( 8,"ed_66","IM 0");
5381: I(0,movb, zIM, D(0), "set IM = 0");
5382: end_opcode("z_op");
5383:
5384: beg_opcode(18,"ed_67","RRD (HL)");
5385: M_RRD();
5386: end_opcode("z_op");
5387:
5388: beg_opcode(12,"ed_68","IN L,(C)");
5389: M_IN_BC( L );
5390: end_opcode("z_op");
5391:
5392: beg_opcode(12,"ed_69","OUT (C),L");
5393: M_OUT_BC( L );
5394: end_opcode("z_op");
5395:
5396: beg_opcode(15,"ed_6a","ADC HL,HL");
5397: M_ADC16( HL );
5398: end_opcode("z_op");
5399:
5400: beg_opcode(20,"ed_6b","LD HL,(imm16)");
5401: ARG16( ECX );
5402: RWORD( 4, EDX, ECX );
5403: I(0,movw, HL, DX, 0);
5404: end_opcode("z_op");
5405:
5406: beg_opcode( 8,"ed_6c","NEG");
5407: M_NEG();
5408: end_opcode("z_op");
5409:
5410: beg_opcode(14,"ed_6d","RETI");
5411: M_RETI( 0x6d );
5412: end_opcode("z_op");
5413:
5414: beg_opcode( 8,"ed_6e","IM 0");
5415: I(0,movb, zIM, D(0), "set IM = 0");
5416: end_opcode("z_op");
5417:
5418: beg_opcode(18,"ed_6f","RLD (HL)");
5419: M_RLD();
5420: end_opcode("z_op");
5421:
5422: beg_opcode(12,"ed_70","IN F,(C)");
5423: M_IN_BC( DL );
5424: end_opcode("z_op");
5425:
5426: beg_opcode(12,"ed_71","OUT (C),0");
5427: I(0,movb, DL, D(0), 0);
5428: M_OUT_BC( DL );
5429: end_opcode("z_op");
5430:
5431: beg_opcode(15,"ed_72","SBC HL,SP");
5432: M_SBC16( zSP );
5433: end_opcode("z_op");
5434:
5435: beg_opcode(20,"ed_73","LD (imm16),SP");
5436: ARG16( ECX );
5437: WWORD( 4, ECX, zSP32 );
5438: end_opcode("z_op");
5439:
5440: beg_opcode( 8,"ed_74","NEG");
5441: M_NEG();
5442: end_opcode("z_op");
5443:
5444: beg_opcode(14,"ed_75","RETN");
5445: M_RETN( 0x75 );
5446: end_opcode("z_op");
5447:
5448: beg_opcode( 8,"ed_76","IM 1");
5449: I(0,movb, zIM, D(1), "set IM = 1");
5450: end_opcode("z_op");
5451:
5452: beg_opcode(12,"ed_78","IN A,(C)");
5453: M_IN_BC( A );
5454: end_opcode("z_op");
5455:
5456: beg_opcode(12,"ed_79","OUT (C),A");
5457: M_OUT_BC( A );
5458: end_opcode("z_op");
5459:
5460: beg_opcode(15,"ed_7a","ADC HL,SP");
5461: M_ADC16( zSP );
5462: end_opcode("z_op");
5463:
5464: beg_opcode(20,"ed_7b","LD SP,(imm16)");
5465: ARG16( ECX );
5466: RWORD( 4, EDX, ECX );
5467: I(0,movw, zSP, DX, 0);
5468: end_opcode("z_op");
5469:
5470: beg_opcode( 8,"ed_7c","NEG");
5471: M_NEG();
5472: end_opcode("z_op");
5473:
5474: beg_opcode(14,"ed_7d","RETI");
5475: M_RETI( 0x7d );
5476: end_opcode("z_op");
5477:
5478: beg_opcode( 8,"ed_7e","IM 2");
5479: I(0,movb, zIM, D(2), "set IM = 2");
5480: end_opcode("z_op");
5481:
5482: beg_opcode(16,"ed_a0","LDI");
5483: RBYTE( 2, EDX, HL32 );
5484: WBYTE( 2, zDE32, EDX );
5485: I(0,andb, F, X(SF|ZF|CF), "keep S,Z and C flags");
5486: I(0,incw, HL, 0, "HL++");
5487: I(0,incw, zDE, 0, "DE++");
5488: I(0,decw, zBC, 0, "BC--");
5489: I(0,je, LS("ed_a0_skip"),0, 0);
5490: I(0,orb, F, X(PF), "BC not zero, set P/V");
5491: S("ed_a0_skip",0);
5492: end_opcode("z_op");
5493:
5494: beg_opcode(16,"ed_a1","CPI");
5495: RBYTE( 2, EDX, HL32 );
5496: I(0,movb, CL, F, "save flags");
5497: I(0,andb, CL, X(CF), "keep C flag");
5498: I(0,cmpb, A, DL, 0);
5499: I(0,lahf, 0, 0, 0);
5500: I(0,andb, F, X(SF|ZF|HF), "mask S,Z and H flags");
5501: I(0,orb, F, X(NF), "set N flag");
5502: I(0,orb, F, CL, "combine with C");
5503: I(0,incw, HL, 0, "HL++");
5504: I(0,decw, zBC, 0, "BC--");
5505: I(0,je, LS("ed_a1_skip"),0, 0);
5506: I(0,orb, F, X(PF), "BC not zero, set P/V");
5507: S("ed_a1_skip",0);
5508: end_opcode("z_op");
5509:
5510: beg_opcode(16,"ed_a2","INI");
5511: I(0,decb, zB, 0, "--B");
5512: M_IN( 2, EDX, zBC32 );
5513: WBYTE( 2, HL32, EDX );
5514: I(0,movb, F, X(ZF|NF), "set Z and N flags");
5515: I(0,incw, HL, 0, "HL++");
5516: I(0,testb, zB, B(-1), "B counted down?");
5517: I(0,je, LS("ed_a2_skip"),0, 0);
5518: I(0,movb, F, X(NF), "set N only");
5519: S("ed_a2_skip",0);
5520: end_opcode("z_op");
5521:
5522: beg_opcode(16,"ed_a3","OUTI");
5523: RBYTE( 2, EDX, HL32 );
5524: M_OUT( 2, zBC32, EDX );
5525: I(0,movb, F, X(ZF|NF), "set Z and N");
5526: I(0,incw, HL, 0, "HL++");
5527: I(0,decb, zB, 0, "B--");
5528: I(0,je, LS("ed_a3_skip"),0, 0);
5529: I(0,movb, F, X(NF), "set N only");
5530: S("ed_a3_skip",0);
5531: end_opcode("z_op");
5532:
5533: beg_opcode(16,"ed_a8","LDD");
5534: RBYTE( 2, EDX, HL32 );
5535: WBYTE( 2, zDE32, EDX );
5536: I(0,andb, F, X(SF|ZF|CF), "keep S,Z and C flags");
5537: I(0,decw, HL, 0, "HL--");
5538: I(0,decw, zDE, 0, "DE--");
5539: I(0,decw, zBC, 0, "BC--");
5540: I(0,je, LS("ed_a8_skip"),0, 0);
5541: I(0,orb, F, X(PF), "BC not zero, set P/V");
5542: S("ed_a8_skip",0);
5543: end_opcode("z_op");
5544:
5545: beg_opcode(16,"ed_a9","CPD");
5546: RBYTE( 2, EDX, HL32 );
5547: I(0,movb, CL, F, "save flags");
5548: I(0,andb, CL, X(CF), "keep C flag");
5549: I(0,cmpb, A, DL, 0);
5550: I(0,lahf, 0, 0, 0);
5551: I(0,andb, F, X(SF|ZF|HF), "mask S,Z and H flags");
5552: I(0,orb, F, X(NF), "set N flag");
5553: I(0,orb, F, CL, "combine with C");
5554: I(0,decw, HL, 0, "HL--");
5555: I(0,decw, zBC, 0, "BC--");
5556: I(0,je, LS("ed_a9_skip"),0, 0);
5557: I(0,orb, F, X(PF), "BC not zero, set P/V");
5558: S("ed_a9_skip",0);
5559: end_opcode("z_op");
5560:
5561: beg_opcode(16,"ed_aa","IND");
5562: I(0,decb, zB, 0, "--B");
5563: M_IN( 2, EDX, zBC32 );
5564: WBYTE( 2, HL32, EDX );
5565: I(0,movb, F, X(ZF|NF), "set Z and N flags");
5566: I(0,decw, HL, 0, "HL--");
5567: I(0,testb, zB, B(-1), "B counted down?");
5568: I(0,je, LS("ed_aa_skip"),0, 0);
5569: I(0,andb, F, X(NF), "leave N only");
5570: S("ed_aa_skip",0);
5571: end_opcode("z_op");
5572:
5573: beg_opcode(16,"ed_ab","OUTD");
5574: RBYTE( 2, EDX, HL32 );
5575: M_OUT( 2, zBC32, EDX );
5576: I(0,movb, F, X(ZF|NF), "set Z and N flags");
5577: I(0,decw, HL, 0, "HL--");
5578: I(0,decb, zB, 0, "B--");
5579: I(0,je, LS("ed_ab_skip"),0, 0);
5580: I(0,andb, F, X(NF), "set N only");
5581: S("ed_ab_skip",0);
5582: end_opcode("z_op");
5583:
5584: beg_opcode(16,"ed_b0","LDIR");
5585: RBYTE( 2, EDX, HL32 );
5586: WBYTE( 2, zDE32, EDX );
5587: I(0,andb, F, X(SF|ZF|CF), "keep S,Z and C flags");
5588: I(0,incw, HL, 0, "HL++");
5589: I(0,incw, zDE, 0, "DE++");
5590: I(0,decw, zBC, 0, "BC--");
5591: I(0,je, LS("ed_b0_skip"),0, 0);
5592: I(0,orb, F, X(PF), "BC not zero, set P/V");
5593: ADJUST_PC(-2);
5594: I(0,subl, zICOUNT,B(5), "five more cycles");
5595: S("ed_b0_skip",0);
5596: end_opcode("z_op");
5597:
5598: beg_opcode(16,"ed_b1","CPIR");
5599: RBYTE( 2, EDX, HL32 );
5600: I(0,movb, CL, F, "save flags");
5601: I(0,andb, CL, X(CF), "keep C flag");
5602: I(0,cmpb, A, DL, 0);
5603: I(0,lahf, 0, 0, 0);
5604: I(0,andb, F, X(SF|ZF|HF), "mask S,Z and H flags");
5605: I(0,orb, F, X(NF), "set N flag");
5606: I(0,orb, F, CL, "combine with C");
5607: I(0,incw, HL, 0, "HL++");
5608: I(0,decw, zBC, 0, "BC--");
5609: I(0,je, LS("ed_b1_skip"),0, 0);
5610: I(0,orb, F, X(PF), "BC not zero, set P/V");
5611: I(0,testb, F, X(ZF), "Z flag set?");
5612: I(0,jne, LS("ed_b1_skip"),0, "yes, don't repeat");
5613: ADJUST_PC(-2);
5614: I(0,subl, zICOUNT,B(5), "five more cycles");
5615: S("ed_b1_skip",0);
5616: end_opcode("z_op");
5617:
5618: beg_opcode(16,"ed_b2","INIR");
5619: I(0,decb, zB, 0, "--B");
5620: M_IN( 2, EDX, zBC32 );
5621: WBYTE( 2, HL32, EDX );
5622: I(0,incw, HL, 0, "HL++");
5623: I(0,movb, F, X(ZF|NF), "set Z and N");
5624: I(0,testb, zB, B(-1), "B counted down?");
5625: I(0,je, LS("ed_b2_skip"),0, 0);
5626: I(0,movb, F, X(NF), "set N only");
5627: ADJUST_PC(-2);
5628: I(0,subl, zICOUNT,B(5), "five more cycles");
5629: S("ed_b2_skip",0);
5630: end_opcode("z_op");
5631:
5632: beg_opcode(16,"ed_b3","OTIR");
5633: RBYTE( 2, EDX, HL32 );
5634: M_OUT( 2, zBC32, EDX );
5635: I(0,movb, F, X(ZF|NF), "set Z and N");
5636: I(0,incw, HL, 0, "HL++");
5637: I(0,decb, zB, 0, "B--");
5638: I(0,je, LS("ed_b3_skip"),0, 0);
5639: I(0,movb, F, X(NF), "set N only");
5640: ADJUST_PC(-2);
5641: I(0,subl, zICOUNT,B(5), "five more cycles");
5642: S("ed_b3_skip",0);
5643: end_opcode("z_op");
5644:
5645: beg_opcode(16,"ed_b8","LDDR");
5646: RBYTE( 2, EDX, HL32 );
5647: WBYTE( 2, zDE32, EDX );
5648: I(0,andb, F, X(SF|ZF|CF), "keep S,Z and C flags");
5649: I(0,decw, HL, 0, "HL--");
5650: I(0,decw, zDE, 0, "DE--");
5651: I(0,decw, zBC, 0, "BC--");
5652: I(0,je, LS("ed_b8_skip"),0, 0);
5653: I(0,orb, F, X(PF), "BC not zero, set P/V");
5654: ADJUST_PC(-2);
5655: I(0,subl, zICOUNT,B(5), "five more cycles");
5656: S("ed_b8_skip",0);
5657: end_opcode("z_op");
5658:
5659: beg_opcode(16,"ed_b9","CPDR");
5660: RBYTE( 2, EDX, HL32 );
5661: I(0,movb, CL, F, "save flags");
5662: I(0,andb, CL, X(CF), "keep C flag");
5663: I(0,cmpb, A, DL, 0);
5664: I(0,lahf, 0, 0, 0);
5665: I(0,andb, F, X(SF|ZF|HF), "mask S,Z and H flags");
5666: I(0,orb, F, X(NF), "set N flag");
5667: I(0,orb, F, CL, "combine with C");
5668: I(0,decw, HL, 0, "HL--");
5669: I(0,decw, zBC, 0, "BC--");
5670: I(0,je, LS("ed_b9_skip"),0, 0);
5671: I(0,orb, F, X(PF), "BC not zero, set P/V");
5672: I(0,testb, F, X(ZF), "Z flag set?");
5673: I(0,jne, LS("ed_b9_skip"),0, "yes, don't repeat");
5674: ADJUST_PC(-2);
5675: I(0,subl, zICOUNT,B(5), "five more cycles");
5676: S("ed_b9_skip",0);
5677: end_opcode("z_op");
5678:
5679: beg_opcode(16,"ed_ba","INDR");
5680: I(0,decb, zB, 0, "--B");
5681: M_IN( 2, EDX, zBC32 );
5682: WBYTE( 2, HL32, EDX );
5683: I(0,movb, F, X(ZF|NF), "set Z and N");
5684: I(0,decw, HL, 0, "HL--");
5685: I(0,testb, zB, B(-1), 0);
5686: I(0,je, LS("ed_ba_skip"),0, 0);
5687: I(0,movb, F, X(NF), "set N only");
5688: ADJUST_PC(-2);
5689: I(0,subl, zICOUNT,B(5), "five more cycles");
5690: S("ed_ba_skip",0);
5691: end_opcode("z_op");
5692:
5693: beg_opcode(16,"ed_bb","OTDR");
5694: RBYTE( 2, EDX, HL32 );
5695: M_OUT( 2, zBC32, EDX );
5696: I(0,movb, F, X(ZF|NF), "set Z and N");
5697: I(0,decw, HL, 0, "HL--");
5698: I(0,decb, zB, 0, "B--");
5699: I(0,je, LS("ed_bb_skip"),0, 0);
5700: I(0,movb, F, X(NF), "set N only");
5701: ADJUST_PC(-2);
5702: I(0,subl, zICOUNT,B(5), "five more cycles");
5703: S("ed_bb_skip",0);
5704: end_opcode("z_op");
5705: }
5706:
5707: int main(int ac, char **av)
5708: {
5709: int i;
5710:
5711: if (ac < 2) {
5712: fprintf(stderr, "usage: %s [options] output.asm\n", av[0]);
5713: fprintf(stderr, "options can be one of the following\n");
5714: fprintf(stderr, "-nasm\tgenerate NASM output%s\n",(as==NASM)?" (default)":"");
5715: fprintf(stderr, "-gas\tgenerate GNU assembler output%s\n",(as==GAS)?" (default)":"");
5716: fprintf(stderr, "-verbose n\toutput error.log (n= 0 none - 9 everything)\n");
5717: fprintf(stderr, "-On\temit self optimizing code (n=0 no, n=1 yes)\n");
5718: fprintf(stderr, "-Ddefine\tdefines for conditional output\n");
5719: fprintf(stderr, "\t-DMAME_DEBUG output code to call MAMEs debugger\n");
5720: return 1;
5721: }
5722: printf("Z80 x86 asm emitter V0.6 for MAME\n");
5723: printf("Copyright (c) 1999 by Juergen Buchmueller ([email protected])\n");
5724:
5725: for (i = 1; av[i][0] == '-'; i++) {
5726: if (!strcmp(av[i], "-gas")) {
5727: as = GAS;
5728: } else if (!strcmp(av[i], "-nasm") || !strcmp(av[i], "-nasmw")) {
5729: as = NASM;
5730: } else if (!strcmp(av[i], "-tasm")) {
5731: as = TASM;
5732: } else if (!strcmp(av[i],"-verbose")) {
5733: if (++i < ac - 1) {
5734: sscanf(av[i], "%d", &verbose);
5735: }
5736: } else if (!strncmp(av[i], "-D", 2)) {
5737: if (!strcmp(&av[i][2],"MAME_DEBUG")) {
5738: mame_debug = 1;
5739: } else {
5740: /* fprintf(stderr, "ignored define '%s'\n", &av[i][2]); */
5741: }
5742: } else if (!strncmp(av[i], "-m", 2)) {
5743: if (!strncmp(&av[i][2],"386",3)) {
5744: align_funcs = 1;
5745: align_jumps = 1;
5746: align_loops = 1;
5747: } else
5748: if (!strncmp(&av[i][2],"486",3)) {
5749: align_funcs = 2;
5750: align_jumps = 2;
5751: align_loops = 1;
5752: } else
5753: if (!strncmp(&av[i][2],"pentium",3)) {
5754: align_funcs = 2;
5755: align_jumps = 2;
5756: align_loops = 1;
5757: } else
5758: if (!strncmp(&av[i][2],"align-functions=",16)) {
5759: sscanf(&av[i][18], "%d", &align_funcs);
5760: } else
5761: if (!strncmp(&av[i][2],"align-jumps=",12)) {
5762: sscanf(&av[i][14], "%d", &align_jumps);
5763: } else
5764: if (!strncmp(&av[i][2],"align-loops=",12)) {
5765: sscanf(&av[i][14], "%d", &align_loops);
5766: } else {
5767: /* fprintf(stderr, "ignored optimizing option '%s'\n", &av[i][2]); */
5768: }
5769: } else {
5770: /*
5771: * fprintf(stderr, "unsupported option '%s'\n", av[i]);
5772: * return 1;
5773: */
5774: }
5775: }
5776: if (as == GAS) printf("- GNU assembler output\n");
5777: if (as == NASM) printf("- NASM output\n");
5778: if (as == TASM) printf("- TASM output\n");
5779: if (mame_debug) printf("- with MAME_Debug code\n");
5780: printf("- verbose level %d\n", verbose);
5781: printf("- align functions %d (%d bytes)\n", align_funcs, 2<<align_funcs);
5782: printf("- align jumps %d (%d bytes)\n", align_jumps, 2<<align_jumps);
5783: printf("- align loops %d (%d bytes)\n", align_loops, 2<<align_loops);
5784:
5785: output = fopen(av[i], "w");
5786:
5787: mk_header();
5788: mk_interface();
5789: mk_memory_handlers();
5790: mk_opcodes(0x0000);
5791: mk_opcodes_ed();
5792: mk_opcodes_cb();
5793: mk_opcodes(0xdd00);
5794: mk_opcodes(0xfd00);
5795: mk_opcodes_xx();
5796:
5797: if (as == TASM)
5798: emit("\tend");
5799:
5800: printf("generated %d opcodes\n", opcodes);
5801: printf("functions rbyte:%d wbyte:%d rword:%d wword:%d\n",
5802: rbyte, wbyte, rword, wword);
5803:
5804: fclose(output);
5805: return 0;
5806: }
5807:
5808:
5809:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.