@jhlagado/azm 0.2.5 → 0.2.7

package/dist/src/register-care/boundaryHints.d.ts

@@ -1,2 +1,3 @@
 import type { RegisterCareInstruction } from './types.js';
 export declare function precedingCServiceName(item: RegisterCareInstruction | undefined): string | undefined;
+export declare function precedingRegisterImmediateValue(item: RegisterCareInstruction | undefined, register: string): number | undefined;

package/dist/src/register-care/boundaryHints.js

@@ -9,3 +9,72 @@ export function precedingCServiceName(item) {
     }
     return undefined;
 }
+function evaluateKnownConstant(expression, constants) {
+    switch (expression.kind) {
+        case 'number':
+            return expression.value;
+        case 'symbol':
+            return constants.get(expression.name);
+        case 'unary': {
+            const value = evaluateKnownConstant(expression.expression, constants);
+            if (value === undefined)
+                return undefined;
+            switch (expression.operator) {
+                case '+':
+                    return value;
+                case '-':
+                    return -value;
+                case '~':
+                    return ~value;
+            }
+        }
+        case 'binary': {
+            const left = evaluateKnownConstant(expression.left, constants);
+            const right = evaluateKnownConstant(expression.right, constants);
+            if (left === undefined || right === undefined)
+                return undefined;
+            switch (expression.operator) {
+                case '+':
+                    return left + right;
+                case '-':
+                    return left - right;
+                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 'byte-function': {
+            const value = evaluateKnownConstant(expression.expression, constants);
+            if (value === undefined)
+                return undefined;
+            return expression.function === 'LSB' ? value & 0xff : (value >> 8) & 0xff;
+        }
+        default:
+            return undefined;
+    }
+}
+export function precedingRegisterImmediateValue(item, register) {
+    const instruction = item?.instruction;
+    if (!instruction || instruction.mnemonic !== 'ld')
+        return undefined;
+    if (instruction.target?.kind !== 'reg8' ||
+        instruction.target.register !== register.toLowerCase()) {
+        return undefined;
+    }
+    if (instruction.source.kind !== 'imm')
+        return undefined;
+    return evaluateKnownConstant(instruction.source.expression, item.constants ?? new Map());
+}

package/dist/src/register-care/liveness.js

@@ -1,7 +1,7 @@
 import { getZ80InstructionEffect } from '../z80/effects.js';
-import { precedingCServiceName } from './boundaryHints.js';
+import { precedingCServiceName, precedingRegisterImmediateValue } from './boundaryHints.js';
 import { instructionSuccessors, labelIndex } from './controlFlow.js';
-import { rstServiceTargetName, rstTargetName } from './profiles.js';
+import { rstDispatcherServiceTargetNames, rstServiceTargetName, rstTargetName, } from './profiles.js';
 function unique(units) {
     return [...new Set(units)];
 }
@@ -27,10 +27,13 @@ function boundaryTarget(routine, index, effect) {
     }
     if (effect.control.kind === 'rst' && effect.control.vector !== undefined) {
         const target = rstTargetName(effect.control.vector);
+        const previous = routine.instructions[index - 1];
         const service = precedingCServiceName(routine.instructions[index - 1]);
-        const targets = service
-            ? [rstServiceTargetName(effect.control.vector, service), target]
-            : [target];
+        const targets = [
+            ...rstDispatcherServiceTargetNames(effect.control.vector, (register) => precedingRegisterImmediateValue(previous, register)),
+            ...(service ? [rstServiceTargetName(effect.control.vector, service)] : []),
+            target,
+        ];
         return { targets, conditional: false, subject: target };
     }
     return undefined;

package/dist/src/register-care/profiles.d.ts

@@ -1,9 +1,14 @@
-import type { RoutineSummary } from './types.js';
+import type { RegisterCareUnit, RoutineSummary } from './types.js';
 export interface RegisterCareProfileSummary {
     name: 'mon3';
     rst: Map<number, RoutineSummary>;
     rstServices: Map<string, RoutineSummary>;
+    rstDispatchers: Map<number, {
+        selector: RegisterCareUnit;
+        services: Map<number, RoutineSummary>;
+    }>;
 }
 export declare function rstTargetName(vector: number): string;
 export declare function rstServiceTargetName(vector: number, service: string): string;
+export declare function rstDispatcherServiceTargetNames(vector: number, selectorValue: (register: RegisterCareUnit) => number | undefined): string[];
 export declare function getRegisterCareProfile(name: 'mon3' | undefined): RegisterCareProfileSummary | undefined;

package/dist/src/register-care/profiles.js

@@ -8,9 +8,166 @@ function normalizeServiceName(raw) {
 export function rstServiceTargetName(vector, service) {
     return `${rstTargetName(vector)}:${normalizeServiceName(service)}`;
 }
+function mon3ApiTargetName(api, name) {
+    return `MON3_API_${api}_${name.replace(/[^A-Za-z0-9_]/gu, '').toUpperCase()}`;
+}
+function conservativeMon3ApiSummary(api, name) {
+    return {
+        name: mon3ApiTargetName(api, name),
+        mayRead: ['A', 'B', 'C', 'D', 'E', 'H', 'L', ...FLAG_UNITS],
+        mayWrite: ['A', 'B', 'C', 'D', 'E', 'H', 'L', ...FLAG_UNITS],
+        mayOutput: [],
+        preserved: [],
+        valueRelations: [],
+        stackBalanced: true,
+        hasUnknownStackEffect: false,
+    };
+}
+function mon3ApiServices(overrides) {
+    const names = [
+        'SOFTWARE_ID',
+        'VERSION_ID',
+        'PRE_INIT',
+        'BEEP_ALWAYS',
+        'CONV_A_TO_SEG',
+        'REG_A_TO_ASCII',
+        'ASCII_TO_SEGMENT',
+        'STRING_COMPARE',
+        'HL_TO_STRING',
+        'A_TO_STRING',
+        'SCAN_SEGMENTS',
+        'DISPLAY_ERROR',
+        'LCD_BUSY',
+        'STRING_TO_LCD',
+        'CHAR_TO_LCD',
+        'COMMAND_TO_LCD',
+        'SCAN_KEYS',
+        'SCAN_KEYS_WAIT',
+        'MATRIX_SCAN',
+        'JOYSTICK_SCAN',
+        'SERIAL_ENABLE',
+        'SERIAL_DISABLE',
+        'TX_BYTE',
+        'RX_BYTE',
+        'INTEL_HEX_LOAD',
+        'SEND_TO_SERIAL_API',
+        'RECEIVE_FROM_SERIAL_API',
+        'SEND_ASSEMBLY_API',
+        'SEND_HEX_API',
+        'GEN_DATA_DUMP',
+        'CHECK_START_END',
+        'MENU_DRIVER',
+        'PARAM_DRIVER',
+        'TIME_DELAY',
+        'PLAY_NOTE',
+        'PLAY_TUNE',
+        'PLAY_TUNE_MENU',
+        'GET_CAPS',
+        'GET_SHADOW',
+        'GET_PROTECT',
+        'GET_EXPAND',
+        'SET_CAPS',
+        'SET_SHADOW',
+        'SET_PROTECT',
+        'SET_EXPAND',
+        'STRING_TO_SERIAL',
+        'RTC_API',
+        'MENU_POP',
+        'TOGGLE_CAPS',
+        'RANDOM',
+        'SET_DIS_START',
+        'GET_DIS_NEXT',
+        'GET_DISASSEMBLY',
+        'MATRIX_SCAN_ASCII',
+        'PARSE_MATRIX_SCAN',
+        'LCD_CONFIRM',
+        'GET_GLCD_TERM',
+        'SET_GLCD_TERM',
+        'LOAD_FROM_DISK',
+        'OPEN_FILE',
+        'READ_SECTOR',
+        'WRITE_SECTOR',
+        'RGB_SCAN',
+    ];
+    return new Map(names.map((serviceName, api) => [
+        api,
+        overrides.get(api) ?? conservativeMon3ApiSummary(api, serviceName),
+    ]));
+}
+export function rstDispatcherServiceTargetNames(vector, selectorValue) {
+    const mon3 = getRegisterCareProfile('mon3');
+    const dispatcher = mon3?.rstDispatchers.get(vector);
+    if (dispatcher === undefined)
+        return [];
+    const value = selectorValue(dispatcher.selector);
+    if (value === undefined)
+        return [];
+    const service = dispatcher.services.get(value);
+    return service ? [service.name] : [];
+}
 export function getRegisterCareProfile(name) {
     if (name !== 'mon3')
         return undefined;
+    const matrixScan = {
+        name: mon3ApiTargetName(18, 'MATRIX_SCAN'),
+        mayRead: ['C'],
+        mayWrite: ['A', 'B', 'C', 'D', 'E', 'H', 'L', ...FLAG_UNITS],
+        mayOutput: ['D', 'E', 'zero'],
+        preserved: [],
+        valueRelations: [{ out: ['D', 'E', 'zero'], from: [] }],
+        stackBalanced: true,
+        hasUnknownStackEffect: false,
+    };
+    const stringToLcd = {
+        name: mon3ApiTargetName(13, 'STRING_TO_LCD'),
+        mayRead: ['C', 'H', 'L'],
+        mayWrite: ['A', 'H', 'L', ...FLAG_UNITS],
+        mayOutput: [],
+        preserved: ['B', 'C', 'D', 'E'],
+        valueRelations: [],
+        stackBalanced: true,
+        hasUnknownStackEffect: false,
+    };
+    const charToLcd = {
+        name: mon3ApiTargetName(14, 'CHAR_TO_LCD'),
+        mayRead: ['A', 'C'],
+        mayWrite: [],
+        mayOutput: [],
+        preserved: ['A', 'B', 'C', 'D', 'E', 'H', 'L', ...FLAG_UNITS],
+        valueRelations: [],
+        stackBalanced: true,
+        hasUnknownStackEffect: false,
+    };
+    const commandToLcd = {
+        name: mon3ApiTargetName(15, 'COMMAND_TO_LCD'),
+        mayRead: ['B', 'C'],
+        mayWrite: [],
+        mayOutput: [],
+        preserved: ['A', 'B', 'C', 'D', 'E', 'H', 'L', ...FLAG_UNITS],
+        valueRelations: [],
+        stackBalanced: true,
+        hasUnknownStackEffect: false,
+    };
+    const scanKeys = {
+        name: mon3ApiTargetName(16, 'SCAN_KEYS'),
+        mayRead: ['C'],
+        mayWrite: ['A', 'carry', 'zero'],
+        mayOutput: ['A', 'carry', 'zero'],
+        preserved: ['B', 'C', 'H', 'L'],
+        valueRelations: [{ out: ['A', 'carry', 'zero'], from: [] }],
+        stackBalanced: true,
+        hasUnknownStackEffect: false,
+    };
+    const parseMatrixScan = {
+        name: mon3ApiTargetName(54, 'PARSE_MATRIX_SCAN'),
+        mayRead: ['C', 'D', 'E', 'zero'],
+        mayWrite: ['A', 'B', 'C', 'H', 'L', 'carry', 'sign', 'parity', 'halfCarry'],
+        mayOutput: ['A', 'carry'],
+        preserved: ['D', 'E'],
+        valueRelations: [{ out: ['A', 'carry'], from: ['D', 'E', 'zero'] }],
+        stackBalanced: true,
+        hasUnknownStackEffect: false,
+    };
     return {
         name: 'mon3',
         rst: new Map([
@@ -43,5 +200,21 @@ export function getRegisterCareProfile(name) {
                 },
             ],
         ]),
+        rstDispatchers: new Map([
+            [
+                0x10,
+                {
+                    selector: 'C',
+                    services: mon3ApiServices(new Map([
+                        [13, stringToLcd],
+                        [14, charToLcd],
+                        [15, commandToLcd],
+                        [16, scanKeys],
+                        [18, matrixScan],
+                        [54, parseMatrixScan],
+                    ])),
+                },
+            ],
+        ]),
     };
 }

package/dist/src/register-care/programModel.js

@@ -4,6 +4,80 @@ function isGlobalLabel(name) {
 function routineNameFromExpression(expression) {
     return expression.kind === 'symbol' ? expression.name : undefined;
 }
+function evaluateConstantExpression(expression, constants) {
+    switch (expression.kind) {
+        case 'number':
+            return expression.value;
+        case 'symbol':
+            return constants.get(expression.name);
+        case 'unary': {
+            const value = evaluateConstantExpression(expression.expression, constants);
+            if (value === undefined)
+                return undefined;
+            switch (expression.operator) {
+                case '+':
+                    return value;
+                case '-':
+                    return -value;
+                case '~':
+                    return ~value;
+            }
+        }
+        case 'binary': {
+            const left = evaluateConstantExpression(expression.left, constants);
+            const right = evaluateConstantExpression(expression.right, constants);
+            if (left === undefined || right === undefined)
+                return undefined;
+            switch (expression.operator) {
+                case '+':
+                    return left + right;
+                case '-':
+                    return left - right;
+                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 'byte-function': {
+            const value = evaluateConstantExpression(expression.expression, constants);
+            if (value === undefined)
+                return undefined;
+            return expression.function === 'LSB' ? value & 0xff : (value >> 8) & 0xff;
+        }
+        default:
+            return undefined;
+    }
+}
+function collectConstants(items) {
+    const constants = new Map();
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const item of items) {
+            if (item.kind !== 'equ' || constants.has(item.name))
+                continue;
+            const value = evaluateConstantExpression(item.expression, constants);
+            if (value === undefined)
+                continue;
+            constants.set(item.name, value);
+            changed = true;
+        }
+    }
+    return constants;
+}
 function instructionCallTarget(item) {
     if (item.kind !== 'instruction')
         return undefined;
@@ -28,13 +102,14 @@ function instructionTailJumpTarget(item, entryNames) {
         return undefined;
     return target;
 }
-function toInstruction(item, labels) {
+function toInstruction(item, labels, constants) {
     return {
         instruction: item.instruction,
         file: item.span.sourceName,
         line: item.span.line,
         column: item.span.column,
         labels: [...labels],
+        constants,
     };
 }
 function pushDirectBoundary(boundaries, target, subject, file, line, column) {
@@ -43,6 +118,7 @@ function pushDirectBoundary(boundaries, target, subject, file, line, column) {
 export function buildRegisterCareProgramModel(items) {
     const routines = [];
     const directCalls = [];
+    const constants = collectConstants(items);
     const filesWithEntryLabels = new Set(items
         .filter((item) => item.kind === 'label')
         .filter((item) => item.isEntry === true)
@@ -73,6 +149,7 @@ export function buildRegisterCareProgramModel(items) {
                 labels: [...labels],
                 entryLabels: [...entryLabels],
                 instructions: [],
+                constants,
                 span: {
                     file: sourceName ?? '',
                     start: { line: routineStartLine, column: routineStartColumn ?? 1 },
@@ -89,6 +166,7 @@ export function buildRegisterCareProgramModel(items) {
             labels: [...labels],
             entryLabels: [...entryLabels],
             instructions: [...instructions],
+            constants,
             span: {
                 file: sourceName ?? '',
                 start: { line: routineStartLine, column: routineStartColumn ?? 1 },
@@ -121,7 +199,7 @@ export function buildRegisterCareProgramModel(items) {
             if (item.span.sourceName !== sourceName) {
                 continue;
             }
-            instructions.push(toInstruction(item, labels));
+            instructions.push(toInstruction(item, labels, constants));
             const directTarget = instructionCallTarget(item);
             if (directTarget !== undefined) {
                 pushDirectBoundary(directCalls, directTarget, `CALL ${directTarget}`, item.span.sourceName, item.span.line, item.span.column);

package/dist/src/register-care/summaries.js

@@ -24,7 +24,13 @@ export function buildProfileSummaries(profileName) {
     if (profile === undefined) {
         return [];
     }
-    return [...profile.rst.values(), ...profile.rstServices.values()];
+    return [
+        ...profile.rst.values(),
+        ...profile.rstServices.values(),
+        ...[...profile.rstDispatchers.values()].flatMap((dispatcher) => [
+            ...dispatcher.services.values(),
+        ]),
+    ];
 }
 export function buildProfileSummaryLookup(profileName) {
     const profile = getRegisterCareProfile(profileName);
@@ -37,6 +43,11 @@ export function buildProfileSummaryLookup(profileName) {
     for (const summary of profile.rstServices.values()) {
         out.set(summary.name, summary);
     }
+    for (const dispatcher of profile.rstDispatchers.values()) {
+        for (const summary of dispatcher.services.values()) {
+            out.set(summary.name, summary);
+        }
+    }
     return out;
 }
 export function routineNames(routines) {
@@ -44,7 +55,9 @@ export function routineNames(routines) {
 }
 export function buildSummaries(routines, contractMap, profileSummaries = []) {
     const names = routineNameSet(routines);
-    const routineSummaries = inferRoutineSummariesToFixedPoint([...routines], contractMap, names, [...profileSummaries]);
+    const routineSummaries = inferRoutineSummariesToFixedPoint([...routines], contractMap, names, [
+        ...profileSummaries,
+    ]);
     const summaries = routineSummaries.map((item) => item.summary);
     return summariesWithExternalContracts(summaries, contractMap, names);
 }

package/dist/src/register-care/types.d.ts

@@ -44,12 +44,14 @@ export interface RegisterCareInstruction {
     line: number;
     column: number;
     labels: string[];
+    constants?: ReadonlyMap<string, number>;
 }
 export interface RegisterCareRoutine {
     name: string;
     labels: string[];
     entryLabels: string[];
     instructions: RegisterCareInstruction[];
+    constants?: ReadonlyMap<string, number>;
     span: {
         file: string;
         start: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jhlagado/azm",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "AZM assembler for the Z80 family (Node.js CLI)",
   "license": "GPL-3.0-only",
   "engines": {