@jhlagado/azm 0.1.0

package/dist/src/lowering/fixupEmission.js

@@ -0,0 +1,199 @@
+import { formatAbs16FixupAsm, formatAbs16FixupEdAsm, formatAbs16FixupPrefixedAsm, } from './traceFormat.js';
+export function createFixupEmissionHelpers(ctx) {
+    const recordLoweredInstr = (bytes, asmText, span) => {
+        ctx.recordLoweredInstr?.(bytes, asmText, span);
+    };
+    const emitAbs16Bytes = (bytes, patchOffsetFromStart, baseLower, addend, span, asmText) => {
+        const start = ctx.getCodeOffset();
+        for (let index = 0; index < bytes.length; index++) {
+            ctx.setCodeByte(start + index, bytes[index]);
+        }
+        ctx.setCodeOffset(start + bytes.length);
+        ctx.recordCodeSourceRange(start, start + bytes.length);
+        ctx.pushFixup({ offset: start + patchOffsetFromStart, baseLower, addend, file: span.file });
+        ctx.traceInstruction(start, bytes, asmText);
+        recordLoweredInstr(bytes, asmText, span);
+    };
+    const emitAbs16Fixup = (opcode, baseLower, addend, span, asmText) => {
+        const bytes = Uint8Array.of(opcode, 0x00, 0x00);
+        const text = asmText ?? formatAbs16FixupAsm(opcode, baseLower, addend);
+        emitAbs16Bytes(bytes, 1, baseLower, addend, span, text);
+    };
+    const emitAbs16FixupEd = (opcode2, baseLower, addend, span, asmText) => {
+        const bytes = Uint8Array.of(0xed, opcode2, 0x00, 0x00);
+        const text = asmText ?? formatAbs16FixupEdAsm(opcode2, baseLower, addend);
+        emitAbs16Bytes(bytes, 2, baseLower, addend, span, text);
+    };
+    const emitAbs16FixupPrefixed = (prefix, opcode2, baseLower, addend, span, asmText) => {
+        const bytes = Uint8Array.of(prefix, opcode2, 0x00, 0x00);
+        const text = asmText ?? formatAbs16FixupPrefixedAsm(prefix, opcode2, baseLower, addend);
+        emitAbs16Bytes(bytes, 2, baseLower, addend, span, text);
+    };
+    const emitRel8Fixup = (opcode, baseLower, addend, span, mnemonic, asmText) => {
+        const start = ctx.getCodeOffset();
+        ctx.setCodeByte(start, opcode);
+        ctx.setCodeByte(start + 1, 0x00);
+        ctx.setCodeOffset(start + 2);
+        ctx.recordCodeSourceRange(start, start + 2);
+        ctx.pushRel8Fixup({
+            offset: start + 1,
+            origin: start + 2,
+            baseLower,
+            addend,
+            file: span.file,
+            mnemonic,
+        });
+        const bytes = Uint8Array.of(opcode, 0x00);
+        const text = asmText ?? `${mnemonic} ${baseLower}`;
+        ctx.traceInstruction(start, bytes, text);
+        recordLoweredInstr(bytes, text, span);
+    };
+    const conditionOpcodeFromName = (nameRaw) => {
+        const asName = nameRaw.toUpperCase();
+        switch (asName) {
+            case 'NZ':
+                return 0xc2;
+            case 'Z':
+                return 0xca;
+            case 'NC':
+                return 0xd2;
+            case 'C':
+                return 0xda;
+            case 'PO':
+                return 0xe2;
+            case 'PE':
+                return 0xea;
+            case 'P':
+                return 0xf2;
+            case 'M':
+                return 0xfa;
+            default:
+                return undefined;
+        }
+    };
+    const conditionNameFromOpcode = (opcode) => {
+        switch (opcode) {
+            case 0xc2:
+                return 'NZ';
+            case 0xca:
+                return 'Z';
+            case 0xd2:
+                return 'NC';
+            case 0xda:
+                return 'C';
+            case 0xe2:
+                return 'PO';
+            case 0xea:
+                return 'PE';
+            case 0xf2:
+                return 'P';
+            case 0xfa:
+                return 'M';
+            default:
+                return undefined;
+        }
+    };
+    const callConditionOpcodeFromName = (nameRaw) => {
+        switch (nameRaw.toUpperCase()) {
+            case 'NZ':
+                return 0xc4;
+            case 'Z':
+                return 0xcc;
+            case 'NC':
+                return 0xd4;
+            case 'C':
+                return 0xdc;
+            case 'PO':
+                return 0xe4;
+            case 'PE':
+                return 0xec;
+            case 'P':
+                return 0xf4;
+            case 'M':
+                return 0xfc;
+            default:
+                return undefined;
+        }
+    };
+    const symbolicTargetFromExpr = (expr) => {
+        if (expr.kind === 'ImmName')
+            return { baseLower: expr.name.toLowerCase(), addend: 0 };
+        if (expr.kind !== 'ImmBinary')
+            return undefined;
+        if (expr.op !== '+' && expr.op !== '-')
+            return undefined;
+        const leftName = expr.left.kind === 'ImmName' ? expr.left.name.toLowerCase() : undefined;
+        const rightName = expr.right.kind === 'ImmName' ? expr.right.name.toLowerCase() : undefined;
+        if (leftName) {
+            const right = ctx.evalImmExpr(expr.right);
+            if (right === undefined)
+                return undefined;
+            return { baseLower: leftName, addend: expr.op === '+' ? right : -right };
+        }
+        if (expr.op === '+' && rightName) {
+            const left = ctx.evalImmExpr(expr.left);
+            if (left === undefined)
+                return undefined;
+            return { baseLower: rightName, addend: left };
+        }
+        return undefined;
+    };
+    const jrConditionOpcodeFromName = (nameRaw) => {
+        switch (nameRaw.toUpperCase()) {
+            case 'NZ':
+                return 0x20;
+            case 'Z':
+                return 0x28;
+            case 'NC':
+                return 0x30;
+            case 'C':
+                return 0x38;
+            default:
+                return undefined;
+        }
+    };
+    const conditionOpcode = (op) => {
+        const asName = op.kind === 'Imm' && op.expr.kind === 'ImmName'
+            ? op.expr.name
+            : op.kind === 'Reg'
+                ? op.name
+                : undefined;
+        return asName ? conditionOpcodeFromName(asName) : undefined;
+    };
+    const inverseConditionName = (nameRaw) => {
+        const name = nameRaw.toUpperCase();
+        switch (name) {
+            case 'NZ':
+                return 'Z';
+            case 'Z':
+                return 'NZ';
+            case 'NC':
+                return 'C';
+            case 'C':
+                return 'NC';
+            case 'PO':
+                return 'PE';
+            case 'PE':
+                return 'PO';
+            case 'P':
+                return 'M';
+            case 'M':
+                return 'P';
+            default:
+                return undefined;
+        }
+    };
+    return {
+        callConditionOpcodeFromName,
+        conditionNameFromOpcode,
+        conditionOpcode,
+        conditionOpcodeFromName,
+        emitAbs16Fixup,
+        emitAbs16FixupEd,
+        emitAbs16FixupPrefixed,
+        emitRel8Fixup,
+        inverseConditionName,
+        jrConditionOpcodeFromName,
+        symbolicTargetFromExpr,
+    };
+}

