@jhlagado/azm 0.2.7 → 0.2.8

package/dist/src/z80/encode.js

@@ -1,128 +1,194 @@
+import { encodeCore } from './encode-core.js';
+import { encodeLd } from './encode-ld.js';
+const ROTATE_SHIFT_OPCODE_BASES = {
+    rlc: 0x00,
+    rrc: 0x08,
+    rl: 0x10,
+    rr: 0x18,
+    sla: 0x20,
+    sra: 0x28,
+    sll: 0x30,
+    sls: 0x30,
+    srl: 0x38,
+};
+function oneByteInstruction(opcode) {
+    return { size: 1, fragments: [{ kind: 'bytes', bytes: [opcode] }] };
+}
+const Z80_ENCODERS = {
+    nop: () => oneByteInstruction(0x00),
+    ret: () => oneByteInstruction(0xc9),
+    'ret-cc': encodeRetConditionInstruction,
+    di: encodeCoreInstruction,
+    ei: encodeCoreInstruction,
+    scf: encodeCoreInstruction,
+    ccf: encodeCoreInstruction,
+    cpl: encodeCoreInstruction,
+    daa: encodeCoreInstruction,
+    exx: encodeCoreInstruction,
+    halt: encodeCoreInstruction,
+    rlca: encodeCoreInstruction,
+    rrca: encodeCoreInstruction,
+    rla: encodeCoreInstruction,
+    rra: encodeCoreInstruction,
+    neg: encodeCoreInstruction,
+    rrd: encodeCoreInstruction,
+    rld: encodeCoreInstruction,
+    ldi: encodeCoreInstruction,
+    ldir: encodeCoreInstruction,
+    ldd: encodeCoreInstruction,
+    lddr: encodeCoreInstruction,
+    cpi: encodeCoreInstruction,
+    cpir: encodeCoreInstruction,
+    cpd: encodeCoreInstruction,
+    cpdr: encodeCoreInstruction,
+    ini: encodeCoreInstruction,
+    inir: encodeCoreInstruction,
+    ind: encodeCoreInstruction,
+    indr: encodeCoreInstruction,
+    outi: encodeCoreInstruction,
+    otir: encodeCoreInstruction,
+    outd: encodeCoreInstruction,
+    otdr: encodeCoreInstruction,
+    reti: encodeCoreInstruction,
+    retn: encodeCoreInstruction,
+    ex: encodeExchangeInstruction,
+    im: encodeInterruptModeInstruction,
+    rst: encodeRstInstruction,
+    inc: encodeIncDecInstruction,
+    dec: encodeIncDecInstruction,
+    push: encodeStackInstruction,
+    pop: encodeStackInstruction,
+    'ld-a-imm': encodeLdAImmediateInstruction,
+    ld: encodeLdInstruction,
+    in: encodeInInstruction,
+    out: encodeOutInstruction,
+    bit: encodeBitLikeInstruction,
+    res: encodeBitLikeInstruction,
+    set: encodeBitLikeInstruction,
+    rlc: encodeRotateShiftInstruction,
+    rrc: encodeRotateShiftInstruction,
+    rl: encodeRotateShiftInstruction,
+    rr: encodeRotateShiftInstruction,
+    sla: encodeRotateShiftInstruction,
+    sra: encodeRotateShiftInstruction,
+    sll: encodeRotateShiftInstruction,
+    sls: encodeRotateShiftInstruction,
+    srl: encodeRotateShiftInstruction,
+    add: encodeAluInstruction,
+    adc: encodeAluInstruction,
+    sub: encodeAluInstruction,
+    sbc: encodeAluInstruction,
+    and: encodeAluInstruction,
+    or: encodeAluInstruction,
+    xor: encodeAluInstruction,
+    cp: encodeAluInstruction,
+    jp: encodeJumpInstruction,
+    'jp-cc': encodeConditionalJumpInstruction,
+    'jp-indirect': encodeIndirectJumpInstruction,
+    call: encodeCallInstruction,
+    'call-cc': encodeConditionalCallInstruction,
+    jr: encodeRelativeJumpInstruction,
+    'jr-cc': encodeConditionalRelativeJumpInstruction,
+    djnz: encodeDjnzInstruction,
+};
 export function encodeZ80Instruction(instruction) {
-    switch (instruction.mnemonic) {
-        case 'nop':
-            return { size: 1, fragments: [{ kind: 'bytes', bytes: [0x00] }] };
-        case 'ret':
-            return { size: 1, fragments: [{ kind: 'bytes', bytes: [0xc9] }] };
-        case 'ret-cc':
-            return {
-                size: 1,
-                fragments: [{ kind: 'bytes', bytes: [retConditionOpcode(instruction.condition)] }],
-            };
-        case 'di':
-        case 'ei':
-        case 'scf':
-        case 'ccf':
-        case 'cpl':
-        case 'daa':
-        case 'exx':
-        case 'halt':
-        case 'rlca':
-        case 'rrca':
-        case 'rla':
-        case 'rra':
-        case 'neg':
-        case 'rrd':
-        case 'rld':
-        case 'ldi':
-        case 'ldir':
-        case 'ldd':
-        case 'lddr':
-        case 'cpi':
-        case 'cpir':
-        case 'cpd':
-        case 'cpdr':
-        case 'ini':
-        case 'inir':
-        case 'ind':
-        case 'indr':
-        case 'outi':
-        case 'otir':
-        case 'outd':
-        case 'otdr':
-        case 'reti':
-        case 'retn':
-            return encodeCore(instruction.mnemonic);
-        case 'ex':
-            return encodeExchange(instruction.form);
-        case 'im':
-            return {
-                size: 2,
-                fragments: [{ kind: 'bytes', bytes: [0xed, imOpcode(instruction.mode)] }],
-            };
-        case 'rst':
-            return {
-                size: 1,
-                fragments: [{ kind: 'bytes', bytes: [rstOpcode(instruction.vector)] }],
-            };
-        case 'inc':
-        case 'dec':
-            return encodeIncDec(instruction.mnemonic, instruction.operand);
-        case 'push':
-        case 'pop':
-            return encodeStack(instruction.mnemonic, instruction.register);
-        case 'ld-a-imm':
-            return {
-                size: 2,
-                fragments: [
-                    { kind: 'bytes', bytes: [0x3e] },
-                    { kind: 'imm8', expression: instruction.expression },
-                ],
-            };
-        case 'ld':
-            return encodeLd(instruction.target, instruction.source);
-        case 'in':
-            return encodeIn(instruction.target, instruction.port);
-        case 'out':
-            return encodeOut(instruction.port, instruction.source);
-        case 'bit':
-        case 'res':
-        case 'set':
-            return encodeBitLike(instruction.mnemonic, instruction.bit, instruction.operand, instruction.destination);
-        case 'rlc':
-        case 'rrc':
-        case 'rl':
-        case 'rr':
-        case 'sla':
-        case 'sra':
-        case 'sll':
-        case 'sls':
-        case 'srl':
-            return encodeRotateShift(instruction.mnemonic, instruction.operand, instruction.destination);
-        case 'add':
-        case 'adc':
-            if ('target' in instruction) {
-                return encode16BitAlu(instruction.mnemonic, instruction.target.register, instruction.source.register);
-            }
-            return encodeAlu(instruction.mnemonic, instruction.source);
-        case 'sub':
-        case 'sbc':
-            if ('target' in instruction) {
-                return encode16BitAlu(instruction.mnemonic, instruction.target.register, instruction.source.register);
-            }
-            return encodeAlu(instruction.mnemonic, instruction.source);
-        case 'and':
-        case 'or':
-        case 'xor':
-        case 'cp':
-            return encodeAlu(instruction.mnemonic, instruction.source);
-        case 'jp':
-            return absoluteTarget(0xc3, instruction.expression);
-        case 'jp-cc':
-            return absoluteTarget(jpConditionOpcode(instruction.condition), instruction.expression);
-        case 'jp-indirect':
-            return jumpIndirect(instruction.register);
-        case 'call':
-            return absoluteTarget(0xcd, instruction.expression);
-        case 'call-cc':
-            return absoluteTarget(callConditionOpcode(instruction.condition), instruction.expression);
-        case 'jr':
-            return relativeTarget(0x18, 'jr', instruction.expression);
-        case 'jr-cc':
-            return relativeTarget(jrConditionOpcode(instruction.condition), `jr ${instruction.condition}`, instruction.expression);
-        case 'djnz':
-            return relativeTarget(0x10, 'djnz', instruction.expression);
+    return Z80_ENCODERS[instruction.mnemonic](instruction);
+}
+function encodeRetConditionInstruction(instruction) {
+    const ret = instruction;
+    return oneByteInstruction(retConditionOpcode(ret.condition));
+}
+function encodeCoreInstruction(instruction) {
+    return encodeCore(instruction.mnemonic);
+}
+function encodeExchangeInstruction(instruction) {
+    const exchange = instruction;
+    return encodeExchange(exchange.form);
+}
+function encodeInterruptModeInstruction(instruction) {
+    const im = instruction;
+    return { size: 2, fragments: [{ kind: 'bytes', bytes: [0xed, imOpcode(im.mode)] }] };
+}
+function encodeRstInstruction(instruction) {
+    const rst = instruction;
+    return oneByteInstruction(rstOpcode(rst.vector));
+}
+function encodeIncDecInstruction(instruction) {
+    const incDec = instruction;
+    return encodeIncDec(incDec.mnemonic, incDec.operand);
+}
+function encodeStackInstruction(instruction) {
+    const stack = instruction;
+    return encodeStack(stack.mnemonic, stack.register);
+}
+function encodeLdAImmediateInstruction(instruction) {
+    const ldA = instruction;
+    return {
+        size: 2,
+        fragments: [
+            { kind: 'bytes', bytes: [0x3e] },
+            { kind: 'imm8', expression: ldA.expression },
+        ],
+    };
+}
+function encodeLdInstruction(instruction) {
+    const ld = instruction;
+    return encodeLd(ld.target, ld.source);
+}
+function encodeInInstruction(instruction) {
+    const input = instruction;
+    return encodeIn(input.target, input.port);
+}
+function encodeOutInstruction(instruction) {
+    const output = instruction;
+    return encodeOut(output.port, output.source);
+}
+function encodeBitLikeInstruction(instruction) {
+    const bitLike = instruction;
+    return encodeBitLike(bitLike.mnemonic, bitLike.bit, bitLike.operand, bitLike.destination);
+}
+function encodeRotateShiftInstruction(instruction) {
+    const rotateShift = instruction;
+    return encodeRotateShift(rotateShift.mnemonic, rotateShift.operand, rotateShift.destination);
+}
+function encodeAluInstruction(instruction) {
+    const alu = instruction;
+    if ('target' in alu) {
+        return encode16BitAlu(alu.mnemonic, alu.target.register, alu.source.register);
     }
+    return encodeAlu(alu.mnemonic, alu.source);
+}
+function encodeJumpInstruction(instruction) {
+    const jump = instruction;
+    return absoluteTarget(0xc3, jump.expression);
+}
+function encodeConditionalJumpInstruction(instruction) {
+    const jump = instruction;
+    return absoluteTarget(jpConditionOpcode(jump.condition), jump.expression);
+}
+function encodeIndirectJumpInstruction(instruction) {
+    const jump = instruction;
+    return jumpIndirect(jump.register);
+}
+function encodeCallInstruction(instruction) {
+    const call = instruction;
+    return absoluteTarget(0xcd, call.expression);
+}
+function encodeConditionalCallInstruction(instruction) {
+    const call = instruction;
+    return absoluteTarget(callConditionOpcode(call.condition), call.expression);
+}
+function encodeRelativeJumpInstruction(instruction) {
+    const jump = instruction;
+    return relativeTarget(0x18, 'jr', jump.expression);
+}
+function encodeConditionalRelativeJumpInstruction(instruction) {
+    const jump = instruction;
+    return relativeTarget(jrConditionOpcode(jump.condition), `jr ${jump.condition}`, jump.expression);
+}
+function encodeDjnzInstruction(instruction) {
+    const djnz = instruction;
+    return relativeTarget(0x10, 'djnz', djnz.expression);
 }
 function encodeExchange(form) {
     switch (form) {
@@ -138,83 +204,6 @@ function encodeExchange(form) {
             return { size: 2, fragments: [{ kind: 'bytes', bytes: [0xfd, 0xe3] }] };
     }
 }
-function encodeCore(mnemonic) {
-    const opcode = coreOpcode(mnemonic);
-    return {
-        size: opcode.length,
-        fragments: [{ kind: 'bytes', bytes: opcode }],
-    };
-}
-function coreOpcode(mnemonic) {
-    switch (mnemonic) {
-        case 'di':
-            return [0xf3];
-        case 'ei':
-            return [0xfb];
-        case 'scf':
-            return [0x37];
-        case 'ccf':
-            return [0x3f];
-        case 'cpl':
-            return [0x2f];
-        case 'daa':
-            return [0x27];
-        case 'exx':
-            return [0xd9];
-        case 'halt':
-            return [0x76];
-        case 'rlca':
-            return [0x07];
-        case 'rrca':
-            return [0x0f];
-        case 'rla':
-            return [0x17];
-        case 'rra':
-            return [0x1f];
-        case 'neg':
-            return [0xed, 0x44];
-        case 'rrd':
-            return [0xed, 0x67];
-        case 'rld':
-            return [0xed, 0x6f];
-        case 'ldi':
-            return [0xed, 0xa0];
-        case 'ldir':
-            return [0xed, 0xb0];
-        case 'ldd':
-            return [0xed, 0xa8];
-        case 'lddr':
-            return [0xed, 0xb8];
-        case 'cpi':
-            return [0xed, 0xa1];
-        case 'cpir':
-            return [0xed, 0xb1];
-        case 'cpd':
-            return [0xed, 0xa9];
-        case 'cpdr':
-            return [0xed, 0xb9];
-        case 'ini':
-            return [0xed, 0xa2];
-        case 'inir':
-            return [0xed, 0xb2];
-        case 'ind':
-            return [0xed, 0xaa];
-        case 'indr':
-            return [0xed, 0xba];
-        case 'outi':
-            return [0xed, 0xa3];
-        case 'otir':
-            return [0xed, 0xb3];
-        case 'outd':
-            return [0xed, 0xab];
-        case 'otdr':
-            return [0xed, 0xbb];
-        case 'reti':
-            return [0xed, 0x4d];
-        case 'retn':
-            return [0xed, 0x45];
-    }
-}
 function encodeIn(target, port) {
     if (port.kind === 'c') {
         const opcode = target ? 0x40 + register8Code(target.register) * 8 : 0x70;
@@ -398,25 +387,7 @@ function bitLikeOpcodeBase(mnemonic) {
     }
 }
 function rotateShiftOpcodeBase(mnemonic) {
-    switch (mnemonic) {
-        case 'rlc':
-            return 0x00;
-        case 'rrc':
-            return 0x08;
-        case 'rl':
-            return 0x10;
-        case 'rr':
-            return 0x18;
-        case 'sla':
-            return 0x20;
-        case 'sra':
-            return 0x28;
-        case 'sll':
-        case 'sls':
-            return 0x30;
-        case 'srl':
-            return 0x38;
-    }
+    return ROTATE_SHIFT_OPCODE_BASES[mnemonic];
 }
 function cbOperandCode(operand) {
     return operand.kind === 'reg8' ? register8Code(operand.register) : 0x06;
@@ -550,284 +521,9 @@ function aluOpcodes(mnemonic) {
             return { registerBase: 0xb8, immediate: 0xfe, memHl: 0xbe };
     }
 }
-const LD_UNSUPPORTED_FORM_MESSAGE = 'ld expects a supported register/memory/immediate transfer form';
-function encodeLd(target, source) {
-    const legacyReg16Pair = encodeLegacyReg16ByteTransferLd(target, source);
-    if (legacyReg16Pair) {
-        return legacyReg16Pair;
-    }
-    const specialRegisterLd = encodeSpecialRegisterLd(target, source);
-    if (specialRegisterLd) {
-        return specialRegisterLd;
-    }
-    if (target.kind === 'reg8' && source.kind === 'imm') {
-        return {
-            size: 2,
-            fragments: [
-                { kind: 'bytes', bytes: [0x06 + register8Code(target.register) * 8] },
-                {
-                    kind: 'imm8',
-                    expression: source.expression,
-                    failureMessage: LD_UNSUPPORTED_FORM_MESSAGE,
-                },
-            ],
-        };
-    }
-    if (target.kind === 'reg8' && source.kind === 'reg8') {
-        return {
-            size: 1,
-            fragments: [
-                {
-                    kind: 'bytes',
-                    bytes: [0x40 + register8Code(target.register) * 8 + register8Code(source.register)],
-                },
-            ],
-        };
-    }
-    if (target.kind === 'reg8' && target.register === 'a' && source.kind === 'mem-abs') {
-        return absoluteLd(0x3a, source.expression);
-    }
-    if (target.kind === 'mem-abs' && source.kind === 'reg8' && source.register === 'a') {
-        return absoluteLd(0x32, target.expression);
-    }
-    if ((target.kind === 'reg8' || target.kind === 'reg-half-index') &&
-        (source.kind === 'reg8' || source.kind === 'reg-half-index') &&
-        isEncodableHalfIndexLd(target, source)) {
-        const prefix = halfIndexPrefix(target, source);
-        return {
-            size: 2,
-            fragments: [
-                {
-                    kind: 'bytes',
-                    bytes: [prefix, 0x40 + byteRegisterCode(target) * 8 + byteRegisterCode(source)],
-                },
-            ],
-        };
-    }
-    if (target.kind === 'reg16' && source.kind === 'imm') {
-        return {
-            size: 3,
-            fragments: [
-                { kind: 'bytes', bytes: [0x01 + register16Code(target.register) * 0x10] },
-                { kind: 'abs16', expression: source.expression },
-            ],
-        };
-    }
-    if (target.kind === 'reg-index16' && source.kind === 'imm') {
-        return {
-            size: 4,
-            fragments: [
-                { kind: 'bytes', bytes: [indexPrefix(target.register), 0x21] },
-                { kind: 'abs16', expression: source.expression },
-            ],
-        };
-    }
-    if (target.kind === 'reg16' &&
-        target.register === 'sp' &&
-        ((source.kind === 'reg16' && source.register === 'hl') || source.kind === 'reg-index16')) {
-        return {
-            size: source.kind === 'reg-index16' ? 2 : 1,
-            fragments: [{ kind: 'bytes', bytes: loadSpOpcode(source.register) }],
-        };
-    }
-    if (target.kind === 'reg16' && source.kind === 'mem-abs') {
-        return absoluteRegister16Load(target.register, source.expression);
-    }
-    if (target.kind === 'reg-index16' && source.kind === 'mem-abs') {
-        return prefixedAbsoluteLd(indexPrefix(target.register), 0x2a, source.expression);
-    }
-    if (target.kind === 'mem-abs' && source.kind === 'reg16') {
-        return absoluteRegister16Store(source.register, target.expression);
-    }
-    if (target.kind === 'mem-abs' && source.kind === 'reg-index16') {
-        return prefixedAbsoluteLd(indexPrefix(source.register), 0x22, target.expression);
-    }
-    if (target.kind === 'reg8' && target.register === 'a' && source.kind === 'reg-indirect') {
-        return {
-            size: 1,
-            fragments: [{ kind: 'bytes', bytes: [loadAFromIndirectOpcode(source.register)] }],
-        };
-    }
-    if (target.kind === 'reg-indirect' && source.kind === 'reg8' && source.register === 'a') {
-        return {
-            size: 1,
-            fragments: [{ kind: 'bytes', bytes: [storeAToIndirectOpcode(target.register)] }],
-        };
-    }
-    if (target.kind === 'reg-indirect' && target.register === 'hl' && source.kind === 'reg8') {
-        return {
-            size: 1,
-            fragments: [{ kind: 'bytes', bytes: [0x70 + register8Code(source.register)] }],
-        };
-    }
-    if (target.kind === 'reg-indirect' && target.register === 'hl' && source.kind === 'imm') {
-        return {
-            size: 2,
-            fragments: [
-                { kind: 'bytes', bytes: [0x36] },
-                {
-                    kind: 'imm8',
-                    expression: source.expression,
-                    failureMessage: LD_UNSUPPORTED_FORM_MESSAGE,
-                },
-            ],
-        };
-    }
-    if (target.kind === 'reg8' && source.kind === 'reg-indirect' && source.register === 'hl') {
-        return {
-            size: 1,
-            fragments: [{ kind: 'bytes', bytes: [0x46 + register8Code(target.register) * 8] }],
-        };
-    }
-    if (target.kind === 'reg8' && source.kind === 'indexed') {
-        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',
-                },
-            ],
-        };
-    }
-    if (target.kind === 'indexed' && source.kind === 'reg8') {
-        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',
-                },
-            ],
-        };
-    }
-    if (target.kind === 'indexed' && source.kind === 'imm') {
-        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,
-                },
-            ],
-        };
-    }
-    return {
-        size: 0,
-        fragments: [],
-    };
-}
-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;
-}
-function absoluteLd(opcode, expression) {
-    return {
-        size: 3,
-        fragments: [
-            { kind: 'bytes', bytes: [opcode] },
-            { kind: 'abs16', expression },
-        ],
-    };
-}
-function prefixedAbsoluteLd(prefix, opcode, expression) {
-    return {
-        size: 4,
-        fragments: [
-            { kind: 'bytes', bytes: [prefix, opcode] },
-            { kind: 'abs16', expression },
-        ],
-    };
-}
-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);
-    }
-}
-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);
-    }
-}
 function indexPrefix(register) {
     return register === 'ix' ? 0xdd : 0xfd;
 }
-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}`);
-    }
-}
 function halfIndexPrefix(target, source) {
     const register = target.kind === 'reg-half-index'
         ? target.register
@@ -839,34 +535,6 @@ function halfIndexPrefix(target, source) {
     }
     return register.startsWith('ix') ? 0xdd : 0xfd;
 }
-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 byteRegisterCode(operand) {
-    return operand.kind === 'reg8'
-        ? register8Code(operand.register)
-        : halfIndexRegisterCode(operand.register);
-}
 function halfIndexRegisterCode(register) {
     switch (register) {
         case 'ixh':
@@ -907,26 +575,6 @@ function register16Code(register) {
             return 3;
     }
 }
-function loadAFromIndirectOpcode(register) {
-    switch (register) {
-        case 'bc':
-            return 0x0a;
-        case 'de':
-            return 0x1a;
-        case 'hl':
-            return 0x7e;
-    }
-}
-function storeAToIndirectOpcode(register) {
-    switch (register) {
-        case 'bc':
-            return 0x02;
-        case 'de':
-            return 0x12;
-        case 'hl':
-            return 0x77;
-    }
-}
 function absoluteTarget(opcode, expression) {
     return {
         size: 3,