reverseport 0.0.0-stage → 1.2.0

package/dist/ghidra/GhidraLoadImageValues.js

@@ -0,0 +1,260 @@
+import { createHash } from "node:crypto";
+import { nativeLoadImageSchema, } from "../domain/native/nativeLoadImage.js";
+import { parseDosMzHeader } from "../domain/dosMz.js";
+import { validateDosComLength } from "../domain/dosCom.js";
+import { err, ok } from "../domain/result.js";
+import { ghidraRawBinaryLanguage } from "./GhidraRawBinaryLanguage.js";
+const sha256 = (bytes) => createHash("sha256").update(bytes).digest("hex");
+const address = (offset) => `0x${offset.toString(16)}`;
+const limitations = [
+    "Verification covers original/modified FileBytes, every initialized target-backed header/module mapping, relocation records and the external entry point. Mapping ends are inclusive.",
+    "Appended overlay bytes are identified by file extent and included in FileBytes identity; they must not be mapped as initialized header/module memory. Uninitialized allocations are reported but their contents and DOS runtime behavior are not verified.",
+    "The fixed load segment 0x1000 describes Ghidra's analysis image, not a running DOS process. Verified import does not establish original source ownership or recovered program behavior.",
+    "A mismatching memory digest identifies the reported source range; it does not locate the first differing byte inside that range.",
+];
+/** Verify measured MZ import state against the session's immutable snapshot. */
+export const attestGhidraDosLoadImage = (bytes, targetSha256, observations) => {
+    if (sha256(bytes) !== targetSha256)
+        return err("Ghidra load-image snapshot digest does not match the admitted target");
+    const parsed = parseDosMzHeader(bytes);
+    if (!parsed.ok)
+        return parsed;
+    const header = parsed.value;
+    const loadSegment = 0x1000;
+    const modified = Buffer.from(bytes);
+    const expectedRelocations = [];
+    for (let index = 0; index < header.relocationCount; index += 1) {
+        const table = header.relocationTableOffset + index * 4;
+        const offset = bytes.readUInt16LE(table);
+        const segment = bytes.readUInt16LE(table + 2);
+        const fileOffset = header.headerBytes + segment * 16 + offset;
+        const original = modified
+            .subarray(fileOffset, fileOffset + 2)
+            .toString("hex");
+        const relocated = (modified.readUInt16LE(fileOffset) + loadSegment) & 0xffff;
+        modified.writeUInt16LE(relocated, fileOffset);
+        expectedRelocations.push({
+            address: address(loadSegment * 16 + segment * 16 + offset),
+            segment: (loadSegment + segment) & 0xffff,
+            offset,
+            status: "APPLIED",
+            type: 0,
+            values: [segment, offset, relocated],
+            original_bytes_hex: original,
+            memory_bytes_hex: modified
+                .subarray(fileOffset, fileOffset + 2)
+                .toString("hex"),
+        });
+    }
+    const checks = [];
+    const check = (name, expected, observed, fileOffset = null, location = null) => {
+        checks.push({
+            name,
+            matched: JSON.stringify(expected) === JSON.stringify(observed),
+            expected,
+            observed,
+            file_offset: fileOffset,
+            address: location,
+        });
+    };
+    check("executable_format", "Old-style DOS Executable (MZ)", observations.executable_format);
+    check("language_id", "x86:LE:16:Real Mode", observations.language_id);
+    check("compiler_spec_id", "default", observations.compiler_spec_id);
+    check("image_base", "0x0", observations.image_base);
+    check("default_address_space", "ram", observations.default_address_space);
+    check("source_file_count", 1, observations.source_files.length);
+    const source = observations.source_files[0];
+    check("source_file_size", bytes.length, source?.size ?? null);
+    check("original_file_sha256", targetSha256, source?.original_sha256 ?? null);
+    check("modified_file_sha256", sha256(modified), source?.modified_sha256 ?? null);
+    const entryAddress = address(((loadSegment + header.entrySegment) & 0xffff) * 16 + header.entryOffset);
+    check("entry_points", [entryAddress], [...observations.entry_points].sort());
+    // A multiset preserves duplicate relocations and aliases; iteration order is not semantic.
+    const rows = (values) => values
+        .map(({ segment: _segment, offset: _offset, ...value }) => JSON.stringify(value))
+        .sort();
+    check("relocation_address_aliases", [], observations.relocations.filter((row) => row.segment === null ||
+        row.offset === null ||
+        address(row.segment * 16 + row.offset) !== row.address));
+    check("relocation_records", rows(expectedRelocations), rows(observations.relocations));
+    checkMappings(header, loadSegment * 16, bytes, modified, observations, check);
+    return ok(nativeLoadImageSchema.parse({
+        status: checks.every((item) => item.matched) ? "verified" : "mismatch",
+        format: "dos-mz",
+        target_sha256: targetSha256,
+        load_segment: loadSegment,
+        header_bytes: header.headerBytes,
+        module_bytes: header.moduleBytes,
+        overlay_bytes: header.overlayBytes,
+        entry: {
+            relative_segment: header.entrySegment,
+            offset: header.entryOffset,
+            linear_address: entryAddress,
+        },
+        observations,
+        checks,
+        limitations,
+    }));
+};
+const checkMappings = (header, loadBase, bytes, modified, observations, check) => {
+    const backed = observations.mappings.filter((mapping) => mapping.source_file_index !== null);
+    const sorted = [...backed].sort((left, right) => (left.file_offset ?? -1) - (right.file_offset ?? -1));
+    let covered = 0;
+    for (let index = 0; index < sorted.length; index += 1) {
+        const mapping = sorted[index];
+        if (mapping === undefined)
+            continue;
+        const start = mapping.file_offset;
+        const end = start === null ? null : start + mapping.length;
+        const headerMapping = start !== null && end !== null && start >= 0 && end <= header.headerBytes;
+        const moduleMapping = start !== null &&
+            end !== null &&
+            start >= header.headerBytes &&
+            end <= header.imageBytes;
+        const at = `mapping[${index}]`;
+        check(`${at}.source_file_index`, 0, mapping.source_file_index, start, mapping.start);
+        check(`${at}.file_coverage_start`, covered, start, start, mapping.start);
+        check(`${at}.partition`, true, headerMapping || moduleMapping, start, mapping.start);
+        check(`${at}.initialized`, true, mapping.initialized, start, mapping.start);
+        check(`${at}.loaded`, moduleMapping, mapping.loaded, start, mapping.start);
+        check(`${at}.overlay`, headerMapping, mapping.overlay, start, mapping.start);
+        check(`${at}.address_space`, headerMapping ? "HEADER" : observations.default_address_space, mapping.address_space, start, mapping.start);
+        const expectedStart = start === null
+            ? null
+            : headerMapping
+                ? `HEADER:${address(start)}`
+                : address(loadBase + start - header.headerBytes);
+        const expectedEnd = start === null
+            ? null
+            : headerMapping
+                ? `HEADER:${address(start + mapping.length - 1)}`
+                : address(loadBase + start - header.headerBytes + mapping.length - 1);
+        check(`${at}.start`, expectedStart, mapping.start, start, mapping.start);
+        check(`${at}.end`, expectedEnd, mapping.end, start, mapping.end);
+        check(`${at}.memory_sha256`, start !== null && end !== null && end <= bytes.length
+            ? sha256(modified.subarray(start, end))
+            : null, mapping.sha256, start, mapping.start);
+        covered = end ?? covered;
+    }
+    check("initialized_file_coverage_end", header.imageBytes, covered);
+    check("initialized_unbacked_mappings", [], observations.mappings.filter((mapping) => mapping.initialized && mapping.source_file_index === null));
+};
+/** Verify the explicit DOS COM interpretation against measured bytes and context. */
+export const attestGhidraDosComLoadImage = (bytes, targetSha256, observations) => {
+    if (sha256(bytes) !== targetSha256)
+        return err("Ghidra COM snapshot digest does not match the admitted target");
+    const length = validateDosComLength(bytes.length);
+    if (!length.ok)
+        return length;
+    const checks = [];
+    const check = (name, expected, observed, fileOffset = null, location = null) => {
+        checks.push({
+            name,
+            matched: JSON.stringify(expected) === JSON.stringify(observed),
+            expected,
+            observed,
+            file_offset: fileOffset,
+            address: location,
+        });
+    };
+    const source = observations.source_files[0];
+    check("executable_format", "Raw Binary", observations.executable_format);
+    check("language_id", "x86:LE:16:Real Mode", observations.language_id);
+    check("compiler_spec_id", "default", observations.compiler_spec_id);
+    check("image_base", "0x0", observations.image_base);
+    check("default_address_space", "ram", observations.default_address_space);
+    check("source_file_count", 1, observations.source_files.length);
+    check("source_file_size", bytes.length, source?.size ?? null);
+    check("original_file_sha256", targetSha256, source?.original_sha256 ?? null);
+    check("modified_file_sha256", targetSha256, source?.modified_sha256 ?? null);
+    check("entry_points", ["0x10100"], [...observations.entry_points].sort());
+    check("entry_context", [
+        {
+            address: "0x10100",
+            registers: ["CS", "DS", "ES", "SS"].map((name) => ({
+                name,
+                value_hex: "0x1000",
+            })),
+        },
+    ], observations.entry_context);
+    check("relocation_records", [], observations.relocations);
+    checkMappings({ headerBytes: 0, imageBytes: bytes.length }, 0x10100, bytes, bytes, observations, check);
+    return ok(nativeLoadImageSchema.parse({
+        status: checks.every((item) => item.matched) ? "verified" : "mismatch",
+        format: "dos-com",
+        target_sha256: targetSha256,
+        load_segment: 0x1000,
+        header_bytes: 0,
+        module_bytes: bytes.length,
+        overlay_bytes: 0,
+        entry: { relative_segment: 0, offset: 0x100, linear_address: "0x10100" },
+        observations,
+        checks,
+        limitations: [
+            "DOS COM is a headerless interpretation explicitly selected by the caller, not format identification from file bytes.",
+            "Verification covers complete original/modified source identity, mapped file bytes, entry and measured CS/DS/ES/SS entry context. Context 0x1000 is imposed for analysis; it is not an observed running process.",
+            "The PSP, initial stack contents/registers, DOS interrupts, PC-98 devices and runtime behavior are not modeled or verified. No original executable bytes are changed.",
+            "Mapping ends are inclusive; a mismatching digest identifies its source range, not the first differing byte.",
+        ],
+    }));
+};
+const hexAddress = (value) => `0x${value.toString(16)}`;
+/** Verify a caller-supplied raw-binary mapping against measured Ghidra import facts. */
+export const attestGhidraRawBinaryLoadImage = (snapshot, target, observations) => {
+    if (snapshot.sha256 !== target.sha256)
+        return err("Ghidra raw-binary snapshot digest does not match the admitted target");
+    const language = ghidraRawBinaryLanguage(target.architecture);
+    const base = BigInt(target.entryPoint);
+    const last = hexAddress(base + BigInt(snapshot.bytes) - 1n);
+    const checks = [];
+    const check = (name, expected, observed, fileOffset = null, location = null) => {
+        checks.push({
+            name,
+            matched: JSON.stringify(expected) === JSON.stringify(observed),
+            expected,
+            observed,
+            file_offset: fileOffset,
+            address: location,
+        });
+    };
+    const source = observations.source_files[0];
+    const mapping = observations.mappings[0];
+    check("executable_format", "Raw Binary", observations.executable_format);
+    check("language_id", language.languageId, observations.language_id);
+    check("compiler_spec_id", language.compilerSpecId, observations.compiler_spec_id);
+    // BinaryLoader's block base is independent of the Program image base.
+    check("image_base", "0x0", observations.image_base);
+    check("source_file_count", 1, observations.source_files.length);
+    check("source_file_size", snapshot.bytes, source?.size ?? null);
+    check("original_file_sha256", target.sha256, source?.original_sha256 ?? null);
+    check("modified_file_sha256", target.sha256, source?.modified_sha256 ?? null);
+    check("mapping_count", 1, observations.mappings.length);
+    check("mapping.file_offset", 0, mapping?.file_offset ?? null, 0, mapping?.start ?? null);
+    check("mapping.start", target.entryPoint, mapping?.start ?? null, 0, mapping?.start ?? null);
+    check("mapping.end", last, mapping?.end ?? null, 0, mapping?.end ?? null);
+    check("mapping.length", snapshot.bytes, mapping?.length ?? null, 0, mapping?.start ?? null);
+    check("mapping.sha256", snapshot.sha256, mapping?.sha256 ?? null, 0, mapping?.start ?? null);
+    check("entry_point", target.entryPoint, observations.entry_points.find((entry) => entry === target.entryPoint) ??
+        null);
+    check("relocation_records", [], observations.relocations);
+    return ok(nativeLoadImageSchema.parse({
+        status: checks.every((item) => item.matched) ? "verified" : "mismatch",
+        format: "raw-binary",
+        target_sha256: target.sha256,
+        architecture: target.architecture,
+        language_id: language.languageId,
+        compiler_spec_id: language.compilerSpecId,
+        base_address: target.entryPoint,
+        file_bytes: snapshot.bytes,
+        entry: { address: target.entryPoint, file_offset: 0 },
+        observations,
+        checks,
+        limitations: [
+            "Raw binary is a headerless interpretation explicitly selected by the caller, not format identification from file bytes.",
+            "Verification covers complete original/modified source identity, mapped file bytes, the caller-supplied entry, and the bound little-endian Ghidra language. File offset 0 is mapped at the entry address.",
+            "Ghidra may report additional language-defined external entries outside the mapped image. They are preserved as observations; verification requires the caller-supplied entry and does not attest other entries.",
+            "Reset vectors, memory-mapped I/O, big-endian and Thumb-only variants, and runtime boot behavior are not modeled or verified. No original executable bytes are changed.",
+            "Mapping ends are inclusive; a mismatching digest identifies its source range, not the first differing byte.",
+        ],
+    }));
+};

