@jhlagado/azm 0.2.7 → 0.2.9

package/dist/src/z80/effect-groups.js

@@ -0,0 +1,265 @@
+import { BIT_FLAG_WRITES, FLAG_WRITES, INC_DEC_FLAG_WRITES, ROTATE_SHIFT_FLAG_WRITES, STACK_POINTER_UNITS, baseEffect, concatUnique, operandReads, operandWrites, reg16Units, reg8Units, regHalfUnits, unknownEffect, } from './effect-units.js';
+export function callControl(target, conditional) {
+    return target === undefined
+        ? { kind: 'call', conditional }
+        : { kind: 'call', target, conditional };
+}
+export function rstControl(vector) {
+    return vector === undefined ? { kind: 'rst' } : { kind: 'rst', vector };
+}
+export function jumpControl(target, conditional) {
+    return target === undefined
+        ? { kind: 'jump', conditional }
+        : { kind: 'jump', target, conditional };
+}
+export function controlEffect(control, reads = []) {
+    return {
+        ...baseEffect(),
+        reads,
+        control,
+    };
+}
+export function stackControlEffect(control, reads = []) {
+    return {
+        ...controlEffect(control, reads),
+        writes: STACK_POINTER_UNITS,
+        stack: { kind: 'unknown' },
+    };
+}
+export function ldEffect(instruction) {
+    const srcReads = operandReads(instruction.source);
+    if (srcReads === undefined)
+        return unknownEffect();
+    const dstWrites = operandWrites(instruction.target);
+    if (instruction.target.kind === 'reg8' || instruction.target.kind === 'reg16') {
+        if (dstWrites === undefined)
+            return unknownEffect();
+        return {
+            ...baseEffect(),
+            reads: srcReads,
+            writes: dstWrites,
+        };
+    }
+    if (instruction.target.kind === 'reg-index16' ||
+        instruction.target.kind === 'reg-half-index') {
+        if (dstWrites === undefined)
+            return unknownEffect();
+        return {
+            ...baseEffect(),
+            reads: srcReads,
+            writes: dstWrites,
+        };
+    }
+    if (instruction.target.kind === 'reg-indirect' || instruction.target.kind === 'indexed') {
+        const dstReads = operandReads(instruction.target);
+        if (dstReads === undefined)
+            return unknownEffect();
+        return {
+            ...baseEffect(),
+            reads: concatUnique(dstReads, srcReads),
+        };
+    }
+    if (instruction.target.kind === 'mem-abs') {
+        return {
+            ...baseEffect(),
+            reads: srcReads,
+        };
+    }
+    return unknownEffect();
+}
+export function incDecEffect(instruction) {
+    const operand = instruction.operand;
+    if (operand.kind === 'reg8') {
+        const units = reg8Units(operand.register);
+        return {
+            ...baseEffect(),
+            reads: units,
+            writes: concatUnique(units, INC_DEC_FLAG_WRITES),
+        };
+    }
+    if (operand.kind === 'reg16') {
+        const units = reg16Units(operand.register);
+        return {
+            ...baseEffect(),
+            reads: units,
+            writes: units,
+        };
+    }
+    if (operand.kind === 'reg-half-index') {
+        const units = regHalfUnits(operand.register);
+        return {
+            ...baseEffect(),
+            reads: units,
+            writes: concatUnique(units, INC_DEC_FLAG_WRITES),
+        };
+    }
+    const reads = operandReads(operand);
+    if (reads === undefined)
+        return unknownEffect();
+    return {
+        ...baseEffect(),
+        reads,
+        writes: INC_DEC_FLAG_WRITES,
+    };
+}
+export function aluEffect(instruction) {
+    if (instruction.mnemonic === 'add' &&
+        'target' in instruction &&
+        (instruction.target.kind === 'reg16' || instruction.target.kind === 'reg-index16')) {
+        return wideAluEffect(instruction, []);
+    }
+    if (instruction.mnemonic === 'adc' &&
+        'target' in instruction &&
+        (instruction.target.kind === 'reg16' || instruction.target.kind === 'reg-index16')) {
+        return wideAluEffect(instruction, ['carry']);
+    }
+    if (instruction.mnemonic === 'sbc' &&
+        'target' in instruction &&
+        (instruction.target.kind === 'reg16' || instruction.target.kind === 'reg-index16')) {
+        return wideAluEffect(instruction, ['carry']);
+    }
+    if (!('source' in instruction))
+        return unknownEffect();
+    const source = instruction.source;
+    const sourceReads = aluSourceReads(source);
+    const xorSelfZero = instruction.mnemonic === 'xor' &&
+        source.kind === 'reg8' &&
+        source.register === 'a';
+    const reads = xorSelfZero ? [] : concatUnique(['A'], sourceReads);
+    const carryReads = instruction.mnemonic === 'adc' || instruction.mnemonic === 'sbc' ? ['carry'] : [];
+    if (instruction.mnemonic === 'cp') {
+        return {
+            ...baseEffect(),
+            reads: concatUnique(reads, carryReads),
+            writes: FLAG_WRITES,
+        };
+    }
+    return {
+        ...baseEffect(),
+        reads: concatUnique(reads, carryReads),
+        writes: concatUnique(['A'], FLAG_WRITES),
+    };
+}
+export function pushEffect(register) {
+    const units = reg16Units(register);
+    return {
+        ...baseEffect(),
+        reads: units,
+        writes: STACK_POINTER_UNITS,
+        stack: { kind: 'push', units },
+    };
+}
+export function popEffect(register) {
+    const units = reg16Units(register);
+    return {
+        ...baseEffect(),
+        writes: concatUnique(units, STACK_POINTER_UNITS),
+        stack: { kind: 'pop', units },
+    };
+}
+export function rotateShiftEffect(instruction) {
+    const reads = operandReads(instruction.operand);
+    const writes = operandWrites(instruction.operand);
+    if (reads === undefined || writes === undefined)
+        return unknownEffect();
+    return {
+        ...baseEffect(),
+        reads,
+        writes: concatUnique(writes, ROTATE_SHIFT_FLAG_WRITES),
+    };
+}
+export function bitEffect(instruction) {
+    const reads = operandReads(instruction.operand);
+    if (reads === undefined)
+        return unknownEffect();
+    if (instruction.mnemonic === 'bit') {
+        return {
+            ...baseEffect(),
+            reads,
+            writes: BIT_FLAG_WRITES,
+        };
+    }
+    const writes = operandWrites(instruction.operand);
+    if (writes === undefined)
+        return unknownEffect();
+    return {
+        ...baseEffect(),
+        reads,
+        writes,
+    };
+}
+export function inEffect(instruction) {
+    const targetWrites = instruction.target?.kind === 'reg8' ? reg8Units(instruction.target.register) : undefined;
+    if (instruction.port.kind === 'imm') {
+        return {
+            ...baseEffect(),
+            reads: ['A'],
+            writes: targetWrites ?? [],
+        };
+    }
+    return {
+        ...baseEffect(),
+        reads: ['C'],
+        writes: concatUnique(targetWrites ?? [], BIT_FLAG_WRITES),
+    };
+}
+export function outEffect(instruction) {
+    const valueReads = instruction.source.kind === 'reg8' ? reg8Units(instruction.source.register) : [];
+    if (instruction.port.kind === 'c') {
+        return {
+            ...baseEffect(),
+            reads: concatUnique(['C'], valueReads),
+        };
+    }
+    return {
+        ...baseEffect(),
+        reads: valueReads,
+    };
+}
+export function blockTransferEffect() {
+    return {
+        ...baseEffect(),
+        reads: ['H', 'L', 'D', 'E', 'B', 'C'],
+        writes: ['H', 'L', 'D', 'E', 'B', 'C', 'halfCarry', 'parity'],
+    };
+}
+export function exEffect(instruction) {
+    if (instruction.form === 'de-hl') {
+        return {
+            ...baseEffect(),
+            reads: ['D', 'E', 'H', 'L'],
+            writes: ['D', 'E', 'H', 'L'],
+        };
+    }
+    return unknownEffect();
+}
+export function accumulatorRotateEffect(mnemonic) {
+    const reads = mnemonic === 'rla' || mnemonic === 'rra' ? ['A', 'carry'] : ['A'];
+    return {
+        ...baseEffect(),
+        reads,
+        writes: ['A', 'carry', 'halfCarry'],
+    };
+}
+function wideAluEffect(instruction, extraReads) {
+    const targetReads = operandReads(instruction.target);
+    const sourceReads = operandReads(instruction.source);
+    if (targetReads === undefined || sourceReads === undefined)
+        return unknownEffect();
+    return {
+        ...baseEffect(),
+        reads: concatUnique(targetReads, sourceReads, extraReads),
+        writes: concatUnique(operandWrites(instruction.target) ?? [], FLAG_WRITES),
+    };
+}
+function aluSourceReads(source) {
+    if (source.kind === 'reg8')
+        return reg8Units(source.register);
+    if (source.kind === 'reg16' || source.kind === 'reg-index16')
+        return reg16Units(source.register);
+    if (source.kind === 'reg-half-index')
+        return regHalfUnits(source.register);
+    if (source.kind === 'reg-indirect' || source.kind === 'indexed')
+        return operandReads(source) ?? [];
+    return [];
+}

