## x0 x1 x2 x3 x4 x5 x6 x7 0x NOP 1x ld ld ld ld ld ld ld ld 2x bgt st st st ?? st st st 3x RECHECK ADD!! 4x 5x 6x 7x 8x cmp cmp cmp cmp cmp cmp cmp cmp 9x RECHECK MULT!! ax asl;lsl lsr;asr bx or or or or or or or or cx and and and and and and and and dx xor xor xor xor xor xor xor xor ex BRA BRA;RTS BRA blt blt blt fx bne bne bne beq beq beq ## x8 x9 xa xb xc xd xe xf 0x MDFY ld xh enterl st xh leavel 1x ld ld ld ld ld ld ld ld 2x ?? st st st bcz st st st 3x RECHECK ADD!! 4x 5x 6x 7x 8x cmp cmp cmp cmp cmp cmp cmp cmp 9x tst tst tst bsr bsr bsr ax bx or or or or or or or or cx and and and and and and and and dx xor xor xor xor xor xor xor xor ex fx bcc bcc bcc bcs bcs bcs nop, ld, st, add, sub, umult, smult, sdiv, udiv lsr lsl asr asl bra, beq,bne, bcs,bcc,bcz blt bgt cmp tst and, or, xor enterl //begin routine leavel //end routine bsr, rts CHECK: bcs bgt Kollision mit st 0 , C belegt. beides sind ungültige immediate-modes für store asm opcodes: nop: 0x0000 Zusatzbytes für Opcode: "parameterisiertes NOP" 0x??0X = specialcase-opcodes 0009 Modifier für nächsten opcode 0a load xh 0e st xh 0xb enterl Struktur: 0009 präfix(optional) xx00 Zusatzbyte (optional) xx00 Zusatzbyte (optional), für große parameter xxYY Opcode xx der integerparameter ld: Load Value into Register ld AL #CONSTANT: xx14 (0-127) Values itieriert von -32768-32767 in file. ld suffixes: AL 14, AH 10, X 18, Y 1C LSB Or-In 0x03: (????, Y) Load from Address, (offset based on register Y?) 0x02: (????, X) Load from Address, (offset based on register X?) 0x01: (????): Load From Address, absolute 0x00: Immediate LD specialcases: ld xh, @(1,y) = xx0e, Regel rausfinden, Riect nach dem MSByte für die bra-adresse st: Selbe Logik wie für ld bei Multibyte-Opcodes Store Register on Address st x, @address xx29 st y, @address xx2d st al, @address xx25 st ah, @address xx21 LSB Or-In 0x03: (????, Y) Load from Address, (offset based on register Y?) 0x02: (????, X) Load from Address, (offset based on register X?) 0x01: (????): Load From Address, absolute 0x00: Ungültig, Immediate gilt hier nicht ST specialcases: st xh, @(1,y) = xx0a ADD: add AH #CONSTANT: XX30 (0-127) LSB OR-In Indirects Unacceptable 0x01: (????): Load From Address, absolute 0x00: Immediate sub AH #CONSTANT: XX50 (0-127) umult: smult: umult 0009 (Extensionbyte immer nötig für 09-flag) xx90 smult xx90 udiv: 0009 xx94 sdiv: xx94 LSR: 0009 xxa4 LSL: xxa0 ASR: xxa4 ASL: == LSL, verhalten sich identisch xxa0 bra: bra @x xxe1 -128=0x80 -1 = xff +127=7f bra @(x,Y) xxe3 -128=0x80 -1 = xff +127=7f bra @(x,X) xxe2 -128=0x80 -1 = xff +127=7f bsr: bsr: @(x,Y) xx9f bsr @(x,X) xx9e bsr @XX xx9d beq: beq: @(x,Y) xxf7 beq @(x,X) xxf6 beq @XX xxf5 bne: bne: @(x,Y) xxf3 bne @(x,X) xxf2 bne @XX xxf1 bcs: bcs: @(x,Y) xxff bcs @(x,X) xxfe bcs @XX xxfd bcc: bcc: @(x,Y) xxfb bcc @(x,X) xxfa bcc @XX xxf9 bcz: bcz @XX xx2c kann nur direkt adressieren bgt: bgt @XX xx20 kann nur direkt adressieren blt: blt @XX xxe5 blt @(xx,x) xxe6 blt @(xx,Y) xxe7 -------------------------------------- cmp: cmp AL #XX xx84 cmp AL @x xx85 cmp AL @(xx,X) xx86 cmp AL @(xx,y) xx87 cmp AH #XX xx80 cmp AH @x xx81 cmp AH @(xx,2) xx82 cmp AH @(xx,y) xx83 cmp X #XX xx88 cmp X @x xx89 cmp X @(xx,2) xx8a cmp X @(xx,y) xx8b cmp Y #XX xx8c cmp Y @x xx8d cmp Y @(xx,2) xx8e cmp Y @(xx,y) xx8f tst tst @XX xx99 tst @(1,x) xx9a tst @(1,y) xx9b and: and AH #x xxc0 and AH @x: xxc1 and AH @(x,X): xxc2 and AH @(x,Y): xxc3 and AL #x xxc4 and AL @x: xxc5 and AL @(x,X): xxc6 and AL @(x,Y): xxc7 and X #x xxc8 and X @x: xxc9 and X @(x,X): xxca and X @(x,Y): xxcb and AL #x xxcc and AL @x: xxcd and AL @(x,X): xxce and AL @(x,Y): xxcf OR: OR AH #x xxb0 OR AH @x: xxb1 OR AH @(x,X): xxb2 OR AH @(x,Y): xxb3 OR AL #x xxb4 OR AL @x: xxb5 OR AL @(x,X): xxb6 OR AL @(x,Y): xxb7 OR X #x xxb8 OR X @x: xxb9 OR X @(x,X): xxba OR X @(x,Y): xxbb OR AL #x xxbc OR AL @x: xxbd OR AL @(x,X): xxbe OR AL @(x,Y): xxbf XOR: XOR AH #x xxd0 XOR AH @x: xxd1 XOR AH @(x,X): xxd2 XOR AH @(x,Y): xxd3 XOR AL #x xxd4 XOR AL @x: xxd5 XOR AL @(x,X): xxd6 XOR AL @(x,Y): xxd7 XOR X #x xxd8 XOR X @x: xxd9 XOR X @(x,X): xxda XOR X @(x,Y): xxdb XOR AL #x xxdc XOR AL @x: xxdd XOR AL @(x,X): xxde XOR AL @(x,Y): xxdf enterl: begin routine xx0b parametercode anders!!!, tabelle bruteforcen... leavel: end routine xx0f parameter gleich wie enterl rts 00e2 ???? bra. == bra @(0,x)