@jhlagado/azm 0.1.0

package/dist/src/lowering/opExpansionStream.js

@@ -0,0 +1,176 @@
+import { cloneEaExpr, cloneImmExpr, cloneOperand, flattenEaDottedName } from './asmUtils.js';
+import { expandInlineOpBodyItems } from './opExpansionExecution.js';
+import { createOpMatchingHelpers } from './opMatching.js';
+import { createOpSubstitutionHelpers } from './opSubstitution.js';
+const REG8_NAMES = new Set(['A', 'B', 'C', 'D', 'E', 'H', 'L']);
+const CONDITION_CODES = new Set(['NZ', 'Z', 'NC', 'C', 'PO', 'PE', 'P', 'M']);
+const MAX_OP_EXPANSION_DEPTH = 64;
+const EMPTY_OP_SUBSTITUTION_ENV = {
+    equates: new Map(),
+    enums: new Map(),
+    types: new Map(),
+};
+function isIxIyIndexedMem(op) {
+    return (op.kind === 'Mem' &&
+        ((op.expr.kind === 'EaName' && /^(IX|IY)$/i.test(op.expr.name)) ||
+            ((op.expr.kind === 'EaAdd' || op.expr.kind === 'EaSub') &&
+                op.expr.base.kind === 'EaName' &&
+                /^(IX|IY)$/i.test(op.expr.base.name))));
+}
+function normalizeFixedToken(op) {
+    switch (op.kind) {
+        case 'Reg':
+            return op.name.toUpperCase();
+        case 'Imm':
+            return op.expr.kind === 'ImmName' ? op.expr.name.toUpperCase() : undefined;
+        case 'Ea': {
+            const name = flattenEaDottedName(op.expr);
+            return name ? name.toUpperCase() : undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+function evalImmNoDiag(expr) {
+    switch (expr.kind) {
+        case 'ImmLiteral':
+            return expr.value;
+        case 'ImmUnary': {
+            const value = evalImmNoDiag(expr.expr);
+            if (value === undefined)
+                return undefined;
+            if (expr.op === '-')
+                return -value;
+            if (expr.op === '+')
+                return value;
+            return undefined;
+        }
+        case 'ImmBinary': {
+            const left = evalImmNoDiag(expr.left);
+            const right = evalImmNoDiag(expr.right);
+            if (left === undefined || right === undefined)
+                return undefined;
+            if (expr.op === '+')
+                return left + right;
+            if (expr.op === '-')
+                return left - right;
+            if (expr.op === '*')
+                return left * right;
+            return undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+const { selectOpOverload } = createOpMatchingHelpers({
+    reg8: REG8_NAMES,
+    isIxIyIndexedMem,
+    flattenEaDottedName,
+    isEnumName: () => false,
+    normalizeFixedToken,
+    conditionOpcodeFromName: (name) => (CONDITION_CODES.has(name.toUpperCase()) ? 0 : undefined),
+    evalImmNoDiag,
+    inferMemWidth: () => undefined,
+});
+function addOpDeclForFile(ctx, file, key, op) {
+    let fileOps = ctx.localOpsByFile.get(file);
+    if (!fileOps) {
+        fileOps = new Map();
+        ctx.localOpsByFile.set(file, fileOps);
+    }
+    const local = fileOps.get(key);
+    if (local)
+        local.push(op);
+    else
+        fileOps.set(key, [op]);
+}
+function collectOpDeclsFromItems(items, ctx, sourceUnitFile) {
+    for (const item of items) {
+        if (item.kind !== 'OpDecl')
+            continue;
+        const op = item;
+        const key = op.name.toLowerCase();
+        addOpDeclForFile(ctx, sourceUnitFile, key, op);
+        if (op.span.file !== sourceUnitFile)
+            addOpDeclForFile(ctx, op.span.file, key, op);
+    }
+}
+function buildOpExpansionContext(program) {
+    const ctx = {
+        localOpsByFile: new Map(),
+        nextSyntheticLabelId: 0,
+    };
+    for (const file of program.files) {
+        collectOpDeclsFromItems(file.items, ctx, file.path);
+    }
+    return ctx;
+}
+function resolveOpCandidates(inst, ctx) {
+    const lower = inst.head.toLowerCase();
+    return ctx.localOpsByFile.get(inst.span.file)?.get(lower);
+}
+export function createInlineOpInstructionStreamExpander(program) {
+    const ctx = buildOpExpansionContext(program);
+    function expandInstruction(inst, stack = new Set()) {
+        if (stack.size >= MAX_OP_EXPANSION_DEPTH)
+            return [{ kind: 'instruction', instruction: inst }];
+        const candidates = resolveOpCandidates(inst, ctx);
+        if (!candidates || candidates.length === 0)
+            return [{ kind: 'instruction', instruction: inst }];
+        const selection = selectOpOverload(candidates, inst.operands);
+        if (selection.kind !== 'selected')
+            return [{ kind: 'instruction', instruction: inst }];
+        const opDecl = selection.overload;
+        const opKey = `${opDecl.name.toLowerCase()}:${opDecl.span.file}:${opDecl.span.start.line}`;
+        if (stack.has(opKey))
+            return [{ kind: 'instruction', instruction: inst }];
+        const nextStack = new Set(stack);
+        nextStack.add(opKey);
+        const bindings = new Map();
+        for (let index = 0; index < opDecl.params.length; index += 1) {
+            bindings.set(opDecl.params[index].name.toLowerCase(), inst.operands[index]);
+        }
+        const { substituteOperandWithOpLabels } = createOpSubstitutionHelpers({
+            bindings,
+            env: EMPTY_OP_SUBSTITUTION_ENV,
+            diagnostics: [],
+            diagAt: () => { },
+            cloneImmExpr,
+            cloneEaExpr,
+            cloneOperand,
+            flattenEaDottedName,
+        });
+        const out = [];
+        const expansionId = ctx.nextSyntheticLabelId;
+        ctx.nextSyntheticLabelId += 1;
+        const expandedItems = expandInlineOpBodyItems({
+            opDecl,
+            allocateLocalLabel: (labelName) => `.__azm_op_${opDecl.name.toLowerCase()}_${expansionId}_${labelName.replace(/^\.+/, '')}`,
+            substituteOperandWithOpLabels,
+        });
+        for (const bodyItem of expandedItems) {
+            if (bodyItem.kind === 'AsmLabel') {
+                out.push({
+                    kind: 'label',
+                    label: {
+                        kind: 'AsmLabel',
+                        span: inst.span,
+                        name: bodyItem.name,
+                    },
+                });
+                continue;
+            }
+            if (bodyItem.kind !== 'AsmInstruction')
+                continue;
+            const expanded = {
+                kind: 'AsmInstruction',
+                span: inst.span,
+                head: bodyItem.head,
+                operands: bodyItem.operands,
+            };
+            out.push(...expandInstruction(expanded, nextStack));
+        }
+        return out;
+    }
+    return { expandInstruction };
+}

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

@@ -0,0 +1,52 @@
+import type { AsmOperandNode, EaExprNode, ImmExprNode, OpDeclNode, OpMatcherNode } from '../frontend/ast.js';
+type OpMatchingContext = {
+    /** 8-bit register names for matching. */
+    reg8: Set<string>;
+    /** True when operand uses IX/IY indexed memory form. */
+    isIxIyIndexedMem: (operand: AsmOperandNode) => boolean;
+    /** Flattens dotted EA; `undefined` if not expressible as dotted. */
+    flattenEaDottedName: (ea: EaExprNode) => string | undefined;
+    /** True for declared enum names. */
+    isEnumName: (name: string) => boolean;
+    /** Normalizes fixed tokens for overload keys. */
+    normalizeFixedToken: (operand: AsmOperandNode) => string | undefined;
+    /** Maps condition name to opcode; `undefined` if unknown. */
+    conditionOpcodeFromName: (name: string) => number | undefined;
+    /** Best-effort imm evaluation. */
+    evalImmNoDiag: (expr: ImmExprNode) => number | undefined;
+    /** Infers memory operand width in bytes; `undefined` if unknown. */
+    inferMemWidth: (operand: AsmOperandNode) => number | undefined;
+};
+export type OpOverloadSelection = {
+    kind: 'arity_mismatch';
+    /** Candidate overloads. */
+    overloads: OpDeclNode[];
+    /** Rendered arity signatures for diagnostics. */
+    signatures: string[];
+} | {
+    kind: 'no_match';
+    /** Candidate overloads. */
+    overloads: OpDeclNode[];
+    /** Per-operand mismatch notes. */
+    mismatchDetails: string[];
+} | {
+    kind: 'ambiguous';
+    /** Competing overloads. */
+    overloads: OpDeclNode[];
+    /** Rendered definitions for diagnostics. */
+    definitions: string[];
+} | {
+    kind: 'selected';
+    /** Chosen overload. */
+    overload: OpDeclNode;
+};
+export declare function createOpMatchingHelpers(ctx: OpMatchingContext): {
+    matcherMatchesOperand: (matcher: OpMatcherNode, operand: AsmOperandNode) => boolean;
+    selectMostSpecificOpOverload: (candidates: OpDeclNode[], operands: AsmOperandNode[]) => OpDeclNode | undefined;
+    selectOpOverload: (overloads: OpDeclNode[], operands: AsmOperandNode[]) => OpOverloadSelection;
+    formatAsmOperandForOpDiag: (operand: AsmOperandNode) => string;
+    formatOpSignature: (opDecl: OpDeclNode) => string;
+    formatOpDefinitionForDiag: (opDecl: OpDeclNode) => string;
+    firstOpOverloadMismatchReason: (opDecl: OpDeclNode, operands: AsmOperandNode[]) => string | undefined;
+};
+export {};

package/dist/src/lowering/opMatching.js

@@ -0,0 +1,355 @@
+import { formatEaExpr } from './traceFormat.js';
+const fitsImm8 = (value) => value >= -0x80 && value <= 0xff;
+const fitsImm16 = (value) => value >= -0x8000 && value <= 0xffff;
+export function createOpMatchingHelpers(ctx) {
+    const enumImmExprFromOperand = (op) => {
+        switch (op.kind) {
+            case 'Imm':
+                return op.expr;
+            case 'Reg':
+                return { kind: 'ImmName', span: op.span, name: op.name };
+            case 'Ea': {
+                const name = ctx.flattenEaDottedName(op.expr);
+                if (!name || !ctx.isEnumName(name))
+                    return undefined;
+                return { kind: 'ImmName', span: op.span, name };
+            }
+            default:
+                return undefined;
+        }
+    };
+    const matcherMatchesOperand = (matcher, operand) => {
+        switch (matcher.kind) {
+            case 'MatcherReg8':
+                return operand.kind === 'Reg' && ctx.reg8.has(operand.name.toUpperCase());
+            case 'MatcherReg16':
+                return (operand.kind === 'Reg' &&
+                    (operand.name.toUpperCase() === 'BC' ||
+                        operand.name.toUpperCase() === 'DE' ||
+                        operand.name.toUpperCase() === 'HL' ||
+                        operand.name.toUpperCase() === 'SP'));
+            case 'MatcherIdx16':
+                return ctx.isIxIyIndexedMem(operand);
+            case 'MatcherCc': {
+                const token = ctx.normalizeFixedToken(operand);
+                return token !== undefined && ctx.conditionOpcodeFromName(token) !== undefined;
+            }
+            case 'MatcherImm8': {
+                const expr = enumImmExprFromOperand(operand);
+                if (!expr)
+                    return false;
+                const v = ctx.evalImmNoDiag(expr);
+                return v !== undefined && fitsImm8(v);
+            }
+            case 'MatcherImm16': {
+                const expr = enumImmExprFromOperand(operand);
+                if (!expr)
+                    return false;
+                const v = ctx.evalImmNoDiag(expr);
+                return v !== undefined && fitsImm16(v);
+            }
+            case 'MatcherEa':
+                return operand.kind === 'Ea';
+            case 'MatcherMem8': {
+                if (operand.kind !== 'Mem')
+                    return false;
+                const width = ctx.inferMemWidth(operand);
+                return width === undefined ? true : width === 1;
+            }
+            case 'MatcherMem16': {
+                if (operand.kind !== 'Mem')
+                    return false;
+                const width = ctx.inferMemWidth(operand);
+                return width === undefined ? true : width === 2;
+            }
+            case 'MatcherFixed': {
+                const got = ctx.normalizeFixedToken(operand);
+                return got !== undefined && got === matcher.token.toUpperCase();
+            }
+            default:
+                return false;
+        }
+    };
+    const fixedTokenBeatsClassMatcher = (fixed, other, operand) => {
+        const fixedToken = fixed.token.toUpperCase();
+        switch (other.kind) {
+            case 'MatcherReg8':
+                return (operand.kind === 'Reg' &&
+                    operand.name.toUpperCase() === fixedToken &&
+                    ctx.reg8.has(fixedToken));
+            case 'MatcherReg16':
+                return (operand.kind === 'Reg' &&
+                    operand.name.toUpperCase() === fixedToken &&
+                    (fixedToken === 'BC' || fixedToken === 'DE' || fixedToken === 'HL' || fixedToken === 'SP'));
+            case 'MatcherCc':
+                return ctx.conditionOpcodeFromName(fixedToken) !== undefined;
+            default:
+                return false;
+        }
+    };
+    const compareMatcherSpecificity = (matcherX, matcherY, operand) => {
+        if (matcherX.kind === matcherY.kind)
+            return 'equal';
+        if (matcherX.kind === 'MatcherFixed' &&
+            fixedTokenBeatsClassMatcher(matcherX, matcherY, operand)) {
+            return 'x_more_specific';
+        }
+        if (matcherY.kind === 'MatcherFixed' &&
+            fixedTokenBeatsClassMatcher(matcherY, matcherX, operand)) {
+            return 'y_more_specific';
+        }
+        if (matcherX.kind === 'MatcherImm8' && matcherY.kind === 'MatcherImm16') {
+            const expr = enumImmExprFromOperand(operand);
+            if (!expr)
+                return 'equal';
+            const value = ctx.evalImmNoDiag(expr);
+            return value !== undefined && fitsImm8(value) ? 'x_more_specific' : 'equal';
+        }
+        if (matcherX.kind === 'MatcherImm16' && matcherY.kind === 'MatcherImm8') {
+            const expr = enumImmExprFromOperand(operand);
+            if (!expr)
+                return 'equal';
+            const value = ctx.evalImmNoDiag(expr);
+            return value !== undefined && fitsImm8(value) ? 'y_more_specific' : 'equal';
+        }
+        if ((matcherX.kind === 'MatcherMem8' || matcherX.kind === 'MatcherMem16') &&
+            matcherY.kind === 'MatcherEa' &&
+            operand.kind === 'Mem') {
+            return 'x_more_specific';
+        }
+        if (matcherX.kind === 'MatcherEa' &&
+            (matcherY.kind === 'MatcherMem8' || matcherY.kind === 'MatcherMem16') &&
+            operand.kind === 'Mem') {
+            return 'y_more_specific';
+        }
+        return 'equal';
+    };
+    const compareOpOverloadSpecificity = (overloadX, overloadY, operands) => {
+        let xBetter = 0;
+        let yBetter = 0;
+        for (let i = 0; i < operands.length; i++) {
+            const xMatcher = overloadX.params[i].matcher;
+            const yMatcher = overloadY.params[i].matcher;
+            const cmp = compareMatcherSpecificity(xMatcher, yMatcher, operands[i]);
+            if (cmp === 'x_more_specific')
+                xBetter++;
+            if (cmp === 'y_more_specific')
+                yBetter++;
+        }
+        if (xBetter > 0 && yBetter === 0)
+            return 'x_wins';
+        if (yBetter > 0 && xBetter === 0)
+            return 'y_wins';
+        if (xBetter === 0 && yBetter === 0)
+            return 'equal';
+        return 'incomparable';
+    };
+    const selectMostSpecificOpOverload = (candidates, operands) => {
+        if (candidates.length === 0)
+            return undefined;
+        if (candidates.length === 1)
+            return candidates[0];
+        for (let i = 0; i < candidates.length; i++) {
+            const candidate = candidates[i];
+            let beatsAll = true;
+            for (let j = 0; j < candidates.length; j++) {
+                if (i === j)
+                    continue;
+                const cmp = compareOpOverloadSpecificity(candidate, candidates[j], operands);
+                if (cmp !== 'x_wins') {
+                    beatsAll = false;
+                    break;
+                }
+            }
+            if (beatsAll)
+                return candidate;
+        }
+        return undefined;
+    };
+    const formatOpMatcher = (matcher) => {
+        switch (matcher.kind) {
+            case 'MatcherReg8':
+                return 'reg8';
+            case 'MatcherReg16':
+                return 'reg16';
+            case 'MatcherIdx16':
+                return 'idx16';
+            case 'MatcherCc':
+                return 'cc';
+            case 'MatcherImm8':
+                return 'imm8';
+            case 'MatcherImm16':
+                return 'imm16';
+            case 'MatcherEa':
+                return 'ea';
+            case 'MatcherMem8':
+                return 'mem8';
+            case 'MatcherMem16':
+                return 'mem16';
+            case 'MatcherFixed':
+                return matcher.token;
+            default:
+                return 'unknown';
+        }
+    };
+    const formatImmExprForOpDiag = (expr) => {
+        switch (expr.kind) {
+            case 'ImmLiteral':
+                return String(expr.value);
+            case 'ImmName':
+                return expr.name;
+            case 'ImmSizeof':
+                return 'sizeof(...)';
+            case 'ImmOffset':
+                return 'offset(...)';
+            case 'ImmUnary':
+                return `${expr.op}${formatImmExprForOpDiag(expr.expr)}`;
+            case 'ImmBinary':
+                return `${formatImmExprForOpDiag(expr.left)} ${expr.op} ${formatImmExprForOpDiag(expr.right)}`;
+            default:
+                return 'imm';
+        }
+    };
+    const formatAsmOperandForOpDiag = (operand) => {
+        switch (operand.kind) {
+            case 'Reg':
+                return operand.name;
+            case 'Imm':
+                return formatImmExprForOpDiag(operand.expr);
+            case 'Ea':
+                return formatEaExpr(operand.expr, {
+                    formatImmExpr: formatImmExprForOpDiag,
+                    wrapImmEa: true,
+                });
+            case 'Mem':
+                return `(${formatEaExpr(operand.expr, { formatImmExpr: formatImmExprForOpDiag, wrapImmEa: true })})`;
+            case 'PortC':
+                return '(C)';
+            case 'PortImm8':
+                return `(${formatImmExprForOpDiag(operand.expr)})`;
+            default:
+                return '?';
+        }
+    };
+    const formatOpSignature = (opDecl) => {
+        const params = opDecl.params.map((p) => `${p.name} ${formatOpMatcher(p.matcher)}`).join(', ');
+        return `${opDecl.name}(${params})`;
+    };
+    const formatOpDefinitionForDiag = (opDecl) => `${formatOpSignature(opDecl)} (${opDecl.span.file}:${opDecl.span.start.line})`;
+    const matcherMismatchReason = (matcher, operand) => {
+        const got = formatAsmOperandForOpDiag(operand);
+        switch (matcher.kind) {
+            case 'MatcherReg8':
+                return `expects reg8, got ${got}`;
+            case 'MatcherReg16':
+                return `expects reg16, got ${got}`;
+            case 'MatcherIdx16':
+                return `expects IX/IY indexed memory operand, got ${got}`;
+            case 'MatcherCc':
+                return 'expects condition token NZ/Z/NC/C/PO/PE/P/M, got ' + got;
+            case 'MatcherImm8': {
+                const expr = enumImmExprFromOperand(operand);
+                if (!expr)
+                    return `expects imm8, got ${got}`;
+                const value = ctx.evalImmNoDiag(expr);
+                if (value === undefined)
+                    return `expects imm8, got ${got}`;
+                if (!fitsImm8(value))
+                    return `expects imm8 (-128..255), got ${got}`;
+                return `expects imm8, got ${got}`;
+            }
+            case 'MatcherImm16': {
+                const expr = enumImmExprFromOperand(operand);
+                if (!expr)
+                    return `expects imm16, got ${got}`;
+                const value = ctx.evalImmNoDiag(expr);
+                if (value === undefined)
+                    return `expects imm16, got ${got}`;
+                if (!fitsImm16(value))
+                    return `expects imm16 (-32768..65535), got ${got}`;
+                return `expects imm16, got ${got}`;
+            }
+            case 'MatcherEa':
+                return `expects ea, got ${got}`;
+            case 'MatcherMem8': {
+                if (operand.kind !== 'Mem')
+                    return `expects mem8 dereference, got ${got}`;
+                const width = ctx.inferMemWidth(operand);
+                if (width !== undefined && width !== 1)
+                    return `expects mem8 dereference, got mem${width * 8}`;
+                return `expects mem8 dereference, got ${got}`;
+            }
+            case 'MatcherMem16': {
+                if (operand.kind !== 'Mem')
+                    return `expects mem16 dereference, got ${got}`;
+                const width = ctx.inferMemWidth(operand);
+                if (width !== undefined && width !== 2)
+                    return `expects mem16 dereference, got mem${width * 8}`;
+                return `expects mem16 dereference, got ${got}`;
+            }
+            case 'MatcherFixed':
+                return `expects ${matcher.token}, got ${got}`;
+            default:
+                return `operand mismatch: expected ${formatOpMatcher(matcher)}, got ${got}`;
+        }
+    };
+    const firstOpOverloadMismatchReason = (opDecl, operands) => {
+        for (let i = 0; i < opDecl.params.length && i < operands.length; i++) {
+            const param = opDecl.params[i];
+            const operand = operands[i];
+            if (matcherMatchesOperand(param.matcher, operand))
+                continue;
+            return `${param.name}: ${matcherMismatchReason(param.matcher, operand)}`;
+        }
+        return undefined;
+    };
+    const selectOpOverload = (overloads, operands) => {
+        const arityMatches = overloads.filter((candidate) => candidate.params.length === operands.length);
+        if (arityMatches.length === 0) {
+            return {
+                kind: 'arity_mismatch',
+                overloads,
+                signatures: overloads.map((candidate) => formatOpSignature(candidate)),
+            };
+        }
+        const matches = arityMatches.filter((candidate) => {
+            if (candidate.params.length !== operands.length)
+                return false;
+            for (let idx = 0; idx < candidate.params.length; idx++) {
+                const param = candidate.params[idx];
+                const arg = operands[idx];
+                if (!matcherMatchesOperand(param.matcher, arg))
+                    return false;
+            }
+            return true;
+        });
+        if (matches.length === 0) {
+            return {
+                kind: 'no_match',
+                overloads: arityMatches,
+                mismatchDetails: arityMatches.map((candidate) => {
+                    const reason = firstOpOverloadMismatchReason(candidate, operands);
+                    return `${formatOpDefinitionForDiag(candidate)}${reason ? ` ; ${reason}` : ''}`;
+                }),
+            };
+        }
+        const selected = selectMostSpecificOpOverload(matches, operands);
+        if (!selected) {
+            return {
+                kind: 'ambiguous',
+                overloads: matches,
+                definitions: matches.map((candidate) => formatOpDefinitionForDiag(candidate)),
+            };
+        }
+        return { kind: 'selected', overload: selected };
+    };
+    return {
+        matcherMatchesOperand,
+        selectMostSpecificOpOverload,
+        selectOpOverload,
+        formatAsmOperandForOpDiag,
+        formatOpSignature,
+        formatOpDefinitionForDiag,
+        firstOpOverloadMismatchReason,
+    };
+}

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

@@ -0,0 +1,13 @@
+import type { AsmOperandNode, ImmExprNode, SourceSpan } from '../frontend/ast.js';
+import type { AstCloneCapability, CompileEnvCapability, DottedEaNameCapability, LoweringDiagnosticsCapability } from './capabilities.js';
+type OpSubstitutionContext = LoweringDiagnosticsCapability & CompileEnvCapability & AstCloneCapability & DottedEaNameCapability & {
+    bindings: Map<string, AsmOperandNode>;
+};
+export declare function createOpSubstitutionHelpers(ctx: OpSubstitutionContext): {
+    bindingAsImmExpr: (bound: AsmOperandNode | undefined, span: SourceSpan) => ImmExprNode | undefined;
+    substituteImm: (expr: ImmExprNode) => ImmExprNode;
+    substituteOperand: (operand: AsmOperandNode) => AsmOperandNode;
+    substituteImmWithOpLabels: (expr: ImmExprNode, localLabelMap: Map<string, string>) => ImmExprNode;
+    substituteOperandWithOpLabels: (operand: AsmOperandNode, localLabelMap: Map<string, string>) => AsmOperandNode;
+};
+export {};