@jhlagado/azm 0.2.6 → 0.2.8

package/dist/src/z80/encode-core.js

@@ -0,0 +1,42 @@
+const CORE_OPCODES = {
+    di: [0xf3],
+    ei: [0xfb],
+    scf: [0x37],
+    ccf: [0x3f],
+    cpl: [0x2f],
+    daa: [0x27],
+    exx: [0xd9],
+    halt: [0x76],
+    rlca: [0x07],
+    rrca: [0x0f],
+    rla: [0x17],
+    rra: [0x1f],
+    neg: [0xed, 0x44],
+    rrd: [0xed, 0x67],
+    rld: [0xed, 0x6f],
+    ldi: [0xed, 0xa0],
+    ldir: [0xed, 0xb0],
+    ldd: [0xed, 0xa8],
+    lddr: [0xed, 0xb8],
+    cpi: [0xed, 0xa1],
+    cpir: [0xed, 0xb1],
+    cpd: [0xed, 0xa9],
+    cpdr: [0xed, 0xb9],
+    ini: [0xed, 0xa2],
+    inir: [0xed, 0xb2],
+    ind: [0xed, 0xaa],
+    indr: [0xed, 0xba],
+    outi: [0xed, 0xa3],
+    otir: [0xed, 0xb3],
+    outd: [0xed, 0xab],
+    otdr: [0xed, 0xbb],
+    reti: [0xed, 0x4d],
+    retn: [0xed, 0x45],
+};
+export function encodeCore(mnemonic) {
+    const opcode = CORE_OPCODES[mnemonic];
+    return {
+        size: opcode.length,
+        fragments: [{ kind: 'bytes', bytes: opcode }],
+    };
+}

package/dist/src/z80/encode-ld-helpers.d.ts

@@ -0,0 +1,25 @@
+import type { EncodedZ80Instruction, Z80IndexRegister16, Z80Instruction, Z80Operand, Z80Register16, Z80Register8, Z80RegisterIndirect } from './instruction.js';
+export type Z80InstructionTarget = Extract<Z80Instruction, {
+    readonly expression: unknown;
+}>['expression'];
+export type HalfIndexLdOperand = Extract<Z80Operand, {
+    readonly kind: 'reg8' | 'reg-half-index';
+}>;
+export type LoadSpSourceOperand = Extract<Z80Operand, {
+    readonly kind: 'reg16' | 'reg-index16';
+}>;
+export declare function absoluteLd(opcode: number, expression: Z80InstructionTarget): EncodedZ80Instruction;
+export declare function prefixedAbsoluteLd(prefix: number, opcode: number, expression: Z80InstructionTarget): EncodedZ80Instruction;
+export declare function absoluteRegister16Load(register: Z80Register16, expression: Z80InstructionTarget): EncodedZ80Instruction;
+export declare function absoluteRegister16Store(register: Z80Register16, expression: Z80InstructionTarget): EncodedZ80Instruction;
+export declare function isHalfIndexTransferLd(target: Z80Operand, source: Z80Operand): boolean;
+export declare function isLoadSpFromWordRegister(target: Z80Operand, source: Z80Operand): boolean;
+export declare function loadSpOpcode(register: Z80Register16 | Z80IndexRegister16): readonly number[];
+export declare function halfIndexPrefix(target: HalfIndexLdOperand, source: HalfIndexLdOperand): number;
+export declare function byteRegisterCode(operand: HalfIndexLdOperand): number;
+export declare function oneByteInstruction(opcode: number): EncodedZ80Instruction;
+export declare function indexPrefix(register: 'ix' | 'iy'): number;
+export declare function register8Code(register: Z80Register8): number;
+export declare function register16Code(register: Z80Register16): number;
+export declare function loadAFromIndirectOpcode(register: Z80RegisterIndirect): number;
+export declare function storeAToIndirectOpcode(register: Z80RegisterIndirect): number;

package/dist/src/z80/encode-ld-helpers.js