package/dist/src/lowering/immMath.d.ts

@@ -0,0 +1,2 @@
+export declare function evalUnaryImmOp(op: '+' | '-' | '~', value: number): number;
+export declare function evalBinaryImmOp(op: '*' | '/' | '%' | '+' | '-' | '&' | '^' | '|' | '<<' | '>>', left: number, right: number): number | undefined;

package/dist/src/lowering/immMath.js

@@ -0,0 +1,34 @@
+export function evalUnaryImmOp(op, value) {
+    switch (op) {
+        case '+':
+            return +value;
+        case '-':
+            return -value;
+        case '~':
+            return ~value;
+    }
+}
+export function evalBinaryImmOp(op, left, right) {
+    switch (op) {
+        case '*':
+            return left * right;
+        case '/':
+            return right === 0 ? undefined : Math.trunc(left / right);
+        case '%':
+            return right === 0 ? undefined : left % right;
+        case '+':
+            return left + right;
+        case '-':
+            return left - right;
+        case '&':
+            return left & right;
+        case '^':
+            return left ^ right;
+        case '|':
+            return left | right;
+        case '<<':
+            return left << right;
+        case '>>':
+            return left >> right;
+    }
+}

package/dist/src/lowering/inputAssets.d.ts

@@ -0,0 +1,7 @@
+type InputDiag = (file: string, message: string) => void;
+export declare function loadBinInput(fromFile: string, fromPath: string, includeDirs: readonly string[], report: InputDiag): Buffer | undefined;
+export declare function parseIntelHex(ownerFile: string, hexText: string, report: InputDiag): {
+    bytes: Map<number, number>;
+    minAddress: number;
+} | undefined;
+export {};