package/dist/ghidra/GhidraMipsProfile.js

@@ -0,0 +1,187 @@
+const MIPS_FP_ABI_SOFT = 3;
+const MIPS_ET_REL = 1;
+const MIPS_ET_EXEC = 2;
+const MIPS_ET_DYN = 3;
+const MIPS16_HEADER_ASE = 0x04000000;
+/** A distinct compressed shared-image shape; admission still checks every declaration. */
+const isGhidraMips16SharedTarget = (target) => target.kind === "executable" &&
+    target.architecture === "mips" &&
+    target.mips.type === MIPS_ET_DYN &&
+    (target.mips.flags & 0x0f000000) === MIPS16_HEADER_ASE;
+/** Generic MIPS32 permits per-function ISA_MODE; a global 16e processor does not. */
+export const ghidraMipsSharedLanguageOverride = (target) => isGhidraMips16SharedTarget(target) && target.architecture === "mips"
+    ? {
+        languageId: `MIPS:${target.mips.byteOrder === "little" ? "LE" : "BE"}:32:default`,
+        compilerSpecId: "default",
+    }
+    : undefined;
+/** Keep family recognition separate from the deliberately bounded Ghidra lane. */
+export const ghidraMipsUnsupportedReason = (target) => {
+    if (target.kind !== "executable" || target.architecture !== "mips")
+        return null;
+    const metadata = target.mips;
+    if (target.format !== "elf" || metadata === undefined)
+        return "MIPS analysis requires ELF header metadata; a family name alone does not select an ISA or ABI.";
+    const shared = isGhidraMips16SharedTarget(target);
+    if (metadata.elfClass !== 32)
+        return "This Ghidra MIPS lane supports ELF32 only; MIPS64 and n64 remain unsupported.";
+    if (metadata.type !== MIPS_ET_EXEC &&
+        metadata.type !== MIPS_ET_REL &&
+        !shared)
+        return "This Ghidra MIPS lane supports ET_EXEC and ET_REL only; shared images and PSP PRX need separate load verification.";
+    if ((metadata.flags & 0x0f000000) !== 0 && !shared)
+        return "MIPS16, microMIPS and other ASE encodings are outside this standard-instruction MIPS lane.";
+    if ((metadata.flags & 0x00ff0000) !== 0)
+        return "Machine-specific MIPS variants, including PSP Allegrex, need a separately supported processor profile.";
+    if ((metadata.flags & 0xf0000000) !== 0x70000000)
+        return "This Ghidra MIPS lane requires EF_MIPS_ARCH_32R2; other ISA revisions need separate verification.";
+    if ((metadata.flags & 0x0000f000) !== 0x00001000 ||
+        (metadata.flags & 0x20) !== 0)
+        return "This Ghidra MIPS lane requires an explicit o32 ABI; unspecified, n32 and EABI targets remain unsupported.";
+    if ((metadata.flags & 0x00000200) !== 0)
+        return "EF_MIPS_FP64 requires separate verification of 64-bit floating-point register semantics in this Ghidra lane.";
+    if ((metadata.flags & 0x00000400) !== 0)
+        return "EF_MIPS_NAN2008 requires separate verification of NaN encoding semantics in this Ghidra lane.";
+    if (shared) {
+        if ((metadata.flags & 0x40) !== 0)
+            return "EF_MIPS_ABI_ON32 declares an unverified ABI for the MIPS16 shared-image lane.";
+        const load = metadata.sharedLoad;
+        if (load === undefined || load.status !== "complete")
+            return `MIPS16 shared images require complete dynamic relocation inspection. ${load?.reason ?? "The source declarations have not been inspected."}`;
+        if (load.relocationTypes.some((type) => type !== 0 && type !== 3))
+            return "This MIPS16 shared-image lane verifies R_MIPS_NONE and R_MIPS_REL32 only; other dynamic relocation types require separate verification.";
+        if (load.symbolRelativeCount !== 0)
+            return "Symbol-bearing R_MIPS_REL32 is unsupported: Ghidra normalizes MIPS16 function addresses and can lose the source function-pointer mode tag. Symbol-index-zero REL32 is verified separately.";
+    }
+    const abi = metadata.abiFlags;
+    if (shared && abi === null && (metadata.limitations?.length ?? 0) === 0)
+        return null; // Inspected absence leaves FP semantics unknown, never inferred.
+    if (abi === undefined || abi === null)
+        return [
+            "This Ghidra MIPS lane requires an inspected ABI flags record; header flags alone do not establish the floating-point ABI.",
+            ...(metadata.limitations ?? []),
+        ].join(" ");
+    if (abi.version !== 0)
+        return "This Ghidra MIPS lane requires ABI flags version 0; newer record semantics are unsupported.";
+    if (abi.isaLevel !== 32 || abi.isaRevision !== 2)
+        return "MIPS ABI flags must agree with the declared MIPS32r2 ISA.";
+    if (abi.gprSize !== 1 || abi.cpr2Size !== 0)
+        return "This Ghidra MIPS lane requires 32-bit GPRs and no CPR2; other register modes need separate verification.";
+    const hardFloat = abi.cpr1Size === 1 && (abi.fpAbi === 1 || abi.fpAbi === 5);
+    const softFloat = abi.cpr1Size === 0 && abi.fpAbi === MIPS_FP_ABI_SOFT;
+    if (!hardFloat && !softFloat)
+        return "This Ghidra MIPS lane admits double-precision or FPXX ABI declarations with 32-bit CPR1, or soft-float without CPR1; single-float, FP64 and unspecified modes need separate verification.";
+    if (abi.isaExtension !== 0 || abi.ases !== (shared ? 0x400 : 0))
+        return "MIPS ABI flags declare an ISA extension or ASE outside this profile's verified instruction declarations.";
+    // MIPS_AFL_FLAGS1_ODDSPREG (bit 0) is the GCC and LLVM default for MIPS32 o32
+    // whatever the FP ABI; soft-float objects from both carry it. With no CPR1 it
+    // selects nothing, so it is accepted for soft-float as well as hard-float.
+    if ((abi.flags1 & ~1) !== 0 || abi.flags2 !== 0)
+        return "MIPS ABI flags contain unsupported general flags.";
+    return null;
+};
+/** Soft-float prototype policy applied by ReaGhidraMipsSoftFloat.java after analysis. */
+export const GHIDRA_MIPS_SOFT_FLOAT_STORAGE = "o32-soft-float-prototype-v1";
+/** Whether the admitted target declares the soft-float o32 ABI. */
+export const isGhidraMipsSoftFloatTarget = (target) => target.kind === "executable" &&
+    target.architecture === "mips" &&
+    target.mips?.abiFlags?.cpr1Size === 0 &&
+    target.mips.abiFlags.fpAbi === MIPS_FP_ABI_SOFT;
+/** Fail closed unless soft-float storage ran exactly for soft-float targets. */
+export const ghidraMipsSoftFloatFailure = (expected, report) => expected === (report !== undefined)
+    ? undefined
+    : expected
+        ? "The Ghidra session did not report the committed MIPS soft-float prototype."
+        : "The Ghidra session reported MIPS soft-float storage that the profile did not commit.";
+/** Keep REA's soft-float prototype distinct from Ghidra's hard-float o32 model. */
+export const ghidraMipsSoftFloatLimitations = (expected, report) => expected
+    ? [
+        "Soft-float o32: Ghidra's MIPS32 compiler specifications model hard-float o32 only. After analysis REA installs a program-specific `__rea_soft_float` prototype, derived from the default o32 model without its floating-point registers and rules, and assigns it to every function, external function and function-pointer definition whose declared types use float or double, so those values keep their types and use integer registers and stack slots.",
+        ...(report === undefined
+            ? []
+            : [
+                `Soft-float prototype outcome: ${report.functions} functions and ${report.definitions} function-pointer definitions use __rea_soft_float.`,
+            ]),
+    ]
+    : [];
+/** Ghidra-placed relocatable objects need coordinates and relocation caveats. */
+export const ghidraMipsRelocatableLimitations = (target) => target.kind === "executable" &&
+    target.architecture === "mips" &&
+    target.mips?.type === MIPS_ET_REL
+    ? [
+        "Relocatable MIPS ELF: Ghidra assigns each allocated section an analysis address and applies the object's relocations there. Returned addresses are analysis coordinates, not the addresses a kernel or linker would choose at load time.",
+        "Undefined symbols (for example kernel exports used by a module) are placed in Ghidra's EXTERNAL block; their definitions are outside this artifact. inspect_native_load_image reports each relocation with Ghidra's status; HI16 entries report PARTIAL because Ghidra applies them together with their paired LO16.",
+    ]
+    : [];
+/** Shared-image results are analysis observations, not dynamic-loader execution. */
+export const ghidraMipsSharedLimitations = (target) => isGhidraMips16SharedTarget(target) && target.architecture === "mips"
+    ? [
+        "MIPS16 shared ELF: the endian-matched generic MIPS32 language uses the provider's per-address ISA_MODE context. The program language variant is not the instruction's encoding mode.",
+        "Shared-image addresses are Ghidra analysis coordinates, not runtime addresses. The source bytes remain unchanged; inspect_native_load_image retains original relocation bytes, loaded memory bytes and provider relocation status. External GOT bindings remain unverified without their defining images.",
+        ...(target.mips.abiFlags === null
+            ? [
+                "No MIPS ABI flags record was found in the completely examined declaration tables. The header declares o32 but does not establish the floating-point ABI; the default compiler specification does not verify floating-point argument or return storage.",
+            ]
+            : []),
+    ]
+    : [];
+/** Commit source ELF interpretation without confusing target ISA with host CPU. */
+export const ghidraMipsProfileParameters = (target) => {
+    if (target.kind !== "executable" ||
+        target.architecture !== "mips" ||
+        target.mips === undefined)
+        return {};
+    const abi = target.mips.abiFlags;
+    return {
+        mips_elf: {
+            elf_class: target.mips.elfClass,
+            byte_order: target.mips.byteOrder,
+            type: target.mips.type,
+            flags: target.mips.flags,
+            ...(target.mips.limitations === undefined
+                ? {}
+                : { abi_flags_limitations: [...target.mips.limitations] }),
+            abi_flags: abi === undefined || abi === null
+                ? null
+                : {
+                    version: abi.version,
+                    isa_level: abi.isaLevel,
+                    isa_revision: abi.isaRevision,
+                    gpr_size: abi.gprSize,
+                    cpr1_size: abi.cpr1Size,
+                    cpr2_size: abi.cpr2Size,
+                    fp_abi: abi.fpAbi,
+                    isa_extension: abi.isaExtension,
+                    ases: abi.ases,
+                    flags1: abi.flags1,
+                    flags2: abi.flags2,
+                },
+            ...(target.mips.sharedLoad === undefined
+                ? {}
+                : {
+                    shared_load: target.mips.sharedLoad.status === "complete"
+                        ? {
+                            status: "complete",
+                            relocation_count: target.mips.sharedLoad.relocationCount,
+                            relocation_types: [
+                                ...target.mips.sharedLoad.relocationTypes,
+                            ],
+                            symbol_relative_count: target.mips.sharedLoad.symbolRelativeCount,
+                        }
+                        : {
+                            status: "unavailable",
+                            reason: target.mips.sharedLoad.reason,
+                        },
+                }),
+        },
+        ...(isGhidraMipsSoftFloatTarget(target)
+            ? { mips_soft_float_storage: GHIDRA_MIPS_SOFT_FLOAT_STORAGE }
+            : {}),
+        instruction_context_evidence: "per-address-isa-mode-v1",
+        mips_support_lane: isGhidraMips16SharedTarget(target)
+            ? "elf32-dyn-o32-arch32r2-mips16-local-rel32-v1"
+            : target.mips.type === MIPS_ET_REL
+                ? "elf32-rel-o32-arch32r2-standard-v1"
+                : "elf32-exec-o32-arch32r2-standard-v3",
+    };
+};