@@ -0,0 +1,172 @@
+export function absoluteLd(opcode, expression) {
+    return {
+        size: 3,
+        fragments: [
+            { kind: 'bytes', bytes: [opcode] },
+            { kind: 'abs16', expression },
+        ],
+    };
+}
+export function prefixedAbsoluteLd(prefix, opcode, expression) {
+    return {
+        size: 4,
+        fragments: [
+            { kind: 'bytes', bytes: [prefix, opcode] },
+            { kind: 'abs16', expression },
+        ],
+    };
+}
+export function absoluteRegister16Load(register, expression) {
+    switch (register) {
+        case 'hl':
+            return absoluteLd(0x2a, expression);
+        case 'bc':
+            return prefixedAbsoluteLd(0xed, 0x4b, expression);
+        case 'de':
+            return prefixedAbsoluteLd(0xed, 0x5b, expression);
+        case 'sp':
+            return prefixedAbsoluteLd(0xed, 0x7b, expression);
+    }
+}
+export function absoluteRegister16Store(register, expression) {
+    switch (register) {
+        case 'hl':
+            return absoluteLd(0x22, expression);
+        case 'bc':
+            return prefixedAbsoluteLd(0xed, 0x43, expression);
+        case 'de':
+            return prefixedAbsoluteLd(0xed, 0x53, expression);
+        case 'sp':
+            return prefixedAbsoluteLd(0xed, 0x73, expression);
+    }
+}
+export function isHalfIndexTransferLd(target, source) {
+    return ((target.kind === 'reg8' || target.kind === 'reg-half-index') &&
+        (source.kind === 'reg8' || source.kind === 'reg-half-index') &&
+        isEncodableHalfIndexLd(target, source));
+}
+export function isLoadSpFromWordRegister(target, source) {
+    return (target.kind === 'reg16' &&
+        target.register === 'sp' &&
+        ((source.kind === 'reg16' && source.register === 'hl') || source.kind === 'reg-index16'));
+}
+export function loadSpOpcode(register) {
+    switch (register) {
+        case 'hl':
+            return [0xf9];
+        case 'ix':
+            return [0xdd, 0xf9];
+        case 'iy':
+            return [0xfd, 0xf9];
+        default:
+            throw new Error(`unsupported LD SP source register: ${register}`);
+    }
+}
+export function halfIndexPrefix(target, source) {
+    const register = target.kind === 'reg-half-index'
+        ? target.register
+        : source.kind === 'reg-half-index'
+            ? source.register
+            : undefined;
+    if (!register) {
+        throw new Error('expected half-index register');
+    }
+    return register.startsWith('ix') ? 0xdd : 0xfd;
+}
+export function byteRegisterCode(operand) {
+    return operand.kind === 'reg8'
+        ? register8Code(operand.register)
+        : halfIndexRegisterCode(operand.register);
+}
+export function oneByteInstruction(opcode) {
+    return {
+        size: 1,
+        fragments: [{ kind: 'bytes', bytes: [opcode] }],
+    };
+}
+export function indexPrefix(register) {
+    return register === 'ix' ? 0xdd : 0xfd;
+}
+export function register8Code(register) {
+    switch (register) {
+        case 'b':
+            return 0;
+        case 'c':
+            return 1;
+        case 'd':
+            return 2;
+        case 'e':
+            return 3;
+        case 'h':
+            return 4;
+        case 'l':
+            return 5;
+        case 'a':
+            return 7;
+    }
+}
+export function register16Code(register) {
+    switch (register) {
+        case 'bc':
+            return 0;
+        case 'de':
+            return 1;
+        case 'hl':
+            return 2;
+        case 'sp':
+            return 3;
+    }
+}
+export function loadAFromIndirectOpcode(register) {
+    switch (register) {
+        case 'bc':
+            return 0x0a;
+        case 'de':
+            return 0x1a;
+        case 'hl':
+            return 0x7e;
+    }
+}
+export function storeAToIndirectOpcode(register) {
+    switch (register) {
+        case 'bc':
+            return 0x02;
+        case 'de':
+            return 0x12;
+        case 'hl':
+            return 0x77;
+    }
+}
+function isEncodableHalfIndexLd(target, source) {
+    if (target.kind !== 'reg-half-index' && source.kind !== 'reg-half-index') {
+        return false;
+    }
+    return (isSameHalfIndexFamily(target, source) &&
+        isHalfIndexCompatibleByteOperand(target) &&
+        isHalfIndexCompatibleByteOperand(source));
+}
+function isSameHalfIndexFamily(target, source) {
+    const targetFamily = halfIndexFamily(target);
+    const sourceFamily = halfIndexFamily(source);
+    return !targetFamily || !sourceFamily || targetFamily === sourceFamily;
+}
+function halfIndexFamily(operand) {
+    if (operand.kind !== 'reg-half-index') {
+        return undefined;
+    }
+    return operand.register.startsWith('ix') ? 'ix' : 'iy';
+}
+function isHalfIndexCompatibleByteOperand(operand) {
+    return (operand.kind === 'reg-half-index' ||
+        (operand.kind === 'reg8' && operand.register !== 'h' && operand.register !== 'l'));
+}
+function halfIndexRegisterCode(register) {
+    switch (register) {
+        case 'ixh':
+        case 'iyh':
+            return 4;
+        case 'ixl':
+        case 'iyl':
+            return 5;
+    }
+}