package/dist/src/lowering/inputAssets.js

@@ -0,0 +1,106 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+function resolveInputPath(fromFile, fromPath, includeDirs, report) {
+    const candidates = [];
+    candidates.push(resolve(dirname(fromFile), fromPath));
+    for (const inc of includeDirs)
+        candidates.push(resolve(inc, fromPath));
+    const seen = new Set();
+    for (const candidate of candidates) {
+        if (seen.has(candidate))
+            continue;
+        seen.add(candidate);
+        if (existsSync(candidate))
+            return candidate;
+    }
+    report(fromFile, `Failed to resolve input path "${fromPath}".`);
+    return undefined;
+}
+export function loadBinInput(fromFile, fromPath, includeDirs, report) {
+    const path = resolveInputPath(fromFile, fromPath, includeDirs, report);
+    if (!path)
+        return undefined;
+    try {
+        return readFileSync(path);
+    }
+    catch (err) {
+        report(fromFile, `Failed to read bin file "${path}": ${String(err)}`);
+        return undefined;
+    }
+}
+export function parseIntelHex(ownerFile, hexText, report) {
+    const out = new Map();
+    let minAddress = Number.POSITIVE_INFINITY;
+    const lines = hexText.split(/\r?\n/);
+    let sawData = false;
+    let sawEof = false;
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+        const raw = lines[lineIndex].trim();
+        if (raw.length === 0)
+            continue;
+        if (!raw.startsWith(':')) {
+            report(ownerFile, `Invalid Intel HEX record at line ${lineIndex + 1}.`);
+            return undefined;
+        }
+        const body = raw.slice(1);
+        if (body.length < 10 || body.length % 2 !== 0) {
+            report(ownerFile, `Malformed Intel HEX record at line ${lineIndex + 1}.`);
+            return undefined;
+        }
+        const bytesLine = [];
+        for (let i = 0; i < body.length; i += 2) {
+            const pair = body.slice(i, i + 2);
+            const value = Number.parseInt(pair, 16);
+            if (Number.isNaN(value)) {
+                report(ownerFile, `Invalid HEX byte "${pair}" at line ${lineIndex + 1}.`);
+                return undefined;
+            }
+            bytesLine.push(value & 0xff);
+        }
+        const len = bytesLine[0];
+        const addr = ((bytesLine[1] << 8) | bytesLine[2]) & 0xffff;
+        const type = bytesLine[3];
+        const data = bytesLine.slice(4, bytesLine.length - 1);
+        if (len !== data.length) {
+            report(ownerFile, `Intel HEX length mismatch at line ${lineIndex + 1}.`);
+            return undefined;
+        }
+        const sum = bytesLine.reduce((acc, byte) => (acc + byte) & 0xff, 0);
+        if (sum !== 0) {
+            report(ownerFile, `Intel HEX checksum mismatch at line ${lineIndex + 1}.`);
+            return undefined;
+        }
+        if (sawEof) {
+            report(ownerFile, `Intel HEX data found after EOF record.`);
+            return undefined;
+        }
+        if (type === 0x00) {
+            for (let i = 0; i < data.length; i++) {
+                const address = addr + i;
+                if (address < 0 || address > 0xffff) {
+                    report(ownerFile, `Intel HEX address out of range at line ${lineIndex + 1}.`);
+                    return undefined;
+                }
+                if (out.has(address)) {
+                    report(ownerFile, `Intel HEX overlaps itself at address ${address}.`);
+                    return undefined;
+                }
+                out.set(address, data[i]);
+                minAddress = Math.min(minAddress, address);
+            }
+            sawData = true;
+            continue;
+        }
+        if (type === 0x01) {
+            sawEof = true;
+            continue;
+        }
+        report(ownerFile, `Unsupported Intel HEX record type ${type.toString(16).padStart(2, '0')} at line ${lineIndex + 1}.`);
+        return undefined;
+    }
+    if (!sawData) {
+        report(ownerFile, `Intel HEX file has no data records.`);
+        return undefined;
+    }
+    return { bytes: out, minAddress };
+}

