@jhlagado/azm 0.2.0 → 0.2.2

package/dist/src/register-care/instruction-shape.js

@@ -0,0 +1,129 @@
+export function instructionHead(item) {
+    return item.instruction.mnemonic.toLowerCase();
+}
+export function regName(operand) {
+    if (operand === undefined)
+        return undefined;
+    switch (operand.kind) {
+        case 'reg8':
+            return operand.register.toUpperCase();
+        case 'reg16':
+            return operand.register.toUpperCase();
+        case 'reg-index16':
+            return operand.register.toUpperCase();
+        case 'reg-half-index':
+            return operand.register.toUpperCase();
+        default:
+            return undefined;
+    }
+}
+function immValue(operand) {
+    if (operand?.kind !== 'imm')
+        return undefined;
+    const expression = operand.expression;
+    return expression.kind === 'number' ? expression.value : undefined;
+}
+export function instructionOperandCount(instruction) {
+    switch (instruction.mnemonic) {
+        case 'ret':
+        case 'ret-cc':
+            return instruction.mnemonic === 'ret' ? 0 : 1;
+        case 'ld':
+            return 2;
+        case 'ex':
+            return 2;
+        case 'jp':
+        case 'jp-cc':
+        case 'jr':
+        case 'jr-cc':
+        case 'djnz':
+        case 'call':
+        case 'call-cc':
+            return 1;
+        case 'add':
+        case 'adc':
+        case 'sbc':
+            return 'target' in instruction ? 2 : 1;
+        case 'sub':
+        case 'and':
+        case 'or':
+        case 'xor':
+        case 'cp':
+            return 1;
+        default:
+            return 0;
+    }
+}
+export function instructionOperand(instruction, index) {
+    switch (instruction.mnemonic) {
+        case 'ld':
+            return index === 0 ? instruction.target : index === 1 ? instruction.source : undefined;
+        case 'ex': {
+            if (index === 0) {
+                return instruction.form === 'de-hl'
+                    ? { kind: 'reg16', register: 'de' }
+                    : instruction.form === 'af-af'
+                        ? { kind: 'reg16', register: 'af' }
+                        : undefined;
+            }
+            if (index === 1) {
+                return instruction.form === 'de-hl'
+                    ? { kind: 'reg16', register: 'hl' }
+                    : undefined;
+            }
+            return undefined;
+        }
+        case 'add':
+        case 'adc':
+        case 'sbc':
+            if ('target' in instruction) {
+                return index === 0 ? instruction.target : index === 1 ? instruction.source : undefined;
+            }
+            return index === 0 ? instruction.source : undefined;
+        case 'sub':
+        case 'and':
+        case 'or':
+        case 'xor':
+        case 'cp':
+            return index === 0 ? instruction.source : undefined;
+        default:
+            return undefined;
+    }
+}
+export function isUnconditionalReturnInstruction(item) {
+    const head = instructionHead(item);
+    if (head === 'ret')
+        return item.instruction.mnemonic === 'ret';
+    return head === 'retn' || head === 'reti';
+}
+export function isPureTokenTransferInstruction(item) {
+    const head = instructionHead(item);
+    if (head === 'ex')
+        return true;
+    if (head !== 'ld' || instructionOperandCount(item.instruction) !== 2)
+        return false;
+    const dst = instructionOperand(item.instruction, 0);
+    const src = instructionOperand(item.instruction, 1);
+    if (regName(dst) === undefined)
+        return false;
+    return regName(src) !== undefined || src?.kind === 'imm';
+}
+export function isAccumulatorSelfOperand(item) {
+    const inst = item.instruction;
+    if (inst.mnemonic === 'or' || inst.mnemonic === 'and' || inst.mnemonic === 'xor') {
+        return inst.source.kind === 'reg8' && inst.source.register === 'a';
+    }
+    return false;
+}
+export function isImmediateZeroOperand(item) {
+    const inst = item.instruction;
+    if (inst.mnemonic !== 'cp')
+        return false;
+    return immValue(inst.source) === 0;
+}
+export function isRegisterOperand(item, index, name) {
+    if (item === undefined)
+        return false;
+    const operand = instructionOperand(item.instruction, index);
+    return regName(operand) === name.toUpperCase();
+}

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