package/dist/src/z80/effect-units.d.ts

@@ -0,0 +1,18 @@
+import type { Expression } from '../model/expression.js';
+import type { InstructionEffect, RegisterContractsUnit } from '../register-contracts/types.js';
+import type { Z80Condition, Z80Operand, Z80RelativeCondition } from './instruction.js';
+export declare const FLAG_WRITES: RegisterContractsUnit[];
+export declare const INC_DEC_FLAG_WRITES: RegisterContractsUnit[];
+export declare const ROTATE_SHIFT_FLAG_WRITES: RegisterContractsUnit[];
+export declare const BIT_FLAG_WRITES: RegisterContractsUnit[];
+export declare const STACK_POINTER_UNITS: RegisterContractsUnit[];
+export declare function baseEffect(): InstructionEffect;
+export declare function unknownEffect(): InstructionEffect;
+export declare function concatUnique(...groups: RegisterContractsUnit[][]): RegisterContractsUnit[];
+export declare function reg8Units(raw: string): RegisterContractsUnit[];
+export declare function reg16Units(raw: string): RegisterContractsUnit[];
+export declare function regHalfUnits(raw: string): RegisterContractsUnit[];
+export declare function expressionSymbol(expression: Expression): string | undefined;
+export declare function operandReads(op: Z80Operand): RegisterContractsUnit[] | undefined;
+export declare function operandWrites(op: Z80Operand): RegisterContractsUnit[] | undefined;
+export declare function conditionFlagRead(condition: Z80Condition | Z80RelativeCondition): RegisterContractsUnit[];