package/dist/src/lowering/ldEncoding.d.ts

@@ -0,0 +1,15 @@
+import type { Diagnostic } from '../diagnosticTypes.js';
+import type { SourceSpan } from '../frontend/ast.js';
+import type { LdForm } from './ldFormSelection.js';
+export type LdEncodingContext = {
+    diagAt: (diagnostics: Diagnostic[], span: SourceSpan, message: string) => void;
+    diagnostics: Diagnostic[];
+    emitAbs16Fixup: (opcode: number, target: string, addend: number, span: SourceSpan, asmText?: string) => void;
+    emitAbs16FixupEd: (opcode: number, target: string, addend: number, span: SourceSpan, asmText?: string) => void;
+    emitAbs16FixupPrefixed: (prefix: number, opcode: number, target: string, addend: number, span: SourceSpan, asmText?: string) => void;
+    reg8Code: ReadonlyMap<string, number>;
+    setSpTrackingInvalid: () => void;
+};
+export declare function createLdEncodingHelpers(ctx: LdEncodingContext): {
+    emitLdForm: (form: LdForm) => boolean;
+};

package/dist/src/lowering/ldEncoding.js

@@ -0,0 +1,12 @@
+import { createLdEncodingRegMemHelpers } from './ldEncodingRegMemHelpers.js';
+export function createLdEncodingHelpers(ctx) {
+    const { emitLdRegMemForm } = createLdEncodingRegMemHelpers(ctx);
+    const emitLdForm = (form) => {
+        const regMemHandled = emitLdRegMemForm(form);
+        if (regMemHandled !== null) {
+            return regMemHandled;
+        }
+        return false;
+    };
+    return { emitLdForm };
+}

package/dist/src/lowering/ldEncodingRegMemHelpers.d.ts

@@ -0,0 +1,5 @@
+import type { LdForm } from './ldFormSelection.js';
+import type { LdEncodingContext } from './ldEncoding.js';
+export declare function createLdEncodingRegMemHelpers(ctx: LdEncodingContext): {
+    emitLdRegMemForm: (form: LdForm) => boolean | null;
+};

package/dist/src/lowering/ldEncodingRegMemHelpers.js