package/dist/src/z80/encode-ld.d.ts

@@ -0,0 +1,2 @@
+import type { EncodedZ80Instruction, Z80Operand } from './instruction.js';
+export declare function encodeLd(target: Z80Operand, source: Z80Operand): EncodedZ80Instruction;

package/dist/src/z80/encode-ld.js

@@ -0,0 +1,285 @@
+import { absoluteLd, absoluteRegister16Load, absoluteRegister16Store, byteRegisterCode, halfIndexPrefix, indexPrefix, isHalfIndexTransferLd, isLoadSpFromWordRegister, loadAFromIndirectOpcode, loadSpOpcode, oneByteInstruction, prefixedAbsoluteLd, register16Code, register8Code, storeAToIndirectOpcode, } from './encode-ld-helpers.js';
+const LD_UNSUPPORTED_FORM_MESSAGE = 'ld expects a supported register/memory/immediate transfer form';
+const BYTE_REGISTER_LD_ENCODERS = [
+    encodeReg8ImmediateLd,
+    encodeReg8RegisterLd,
+    encodeLoadAFromAbsoluteLd,
+    encodeStoreAToAbsoluteLd,
+    encodeHalfIndexTransferLd,
+];
+const WORD_REGISTER_LD_ENCODERS = [
+    encodeReg16ImmediateLd,
+    encodeIndex16ImmediateLd,
+    encodeLoadSpFromWordRegisterLd,
+    encodeAbsoluteRegister16LoadLd,
+    encodeAbsoluteIndex16LoadLd,
+    encodeAbsoluteRegister16StoreLd,
+    encodeAbsoluteIndex16StoreLd,
+];
+const HL_INDIRECT_LD_ENCODERS = [
+    encodeStoreReg8ToHlLd,
+    encodeStoreImmToHlLd,
+    encodeLoadReg8FromHlLd,
+];
+export function encodeLd(target, source) {
+    const encoded = encodeLegacyReg16ByteTransferLd(target, source) ??
+        encodeSpecialRegisterLd(target, source) ??
+        firstLdEncoding(BYTE_REGISTER_LD_ENCODERS, target, source) ??
+        firstLdEncoding(WORD_REGISTER_LD_ENCODERS, target, source) ??
+        encodeAccumulatorIndirectLd(target, source) ??
+        firstLdEncoding(HL_INDIRECT_LD_ENCODERS, target, source) ??
+        encodeIndexedLd(target, source);
+    if (encoded)
+        return encoded;
+    return {
+        size: 0,
+        fragments: [],
+    };
+}
+function firstLdEncoding(encoders, target, source) {
+    for (const encoder of encoders) {
+        const encoded = encoder(target, source);
+        if (encoded)
+            return encoded;
+    }
+    return undefined;
+}
+function encodeReg8ImmediateLd(target, source) {
+    if (target.kind !== 'reg8' || source.kind !== 'imm')
+        return undefined;
+    return {
+        size: 2,
+        fragments: [
+            { kind: 'bytes', bytes: [0x06 + register8Code(target.register) * 8] },
+            {
+                kind: 'imm8',
+                expression: source.expression,
+                failureMessage: LD_UNSUPPORTED_FORM_MESSAGE,
+            },
+        ],
+    };
+}
+function encodeReg8RegisterLd(target, source) {
+    if (target.kind !== 'reg8' || source.kind !== 'reg8')
+        return undefined;
+    return oneByteInstruction(0x40 + register8Code(target.register) * 8 + register8Code(source.register));
+}
+function encodeLoadAFromAbsoluteLd(target, source) {
+    if (target.kind !== 'reg8' || target.register !== 'a' || source.kind !== 'mem-abs') {
+        return undefined;
+    }
+    return absoluteLd(0x3a, source.expression);
+}
+function encodeStoreAToAbsoluteLd(target, source) {
+    if (target.kind !== 'mem-abs' || source.kind !== 'reg8' || source.register !== 'a') {
+        return undefined;
+    }
+    return absoluteLd(0x32, target.expression);
+}
+function encodeHalfIndexTransferLd(target, source) {
+    if (!isHalfIndexTransferLd(target, source))
+        return undefined;
+    const ldTarget = target;
+    const ldSource = source;
+    const prefix = halfIndexPrefix(ldTarget, ldSource);
+    return {
+        size: 2,
+        fragments: [
+            {
+                kind: 'bytes',
+                bytes: [prefix, 0x40 + byteRegisterCode(ldTarget) * 8 + byteRegisterCode(ldSource)],
+            },
+        ],
+    };
+}
+function encodeReg16ImmediateLd(target, source) {
+    if (target.kind !== 'reg16' || source.kind !== 'imm')
+        return undefined;
+    return {
+        size: 3,
+        fragments: [
+            { kind: 'bytes', bytes: [0x01 + register16Code(target.register) * 0x10] },
+            { kind: 'abs16', expression: source.expression },
+        ],
+    };
+}
+function encodeIndex16ImmediateLd(target, source) {
+    if (target.kind !== 'reg-index16' || source.kind !== 'imm')
+        return undefined;
+    return {
+        size: 4,
+        fragments: [
+            { kind: 'bytes', bytes: [indexPrefix(target.register), 0x21] },
+            { kind: 'abs16', expression: source.expression },
+        ],
+    };
+}
+function encodeLoadSpFromWordRegisterLd(target, source) {
+    if (!isLoadSpFromWordRegister(target, source))
+        return undefined;
+    const ldSource = source;
+    return {
+        size: ldSource.kind === 'reg-index16' ? 2 : 1,
+        fragments: [{ kind: 'bytes', bytes: loadSpOpcode(ldSource.register) }],
+    };
+}
+function encodeAbsoluteRegister16LoadLd(target, source) {
+    if (target.kind !== 'reg16' || source.kind !== 'mem-abs')
+        return undefined;
+    return absoluteRegister16Load(target.register, source.expression);
+}
+function encodeAbsoluteIndex16LoadLd(target, source) {
+    if (target.kind !== 'reg-index16' || source.kind !== 'mem-abs')
+        return undefined;
+    return prefixedAbsoluteLd(indexPrefix(target.register), 0x2a, source.expression);
+}
+function encodeAbsoluteRegister16StoreLd(target, source) {
+    if (target.kind !== 'mem-abs' || source.kind !== 'reg16')
+        return undefined;
+    return absoluteRegister16Store(source.register, target.expression);
+}
+function encodeAbsoluteIndex16StoreLd(target, source) {
+    if (target.kind !== 'mem-abs' || source.kind !== 'reg-index16')
+        return undefined;
+    return prefixedAbsoluteLd(indexPrefix(source.register), 0x22, target.expression);
+}
+function encodeAccumulatorIndirectLd(target, source) {
+    return (encodeLoadAFromRegisterIndirectLd(target, source) ??
+        encodeStoreAToRegisterIndirectLd(target, source));
+}
+function encodeLoadAFromRegisterIndirectLd(target, source) {
+    if (target.kind !== 'reg8' || target.register !== 'a' || source.kind !== 'reg-indirect') {
+        return undefined;
+    }
+    return oneByteInstruction(loadAFromIndirectOpcode(source.register));
+}
+function encodeStoreAToRegisterIndirectLd(target, source) {
+    if (target.kind !== 'reg-indirect' || source.kind !== 'reg8' || source.register !== 'a') {
+        return undefined;
+    }
+    return oneByteInstruction(storeAToIndirectOpcode(target.register));
+}
+function encodeStoreReg8ToHlLd(target, source) {
+    if (target.kind !== 'reg-indirect' || target.register !== 'hl' || source.kind !== 'reg8') {
+        return undefined;
+    }
+    return oneByteInstruction(0x70 + register8Code(source.register));
+}
+function encodeStoreImmToHlLd(target, source) {
+    if (target.kind !== 'reg-indirect' || target.register !== 'hl' || source.kind !== 'imm') {
+        return undefined;
+    }
+    return {
+        size: 2,
+        fragments: [
+            { kind: 'bytes', bytes: [0x36] },
+            {
+                kind: 'imm8',
+                expression: source.expression,
+                failureMessage: LD_UNSUPPORTED_FORM_MESSAGE,
+            },
+        ],
+    };
+}
+function encodeLoadReg8FromHlLd(target, source) {
+    if (target.kind !== 'reg8' || source.kind !== 'reg-indirect' || source.register !== 'hl') {
+        return undefined;
+    }
+    return oneByteInstruction(0x46 + register8Code(target.register) * 8);
+}
+function encodeIndexedLd(target, source) {
+    return (encodeLoadReg8FromIndexedLd(target, source) ??
+        encodeStoreReg8ToIndexedLd(target, source) ??
+        encodeStoreImmToIndexedLd(target, source));
+}
+function encodeLoadReg8FromIndexedLd(target, source) {
+    if (target.kind !== 'reg8' || source.kind !== 'indexed')
+        return undefined;
+    return {
+        size: 3,
+        fragments: [
+            {
+                kind: 'bytes',
+                bytes: [indexPrefix(source.register), 0x46 + register8Code(target.register) * 8],
+            },
+            {
+                kind: 'disp8',
+                expression: source.displacement,
+                message: 'ld (ix/iy+disp) expects disp8',
+            },
+        ],
+    };
+}
+function encodeStoreReg8ToIndexedLd(target, source) {
+    if (target.kind !== 'indexed' || source.kind !== 'reg8')
+        return undefined;
+    return {
+        size: 3,
+        fragments: [
+            {
+                kind: 'bytes',
+                bytes: [indexPrefix(target.register), 0x70 + register8Code(source.register)],
+            },
+            {
+                kind: 'disp8',
+                expression: target.displacement,
+                message: 'ld (ix/iy+disp) expects disp8',
+            },
+        ],
+    };
+}
+function encodeStoreImmToIndexedLd(target, source) {
+    if (target.kind !== 'indexed' || source.kind !== 'imm')
+        return undefined;
+    return {
+        size: 4,
+        fragments: [
+            { kind: 'bytes', bytes: [indexPrefix(target.register), 0x36] },
+            {
+                kind: 'disp8',
+                expression: target.displacement,
+                message: 'ld (ix/iy+disp), n expects disp8',
+            },
+            {
+                kind: 'imm8',
+                expression: source.expression,
+                failureMessage: LD_UNSUPPORTED_FORM_MESSAGE,
+            },
+        ],
+    };
+}
+function encodeLegacyReg16ByteTransferLd(target, source) {
+    if (target.kind !== 'reg16' || source.kind !== 'reg16') {
+        return undefined;
+    }
+    const transfers = legacyReg16ByteTransferOpcodes(target.register, source.register);
+    if (!transfers) {
+        return undefined;
+    }
+    return {
+        size: transfers.length,
+        fragments: [{ kind: 'bytes', bytes: transfers }],
+    };
+}
+function legacyReg16ByteTransferOpcodes(target, source) {
+    if (target === 'hl' && source === 'de')
+        return [0x62, 0x6b];
+    if (target === 'bc' && source === 'de')
+        return [0x42, 0x4b];
+    return undefined;
+}
+function encodeSpecialRegisterLd(target, source) {
+    if (target.kind === 'special8' && source.kind === 'reg8' && source.register === 'a') {
+        return {
+            size: 2,
+            fragments: [{ kind: 'bytes', bytes: [0xed, target.register === 'i' ? 0x47 : 0x4f] }],
+        };
+    }
+    if (target.kind === 'reg8' && target.register === 'a' && source.kind === 'special8') {
+        return {
+            size: 2,
+            fragments: [{ kind: 'bytes', bytes: [0xed, source.register === 'i' ? 0x57 : 0x5f] }],
+        };
+    }
+    return undefined;
+}