package/dist/src/z80/effect-units.js

@@ -0,0 +1,165 @@
+export const FLAG_WRITES = ['sign', 'zero', 'halfCarry', 'parity', 'carry'];
+export const INC_DEC_FLAG_WRITES = ['sign', 'zero', 'halfCarry', 'parity'];
+export const ROTATE_SHIFT_FLAG_WRITES = [
+    'sign',
+    'zero',
+    'halfCarry',
+    'parity',
+    'carry',
+];
+export const BIT_FLAG_WRITES = ['sign', 'zero', 'halfCarry', 'parity'];
+export const STACK_POINTER_UNITS = ['SPH', 'SPL'];
+const UNKNOWN_UNITS = [
+    'A',
+    'B',
+    'C',
+    'D',
+    'E',
+    'H',
+    'L',
+    'IXH',
+    'IXL',
+    'IYH',
+    'IYL',
+    'SPH',
+    'SPL',
+    'carry',
+    'zero',
+    'sign',
+    'parity',
+    'halfCarry',
+];
+export function baseEffect() {
+    return {
+        reads: [],
+        writes: [],
+        stack: { kind: 'none' },
+        control: { kind: 'fallthrough' },
+    };
+}
+export function unknownEffect() {
+    return {
+        reads: UNKNOWN_UNITS,
+        writes: UNKNOWN_UNITS,
+        stack: { kind: 'unknown' },
+        control: { kind: 'unknown' },
+    };
+}
+export function concatUnique(...groups) {
+    const out = [];
+    for (const group of groups) {
+        appendUnique(out, group);
+    }
+    return out;
+}
+export function reg8Units(raw) {
+    const reg = raw.toLowerCase();
+    if (reg === 'a')
+        return ['A'];
+    if (reg === 'b')
+        return ['B'];
+    if (reg === 'c')
+        return ['C'];
+    if (reg === 'd')
+        return ['D'];
+    if (reg === 'e')
+        return ['E'];
+    if (reg === 'h')
+        return ['H'];
+    if (reg === 'l')
+        return ['L'];
+    return [];
+}
+export function reg16Units(raw) {
+    const reg = raw.toLowerCase();
+    if (reg === 'bc')
+        return ['B', 'C'];
+    if (reg === 'de')
+        return ['D', 'E'];
+    if (reg === 'hl')
+        return ['H', 'L'];
+    if (reg === 'sp')
+        return ['SPH', 'SPL'];
+    if (reg === 'ix')
+        return ['IXH', 'IXL'];
+    if (reg === 'iy')
+        return ['IYH', 'IYL'];
+    if (reg === 'af')
+        return ['A', ...FLAG_WRITES];
+    return [];
+}
+export function regHalfUnits(raw) {
+    const reg = raw.toLowerCase();
+    if (reg === 'ixh')
+        return ['IXH'];
+    if (reg === 'ixl')
+        return ['IXL'];
+    if (reg === 'iyh')
+        return ['IYH'];
+    if (reg === 'iyl')
+        return ['IYL'];
+    return [];
+}
+export function expressionSymbol(expression) {
+    return expression.kind === 'symbol' ? expression.name : undefined;
+}
+export function operandReads(op) {
+    switch (op.kind) {
+        case 'reg8':
+            return reg8Units(op.register);
+        case 'reg16':
+        case 'reg-index16':
+            return reg16Units(op.register);
+        case 'reg-half-index':
+            return regHalfUnits(op.register);
+        case 'special8':
+            return [];
+        case 'reg-indirect':
+            return reg16Units(op.register);
+        case 'indexed':
+            return reg16Units(op.register);
+        case 'mem-abs':
+        case 'imm':
+            return [];
+        default:
+            return undefined;
+    }
+}
+export function operandWrites(op) {
+    switch (op.kind) {
+        case 'reg8':
+            return reg8Units(op.register);
+        case 'reg16':
+            return reg16Units(op.register);
+        case 'reg-index16':
+            return reg16Units(op.register);
+        case 'reg-half-index':
+            return regHalfUnits(op.register);
+        default:
+            return undefined;
+    }
+}
+export function conditionFlagRead(condition) {
+    switch (condition) {
+        case 'z':
+        case 'nz':
+            return ['zero'];
+        case 'c':
+        case 'nc':
+            return ['carry'];
+        case 'm':
+        case 'p':
+            return ['sign'];
+        case 'pe':
+        case 'po':
+            return ['parity'];
+        default:
+            return [];
+    }
+}
+function appendUnique(out, units) {
+    for (const unit of units) {
+        if (!out.includes(unit))
+            out.push(unit);
+    }
+}

package/dist/src/z80/effects.d.ts

@@ -1,3 +1,3 @@
-import type { InstructionEffect } from '../register-care/types.js';
+import type { InstructionEffect } from '../register-contracts/types.js';
 import type { Z80Instruction } from './instruction.js';
 export declare function getZ80InstructionEffect(instruction: Z80Instruction): InstructionEffect;