@@ -0,0 +1,124 @@
+export function createLdEncodingRegMemHelpers(ctx) {
+    const { emitAbs16Fixup, emitAbs16FixupEd, emitAbs16FixupPrefixed, reg8Code, setSpTrackingInvalid, } = ctx;
+    const emitRegFromMem = (form) => {
+        const { dst, src, inst, srcResolved } = form;
+        if (dst.kind !== 'Reg' || src.kind !== 'Mem')
+            return false;
+        if (form.srcHasRegisterLikeEaBase)
+            return false;
+        if (form.srcIsIxIyDispMem && reg8Code.has(dst.name.toUpperCase()))
+            return false;
+        if (form.srcIsEaNameHL)
+            return false;
+        if (dst.name.toUpperCase() === 'A' && form.srcIsEaNameBCorDE)
+            return false;
+        if (dst.name.toUpperCase() === 'A' && srcResolved?.kind === 'abs') {
+            emitAbs16Fixup(0x3a, srcResolved.baseLower, srcResolved.addend, inst.span);
+            return true;
+        }
+        const regUp = dst.name.toUpperCase();
+        if (reg8Code.has(regUp)) {
+            return false;
+        }
+        const r16 = dst.name.toUpperCase();
+        if (r16 === 'HL') {
+            if (srcResolved?.kind === 'abs') {
+                emitAbs16Fixup(0x2a, srcResolved.baseLower, srcResolved.addend, inst.span);
+                return true;
+            }
+            return false;
+        }
+        if (r16 === 'DE') {
+            if (srcResolved?.kind === 'abs') {
+                emitAbs16FixupEd(0x5b, srcResolved.baseLower, srcResolved.addend, inst.span);
+                return true;
+            }
+            return false;
+        }
+        if (r16 === 'BC') {
+            if (srcResolved?.kind === 'abs') {
+                emitAbs16FixupEd(0x4b, srcResolved.baseLower, srcResolved.addend, inst.span);
+                return true;
+            }
+            return false;
+        }
+        if (r16 === 'SP' && srcResolved?.kind === 'abs') {
+            emitAbs16FixupEd(0x7b, srcResolved.baseLower, srcResolved.addend, inst.span);
+            setSpTrackingInvalid();
+            return true;
+        }
+        if (r16 === 'IX' || r16 === 'IY') {
+            if (srcResolved?.kind === 'abs') {
+                emitAbs16FixupPrefixed(r16 === 'IX' ? 0xdd : 0xfd, 0x2a, srcResolved.baseLower, srcResolved.addend, inst.span);
+                return true;
+            }
+            return false;
+        }
+        return false;
+    };
+    const emitMemFromReg = (form) => {
+        const { dst, src, inst, dstResolved } = form;
+        if (dst.kind !== 'Mem' || src.kind !== 'Reg')
+            return false;
+        if (form.dstHasRegisterLikeEaBase)
+            return false;
+        if (form.dstIsIxIyDispMem && reg8Code.has(src.name.toUpperCase()))
+            return false;
+        if (form.dstIsEaNameHL)
+            return false;
+        if (src.name.toUpperCase() === 'A' && form.dstIsEaNameBCorDE)
+            return false;
+        if (src.name.toUpperCase() === 'A' && dstResolved?.kind === 'abs') {
+            emitAbs16Fixup(0x32, dstResolved.baseLower, dstResolved.addend, inst.span);
+            return true;
+        }
+        const regUp = src.name.toUpperCase();
+        if (reg8Code.has(regUp)) {
+            return false;
+        }
+        const r16 = src.name.toUpperCase();
+        if (r16 === 'HL') {
+            if (dstResolved?.kind === 'abs') {
+                emitAbs16Fixup(0x22, dstResolved.baseLower, dstResolved.addend, inst.span);
+                return true;
+            }
+            return false;
+        }
+        if (r16 === 'DE') {
+            if (dstResolved?.kind === 'abs') {
+                emitAbs16FixupEd(0x53, dstResolved.baseLower, dstResolved.addend, inst.span);
+                return true;
+            }
+            return false;
+        }
+        if (r16 === 'BC') {
+            if (dstResolved?.kind === 'abs') {
+                emitAbs16FixupEd(0x43, dstResolved.baseLower, dstResolved.addend, inst.span);
+                return true;
+            }
+            return false;
+        }
+        if (r16 === 'SP' && dstResolved?.kind === 'abs') {
+            emitAbs16FixupEd(0x73, dstResolved.baseLower, dstResolved.addend, inst.span);
+            return true;
+        }
+        if (r16 === 'IX' || r16 === 'IY') {
+            if (dstResolved?.kind === 'abs') {
+                emitAbs16FixupPrefixed(r16 === 'IX' ? 0xdd : 0xfd, 0x22, dstResolved.baseLower, dstResolved.addend, inst.span);
+                return true;
+            }
+            return false;
+        }
+        return false;
+    };
+    const emitLdRegMemForm = (form) => {
+        if (form.dst.kind === 'Reg' && form.src.kind === 'Mem') {
+            return emitRegFromMem(form);
+        }
+        if (form.dst.kind === 'Mem' && form.src.kind === 'Reg') {
+            return emitMemFromReg(form);
+        }
+        return null;
+    };
+    return { emitLdRegMemForm };
+}

package/dist/src/lowering/ldFormSelection.d.ts