@@ -48,10 +48,7 @@ function hintUnitsForLine(hints, file, callLine) {
     return prior?.comment.kind === 'expectOut' ? unique(prior.comment.carriers) : [];
 }
 function outputUnits(summary) {
-    return unique([
-        ...(summary.valueRelations?.flatMap((relation) => relation.out) ?? []),
-        ...(summary.mayOutput ?? []),
-    ]);
+    return unique(summary.valueRelations.flatMap((relation) => relation.out));
 }
 function setEqual(left, right) {
     if (left.size !== right.size)
@@ -148,7 +145,7 @@ export function findRegisterCareConflicts(routine, summaries, hints) {
         for (const unit of outputUnits(summary))
             accepted.add(unit);
         const carriers = unique(summary.mayWrite.filter((unit) => liveOut[index].has(unit) && !accepted.has(unit)));
-        if (carriers.length > 0 && !boundary.conditional) {
+        if (carriers.length > 0) {
             conflicts.push({
                 file: item.file,
                 line: item.line,
@@ -171,8 +168,19 @@ export function findCallerOutputCandidateObservations(routines, summaries) {
     for (const routine of routines) {
         const { liveOut } = liveSetsForRoutine(routine, summaries);
         for (const { item, index, boundary, target, summary } of resolvedBoundariesForRoutine(routine, summaries)) {
-            const alreadyOutput = new Set(outputUnits(summary));
-            const carriers = unique(summary.mayWrite.filter((unit) => liveOut[index].has(unit) && !alreadyOutput.has(unit)));
+            const intentionalOutputs = new Set(outputUnits(summary));
+            const carrierSources = [];
+            for (const unit of summary.mayWrite) {
+                if (liveOut[index].has(unit) && !intentionalOutputs.has(unit)) {
+                    carrierSources.push(unit);
+                }
+            }
+            for (const unit of intentionalOutputs) {
+                if (liveOut[index].has(unit)) {
+                    carrierSources.push(unit);
+                }
+            }
+            const carriers = unique(carrierSources);
             if (carriers.length > 0) {
                 out.push({
                     file: item.file,

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

@@ -23,6 +23,8 @@ export function getRegisterCareProfile(name) {
                     mayOutput: [],
                     preserved: ['B', 'C', 'D', 'E', 'H', 'L'],
                     valueRelations: [],
+                    stackBalanced: true,
+                    hasUnknownStackEffect: false,
                 },
             ],
         ]),
@@ -36,6 +38,8 @@ export function getRegisterCareProfile(name) {
                     mayOutput: ['A', 'carry', 'zero'],
                     preserved: ['B', 'C', 'D', 'E', 'H', 'L'],
                     valueRelations: [{ out: ['A', 'carry', 'zero'], from: [] }],
+                    stackBalanced: true,
+                    hasUnknownStackEffect: false,
                 },
             ],
         ]),

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

@@ -13,6 +13,21 @@ function instructionCallTarget(item) {
     }
     return undefined;
 }
+function instructionTailJumpTarget(item, entryNames) {
+    if (item.kind !== 'instruction')
+        return undefined;
+    const mnemonic = item.instruction.mnemonic;
+    if (mnemonic === 'jp-cc' && entryNames === undefined)
+        return undefined;
+    if (mnemonic !== 'jp' && mnemonic !== 'jp-cc')
+        return undefined;
+    const target = routineNameFromExpression(item.instruction.expression);
+    if (target === undefined || target.startsWith('.'))
+        return undefined;
+    if (entryNames !== undefined && !entryNames.has(target))
+        return undefined;
+    return target;
+}
 function toInstruction(item, labels) {
     return {
         instruction: item.instruction,
@@ -22,9 +37,16 @@ function toInstruction(item, labels) {
         labels: [...labels],
     };
 }
+function pushDirectBoundary(boundaries, target, subject, file, line, column) {
+    boundaries.push({ target, subject, file, line, column });
+}
 export function buildRegisterCareProgramModel(items) {
     const routines = [];
     const directCalls = [];
+    const filesWithEntryLabels = new Set(items
+        .filter((item) => item.kind === 'label')
+        .filter((item) => item.isEntry === true)
+        .map((item) => item.span.sourceName));
     let routineName;
     let entryLabels = [];
     let labels = [];
@@ -35,14 +57,28 @@ export function buildRegisterCareProgramModel(items) {
     const startRoutine = (item) => {
         sourceName = item.span.sourceName;
         routineName = item.name;
-        entryLabels = [item.name];
+        entryLabels = item.isEntry === true ? [item.name] : [];
         labels = [item.name];
         routineStartLine = item.span.line;
         routineStartColumn = item.span.column;
         instructions = [];
     };
     const flushRoutine = () => {
-        if (routineName === undefined || instructions.length === 0 || routineStartLine === undefined) {
+        if (routineName === undefined || routineStartLine === undefined) {
+            return;
+        }
+        if (instructions.length === 0) {
+            routines.push({
+                name: routineName,
+                labels: [...labels],
+                entryLabels: [...entryLabels],
+                instructions: [],
+                span: {
+                    file: sourceName ?? '',
+                    start: { line: routineStartLine, column: routineStartColumn ?? 1 },
+                    end: { line: routineStartLine, column: routineStartColumn ?? 1 },
+                },
+            });
             return;
         }
         const end = instructions[instructions.length - 1];
@@ -88,12 +124,7 @@ export function buildRegisterCareProgramModel(items) {
             instructions.push(toInstruction(item, labels));
             const directTarget = instructionCallTarget(item);
             if (directTarget !== undefined) {
-                directCalls.push({
-                    target: directTarget,
-                    file: item.span.sourceName,
-                    line: item.span.line,
-                    column: item.span.column,
-                });
+                pushDirectBoundary(directCalls, directTarget, `CALL ${directTarget}`, item.span.sourceName, item.span.line, item.span.column);
             }
             continue;
         }
@@ -104,19 +135,54 @@ export function buildRegisterCareProgramModel(items) {
             continue;
         }
         if (routineName === undefined) {
+            if (filesWithEntryLabels.has(item.span.sourceName) && item.isEntry !== true) {
+                continue;
+            }
             startRoutine(item);
             continue;
         }
-        if (instructions.length > 0 ||
-            sourceName === undefined ||
-            sourceName !== item.span.sourceName) {
+        if (sourceName === undefined || sourceName !== item.span.sourceName) {
+            finalizeAndRestart(item);
+            continue;
+        }
+        if (instructions.length > 0) {
+            if (filesWithEntryLabels.has(item.span.sourceName) && item.isEntry !== true) {
+                labels.push(item.name);
+                continue;
+            }
             finalizeAndRestart(item);
             continue;
         }
         // Multiple global labels before body on same routine are coalesced as entry labels.
         labels.push(item.name);
-        entryLabels.push(item.name);
+        if (item.isEntry === true) {
+            entryLabels.push(item.name);
+        }
     }
     flushRoutine();
-    return { routines, directCalls };
+    const entryNamesByFile = new Map();
+    for (const item of items) {
+        if (item.kind !== 'label' || item.isEntry !== true)
+            continue;
+        const names = entryNamesByFile.get(item.span.sourceName) ?? new Set();
+        names.add(item.name);
+        entryNamesByFile.set(item.span.sourceName, names);
+    }
+    const directTailJumps = [];
+    for (const item of items) {
+        if (item.kind !== 'instruction')
+            continue;
+        const entryNames = filesWithEntryLabels.has(item.span.sourceName)
+            ? entryNamesByFile.get(item.span.sourceName)
+            : undefined;
+        const target = instructionTailJumpTarget(item, entryNames);
+        if (target === undefined)
+            continue;
+        pushDirectBoundary(directTailJumps, target, `JP ${target}`, item.span.sourceName, item.span.line, item.span.column);
+    }
+    return {
+        routines,
+        directCalls,
+        directBoundaries: [...directCalls, ...directTailJumps],
+    };
 }

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

@@ -1,4 +1,5 @@
 import type { RegisterCareReportModel, RegisterCareUnit, RoutineSummary } from './types.js';
-export declare function renderRegisterCareReport(model: RegisterCareReportModel): string;
 export declare function contractCarrierList(units: RegisterCareUnit[]): string;
+export declare function renderRegisterCareReport(model: RegisterCareReportModel): string;
 export declare function renderRegisterCareInterface(summaries: RoutineSummary[]): string;
+export declare function renderRegisterCareSourceBlock(summary: RoutineSummary): string[];

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

@@ -1,23 +1,94 @@
-function listUnits(units) {
+function list(units) {
     return units.length === 0 ? '-' : units.join(',');
 }
+const FLAG_UNITS = new Set(['carry', 'zero', 'sign', 'parity', 'halfCarry']);
+const CONTRACT_CARRIER_PAIRS = [
+    { label: 'BC', hi: 'B', lo: 'C' },
+    { label: 'DE', hi: 'D', lo: 'E' },
+    { label: 'HL', hi: 'H', lo: 'L' },
+    { label: 'IX', hi: 'IXH', lo: 'IXL' },
+    { label: 'IY', hi: 'IYH', lo: 'IYL' },
+    { label: 'SP', hi: 'SPH', lo: 'SPL' },
+];
+export function contractCarrierList(units) {
+    const unique = [...new Set(units)];
+    const unitSet = new Set(unique);
+    const emitted = new Set();
+    const parts = [];
+    for (const unit of unique) {
+        if (emitted.has(unit))
+            continue;
+        const pair = CONTRACT_CARRIER_PAIRS.find((candidate) => (candidate.hi === unit || candidate.lo === unit) &&
+            unitSet.has(candidate.hi) &&
+            unitSet.has(candidate.lo));
+        if (pair) {
+            parts.push(pair.label);
+            emitted.add(pair.hi);
+            emitted.add(pair.lo);
+            continue;
+        }
+        parts.push(unit);
+        emitted.add(unit);
+    }
+    return parts.length === 0 ? '-' : parts.join(',');
+}
+function relationOutputUnits(relations) {
+    return relations.flatMap((rel) => rel.out);
+}
+function contractEntries(summary) {
+    const out = [];
+    if (summary.mayRead.length > 0)
+        out.push({ keyword: 'in', carriers: contractCarrierList(summary.mayRead) });
+    const outputUnits = relationOutputUnits(summary.valueRelations);
+    if (outputUnits.length > 0)
+        out.push({ keyword: 'out', carriers: contractCarrierList(outputUnits) });
+    const relationOut = relationOutUnits(summary);
+    const clobbers = summary.mayWrite.filter((unit) => !relationOut.has(unit));
+    if (clobbers.length > 0)
+        out.push({ keyword: 'clobbers', carriers: contractCarrierList(clobbers) });
+    return out;
+}
+function sourceContractEntries(summary) {
+    const out = [];
+    if (summary.mayRead.length > 0)
+        out.push({ keyword: 'in', carriers: contractCarrierList(summary.mayRead) });
+    const relationOut = relationOutUnits(summary);
+    const candidates = (summary.outputCandidates ?? []).filter((unit) => !relationOut.has(unit));
+    if (candidates.length > 0)
+        out.push({ keyword: 'maybe-out', carriers: contractCarrierList(candidates) });
+    const outputUnits = relationOutputUnits(summary.valueRelations);
+    if (outputUnits.length > 0)
+        out.push({ keyword: 'out', carriers: contractCarrierList(outputUnits) });
+    const clobbers = summary.mayWrite.filter((unit) => !relationOut.has(unit) && !FLAG_UNITS.has(unit));
+    if (clobbers.length > 0)
+        out.push({ keyword: 'clobbers', carriers: contractCarrierList(clobbers) });
+    return out;
+}
+function stackStatus(summary) {
+    const balance = summary.stackBalanced ? 'balanced' : 'unbalanced';
+    return summary.hasUnknownStackEffect ? `${balance}, unknown effect` : balance;
+}
+function relationOutUnits(summary) {
+    return new Set(summary.valueRelations.flatMap((rel) => rel.out));
+}
 export function renderRegisterCareReport(model) {
-    const lines = [
-        'AZM Register-Care Report',
-        `Entry: ${model.entryFile}`,
-        `Mode: ${model.mode}`,
-        ...(model.profile !== undefined ? [`Profile: ${model.profile}`] : []),
-        '',
-    ];
+    const lines = ['AZM Register-Care Report', `Entry: ${model.entryFile}`, `Mode: ${model.mode}`];
+    if (model.profile)
+        lines.push(`Profile: ${model.profile}`);
+    lines.push('');
     if (model.summaries.length === 0) {
         lines.push('Routines: none', '');
     }
     else {
         for (const summary of model.summaries) {
             lines.push(`Routine: ${summary.name}`);
-            lines.push(`  reads: ${listUnits(summary.mayRead)}`);
-            lines.push(`  writes: ${listUnits(summary.mayWrite)}`);
-            lines.push(`  preserves: ${listUnits(summary.preserved)}`);
+            lines.push(`  reads: ${list(summary.mayRead)}`);
+            lines.push(`  writes: ${list(summary.mayWrite)}`);
+            lines.push(`  preserves: ${list(summary.preserved)}`);
+            lines.push(`  stack: ${stackStatus(summary)}`);
+            for (const rel of summary.valueRelations) {
+                lines.push(`  relation: ${list(rel.out)} <= ${list(rel.from)}`);
+            }
             lines.push('');
         }
     }
@@ -27,17 +98,17 @@ export function renderRegisterCareReport(model) {
     }
     else {
         for (const conflict of model.conflicts) {
-            lines.push(`  ${conflict.file}:${conflict.line}:${conflict.column}: ${conflict.callTarget}: ${conflict.message}`);
+            lines.push(`  ${conflict.file}:${conflict.line}:${conflict.column}: ${conflict.callTarget}: ${list(conflict.carriers)}: ${conflict.message}`);
         }
     }
     lines.push('');
     lines.push('Output candidates:');
-    if (model.outputCandidates === undefined || model.outputCandidates.length === 0) {
+    if (!model.outputCandidates || model.outputCandidates.length === 0) {
         lines.push('  none');
     }
     else {
         for (const candidate of model.outputCandidates) {
-            lines.push(`  ${candidate.file}:${candidate.line}:${candidate.column}: ${candidate.routine}: ${candidate.carriers.join(',')}: ${candidate.message}`);
+            lines.push(`  ${candidate.file}:${candidate.line}:${candidate.column}: ${candidate.routine}: ${list(candidate.carriers)}: ${candidate.message}`);
         }
     }
     lines.push('');
@@ -46,37 +117,23 @@ export function renderRegisterCareReport(model) {
         lines.push('  none');
     }
     else {
-        for (const call of model.unknownCalls) {
+        for (const call of model.unknownCalls)
             lines.push(`  ${call}`);
-        }
     }
     lines.push('');
     return `${lines.join('\n')}\n`;
 }
-export function contractCarrierList(units) {
-    return units.length === 0 ? '-' : units.join(',');
-}
 export function renderRegisterCareInterface(summaries) {
     const lines = [];
     for (const summary of summaries) {
-        if (summary.mayRead.length === 0 &&
-            summary.mayWrite.length === 0 &&
-            summary.preserved.length === 0) {
-            continue;
-        }
         lines.push(`extern ${summary.name}`);
-        if (summary.mayRead.length > 0) {
-            lines.push(`in ${contractCarrierList(summary.mayRead)}`);
-        }
-        if (summary.mayWrite.length > 0) {
-            lines.push(`clobbers ${contractCarrierList(summary.mayWrite)}`);
-        }
-        if (summary.preserved.length > 0) {
-            lines.push(`preserves ${contractCarrierList(summary.preserved)}`);
+        for (const entry of contractEntries(summary)) {
+            lines.push(`${entry.keyword} ${entry.carriers}`);
         }
         lines.push('end', '');
     }
-    if (lines.length === 0)
-        lines.push('No inferred contracts were emitted.', '');
     return `${lines.join('\n')}\n`;
 }
+export function renderRegisterCareSourceBlock(summary) {
+    return sourceContractEntries(summary).map((entry) => `;!      ${entry.keyword.padEnd(10)}${entry.carriers}`);
+}

package/dist/src/register-care/routine-summaries.d.ts

@@ -0,0 +1,6 @@
+import type { RegisterCareRoutine, RoutineContract, RoutineSummary } from './types.js';
+export declare function summariesWithExternalContracts(summaries: RoutineSummary[], contracts: Map<string, RoutineContract>, routineNameSet: Set<string>): RoutineSummary[];
+export declare function inferRoutineSummariesToFixedPoint(routines: RegisterCareRoutine[], contracts: Map<string, RoutineContract>, routineNameSet: Set<string>, profileSummaries: RoutineSummary[]): Array<{
+    routine: RegisterCareRoutine;
+    summary: RoutineSummary;
+}>;

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

@@ -0,0 +1,89 @@
+import { applyRoutineContract, inferRoutineSummary } from './summary.js';
+function emptyRoutineSummary(name) {
+    return {
+        name,
+        mayRead: [],
+        mayWrite: [],
+        preserved: [],
+        valueRelations: [],
+        stackBalanced: true,
+        hasUnknownStackEffect: false,
+    };
+}
+function isLocalLabel(name) {
+    return name.startsWith('.');
+}
+function nonLocalLabels(labels) {
+    return labels.filter((label) => !isLocalLabel(label));
+}
+function boundaryLabels(routine) {
+    return routine.entryLabels.length > 0 ? routine.entryLabels : nonLocalLabels(routine.labels);
+}
+function contractForRoutine(routine, contracts) {
+    return boundaryLabels(routine)
+        .map((label) => contracts.get(label))
+        .find((contract) => contract !== undefined);
+}
+export function summariesWithExternalContracts(summaries, contracts, routineNameSet) {
+    const out = [...summaries];
+    for (const contract of contracts.values()) {
+        if (!routineNameSet.has(contract.name)) {
+            out.push(applyRoutineContract(emptyRoutineSummary(contract.name), contract));
+        }
+    }
+    return out;
+}
+function buildBoundarySummaryMap(summaries, routineSummaries, profileSummaries) {
+    const boundarySummaryMap = new Map(profileSummaries.map((summary) => [summary.name, summary]));
+    for (const summary of summaries) {
+        boundarySummaryMap.set(summary.name, summary);
+    }
+    for (const { routine, summary } of routineSummaries) {
+        for (const label of boundaryLabels(routine)) {
+            boundarySummaryMap.set(label, summary);
+        }
+    }
+    return boundarySummaryMap;
+}
+function summarizeRoutines(routines, contracts, boundarySummaryMap = new Map()) {
+    return routines.map((routine) => {
+        const inferred = inferRoutineSummary(routine, boundarySummaryMap);
+        const contract = contractForRoutine(routine, contracts);
+        return { routine, summary: contract ? applyRoutineContract(inferred, contract) : inferred };
+    });
+}
+function sortedUnique(values) {
+    return Array.from(new Set(values)).sort();
+}
+function summaryFingerprint(summary) {
+    const relations = summary.valueRelations
+        .map((relation) => `${relation.out.join(',')}<-${relation.from.join(',')}`)
+        .sort();
+    return JSON.stringify({
+        name: summary.name,
+        mayRead: sortedUnique(summary.mayRead),
+        mayWrite: sortedUnique(summary.mayWrite),
+        preserved: sortedUnique(summary.preserved),
+        relations,
+        stackBalanced: summary.stackBalanced,
+        hasUnknownStackEffect: summary.hasUnknownStackEffect,
+    });
+}
+function routineSummariesFingerprint(routineSummaries) {
+    return routineSummaries.map((item) => summaryFingerprint(item.summary)).join('\n');
+}
+export function inferRoutineSummariesToFixedPoint(routines, contracts, routineNameSet, profileSummaries) {
+    let routineSummaries = summarizeRoutines(routines, contracts);
+    const maxPasses = Math.max(2, routines.length + 2);
+    for (let pass = 0; pass < maxPasses; pass += 1) {
+        const summaries = summariesWithExternalContracts(routineSummaries.map((item) => item.summary), contracts, routineNameSet);
+        const boundarySummaryMap = buildBoundarySummaryMap(summaries, routineSummaries, profileSummaries);
+        const nextRoutineSummaries = summarizeRoutines(routines, contracts, boundarySummaryMap);
+        if (routineSummariesFingerprint(nextRoutineSummaries) ===
+            routineSummariesFingerprint(routineSummaries)) {
+            return nextRoutineSummaries;
+        }
+        routineSummaries = nextRoutineSummaries;
+    }
+    return routineSummaries;
+}

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

@@ -3,10 +3,10 @@ import type { AnalyzeRegisterCareOptions, RegisterCareDirectCall, RegisterCareRo
 export declare function buildProfileSummaries(profileName: AnalyzeRegisterCareOptions['registerCareProfile']): RoutineSummary[];
 export declare function buildProfileSummaryLookup(profileName: AnalyzeRegisterCareOptions['registerCareProfile']): Map<string, RoutineSummary>;
 export declare function routineNames(routines: readonly RegisterCareRoutine[]): string[];
-export declare function buildSummaries(routines: readonly RegisterCareRoutine[], contractMap: Map<string, RoutineContract>): RoutineSummary[];
+export declare function buildSummaries(routines: readonly RegisterCareRoutine[], contractMap: Map<string, RoutineContract>, profileSummaries?: readonly RoutineSummary[]): RoutineSummary[];
 export declare function buildSummaryByName(routines: readonly RegisterCareRoutine[], summaries: readonly RoutineSummary[], profileSummaries?: readonly RoutineSummary[]): Map<string, RoutineSummary>;
 export declare function withAcceptedOutputs(summaries: readonly RoutineSummary[], acceptedOutputCandidates: ReadonlyMap<string, RegisterCareUnit[]> | undefined): RoutineSummary[];
-export declare function unknownBoundaryDiagnostics(directCalls: readonly RegisterCareDirectCall[], knownRoutines: ReadonlySet<string>): Diagnostic[];
-export declare function unknownCallList(directCalls: readonly RegisterCareDirectCall[], knownRoutines: ReadonlySet<string>): string[];
+export declare function unknownBoundaryDiagnostics(directBoundaries: readonly RegisterCareDirectCall[], knownRoutines: ReadonlySet<string>): Diagnostic[];
+export declare function unknownCallList(directBoundaries: readonly RegisterCareDirectCall[], knownRoutines: ReadonlySet<string>): string[];
 export declare function buildOutputCandidateFixability(routines: readonly RegisterCareRoutine[], outputCandidates: readonly RegisterCareOutputCandidate[], autoFixableCandidateKeys: (routines: RegisterCareRoutine[], outputCandidates: RegisterCareOutputCandidate[]) => ReadonlySet<string>): ReadonlyMap<string, boolean>;
 export declare function outputCandidateKey(file: string, line: number, column: number): string;