m68kdecode
Version:
Port of deplinenoise/m68kdecode to Typescript
1,704 lines (1,697 loc) • 143 kB
text/typescript
import CodeStream from "./codestream";
import { simpleDisp, getBits, i16, i8, u8 } from "./lib";
import {
DecodedInstruction,
Implied,
ARIND,
ARDISP,
DR,
IMM16,
CONTROLREG,
IMM8,
REGLIST,
PCDISP,
DPAIR,
ARDEC,
PackAdjustment,
ARINC,
FPAIR,
AR,
FR,
} from "./types";
function decodeGroup0000(w0: number, cs: CodeStream): DecodedInstruction {
if ((w0 & 0b1111111111111111) === 0b0000001000111100) {
const size = 1;
const src = cs.imm8();
const dst = Implied();
const extra = null;
return {
bytesUsed: cs.pos,
instruction: {
size,
operation: "ANDITOCCR",
operands: [src, dst],
extra,
},
};
}
if ((w0 & 0b1111111111111111) === 0b0000001001111100) {
const size = 2;
const src = cs.imm16();
const dst = Implied();
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "ANDITOSR", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111111111) === 0b0000101000111100) {
const size = 1;
const src = cs.imm8();
const dst = Implied();
const extra = null;
return {
bytesUsed: cs.pos,
instruction: {
size,
operation: "EORITOCCR",
operands: [src, dst],
extra,
},
};
}
if ((w0 & 0b1111111111111111) === 0b0000101001111100) {
const size = 2;
const src = cs.imm16();
const dst = Implied();
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "EORITOSR", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111111111) === 0b0000000000111100) {
const size = 1;
const src = cs.imm8();
const dst = Implied();
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "ORITOCCR", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111111111) === 0b0000000001111100) {
const size = 2;
const src = cs.imm16();
const dst = Implied();
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "ORITOSR", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111000110111000) === 0b0000000100001000) {
const d = getBits(w0, 9, 3);
const s = getBits(w0, 6, 1);
const a = getBits(w0, 0, 3);
const size = 1 << (s + 1);
const src = ARDISP(a, simpleDisp(i16(cs.pull16())));
const dst = DR(d);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "MOVEP", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111000110111000) === 0b0000000110001000) {
const d = getBits(w0, 9, 3);
const s = getBits(w0, 6, 1);
const a = getBits(w0, 0, 3);
const size = 1 << (s + 1);
const src = DR(d);
const dst = ARDISP(a, simpleDisp(i16(cs.pull16())));
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "MOVEP", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111000111000000) === 0b0000000100000000) {
const d = getBits(w0, 9, 3);
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = m ? 1 : 4;
const src = DR(d);
const dst = cs.ea(r, m, 2);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "BTST", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111000111000000) === 0b0000000101000000) {
const d = getBits(w0, 9, 3);
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = m ? 1 : 4;
const src = DR(d);
const dst = cs.ea(r, m, 4);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "BCHG", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111000111000000) === 0b0000000110000000) {
const d = getBits(w0, 9, 3);
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = m ? 1 : 4;
const src = DR(d);
const dst = cs.ea(r, m, 4);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "BCLR", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111000111000000) === 0b0000000111000000) {
const d = getBits(w0, 9, 3);
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = m ? 1 : 4;
const src = DR(d);
const dst = cs.ea(r, m, 4);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "BSET", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0000100000000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b1111111000000000) === 0b0000000000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const n = getBits(w1, 0, 9);
cs.skipWords(1);
const size = m ? 1 : 4;
const src = IMM16(n);
const dst = cs.ea(r, m, 1);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "BTST", operands: [src, dst], extra },
};
}
}
if ((w0 & 0b1111111111000000) === 0b0000100001000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b1111111000000000) === 0b0000000000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const n = getBits(w1, 0, 9);
cs.skipWords(1);
const size = m ? 1 : 4;
const src = IMM16(n);
const dst = cs.ea(r, m, 1);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "BCHG", operands: [src, dst], extra },
};
}
}
if ((w0 & 0b1111111111000000) === 0b0000100010000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b1111111000000000) === 0b0000000000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const n = getBits(w1, 0, 9);
cs.skipWords(1);
const size = m ? 1 : 4;
const src = IMM16(n);
const dst = cs.ea(r, m, 1);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "BCLR", operands: [src, dst], extra },
};
}
}
if ((w0 & 0b1111111111000000) === 0b0000100011000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b1111111000000000) === 0b0000000000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const n = getBits(w1, 0, 9);
cs.skipWords(1);
const size = m ? 1 : 4;
const src = IMM16(n);
const dst = cs.ea(r, m, 1);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "BSET", operands: [src, dst], extra },
};
}
}
if ((w0 & 0b1111111111110000) === 0b0000011011000000) {
const d = getBits(w0, 3, 1);
const r = getBits(w0, 0, 3);
const size = 0;
const src = cs.dar(d, r);
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "RTM", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0000011011000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 0;
const src = cs.imm8();
const dst = cs.ea(r, m, 0);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "CALLM", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0000011000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 1;
const src = cs.imm8();
const dst = cs.ea(r, m, 1);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "ADDI", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0000011001000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 2;
const src = cs.imm16();
const dst = cs.ea(r, m, 2);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "ADDI", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0000011010000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 4;
const src = cs.imm32();
const dst = cs.ea(r, m, 4);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "ADDI", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0000010000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 1;
const src = cs.imm8();
const dst = cs.ea(r, m, 1);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "SUBI", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0000010001000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 2;
const src = cs.imm16();
const dst = cs.ea(r, m, 2);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "SUBI", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0000010010000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 4;
const src = cs.imm32();
const dst = cs.ea(r, m, 4);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "SUBI", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0000001000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 1;
const src = cs.imm8();
const dst = cs.ea(r, m, 1);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "ANDI", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0000001001000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 2;
const src = cs.imm16();
const dst = cs.ea(r, m, 2);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "ANDI", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0000001010000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 4;
const src = cs.imm32();
const dst = cs.ea(r, m, 4);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "ANDI", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0000000000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 1;
const src = cs.imm8();
const dst = cs.ea(r, m, 1);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "ORI", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0000000001000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 2;
const src = cs.imm16();
const dst = cs.ea(r, m, 2);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "ORI", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0000000010000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 4;
const src = cs.imm32();
const dst = cs.ea(r, m, 4);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "ORI", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111100111000000) === 0b0000000011000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b0000111111111111) === 0b0000000000000000) {
const s = getBits(w0, 9, 2);
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const a = getBits(w1, 15, 1);
const d = getBits(w1, 12, 3);
cs.skipWords(1);
const size = 1 << s;
const src = cs.ea(r, m, size);
const dst = cs.dar(a, d);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "CMP2", operands: [src, dst], extra },
};
}
}
if ((w0 & 0b1111100111000000) === 0b0000000011000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b0000111111111111) === 0b0000100000000000) {
const s = getBits(w0, 9, 2);
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const a = getBits(w1, 15, 1);
const d = getBits(w1, 12, 3);
cs.skipWords(1);
const size = 1 << s;
const src = cs.ea(r, m, size);
const dst = cs.dar(a, d);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "CHK2", operands: [src, dst], extra },
};
}
}
if ((w0 & 0b1111111111000000) === 0b0000101000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 1;
const src = cs.imm8();
const dst = cs.ea(r, m, 1);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "EORI", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0000101001000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 2;
const src = cs.imm16();
const dst = cs.ea(r, m, 2);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "EORI", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0000101010000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 4;
const src = cs.imm32();
const dst = cs.ea(r, m, 4);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "EORI", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0000110000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 1;
const src = cs.imm8();
const dst = cs.ea(r, m, 1);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "CMPI", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0000110001000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 2;
const src = cs.imm16();
const dst = cs.ea(r, m, 2);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "CMPI", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0000110010000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 4;
const src = cs.imm32();
const dst = cs.ea(r, m, 4);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "CMPI", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0000111000000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b0000111111111111) === 0b0000000000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const a = getBits(w1, 15, 1);
const d = getBits(w1, 12, 3);
cs.skipWords(1);
const size = 1;
const dst = cs.dar(a, d);
const src = cs.ea(r, m, 1);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "MOVES", operands: [src, dst], extra },
};
}
}
if ((w0 & 0b1111111111000000) === 0b0000111001000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b0000111111111111) === 0b0000000000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const a = getBits(w1, 15, 1);
const d = getBits(w1, 12, 3);
cs.skipWords(1);
const size = 2;
const dst = cs.dar(a, d);
const src = cs.ea(r, m, 2);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "MOVES", operands: [src, dst], extra },
};
}
}
if ((w0 & 0b1111111111000000) === 0b0000111010000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b0000111111111111) === 0b0000000000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const a = getBits(w1, 15, 1);
const d = getBits(w1, 12, 3);
cs.skipWords(1);
const size = 4;
const dst = cs.dar(a, d);
const src = cs.ea(r, m, 4);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "MOVES", operands: [src, dst], extra },
};
}
}
if ((w0 & 0b1111111111000000) === 0b0000111000000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b0000111111111111) === 0b0000100000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const a = getBits(w1, 15, 1);
const d = getBits(w1, 12, 3);
cs.skipWords(1);
const size = 1;
const src = cs.dar(a, d);
const dst = cs.ea(r, m, 1);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "MOVES", operands: [src, dst], extra },
};
}
}
if ((w0 & 0b1111111111000000) === 0b0000111001000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b0000111111111111) === 0b0000100000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const a = getBits(w1, 15, 1);
const d = getBits(w1, 12, 3);
cs.skipWords(1);
const size = 2;
const src = cs.dar(a, d);
const dst = cs.ea(r, m, 2);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "MOVES", operands: [src, dst], extra },
};
}
}
if ((w0 & 0b1111111111000000) === 0b0000111010000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b0000111111111111) === 0b0000100000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const a = getBits(w1, 15, 1);
const d = getBits(w1, 12, 3);
cs.skipWords(1);
const size = 4;
const src = cs.dar(a, d);
const dst = cs.ea(r, m, 4);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "MOVES", operands: [src, dst], extra },
};
}
}
if ((w0 & 0b1111111111110000) === 0b0000011011000000) {
const a = getBits(w0, 3, 1);
const r = getBits(w0, 0, 3);
const size = 0;
const src = cs.dar(a, r);
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "RTM", operands: [src, dst], extra },
};
}
throw new Error("NotImplemented");
}
function decodeGroup0001(w0: number, cs: CodeStream): DecodedInstruction {
if ((w0 & 0b1111000000000000) === 0b0001000000000000) {
const R = getBits(w0, 9, 3);
const M = getBits(w0, 6, 3);
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 1;
const src = cs.ea(r, m, 1);
const dst = cs.ea(R, M, 1);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "MOVE", operands: [src, dst], extra },
};
}
throw new Error("NotImplemented");
}
function decodeGroup0010(w0: number, cs: CodeStream): DecodedInstruction {
if ((w0 & 0b1111000111000000) === 0b0010000001000000) {
const R = getBits(w0, 9, 3);
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 4;
const src = cs.ea(r, m, 4);
const dst = cs.ea(R, 0b001, 4);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "MOVEA", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111000000000000) === 0b0010000000000000) {
const R = getBits(w0, 9, 3);
const M = getBits(w0, 6, 3);
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 4;
const src = cs.ea(r, m, 4);
const dst = cs.ea(R, M, 4);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "MOVE", operands: [src, dst], extra },
};
}
throw new Error("NotImplemented");
}
function decodeGroup0011(w0: number, cs: CodeStream): DecodedInstruction {
if ((w0 & 0b1111000111000000) === 0b0011000001000000) {
const R = getBits(w0, 9, 3);
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 2;
const src = cs.ea(r, m, 2);
const dst = cs.ea(R, 0b001, 2);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "MOVEA", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111000000000000) === 0b0011000000000000) {
const R = getBits(w0, 9, 3);
const M = getBits(w0, 6, 3);
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 2;
const src = cs.ea(r, m, 2);
const dst = cs.ea(R, M, 2);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "MOVE", operands: [src, dst], extra },
};
}
throw new Error("NotImplemented");
}
function decodeGroup0100(w0: number, cs: CodeStream): DecodedInstruction {
if ((w0 & 0b1111111111111111) === 0b0100101011111010) {
const size = 0;
const src = null;
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "BGND", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111111111) === 0b0100101011111100) {
const size = 0;
const src = null;
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "ILLEGAL", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111111111) === 0b0100111001110001) {
const size = 0;
const src = null;
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "NOP", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111111111) === 0b0100111001110000) {
const size = 0;
const src = null;
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "RESET", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111111111) === 0b0100111001110100) {
const size = 0;
const src = cs.imm16();
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "RTD", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111111111) === 0b0100111001110011) {
const size = 0;
const src = null;
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "RTE", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111111111) === 0b0100111001110111) {
const size = 0;
const src = null;
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "RTR", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111111111) === 0b0100111001110101) {
const size = 0;
const src = null;
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "RTS", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111111111) === 0b0100111001110010) {
const size = 0;
const src = cs.imm16();
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "STOP", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111111111) === 0b0100111001110110) {
const size = 0;
const src = null;
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "TRAPV", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111111111) === 0b0100111001111010 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b0000000000000000) === 0b0000000000000000) {
const a = getBits(w1, 15, 1);
const r = getBits(w1, 12, 3);
const c = getBits(w1, 0, 12);
cs.skipWords(1);
const size = 4;
const src = CONTROLREG(c);
const dst = cs.dar(a, r);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "MOVEC", operands: [src, dst], extra },
};
}
}
if ((w0 & 0b1111111111111111) === 0b0100111001111011 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b0000000000000000) === 0b0000000000000000) {
const a = getBits(w1, 15, 1);
const r = getBits(w1, 12, 3);
const c = getBits(w1, 0, 12);
cs.skipWords(1);
const size = 4;
const src = cs.dar(a, r);
const dst = CONTROLREG(c);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "MOVEC", operands: [src, dst], extra },
};
}
}
if ((w0 & 0b1111111111111000) === 0b0100100001000000) {
const r = getBits(w0, 0, 3);
const size = 0;
const src = DR(r);
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "SWAP", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111111000) === 0b0100100001001000) {
const n = getBits(w0, 0, 3);
const size = 0;
const src = IMM8(u8(n));
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "BKPT", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111111000) === 0b0100100010000000) {
const r = getBits(w0, 0, 3);
const size = 2;
const src = DR(r);
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "EXTW", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111111000) === 0b0100100011000000) {
const r = getBits(w0, 0, 3);
const size = 4;
const src = DR(r);
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "EXTL", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111111000) === 0b0100100111000000) {
const r = getBits(w0, 0, 3);
const size = 4;
const src = DR(r);
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "EXTBL", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111000111000000) === 0b0100000111000000) {
const n = getBits(w0, 9, 3);
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 4;
const src = cs.ea(r, m, 4);
const dst = AR(n);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "LEA", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111111000) === 0b0100111001010000) {
const r = getBits(w0, 0, 3);
const size = 2;
const src = AR(r);
const dst = cs.imm16();
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "LINK", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111111000) === 0b0100100000001000) {
const r = getBits(w0, 0, 3);
const size = 4;
const src = AR(r);
const dst = cs.imm32();
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "LINK", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111111000) === 0b0100111001011000) {
const r = getBits(w0, 0, 3);
const size = 0;
const src = AR(r);
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "UNLK", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111110000) === 0b0100111001000000) {
const v = getBits(w0, 0, 4);
const size = 0;
const src = IMM8(u8(v));
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "TRAP", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0100110001000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b1000111111111000) === 0b0000110000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const q = getBits(w1, 12, 3);
const R = getBits(w1, 0, 3);
if (R != q) {
cs.skipWords(1);
const size = 4;
const src = cs.ea(r, m, 4);
const dst = DPAIR(q, R);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: {
size,
operation: "DIVSL",
operands: [src, dst],
extra,
},
};
}
}
}
if ((w0 & 0b1111111111000000) === 0b0100110001000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b1000111111111000) === 0b0000110000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const q = getBits(w1, 12, 3);
const R = getBits(w1, 0, 3);
cs.skipWords(1);
const size = 4;
const src = cs.ea(r, m, 4);
const dst = DPAIR(q, R);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "DIVSL", operands: [src, dst], extra },
};
}
}
if ((w0 & 0b1111111111000000) === 0b0100110001000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b1000111111111000) === 0b0000100000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const q = getBits(w1, 12, 3);
const R = getBits(w1, 0, 3);
if (R != q) {
cs.skipWords(1);
const size = 4;
const src = cs.ea(r, m, 4);
const dst = DPAIR(q, R);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: {
size,
operation: "DIVSLL",
operands: [src, dst],
extra,
},
};
}
}
}
if ((w0 & 0b1111111111000000) === 0b0100110001000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b1000111111111000) === 0b0000100000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const q = getBits(w1, 12, 3);
cs.skipWords(1);
const size = 4;
const src = cs.ea(r, m, 4);
const dst = DR(q);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "DIVSL", operands: [src, dst], extra },
};
}
}
if ((w0 & 0b1111111111000000) === 0b0100110001000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b1000111111111000) === 0b0000010000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const q = getBits(w1, 12, 3);
const R = getBits(w1, 0, 3);
if (R != q) {
cs.skipWords(1);
const size = 4;
const src = cs.ea(r, m, 4);
const dst = DPAIR(q, R);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: {
size,
operation: "DIVUL",
operands: [src, dst],
extra,
},
};
}
}
}
if ((w0 & 0b1111111111000000) === 0b0100110001000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b1000111111111000) === 0b0000010000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const q = getBits(w1, 12, 3);
const R = getBits(w1, 0, 3);
cs.skipWords(1);
const size = 4;
const src = cs.ea(r, m, 4);
const dst = DPAIR(q, R);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "DIVUL", operands: [src, dst], extra },
};
}
}
if ((w0 & 0b1111111111000000) === 0b0100110001000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b1000111111111000) === 0b0000000000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const q = getBits(w1, 12, 3);
const R = getBits(w1, 0, 3);
if (R != q) {
cs.skipWords(1);
const size = 4;
const src = cs.ea(r, m, 4);
const dst = DPAIR(q, R);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: {
size,
operation: "DIVULL",
operands: [src, dst],
extra,
},
};
}
}
}
if ((w0 & 0b1111111111000000) === 0b0100110001000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b1000111111111000) === 0b0000000000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const q = getBits(w1, 12, 3);
cs.skipWords(1);
const size = 4;
const src = cs.ea(r, m, 4);
const dst = DR(q);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "DIVUL", operands: [src, dst], extra },
};
}
}
if ((w0 & 0b1111111111000000) === 0b0100111011000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 0;
const src = cs.ea(r, m, 0);
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "JMP", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0100111010000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 0;
const src = cs.ea(r, m, 0);
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "JSR", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0100110000000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b1000111111111000) === 0b0000100000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const l = getBits(w1, 12, 3);
cs.skipWords(1);
const size = 4;
const src = cs.ea(r, m, 4);
const dst = DR(l);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "MULS", operands: [src, dst], extra },
};
}
}
if ((w0 & 0b1111111111000000) === 0b0100110000000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b1000111111111000) === 0b0000110000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const l = getBits(w1, 12, 3);
const h = getBits(w1, 0, 3);
cs.skipWords(1);
const size = 4;
const src = cs.ea(r, m, 4);
const dst = DPAIR(l, h);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "MULS", operands: [src, dst], extra },
};
}
}
if ((w0 & 0b1111111111000000) === 0b0100110000000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b1000111111111000) === 0b0000000000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const l = getBits(w1, 12, 3);
cs.skipWords(1);
const size = 4;
const src = cs.ea(r, m, 4);
const dst = DR(l);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "MULU", operands: [src, dst], extra },
};
}
}
if ((w0 & 0b1111111111000000) === 0b0100110000000000 && cs.hasWords(1)) {
const w1 = cs.peekWord(0);
if ((w1 & 0b1000111111111000) === 0b0000010000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const l = getBits(w1, 12, 3);
const h = getBits(w1, 0, 3);
cs.skipWords(1);
const size = 4;
const src = cs.ea(r, m, 4);
const dst = DPAIR(l, h);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "MULU", operands: [src, dst], extra },
};
}
}
if ((w0 & 0b1111111111000000) === 0b0100100000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 1;
const src = cs.ea(r, m, 1);
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "NBCD", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0100000011000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 2;
const src = Implied();
const dst = cs.ea(r, m, 2);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: {
size,
operation: "MOVEFROMSR",
operands: [src, dst],
extra,
},
};
}
if ((w0 & 0b1111111111000000) === 0b0100011011000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 2;
const src = cs.ea(r, m, 2);
const dst = Implied();
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "MOVETOSR", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111111000) === 0b0100111001100000) {
const r = getBits(w0, 0, 3);
const size = 4;
const src = AR(r);
const dst = Implied();
const extra = null;
return {
bytesUsed: cs.pos,
instruction: {
size,
operation: "MOVETOUSP",
operands: [src, dst],
extra,
},
};
}
if ((w0 & 0b1111111111111000) === 0b0100111001101000) {
const r = getBits(w0, 0, 3);
const size = 4;
const src = Implied();
const dst = AR(r);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: {
size,
operation: "MOVEFROMUSP",
operands: [src, dst],
extra,
},
};
}
if ((w0 & 0b1111111111000000) === 0b0100001011000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 2;
const src = Implied();
const dst = cs.ea(r, m, 2);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: {
size,
operation: "MOVEFROMCCR",
operands: [src, dst],
extra,
},
};
}
if ((w0 & 0b1111111111000000) === 0b0100010011000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 2;
const src = cs.ea(r, m, 2);
const dst = Implied();
const extra = null;
return {
bytesUsed: cs.pos,
instruction: {
size,
operation: "MOVETOCCR",
operands: [src, dst],
extra,
},
};
}
if ((w0 & 0b1111111111000000) === 0b0100100001000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 4;
const src = cs.ea(r, m, 4);
const dst = Implied();
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "PEA", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0100101011000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 1;
const src = cs.ea(r, m, 1);
const dst = null;
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "TAS", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111110000000) === 0b0100100010000000) {
const s = getBits(w0, 6, 1);
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 2 << s;
const src = REGLIST(cs.pull16());
const dst = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "MOVEM", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111110000000) === 0b0100110010000000) {
const s = getBits(w0, 6, 1);
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 2 << s;
const dst = REGLIST(cs.pull16());
const src = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "MOVEM", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0100001000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 1;
const src = Implied();
const dst = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "CLR", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0100001001000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 2;
const src = Implied();
const dst = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "CLR", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0100001010000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 4;
const src = Implied();
const dst = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "CLR", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0100010000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 1;
const src = Implied();
const dst = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "NEG", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0100010001000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 2;
const src = Implied();
const dst = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "NEG", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0100010010000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 4;
const src = Implied();
const dst = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "NEG", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0100000000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 1;
const src = Implied();
const dst = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "NEGX", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0100000001000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 2;
const src = Implied();
const dst = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "NEGX", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0100000010000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 4;
const src = Implied();
const dst = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "NEGX", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0100011000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 1;
const src = Implied();
const dst = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "NOT", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0100011001000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 2;
const src = Implied();
const dst = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "NOT", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0100011010000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 4;
const src = Implied();
const dst = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "NOT", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0100101000000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 1;
const src = Implied();
const dst = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "TST", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0100101001000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 2;
const src = Implied();
const dst = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "TST", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111111111000000) === 0b0100101010000000) {
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 4;
const src = Implied();
const dst = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "TST", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111000111000000) === 0b0100000110000000) {
const d = getBits(w0, 9, 3);
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 2;
const src = cs.ea(r, m, size);
const dst = DR(d);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "CHK", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111000111000000) === 0b0100000100000000) {
const d = getBits(w0, 9, 3);
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 4;
const src = cs.ea(r, m, size);
const dst = DR(d);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "CHK", operands: [src, dst], extra },
};
}
throw new Error("NotImplemented");
}
function decodeGroup0101(w0: number, cs: CodeStream): DecodedInstruction {
if ((w0 & 0b1111000011111000) === 0b0101000011001000) {
const c = getBits(w0, 8, 4);
const r = getBits(w0, 0, 3);
const size = 2;
const src = DR(r);
const dst = PCDISP(2, simpleDisp(i16(cs.pull16())));
const extra = cs.cc(c);
return {
bytesUsed: cs.pos,
instruction: { size, operation: "DBCC", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111000111000000) === 0b0101000000000000) {
const d = getBits(w0, 9, 3);
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 1;
const src = cs.quickConst(d);
const dst = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "ADDQ", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111000111000000) === 0b0101000001000000) {
const d = getBits(w0, 9, 3);
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 2;
const src = cs.quickConst(d);
const dst = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "ADDQ", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111000111000000) === 0b0101000010000000) {
const d = getBits(w0, 9, 3);
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 4;
const src = cs.quickConst(d);
const dst = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "ADDQ", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111000111000000) === 0b0101000100000000) {
const d = getBits(w0, 9, 3);
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 1;
const src = cs.quickConst(d);
const dst = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "SUBQ", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111000111000000) === 0b0101000101000000) {
const d = getBits(w0, 9, 3);
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 2;
const src = cs.quickConst(d);
const dst = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "SUBQ", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111000111000000) === 0b0101000110000000) {
const d = getBits(w0, 9, 3);
const m = getBits(w0, 3, 3);
const r = getBits(w0, 0, 3);
const size = 4;
const src = cs.quickConst(d);
const dst = cs.ea(r, m, size);
const extra = null;
return {
bytesUsed: cs.pos,
instruction: { size, operation: "SUBQ", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111000011111111) === 0b0101000011111100) {
const c = getBits(w0, 8, 4);
const size = 0;
const src = null;
const dst = null;
const extra = cs.cc(c);
return {
bytesUsed: cs.pos,
instruction: { size, operation: "TRAPCC", operands: [src, dst], extra },
};
}
if ((w0 & 0b1111000011111111) === 0b0101000011111010) {
const c = getBits(w0, 8, 4);
const size = 2;
const src = cs.imm16();