@@ -0,0 +1,26 @@
+import type { AsmInstructionNode, AsmOperandNode, EaExprNode } from '../frontend/ast.js';
+import type { SourceSpan } from '../frontend/ast.js';
+import type { CompileEnv } from '../semantics/env.js';
+import type { EaResolution } from './eaResolution.js';
+export type LdForm = {
+    inst: AsmInstructionNode;
+    dst: AsmOperandNode;
+    src: AsmOperandNode;
+    dstResolved: EaResolution | undefined;
+    srcResolved: EaResolution | undefined;
+    srcHasRegisterLikeEaBase: boolean;
+    dstHasRegisterLikeEaBase: boolean;
+    srcIsIxIyDispMem: boolean;
+    dstIsIxIyDispMem: boolean;
+    srcIsEaNameHL: boolean;
+    dstIsEaNameHL: boolean;
+    srcIsEaNameBCorDE: boolean;
+    dstIsEaNameBCorDE: boolean;
+};
+export type LdFormSelectionContext = {
+    env: CompileEnv;
+    resolveEa: (ea: EaExprNode, span: SourceSpan) => EaResolution | undefined;
+};
+export declare function createLdFormSelectionHelpers(ctx: LdFormSelectionContext): {
+    analyzeLdInstruction: (inst: AsmInstructionNode) => LdForm | null;
+};

package/dist/src/lowering/ldFormSelection.js

@@ -0,0 +1,92 @@
+export function createLdFormSelectionHelpers(ctx) {
+    const { env, resolveEa } = ctx;
+    const coerceValueOperand = (op) => {
+        if (op.kind === 'Reg') {
+            const lower = op.name.toLowerCase();
+            if (env.equates.has(lower)) {
+                return {
+                    kind: 'Mem',
+                    span: op.span,
+                    expr: { kind: 'EaName', span: op.span, name: op.name },
+                };
+            }
+        }
+        return op;
+    };
+    const isRegisterToken = (name) => {
+        const token = name.toUpperCase();
+        return (token === 'A' ||
+            token === 'B' ||
+            token === 'C' ||
+            token === 'D' ||
+            token === 'E' ||
+            token === 'H' ||
+            token === 'L' ||
+            token === 'AF' ||
+            token === 'BC' ||
+            token === 'DE' ||
+            token === 'HL' ||
+            token === 'SP' ||
+            token === 'IX' ||
+            token === 'IY' ||
+            token === 'IXH' ||
+            token === 'IXL' ||
+            token === 'IYH' ||
+            token === 'IYL');
+    };
+    const isBoundEaName = (name) => {
+        const lower = name.toLowerCase();
+        return env.equates.has(lower);
+    };
+    const hasRegisterLikeEaBase = (ea) => {
+        switch (ea.kind) {
+            case 'EaName':
+                return isRegisterToken(ea.name) && !isBoundEaName(ea.name);
+            case 'EaImm':
+                return false;
+            case 'EaLayoutCast':
+                return false;
+            case 'EaField':
+                return hasRegisterLikeEaBase(ea.base);
+            case 'EaIndex':
+                return hasRegisterLikeEaBase(ea.base);
+            case 'EaAdd':
+            case 'EaSub':
+                return hasRegisterLikeEaBase(ea.base);
+        }
+    };
+    const isEaNameHL = (ea) => ea.kind === 'EaName' && ea.name.toUpperCase() === 'HL';
+    const isEaNameBCorDE = (ea) => ea.kind === 'EaName' && (ea.name.toUpperCase() === 'BC' || ea.name.toUpperCase() === 'DE');
+    const isIxIyBaseEa = (ea) => ea.kind === 'EaName' && (ea.name.toUpperCase() === 'IX' || ea.name.toUpperCase() === 'IY');
+    const isIxIyDispMem = (op) => op.kind === 'Mem' &&
+        (isIxIyBaseEa(op.expr) ||
+            (op.expr.kind === 'EaIndex' &&
+                isIxIyBaseEa(op.expr.base) &&
+                op.expr.index.kind === 'IndexImm') ||
+            ((op.expr.kind === 'EaAdd' || op.expr.kind === 'EaSub') && isIxIyBaseEa(op.expr.base)));
+    const analyzeLdInstruction = (inst) => {
+        const head = inst.head.toLowerCase();
+        if (head !== 'ld' || inst.operands.length !== 2)
+            return null;
+        const dst = coerceValueOperand(inst.operands[0]);
+        const src = coerceValueOperand(inst.operands[1]);
+        const dstResolved = dst.kind === 'Mem' ? resolveEa(dst.expr, inst.span) : undefined;
+        const srcResolved = src.kind === 'Mem' ? resolveEa(src.expr, inst.span) : undefined;
+        return {
+            inst,
+            dst,
+            src,
+            dstResolved,
+            srcResolved,
+            srcHasRegisterLikeEaBase: src.kind === 'Mem' ? hasRegisterLikeEaBase(src.expr) : false,
+            dstHasRegisterLikeEaBase: dst.kind === 'Mem' ? hasRegisterLikeEaBase(dst.expr) : false,
+            srcIsIxIyDispMem: isIxIyDispMem(src),
+            dstIsIxIyDispMem: isIxIyDispMem(dst),
+            srcIsEaNameHL: src.kind === 'Mem' ? isEaNameHL(src.expr) : false,
+            dstIsEaNameHL: dst.kind === 'Mem' ? isEaNameHL(dst.expr) : false,
+            srcIsEaNameBCorDE: src.kind === 'Mem' ? isEaNameBCorDE(src.expr) : false,
+            dstIsEaNameBCorDE: dst.kind === 'Mem' ? isEaNameBCorDE(dst.expr) : false,
+        };
+    };
+    return { analyzeLdInstruction };
+}

package/dist/src/lowering/ldLowering.d.ts

@@ -0,0 +1,7 @@
+import type { LdEncodingContext } from './ldEncoding.js';
+import type { LdFormSelectionContext } from './ldFormSelection.js';
+type LdLoweringContext = LdFormSelectionContext & LdEncodingContext;
+export declare function createLdLoweringHelpers(ctx: LdLoweringContext): {
+    lowerLdWithEa: (inst: Parameters<(inst: import("../frontend/ast.js").AsmInstructionNode) => import("./ldFormSelection.js").LdForm | null>[0]) => boolean;
+};
+export {};

package/dist/src/lowering/ldLowering.js

@@ -0,0 +1,13 @@
+import { createLdEncodingHelpers } from './ldEncoding.js';
+import { createLdFormSelectionHelpers } from './ldFormSelection.js';
+export function createLdLoweringHelpers(ctx) {
+    const { analyzeLdInstruction } = createLdFormSelectionHelpers(ctx);
+    const { emitLdForm } = createLdEncodingHelpers(ctx);
+    const lowerLdWithEa = (inst) => {
+        const form = analyzeLdInstruction(inst);
+        if (!form)
+            return false;
+        return emitLdForm(form);
+    };
+    return { lowerLdWithEa };
+}

package/dist/src/lowering/loweredAsmByteEmission.d.ts

@@ -0,0 +1,23 @@
+import type { Diagnostic } from '../diagnosticTypes.js';
+import type { CompileEnv } from '../semantics/env.js';
+import type { LoweredAsmProgram } from './loweredAsmTypes.js';
+type LoweredAsmByteEmissionContext = {
+    diagnostics: Diagnostic[];
+    diag: (diagnostics: Diagnostic[], file: string, message: string) => void;
+    primaryFile: string;
+    env: CompileEnv;
+};
+type LoweredAsmByteEmissionResult = {
+    codeBytes: Map<number, number>;
+    dataBytes: Map<number, number>;
+    blockSizesByKey: Map<string, number>;
+    maxAddress: number;
+};
+/**
+ * After link-time fixups are applied to `finalBytes`, patch lowered `instr` byte arrays
+ * (including `@raw` placeholders from abs16/rel8 fixups) so ASM80 listings match the
+ * merged image.
+ */
+export declare function syncLoweredAsmInstructionBytesFromFinalBytes(program: LoweredAsmProgram, finalBytes: Map<number, number>, env: CompileEnv): void;
+export declare function emitLoweredAsmProgramBytes(program: LoweredAsmProgram, ctx: LoweredAsmByteEmissionContext): LoweredAsmByteEmissionResult;
+export {};